leetcode——思考——Collections.reverse、RandomAccess（原创）

今天做了剑指 Offer 32 - III. 从上到下打印二叉树 III（https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof/），利用常规的标志位设置奇偶层，根据标志位决定每个元素（对每个元素都要判断一次）是添加在r 的末尾，还是添加在头部。（时间29%）

发现时间效率低，查看了题解发现可以：（1）都添加在末尾（2）最后进行标志位判断，使用 Collections.reverse对 r整体倒置，从而减少标志位的判断次数（每层判断一次）。

结果发现：如果 r 仍然为 LinkedList 类型，时间效率还是29%（很低），若将 r 换为 ArrayList 类型，则时间直接增到99%。

思考

应该是Collections.reverse对LinkedList进行倒置时慢，而ArrayList倒置更快。应该查看下 Collections.reverse源码

确定思考的内容是否正确

编写测试代码，分别对长度为50000的ArrayList 和 LinkedList，进行200次 reverse 操作，结果显示后者的时间几乎为前者的两倍。

import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class Main {
        public static final int N=50000;

        public static List values;

        static{
                Integer vals[]=new Integer[N];

                Random r=new Random();

                for(int i=0,currval=0;i<N;i++){
                        vals[i]=new Integer(currval);
                        currval+=r.nextInt(100)+1;
                }

                values=Arrays.asList(vals);
        }

        static long timeList(List lst){
                long start=System.currentTimeMillis();
//                for(int i=0;i<N;i++){
//                        int index=Collections.binarySearch(lst, values.get(i));
//                        if(index!=i)
//                                System.out.println("***错误***");
//                }
                for(int i=0;i<1000;i++)  Collections.reverse(lst);
                return System.currentTimeMillis()-start;
        }
        public static void main(String args[]){
                System.out.println("ArrayList消耗时间："+timeList(new ArrayList(values)));
                System.out.println("LinkedList消耗时间："+timeList(new LinkedList(values)));
        }
}

Collections.reverse源码

public static void reverse(List<?> list) {
        int size = list.size();
        if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {
            for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--)
                swap(list, i, j);
        } else {
            // instead of using a raw type here, it's possible to capture
            // the wildcard but it will require a call to a supplementary
            // private method
            ListIterator fwd = list.listIterator();
            ListIterator rev = list.listIterator(size);
            for (int i=0, mid=list.size()>>1; i<mid; i++) {
                Object tmp = fwd.next();
                fwd.set(rev.previous());
                rev.set(tmp);
            }
        }
    }

发现

（1）RandomAccess：List 接口，用于标记 List 类型是否支持快速随机访问（数组类型支持常量时间随机访问，而链表则只能顺序访问）；官方注解里还写到：建议 通用 List 算法应该首先检查操作对象列表是否为该接口的实例，从而根据其类型设计不同的逻辑从而保证性能。

“List实现使用的标记接口，表示它们支持快速(通常是常量时间)随机访问。该接口的主要目的是允许泛型算法改变其行为，以便在应用于随机或顺序访问列表时提供良好的性能。”

（2）reverse 逻辑：1.对于支持随机访问的 list（ArrayList），直接对list 的存储结构（数组）进行操作——从两边向中间，首尾元素位置互换；2.对于不支持随机访问的 list（LinkedList），利用 ListIterator 的 set 方法，对链表中的元素值进行首尾互换（不修改链表指针指向）

---

ListIterator 的 set 方法：https://blog.csdn.net/qq_41623154/article/details/93778064

当你使用迭代器遍历时，比如你要查找并替换某个元素，你便可以使用set方法替换前面next方法返回的值，这里的next方法返回值是指最近的那次。

分析

直观来看，关键在于：利用ListIterator.set对首尾互换，比数组元素直接 swap 要更加耗时。