排序算法思想及实现（选择、冒泡、插入、归并、快排）

排序算法总结：https://www.cnblogs.com/guoyaohua/p/8600214.html

目录

冒泡排序

选择排序

插入排序

归并排序

快排

---

冒泡排序

比较相邻元素，大的向后（与小的交换位置）;每次都是从头开始依次比较找到最大的元素
每找到依次最大的元素，就确定了数组右边的一个元素
右边元素有序，且为全局最大的；（在无序中前后交换移动）

    //冒泡排序
    public int[] bubbingSort(int[] a){
        //比较相邻元素，大的向后（与小的交换位置）;每次都是从头开始依次比较找到最大的元素
        //每找到依次最大的元素，就确定了数组右边的一个元素
        //右边元素有序，且为全局最大的；（在无序中前后交换移动）
        if(a.length == 0 || a == null){
            return a;
        }
        for(int i = 0; i < a.length; i++){
            for(int j = 0; j < a.length - i - 1; j++){
                if(a[j] > a[j+1]){
                    int temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
                }
            }
        }
        return a;
    }

选择排序

从余下数组中挑选一个最小的，放到前面的数组最后一位（前面数组有序）
注：前面数组有序，且是所有元素中最小的一些；​​​​​​​

    //选择排序
    public int[] choiceSort(int[] a){
        //从余下数组中挑选一个最小的，放到前面的数组最后一位（前面数组有序）
        //注：前面数组有序，且是所有所有元素中最小的一些；
        if(a.length == 0 || a == null){
            return a;
        }
        for(int i = 0; i < a.length; i++){
            int index = i;
            for(int j = i; j < a.length; j++){
                if(a[index] > a[j]){
                    index =j;
                }
            }
            int temp = a[i];
            a[i] = a[index];
            a[index] = temp;
        }
        return a;
    }

插入排序

从数组中依次选择元素插入到前面的已经排好序的数组中
注：前面数组有序，但不保证全局最小；（在有序中前后交换移动）​​​​​​​

    //插入排序
    public int[] insertSort(int[] a){
        //从数组中依次选择元素插入到前面的已经排好序的数组中
        //注：前面数组有序，但不保证全局最小；（在有序中前后交换移动）
        if(a.length == 0 || a == null){
            return a;
        }
        for(int i = 0 ;i< a.length;i++){
            for(int j = i; j > 0; j--){
                if(a[j] < a[j-1]){
                    int temp = a[j];
                    a[j] = a[j-1];
                    a[j-1] = temp;
                }
            }
        }
        return a;
    }

归并排序

把长度为n的输入序列分成两个长度为n/2的子序列；

对这两个子序列分别采用归并排序；

将两个排序好的子序列合并成一个最终的排序序列。

    public void mergerSort(int[] a, int low ,int high){
        int mid = (low + high)/2;
        if(low < high){
            mergerSort(a,low,mid);
            mergerSort(a,mid+1,high);
            merge(a, low, high,mid );
        }

    }
    public void merge(int[] a, int low, int high, int mid){
        //将数组左右两边合并到一个新的数组中
        int[] temp = new int[high - low + 1];
        int i = low;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= high){
            if(a[i] < a[j]){//将较大的放到新建的数组中
                temp[k++] = a[i++];
            }else {
                temp[k++] = a[j++];
            }
        }
        while (i <= mid){
            temp[k++] = a[i++];
        }
        while (j <= high){
            temp[k++] = a[j++];
        }
        for(int m = 0; m< temp.length; m++){
            a[low + m] = temp[m];
        }
    }

快排

    //快排
    public void quickSort(int[] a, int left, int right){
        if(a.length == 0 || a == null || left >= right){
            return;
        }
        int b = a[left];
        int le = left;
        int ri = right;
        while (le < ri){
            while (a[ri] >= b && ri > le){//顺序很重要,必须从右开始走
                //因为走到左右的碰头处，位置的元素与首元素（选取的基准元素）交换
                ri--;
            }
            while (a[le] <= b && ri > le){//顺序很重要
                le++;
            }
            if(le < ri){
                int temp = a[le];
                a[le] = a[ri];
                a[ri] = temp;
            }
        }
        a[left] = a[le];
        a[le] = b;
        quickSort(a,left, le-1);
        quickSort(a,le+1, right);
    }
    //另一种：快速排序算法实现：
    public void quitSort(int[] a, int low, int high){
        if(low >= high){
            return;
        }
        int i = low;
        int j = high;
        int key = a[i];
        while (i<j){
            while (i<j && a[j]>=key) j--;
            a[i] = a[j];
            while (i<j && a[i] <=key) i++;
            a[j] = a[i];
            a[i] = key;
        }
        quitSort(a, low, i-1);//遍历左边数组
        quitSort(a, i+1, high);//遍历右边数组
    }