Java에서 Timsort 정렬 알고리즘의 단계 및 구현

Background

Timsort는 간단히 말해서 merge sort와 Binary Insertion Sort 알고리즘을 혼합한 하이브리드 정렬 알고리즘입니다. Timsort는 항상 Python의 표준 정렬 알고리즘이었습니다. Timsort API는 Java SE 7 이후에 추가되었습니다. Arrays.sort에서 이것이 이미 Arrays.sort可以看出它已经是非原始类型数组的默认排序算法了。所以不管是进阶编程学习还是面试，理解 Timsort 是比较重要。

// List sort()    
default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
              //数组排序
        Arrays.sort(a, (Comparator) c);
              ...
    }

// Arrays.sort
    public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (c == null) {
            sort(a);
        } else {
              // 废弃版本
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }

    public static void sort(Object[] a) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a);
        else
            ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
    }

前置知识

理解 Timsort 需要先回顾下面的知识。

指数搜索

指数搜索，也被称为加倍搜索，是一种用于在大型数组中搜索元素而创建的算法。它是一个两步走的过程。首先，该算法试图找到目标元素存在的范围 (L，R)，然后在这个范围内使用二叉搜索来寻找目标的准确位置。时间复杂度为O(lgn)。该搜索算法在大量有序数组中比较有效。

二分插入排序

插入排序算法很简单，大体过程是从第二个元素开始，依次向前移动交换元素直到找到合适的位置。

插入排序最优时间复杂度也要O(n) ，我们可以使用二分查找来减少插入时元素的比较次数，将时间复杂度降为logn。但是注意，二分查找插入排序仍然需要移动相同数量的元素，但是复制数组的时间消耗低于逐一互换操作。

特点：二分插入排序主要优点是在小数据集场景下排序效率很高。

public static int[] sort(int[] arr) throws Exception {
        // 开始遍历第一个元素后的所有元素
        for (int i = 1; i < arr.length; i++) {
            // 需要插入的元素
            int tmp = arr[i];
            // 从已排序最后一个元素开始，如果当前元素比插入元素大，就往后移动
            int j = i;
            while (j > 0 && tmp < arr[j - 1]) {
                arr[j] = arr[j - 1];
                j--;
            }
            // 将元素插入
            if (j != i) {
                arr[j] = tmp;
            }
        }
        return arr;
    }

    public static int[] binarySort(int[] arr) throws Exception {
        for (int i = 1; i < arr.length; i++) {
            // 需要插入的元素
            int tmp = arr[i];
            // 通过二分查找直接找到插入位置
            int j = Math.abs(Arrays.binarySearch(arr, 0, i, tmp) + 1);
            // 找到插入位置后，通过数组复制向后移动，腾出元素位置
            System.arraycopy(arr, j, arr, j + 1, i - j);
            // 将元素插入
            arr[j] = tmp;
        }
        return arr;
    }

归并排序

归并排序是利用分治策略的算法，包含两个主要的操作：分割与合并。大体过程是，通过递归将数组不断分成两半，一直到无法再分割（也就是数组为空或只剩一个元素），然后进行合并排序。简单来说合并操作就是不断取两个较小的排序数组然后将它们组合成一个更大的数组。

特点：归并排序主要为大数据集场景设计的排序算法。

public static void mergeSortRecursive(int[] arr, int[] result, int start, int end) {
        // 跳出递归
        if (start >= end) {
            return;
        }
        // 待分割的数组长度
        int len = end - start;
        int mid = (len >> 1) + start;
        int left = start; // 左子数组开始索引
        int right = mid + 1; // 右子数组开始索引
        // 递归切割左子数组，直到只有一个元素
        mergeSortRecursive(arr, result, left, mid);
        // 递归切割右子数组，直到只有一个元素
        mergeSortRecursive(arr, result, right, end);
        int k = start;
        while (left <= mid && right <= end) {
            result[k++] = arr[left] < arr[right] ? arr[left++] : arr[right++];
        }
        while (left <= mid) {
            result[k++] = arr[left++];
        }
        while (right <= end) {
            result[k++] = arr[right++];
        }
        for (k = start; k <= end; k++) {
            arr[k] = result[k];
        }
    }

    public static int[] merge_sort(int[] arr) {
        int len = arr.length;
        int[] result = new int[len];
        mergeSortRecursive(arr, result, 0, len - 1);
        return arr;
    }

Timsort 执行过程

算法大体过程，如果数组长度小于指定阀值（MIN_MERGE）直接使用二分插入算法完成排序，否则执行下面步骤：

• 先从数组左边开始，执行升序运行得到一个子序列。

• 将这个子序列放入运行堆栈里，等待执行合并。

• 检查运行堆栈里的子序列，如果满足合并条件则执行合并。

• 重复第一个步骤，执行下一个升序运行。

升序运行

升序运行就是从数组查找一段连续递增（升序）或递减（降序）子序列的过程，如果子序列为降序则将它反转为升序，也可以将这个过程简称为 run。比如数组 [2,3,6,4,9,30]，可以查找到三个子序列，[2,3,6]、[4,9]、[30]，或说3个 run。

几个关键阀值

MIN_MERGE

这是个常数值，可以简单理解为执行归并的最小阀值，如果整个数组长度小于它，就没必要执行那么复杂的排序，直接二分插入就行了。在 Tim Peter 的 C 实现中为 64，但实际经验中设置为 32 效果更好，所以 java 里面此值为 32。

降序反转时为保证稳定性，相同元素不会被颠倒。

minrun

在合并序列的时候，如果 run 数量等于或者略小于 2 的幂次方的时候，合并效率最高；如果略大于 2 的幂次方，效率就会显著降低。所以为了提高合并效率，需要尽量控制每个 run 的长度，通过定义一个 minrun 来表示每个 run 的最小长度，如果长度太短，就用二分插入排序把 run 后面的元素插入到前面的 run비원시형 배열

에 대한 기본 정렬 알고리즘임을 확인할 수 있습니다. 그래서 고급 프로그래밍 학습이든 면접이든 Timsort를 이해하는 것이 더 중요합니다.

private static int minRunLength(int n) {
        assert n >= 0;
        int r = 0;      // 如果低位任何一位是1，就会变成1
        while (n >= MIN_MERGE) {
            r |= (n & 1);
            n >>= 1;
        }
        return n + r;
    }

전제 지식🎜🎜Timsort를 이해하려면 먼저 다음 지식을 복습해야 합니다. 🎜

지수 검색

🎜이중 검색이라고도 알려진 지수 검색은 큰 배열의 요소를 검색하기 위해 만들어진 알고리즘입니다. 이는 2단계 프로세스입니다. 먼저, 알고리즘은 대상 요소가 존재하는 (L, R) 범위를 찾으려고 시도한 다음 이 범위 내에서 이진 검색을 사용하여 대상의 정확한 위치를 찾습니다. 시간복잡도는 O(lgn)이다. 이 검색 알고리즘은 대규모 정렬 배열에 효과적입니다. 🎜

이진 삽입 정렬

🎜 삽입 정렬 알고리즘은 매우 간단합니다. 일반적인 프로세스는 두 번째 요소부터 시작하여 적절한 위치를 찾을 때까지 앞으로 이동하고 요소를 교환하는 것입니다. 🎜🎜🎜🎜최적의 시간 삽입 정렬 복잡성도 O(n)입니다. 이진 검색을 사용하면 삽입하는 동안 요소 비교 횟수를 줄이고 로그에 걸리는 시간 복잡성을 줄일 수 있습니다. 그러나 이진 검색 삽입 정렬에는 여전히 동일한 수의 요소를 이동해야 하지만 배열을 복사하는 데 소요되는 시간은 하나씩 스왑 작업보다 낮습니다. 🎜🎜특징: 🎜이진 삽입 정렬의 주요 장점은 작은 데이터 세트 시나리오에서 정렬 효율성이 매우 높다는 것입니다. 🎜🎜

private void mergeCollapse() {
      
       // 当存在两个以上run执行合并检查
        while (stackSize > 1) {

          // 表示 Y
            int n = stackSize - 2; 
           
          // Z <= Y + X 
            if (n > 0 && runLen[n-1] <= runLen[n] + runLen[n+1]) { 

              // 如果 Z < X 合并Z+Y ，否则合并X+Y
              if (runLen[n - 1] < runLen[n + 1])
                    n--;
                
                // 合并相邻的两个run，也就是runLen[n] 和 runLen[n+1]
                mergeAt(n); 
            } else if (runLen[n] <= runLen[n + 1]) {
                
                // Y <= X 合并 Y+X
                mergeAt(n);
            } else {
                
                // 满足两个条件，跳出循环
                break; 
            }
        }
    }

병합 정렬

🎜병합 정렬은 분할 정복 전략을 활용하는 알고리즘으로 🎜분할🎜 및 🎜병합🎜이라는 두 가지 주요 작업으로 구성됩니다. 일반적인 프로세스는 배열을 더 이상 나눌 수 없을 때까지(즉, 배열이 비어 있거나 하나의 요소만 남음) 배열을 두 부분으로 재귀적으로 나눈 다음 병합하고 정렬하는 것입니다. 간단히 말해서 병합 작업은 두 개의 작은 정렬 배열을 연속적으로 가져와 더 큰 배열로 결합하는 것입니다. 🎜🎜기능: 🎜병합 정렬은 주로 대규모 데이터 세트 시나리오를 위해 설계된 정렬 알고리즘입니다. 🎜🎜🎜🎜rrreee🎜 Timsort 실행 프로세스 🎜🎜알고리즘의 일반적인 프로세스는 배열 길이가 지정된 임계값(🎜MIN_MERGE🎜)보다 작으면 직접 바이너리 삽입 알고리즘을 사용하여 정렬을 완료하고, 그렇지 않으면 다음 단계를 수행합니다. 🎜

• 🎜배열의 왼쪽부터 시작하여 🎜run in 오름차순🎜을 실행하여 🎜subsequence🎜을 얻습니다. 🎜
• 🎜이 🎜subsequence🎜를 실행 중인 스택에 넣고 🎜병합이 실행될 때까지 기다립니다🎜. 🎜
• 🎜실행 중인 스택에서 🎜subsequence🎜를 확인하고 🎜병합 조건🎜이 충족되면 병합을 실행합니다. 🎜
• 🎜첫 번째 단계를 반복하고 다음 🎜상승 달리기🎜를 수행합니다. 🎜

오름차순

🎜🎜오름차순🎜은 배열에서 연속 증가(오름차순) 또는 감소(내림차순) 하위 시퀀스를 찾는 프로세스입니다. 내림차순으로 오름차순으로 반전됩니다. 간단히 run으로 이 프로세스를 호출할 수도 있습니다. 예를 들어, [2,3,6,4,9,30] 배열에서 세 개의 하위 시퀀스, [2,3,6], [4,9], [30] 또는 3 run을 찾을 수 있습니다. < /코드>. 🎜<h4 id="여러-키-임계값">여러 키 임계값</h4>🎜🎜MIN_MERGE🎜🎜🎜상수 값으로, 단순히 병합을 위한 최소 임계값으로 이해하면 됩니다. 전체 배열 길이가 이보다 작으면 그럴 필요가 없습니다. 이렇게 복잡한 정렬을 수행하려면 두 부분으로 나누어 삽입하면 됩니다. Tim Peter의 C 구현에서는 64이지만 실제 경험에서는 32로 설정하는 것이 더 효과적이므로 Java에서는 이 값이 32입니다. 🎜🎜🎜내림차순을 뒤집을 때 안정성을 보장하기 위해 동일한 요소는 반전되지 않습니다. 🎜🎜🎜🎜minrun🎜🎜🎜 시퀀스를 병합할 때 <code>run 수가 2의 거듭제곱보다 약간 작거나 같으면 병합 효율이 가장 높습니다. 2의 전력을 사용하면 효율성이 크게 감소합니다. 따라서 병합 효율성을 높이기 위해서는 각 run<의 최소 길이를 나타내는 🎜minrun🎜을 정의하여 각 <code>run의 길이를 최대한 제어해야 합니다. /code>, 길이가 너무 짧은 경우 바이너리 삽입 정렬을 사용하여 run 뒤의 요소를 이전 run에 삽입합니다. 🎜🎜일반적으로 정렬 알고리즘을 실행하기 전에 이 minrun이 먼저 계산됩니다(데이터의 특성에 따라 자체 조정됨). minrun은 32에서 64 사이의 숫자를 선택하므로 minrun으로 나눈 데이터의 크기는 같습니다. 2의 제곱 또는 그보다 약간 작습니다. 예를 들어, 길이가 65이면 minrun 값은 33이고, 길이가 165이면 minrun 값은 42입니다. 🎜

看下 Java 里面的实现，如果数据长度（n） < MIN_MERGE，则返回数据长度。如果数据长度恰好是 2 的幂次方，则返回MIN_MERGE/2
也就是16，否则返回一个MIN_MERGE/2 <= k <= MIN_MERGE范围的值k，这样可以使的 n/k 接近但严格小于 2 的幂次方。

private static int minRunLength(int n) {
        assert n >= 0;
        int r = 0;      // 如果低位任何一位是1，就会变成1
        while (n >= MIN_MERGE) {
            r |= (n & 1);
            n >>= 1;
        }
        return n + r;
    }

MIN_GALLOP

MIN_GALLOP 是为了优化合并的过程设定的一个阈值，控制进入 GALLOP 模式中， GALLOP 模式放在后面讲。

下面是 Timsort 执行流程图

运行合并

当栈里面的 run 满足合并条件时，它就将栈里面相邻的两个run 进行合并。

合并条件

Timsort 为了执行平衡合并（让合并的 run 大小尽可能相同），制定了一个合并规则，对于在栈顶的三个run，分别用X、Y 和 Z 表示他们的长度，其中 X 在栈顶，它们必须始终维持一下的两个规则：

一旦有其中的一个条件不被满足，则将 Y 与 X 或 Z 中的较小者合并生成新的 run，并再次检查栈顶是否仍然满足条件。如果不满足则会继续进行合并，直至栈顶的三个元素都满足这两个条件，如果只剩两个run，则满足 Y > X 即可。

如下下图例子

• 当 Z <= Y+X ，将 X+Y 合并，此时只剩下两个run。

• 检测 Y < X ，执行合并，此时只剩下 X，则退出合并检测。

我们看下 Java 里面的合并实现

private void mergeCollapse() {
      
       // 当存在两个以上run执行合并检查
        while (stackSize > 1) {

          // 表示 Y
            int n = stackSize - 2; 
           
          // Z <= Y + X 
            if (n > 0 && runLen[n-1] <= runLen[n] + runLen[n+1]) { 

              // 如果 Z < X 合并Z+Y ，否则合并X+Y
              if (runLen[n - 1] < runLen[n + 1])
                    n--;
                
                // 合并相邻的两个run，也就是runLen[n] 和 runLen[n+1]
                mergeAt(n); 
            } else if (runLen[n] <= runLen[n + 1]) {
                
                // Y <= X 合并 Y+X
                mergeAt(n);
            } else {
                
                // 满足两个条件，跳出循环
                break; 
            }
        }
    }

合并内存开销

原始归并排序空间复杂度是 O(n)也就是数据大小。为了实现中间项，Timsort 进行了一次归并排序，时间开销和空间开销都比 O(n)小。

优化是为了尽可能减少数据移动，占用更少的临时内存，先找出需要移动的元素，然后将较小序列复制到临时内存，在按最终顺序排序并填充到组合序列中。

比如我们需要合并 X [1, 2, 3, 6, 10] 和 Y [4, 5, 7, 9, 12, 14, 17]，X 中最大元素是10，我们可以通过二分查找确定，它需要插入到 Y 的第 5个位置才能保证顺序，而 Y 中最小元素是4，它需要插入到 X 中的第4个位置才能保证顺序，那么就知道了[1, 2, 3] 和 [12, 14, 17] 不需要移动，我们只需要移动 [6, 10] 和 [4, 5, 7, 9]，然后只需要分配一个大小为 2 临时存储就可以了。

合并优化

在归并排序算法中合并两个数组需要一一比较每个元素，为了优化合并的过程，设定了一个阈值 MIN_GALLOP，当B中元素向A合并时，如果A中连续 MIN_GALLOP 个元素比B中某一个元素要小，那么就进入GALLOP模式。

根据基准测试，比如当A中连续7个以上元素比B中某一元素小时切入该模式效果才好，所以初始值为7。

当进入GALLOP模式后，搜索算法变为指数搜索，分为两个步骤，比如想确定 A 中元素x在 B 中确定的位置

• 首先在 B 中找到合适的索引区间(2^k−1,2^k+1−1) 使得 x 元素在这个范围内；

• 然后在第一步找到的范围内通过二分搜索来找到对应的位置。

只有当一次运行的初始元素不是另一次运行的前七个元素之一时，驰骋才是有益的。这意味着初始阈值为 7。

위 내용은 Java에서 Timsort 정렬 알고리즘의 단계 및 구현의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!