排序:归并排序

最新推荐文章于 2024-10-15 19:28:18 发布

WOW爱算法

最新推荐文章于 2024-10-15 19:28:18 发布

阅读量662

点赞数 24

文章标签：排序算法算法数据结构

本文链接：https://blog.csdn.net/2301_80761442/article/details/137261396

版权

一.归并排序介绍:

归并排序，也称为 (MERGE-SORT)，是一种基于分治法（Divide and Conquer）的排序算法。该算法的主要思想是将已有序的子序列合并，以达到完全有序的序列。

二.归并排序的基本步骤：

分解（Divide）：将待排序的原始数组分解成若干个长度为1的子数组，这时候每个子数组都是有序的。然后将这些子数组两两配对，进行合并。
合并（Merge）：对于每次合并，比较两个子数组的首元素，将较小的元素复制到合并后的数组中，然后将较小元素的子数组向后移动一位，继续比较下一个元素。如果两个元素相等，可以选择将其中一个复制到合并后的数组中，以保持元素的相对顺序。重复这个过程，直到其中一个子数组的所有元素都被复制到合并后的数组中。
递归（Recur）：对于合并后的数组，如果它仍然大于1个元素，那么它可以继续被分解成更小的子数组，然后重复分解和合并的过程，直到所有子数组的长度都为1。
完成（Complete）：当所有子数组都合并回原始数组时，原始数组就变成了一个有序的数组。这时候，整个归并排序过程结束。

三.归并排序的java代码实现:

归并排序的实现分为递归和非递归两种。递归实现中，将待排序序列不断分为两个等长的子序列，分别对子序列进行排序，然后将排序结果合并，直到整个序列有序。非递归实现则是通过循环来进行两两归并。

1.非递归

public class MergeSort {

    public static void mergeSort(int[] arr) {
        int n = arr.length;
        for (int size = 1; size < n; size *= 2) {
            for (int left = 0; left < n - 1; left += 2 * size) {
                int mid = Math.min(left + size, n);
                int right = Math.min(left + 2 * size, n);
                merge(arr, left, mid, right);
            }
        }
    }

    private static void merge(int[] arr, int left, int mid, int right) {
        int n1 = mid - left;
        int n2 = right - mid;

        int[] leftArray = new int[n1];
        int[] rightArray = new int[n2];

        for (int i = 0; i < n1; ++i) {
            leftArray[i] = arr[left + i];
        }
        for (int j = 0; j < n2; ++j) {
            rightArray[j] = arr[mid + 1 + j];
        }

        int i = 0, j = 0;
        int k = left;
        while (i < n1 && j < n2) {
            if (leftArray[i] <= rightArray[j]) {
                arr[k] = leftArray[i];
                i++;
            } else {
                arr[k] = rightArray[j];
                j++;
            }
            k++;
        }

        while (i < n1) {
            arr[k] = leftArray[i];
            i++;
            k++;
        }

        while (j < n2) {
            arr[k] = rightArray[j];
            j++;
            k++;
        }
    }

    public static void main(String[] args) {
        int[] arr = {7,3,5,1,6,4,8,2};
        mergeSort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

接下来我们看一看递归的代码

2.递归

public class MergeSort {
    public static void main(String[] args) {
        int[] arr={7,3,5,1,6,4,8,2};
        sort(arr);
        for (int i : arr) {
            System.out.print(i+" ");
        }
    }
    public static void sort(int[] arr){
        sortSection(arr,0, arr.length-1);
    }
    private static void sortSection(int[] arr,int start,int end){
        if (start==end){
            return;
        }
        int mid=(end+start)/2;
        sortSection(arr,start,mid);
        sortSection(arr,mid+1,end);
        merge(arr,start,mid+1,end);
    }
    private static void merge(int[] arr,int start,int start2,int end){
        int len=start2-start;
        int[] temp=new int[len];
        System.arraycopy(arr,start,temp,0,len);

        int p=0;
        int q=start2;
        for (int i = start; i <=end; i++) {
            if(temp[p]<arr[q]){
                arr[i]=temp[p];
                p++;
                if (p==len){
                    break;
                }
            }else {
                arr[i]=arr[q];
                q++;
                if (q>end){
                    while (p<len){
                        i++;
                        arr[i]=temp[p];
                        p++;
                    }
                }
            }
        }
    }
}