文章目录
前言
记录java刷题的一个大坑，ArrayList和LinkedList效率差别
题目
解题思路
层次遍历，对每一层，按照排序的结果对数组进行交换，记录交换次数即可。
遇到的坑：ArrayList和LinkedList
这是第319场周赛T3，这题被卡了好久，看了题解以后发现和我的思路一样，但我的代码就是有两个测试用例超时。
经过反复提交测试，发现是初始化List时用ArrayList和LinkedList的区别。
未通过代码
class Solution {
public int minimumOperations(TreeNode root) {
//层次遍历结果
List<List<Integer>> list = levelOrder(root);
int res = 0;
//加上每层按照排序结果交换的次数
for(int i = 0; i < list.size(); i++){
res += getMinswap(list.get(i));
}
return res;
}
List<List<Integer>> levelOrder(TreeNode root){
List<List<Integer>> list = new LinkedList<>();
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()){
int size = queue.size();
List<Integer> tmp = new LinkedList<>();
for(int i = 0; i < size; i++){
TreeNode now = queue.poll();
tmp.add(now.val);
if(now.left != null) queue.offer(now.left);
if(now.right != null) queue.offer(now.right);
}
list.add(tmp);
}
return list;
}
int getMinswap(List<Integer> nums){
if(nums.size() == 1) return 0;
int n = nums.size();
int res = 0;
List<Integer> sortedNums = new LinkedList<>(nums);
Collections.sort(sortedNums);
HashMap<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < sortedNums.size(); i++){
map.put(sortedNums.get(i), i);
}
for(int i = 0; i < n; ){
if(sortedNums.get(i).equals(nums.get(i))){
i++;
continue;
}
Collections.swap(nums, i, map.get(nums.get(i)));
res++;
}
return res;
}
}
通过代码
class Solution {
public int minimumOperations(TreeNode root) {
//层次遍历结果
List<List<Integer>> list = levelOrder(root);
int res = 0;
//加上每层按照排序结果交换的次数
for(int i = 0; i < list.size(); i++){
res += getMinswap(list.get(i));
}
return res;
}
List<List<Integer>> levelOrder(TreeNode root){
List<List<Integer>> list = new ArrayList<>();
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()){
int size = queue.size();
List<Integer> tmp = new ArrayList<>();
for(int i = 0; i < size; i++){
TreeNode now = queue.poll();
tmp.add(now.val);
if(now.left != null) queue.offer(now.left);
if(now.right != null) queue.offer(now.right);
}
list.add(tmp);
}
return list;
}
int getMinswap(List<Integer> nums){
if(nums.size() == 1) return 0;
int n = nums.size();
int res = 0;
List<Integer> sortedNums = new ArrayList<>(nums);
Collections.sort(sortedNums);
HashMap<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < sortedNums.size(); i++){
map.put(sortedNums.get(i), i);
}
for(int i = 0; i < n; ){
if(sortedNums.get(i).equals(nums.get(i))){
i++;
continue;
}
Collections.swap(nums, i, map.get(nums.get(i)));
res++;
}
return res;
}
}
小结
把我原来的LinkedList改成ArrayList就过了。
ArrayList和LinkedList的区别
ArrayList和LinkedList有什么区别：
- ArrayList底层结构是顺序表(基于数组)；
LinkList是链表; - ArrayList数据存放在内存空间上;
LinkList不是存放在连续的内存空间上; - ArrayList能够高效的进行“随机访问” ,时间复杂度是O(1);
- LinkList能够高效的进行插入删除，时间复杂度为O(1)。
在刷题的时候应该如何选择
大部分应该选择ArrayList，因为很多时候我们都要遍历数组，此时就要调用get方法访问元素，对于随机访问，ArrayList比LinkedList快。
由于LinkList能够高效的进行插入删除，在任意位置插入操作对应add(int index, E element)，删除操作对应remove(int index)，所以遇到这两种操作比较多的时候应该用LinkList。这种情况在我刷题的过程中遇到得比较少。
排序效率
Collections.sort()内部是归并排序，下面对ArrayList和LinkedList实现的List做一个简单的排序效率测试。
测试代码
import java.util.*;
public class Main {
public static void main(String[] args) {
int count = 10000000;
List<Integer> listArray = new ArrayList<>();
List<Integer> listLinked = new LinkedList<>();
Random random = new Random();
//生成count个随机值
for (int i = 0; i < count; i++) {
int rand = random.nextInt();
listArray.add(rand);
listLinked.add(rand);
}
//开始计时
long startTime1 = System.currentTimeMillis();
//对ArrayList排序
Collections.sort(listArray);
long endTime1 = System.currentTimeMillis();
long usedTime1 = (endTime1 - startTime1);
//开始计时
long startTime2 = System.currentTimeMillis();
//对LinkedList排序
Collections.sort(listLinked);
long endTime2 = System.currentTimeMillis();
long usedTime2 = (endTime2 - startTime2);
//打印排序时间
System.out.println("ArrayList排序用时：" + usedTime1);
System.out.println("LinkedList排序用时：" + usedTime2);
}
}
测试结果
单从排序效率来看LinkList是比ArrayList高的，然而根据我上面那道题的例子，里面也有用到排序，当我把排序的那个List改为LinkList时仍然无法通过，应该是排完序之后又对数组进行了遍历，而遍历ArrayList是快的。
遍历效率
测试代码
import java.util.*;
public class Main {
public static void main(String[] args) {
int count = 100000;
List<Integer> listArray = new ArrayList<>();
List<Integer> listLinked = new LinkedList<>();
Random random = new Random();
//生成count个随机值
for (int i = 0; i < count; i++) {
int rand = random.nextInt();
listArray.add(rand);
listLinked.add(rand);
}
//开始计时
long startTime1 = System.currentTimeMillis();
//对ArrayList遍历
for(int i = 0; i < listArray.size(); i++){
int a = listArray.get(i);
}
long endTime1 = System.currentTimeMillis();
long usedTime1 = (endTime1 - startTime1);
//开始计时
long startTime2 = System.currentTimeMillis();
//对LinkedList遍历
for(int i = 0; i < listLinked.size(); i++){
int a = listLinked.get(i);
}
long endTime2 = System.currentTimeMillis();
long usedTime2 = (endTime2 - startTime2);
//打印遍历时间
System.out.println("ArrayList遍历用时：" + usedTime1);
System.out.println("LinkedList遍历用时：" + usedTime2);
}
}
测试结果
由此可见，ArrayList的遍历效率比LinkList高，而且超出LinkList的部分大于LinkList排序超出ArrayList的部分。因此在排序和遍历操作都存在的情况，还是应该选择ArrayList。
结论
刷题的时候首选ArrayList。遇到add(int index, E element)和remove(int index)操作频繁的时候，再改用LinkList。
