归并排序法排序数组（js版）

归并排序

• 归并排序是一种有效的排序算法，采用分治法（Divide and Conquer）策略来对数据进行排序。
• 它将数组分成两半，递归地对每一半进行排序，然后将两个已排序的部分合并在一起。
• 归并排序的时间复杂度为O(n log n)，空间复杂度为O(n)。
• 归并排序的基本思想是将一个数组分成两个子数组，分别对这两个子数组进行排序，然后将它们合并成一个有序的数组。

归并排序的实现过程如下：

1. 将数组分成两半，直到每个子数组只有一个元素为止。
2. 将两个已排序的子数组合并成一个有序的数组。
3. 重复步骤1和步骤2，直到所有的子数组都被合并成一个有序的数组。

        function merge(left, right) {
                var result = [];
                while (left.length && right.length) {
                    if (left[0] <= right[0]) {
                        result.push(left.shift());
                    } else {
                        result.push(right.shift());
                    }
                }

                while (left.length)
                    result.push(left.shift());
                while (right.length)
                    result.push(right.shift());
                return result;
            }
        const mergeSort = array => {
            const len = array.length
            if (len < 2) {
                return array
            }

            const mid = Math.floor(len / 2)
            const first = array.slice(0, mid)
            const last = array.slice(mid)
            let left = mergeSort(first)
            let right = mergeSort(last)
            return merge(left,right)
        }
        const arr = [5,3,8,6,2,7,4,1]
        const sortedArr = mergeSort(arr)
        console.log('排序后的数组:', sortedArr)

执行顺序看下面：

mergeSort函数

• 二分法分解数组，调用merge函数
• 递归调用mergeSort函数，直到数组长度为1，然后调用merge函数

merge 函数

• 有序的两个数组合并成一个有序的数组
• 先比较两个数组的第一个元素，较小的放入新数组中，然后将指针向后移动一位，继续比较，直到有一个数组的元素全部放入新数组中
• 执行顺序：合并小数组，再合并大数组，直到所有小数组都合并成一个大数组

执行顺序拆解 ⬇

从上往下执行：

mergeSort([5,3,8,6,2,7,4,1]){
	//省略步骤二分数组
    left = mergeSort([5,3,8,6]){
        left = mergeSort([5,3]){
            left = mergeSort([5]){
                return [5]
            }
            right = mergeSort([3]){
                return [3]
            }
            return merge([5],[3]) // [3,5]
        }
        right = mergeSort([8,6]){
            left = mergeSort([8]){
                return [8]
            }
            right = mergeSort([6]){
                return [6]
            }
            return merge([8],[6]) // [6,8]
        }
        return merge([3,5],[6,8]) // [3,5,6,8]
    }

    right = mergeSort([2,7,4,1]){
        left = mergeSort([2,7]){
            left = mergeSort([2]){
                return [2]
            }
            right = mergeSort([7]){
                return [7]
            }
            return merge([2],[7]) // [2,7]
        }
        right = mergeSort([4,1]){
            left = mergeSort([4]){
                return [4]
            }
            right = mergeSort([1]){
                return [1]
            }
            return merge([4],[1]) // [1,4]
        }
        return merge([2,7],[1,4]) // [1,2,4,7]
    }

    return merge(left, right) // [1,2,3,4,5,6,7,8]
}

总结： 归并排序通过递归拆分数组，再合并排序好的子数组，高效地实现了整体排序。