数据结构 09 - 快速排序 && 归并排序

一、快速排序

快速排序是对冒泡排序的一种改进
基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按照此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，最终使得整个数据变成有序序列。

代码实现：

public static void QuickSort1(int[] arr,int left,int right){
        int l = left;//左下标
        int r = right;//右下标

        //中轴值
        int pivot = arr[(left + right)/2];
        int temp = 0;
        //while循环的目的就是让比pivot小的值放到左边
        //比pivot大的值放到右边
        while (l < r){
            //在pivot的左边一直找，直到找到大于等于pivot的值，方退出
            while (arr[l] < pivot){
                l += 1;
            }
            //在pivot的右边一直找，直到找到小于等于pivot的值，方退出
            while (arr[r] > pivot){
                r -= 1;
            }
            //如果l>=r说明pivot的左右两边的值已经按照左边都是小于等于pivot值，右边全都是大于等于pivot的值
            if(l >= r){
                break;
            }
            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            //如果交换完后，发现这个arr[l] == pivot值相等，r--前移
            if(arr[l] == pivot){
                r -= 1;
            }
            //如果交换完后，发现这个arr[r] == pivot值相等，l--前移
            if(arr[r] == pivot){
                l += 1;
            }
        }
        //如果l == r,必须l++,r--，否则会出现栈溢出，陷入无限循环
        if(l == r){
            l++;
            r--;
        }
        //向左递归
        if(left < r){
            QuickSort1(arr,left,r);
        }
        //向右递归
        if(right > l){
            QuickSort1(arr,l,right);
        }
    }

二、归并排序

1.思路分析
（1）.分开：采用递归
（2）.合并
（2.1）依次比较左右两段有序序列的每个元素，将较小的值依次拷贝到temp数组中
（2.2）完成第一步后，有一边序列仍然有元素，此时按顺序将其拷贝到temp数组中
（2.3）将temp中的值赋给arr，不是全部赋值，而是特定段的值，即当前合并的这一段：left-right

代码实现：

public class mergessort {
    public static void main(String[] args) {
        int arr[] = {2,5,1,7,3,0,21,45};
        int temp[] = new int[arr.length];

        mergesort(arr,0,arr.length - 1,temp);
        System.out.println("归并排序后：" + Arrays.toString(arr));
    }
    //（一）.分开
    public static void mergesort(int[] arr,int left,int right,int[] temp){
        int mid = (left + right)/2;
        if(left < right){
            //向左递归
            mergesort(arr,left,mid,temp);

            //向右递归
            mergesort(arr,mid + 1,right,temp);

            //合并
            merge(arr,left,mid,right,temp);
        }

    }

    //（二）.合并
    public static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;
        int j = mid + 1;
        int t = 0;

        //1.首先左右逐一比较，依次把小的值拷贝到temp中
        while (i <= mid && j <= right){
            if(arr[i] < arr[j]){
                temp[t] = arr[i];
                t += 1;
                i += 1;
            }else {
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }

        //2.进行完前面的比较后，会出现一边的有序序列还有元素，这时按顺序将其拷贝到temp中
        while (i <= mid){
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }
        while (j <= right){
            temp[t] = arr[j];
            t += 1;
            j += 1;
        }

        //3.将temp的值赋给arr，不是全部赋值，而是特定段的值，即当前合并的这一段left-right
        t = 0;
        int temple = left;

        while (temple <= right){
            arr[temple] = temp[t];
            temple += 1;
            t += 1;
        }
    }
}