数据结构之排序算法

冒泡排序：
时间复杂度：O(n*n)
空间复杂度：O(1)
稳定

---

public class Bubble_Sort {

    public static void Bubble_Sort(int [] arr ,int n){

        for(int i = 0; i < n-1;i++){  //记录循环的次数
            boolean flag = false;  //哨兵，判断元素是否已经有顺序了
            for(int j = 0;j < n - i-1;j++){
                if(arr[j+1] < arr[j]){
                    //交换位置
                    swap(arr,j,j+1);
                    flag = true;
                }
            }
            if(!flag){
                break;
            }
        }
    }

    private static void swap(int[] arr, int j, int i) {

        int tmp = arr[j];
        arr[j] = arr[i];
        arr[i] = tmp;
    }
}

---

直接插入排序
时间复杂度：O(n*n)
空间复杂度：O(1)
稳定

public class Insert_Sort {

     public static void insert_Sort(int [] arr,int n){
         for(int i =1;i<n;i++){
             int j = i - 1;
             int tmp = arr[i];
             while(j>=0 && arr[j] > tmp){
                 arr[j+1] = arr[j];
                 j--;
             }
             arr[j+1] = tmp;
         }
     }
}

快速排序
时间复杂度：O(nlogn)
空间复杂度：O(logn)
不稳定

---

public class Quick_Sort {

    private static int cutOff = 2;  //设置元素个数，进行切换排序
    //对外提供的接口
    public static void quick_Sort(int arr[], int n) {
        quick_Sort(arr, 0, n - 1);
    }

    //内部实现排序
    private static void quick_Sort(int arr[], int left, int right) {

        if (cutOff <= right - left) {  //元素个数大于阈值时候，进行快速排序
            // 使用快速排序
            int pivot = median(arr, left, right);  //获取中间位置元素
            int i = left;
            int j = right - 1;
            for (;;) {
                while (arr[++i] < pivot) {  //从左到右寻找大于pivot的元素位置

                }
                while (arr[--j] > pivot) { //从右到左寻找小于pivot的元素位置

                }
                if (i < j) {  //进行元素交换
                    swap(arr, i, j);
                } else {  //没有这样的元素对，结束循环
                    break;
                }
            }
            swap(arr, i, right - 1);  
            quick_Sort(arr, left, i - 1);  //进行左边分组递归
            quick_Sort(arr, i + 1, right); //进行右边分组递归
        } else {
            // 使用直接插入排序
            insert_Sort(arr, left, right - left + 1);
        }
    }

    public static void insert_Sort(int arr[], int start, int n) {

        for (int i = start + 1; i <= n + start - 1; i++) {
            int j = i - 1;
            int tmp = arr[i];
            while (j >= start && arr[j] > tmp) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = tmp;
        }
    }

    private static int median(int arr[], int left, int right) {
        int mid = (left + right) >> 1;
        // 获取中间的位置
        if (arr[left] > arr[mid]) {
            swap(arr, left, mid);
        }
        if (arr[left] > arr[right]) {
            swap(arr, left, right);
        }
        if (arr[mid] > arr[right]) {
            swap(arr, mid, right);
        }
        swap(arr, mid, right - 1);
        return arr[right - 1];
    }

    private static void swap(int arr[], int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

选择排序

public class Select_Sort {

    public static void selectSort(int arr[],int n){
        for(int i = 0; i < n-1;i++){
            int k = i;
            //找到最小值====选择排序的瓶颈之处，寻找最小值的时间复杂度为O(n)  ===进行改进利用堆，实现最小堆，时间复杂度为O(log n)
            for(int j = i;j< n;j++){
                if(arr[k] > arr[j]){
                    k = j;
                }
            }
            //交换数据
            if(k != i){
                int tmp = arr[i];
                arr[i] = arr[k];
                arr[k] = tmp;
            }
        }
    }
}

希尔排序

public class Shell_Sort {

    public static void shellSort(int [] arr,int n){
        int gap = n / 2;
        int tmp  = 0;
        int j = 0;
        while(gap > 0){
            for(int i = gap;i < n;i++){
                j = i - gap;
                tmp = arr[i];
                //分组比较
                while(j>=0 && arr[j] > tmp){
                    //实现交换
                    arr[j+gap] = arr[j];
                    j = j - gap;
                }
                arr[j+gap] = tmp;
                j = j - gap;
            }
            gap /= 2;
        }
    }

}