八大排序

快速排序

package paixu.itcast.快排;

public class Solution {
    public static void main(String[] args) {
        int[] a = new int[]{9,8,1,5,9,7,5,4,6};
        quickSort(a,0,8);
        for(int i = 0;i<a.length;i++){
            System.out.printf("%d  ",a[i]);
        }
    }
    public static void quickSort(int[] arr,int l,int r){
        if(l>=r){
            return;
        }
        int q = partition(arr,l,r);
        quickSort(arr,l,q-1);
        quickSort(arr,q+1,r);
    }
    private static int partition(int[] array,int l,int r) {
// 默认⽐较元素为待排序数组的第⼀个元素
        int v = array[l];
        int j = l;
        for (int i = l + 1;i <= r;i++) {
// 每当碰到⼩于⽐较元素的值与j+1位置交换，⼩于区间⻓度加⼀
            if (array[i] < v) {
                swap(array,j+1,i);
                j++;
            }
        }
// 当for循环⾛完只需要将array[l]位置与array[j]位置交换即可保证索引⼩于j的元素均⼩于

// 索引⼤于j的元素均⼤于j
        swap(array,l,j);
        return j; }
    /**
     * 交换数组中两个索引下标的元素
     */
    private static void swap(int[] array,int x,int y) {
        int temp = array[x];
        array[x] = array[y];
        array[y] = temp;
    }
}

冒泡排序

package paixu.itcast.冒泡;

public class Solution {
    public static void main(String[] args) {
        int[] array = new int[]{8,5,4,6,3,8};
        function(array);
        for(int i =0;i<array.length;i++){
            System.out.println(array[i]);
        }

    }
    public static void function(int[] arr){
        if(arr.length<=1){
            return;
        }
        for(int i =0;i<arr.length;i++){
            for (int j = 0;j<arr.length-1-i;j++){
                if (arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
    }
    public static void swap(int[] arr,int i,int j){
        int temp = arr[j];
        arr[j] = arr[i];
        arr[i] = temp;
    }
}

优化后的冒泡

package paixu.itcast.冒泡;

public class Solution {
    public static void main(String[] args) {
        int[] array = new int[]{8,5,4,6,3,8};
        function(array);
        for(int i =0;i<array.length;i++){
            System.out.println(array[i]);
        }

    }
    public static void function(int[] arr){
        if(arr.length<=1){
            return;
        }
        for(int i =0;i<arr.length;i++){
            boolean flag = false;
            for (int j = 0;j<arr.length-1-i;j++){
                if (arr[j]>arr[j+1]){
                    flag = true;
                    swap(arr,j,j+1);
                }
            }
            if(!flag){
                break;
            }
        }
    }
    public static void swap(int[] arr,int i,int j){
        int temp = arr[j];
        arr[j] = arr[i];
        arr[i] = temp;
    }
}

• 原地、稳定的排序算法
• 最好时间复杂度为O(n),最坏为O(n^2)。

直接插入排序

package paixu.itcast.直接插入;

public class Solution {
    public static void main(String[] args) {
        int[] arr = new int[]{4,5,6,1,2,3};
        insertSort(arr);
        for(int i =0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
    public static void insertSort(int[] arr){
        if(arr.length<=1){
            return;
        }
        else {
            int n = arr.length;
            for(int i = 1;i<n;i++){
                int value = arr[i];
                int j = i-1;
                for (;j>=0;j--){
                    if(value<arr[j]){
                        arr[j+1]=arr[j];
                    }
                    else {
                        break;
                    }
                }
                arr[j+1] = value;
            }
        }
    }
}

折半插入查找

package paixu.itcast.折半插入查找;

public class Solution {
    public static void main(String[] args) {
        int[] a = new int[]{4,5,6,1,2,3};
        binaryInsertSort(a);
        for(int i = 0;i<a.length;i++){
            System.out.println(a[i]);
        }

    }
    public static void binaryInsertSort(int[] arr){
        if (arr.length<=1){
            return;
        }
        else {
            int n = arr.length;
            for (int i = 1;i<n;i++){
                int value = arr[i];
                int low = 0;
                int high = i-1;
                while(low<=high){
                    int mid = (low+high)/2;
                    if (arr[mid]>value) {
                        high=mid-1;
                    }
                    else {
                        low = mid+1;
                    }
                }
                int j = i-1;
                for(;j>high;j--){
                    arr[j+1] = arr[j];
                }
                arr[j+1] = value;
            }
        }
    }
}

希尔排序

package paixu.itcast.希尔排序;

public class Solution {
    public static void main(String[] args) {
        int[] a = new int[]{4,5,6,1,2,3};
        shellSort(a);
        for (int i = 0;i<a.length;i++){
            System.out.println(a[i]);
        }

    }
    public static void shellSort(int[] arr){
        int n = arr.length;
        if(n==1){
            return;
        }
        else {
            int step = n / 2;
            while (step > 0) {
                for (int i = step; i < n; i++) {
                    int value = arr[i];
                    int j = i - step;
                    for (; j >= 0; j -= step) {
                        if (value < arr[j]) {
                            arr[j + step] = arr[j];
                        } else {
                            break;
                        }
                    }
                    arr[j + step] = value;
                }
                step = step/2;
            }
        }
    }
}

选择排序

• 思想：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
• 时间复杂度：最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
• 稳定性：不稳定
• 空间复杂度：选择排序空间复杂度为 O(1)，原地排序算法

package paixu.itcast.选择排序;

public class Solution {
    public static void main(String[] args) {
        int[] arr = new int[]{4,5,6,1,2,3};
        selectSort(arr);
        for(int i =0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

    }
    public static void selectSort(int[] arr){
        int n =arr.length;
        if (n<=1){
            return;
        }
        else {
            for(int i = 0;i<n;i++){
                int minIndex = i;
                for (int j = i+1;j<n;j++){
                    if(arr[j]<arr[minIndex]){
                        int temp = arr[minIndex];
                        arr[minIndex] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
        }
    }
}