排序算法笔记

1.选择排序

• 比如升序，大致过程是每次从数组中选择一个最小的元素，将它和数组的第一个元素交换位置。之后再剩下的元素中找到最小的元素，将它和数组的第二个元素交换位置，如此重复。
• Time：O(n²)，Space:O(1)。代码如下：

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

2.插入排序

• 比如升序:
  ①从数组的第二个元素开始往前比较，也就是第二个元素和第一个元素比较，若比前面的元素小，则交换位置。
  ②再把第三个元素和第二个元素比较，若第三个元素比第二个元素小则交换位置，之后还得继续往前比较。
  ③重复②，一直到数组末尾
• Time：O(n²)，Space:O(1）。代码如下：

public static int[] insertSort(int[] arr){
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int insertValue = arr[i];
            int index = i-1;
            while(index>=0 && insertValue < arr[index]){
                arr[index+1] = arr[index];
                index--;
            }
            arr[index+1]=insertValue;
        }
        return arr;
    }

3.冒泡排序

第一个元素和第二个元素比较，若第一个比第二个大，则交换位置，接下来再比较第二个元素和第三个元素，如果第二个比第三个大，则交换位置，依此类推
Time：O(n²)，Space:O(1）

public static int[] bubbleSort(int[] arr){
        if (arr==null || arr.length<2){
            return arr;
        }
        int n = arr.length-1;
        while (n>=0){
            for (int i = 0; i < n; i++) {
                if (arr[i]>arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
            n--;
        }
        return arr;
    }

4.希尔排序

希尔排序是插入排序的变种。先让数组中间隔为h的元素有序，h的大小为n/2，n/4,…,1。当间隔为1的元素有序时，也就是数组是有序的了。
Time：O(nlogn)，Space:O(1）

public static void shellSort(int[] arr){
        int dk = arr.length/2;
        while (dk>=1){
            shellInsertSort(arr,dk);
            dk = dk/2;
        }
    }

    public static void shellInsertSort(int[] arr,int dk){
        for (int i = dk; i < arr.length; i++) {
            int insertValue = arr[i];
            int index = i-dk;
            while(index>=0 && insertValue < arr[index]){
                arr[index+dk] = arr[index];
                index = index - dk;
            }
            arr[index+dk] = insertValue;
        }
    }

5.归并排序

Time：O(nlogn)，Space:O(n）

public static int[] mergeSort(int[] arr,int left,int right){
        if (left<right){
            int mid = (left+right)/2;
            mergeSort(arr,left,mid);
            mergeSort(arr,mid+1,right);
            merge(arr,left,mid,right);
        }
        return arr;
    }
    public static void merge(int[] arr, int left,int mid,int right){
        int[] temp = new int[right-left+1];
        int i = left;
        int j = mid+1;
        int k = 0;
        while (i<=mid && j<=right){
            if (arr[i]<arr[j]){
                temp[k++] = arr[i++];
            }else {
                temp[k++] = arr[j++];
            }
        }
        while(i<=mid){
            temp[k++] = arr[i++];
        }
        while (j<=right){
            temp[k++] = arr[j++];
        }
        for (int m = 0; m < k; m++) {
            arr[left++] = temp[m];
        }
    }

6.快速排序

在数组中选择一个元素作为主元，把所有小于主元的元素放在数组的左边，把大于主元的元素放在右边。显然主元的位置是有序的，不用再变化。在主元那里，我们把大的数组分成了两个小的数组，接着通过递归的方式，让主元左边的数组和右边的数组也重复同样的操作，直到数组的大小为1，此时每个元素都处于有序的位置。
Time：O(nlogn)，Space:O(logn）

public static int[] quickSort(int[] arr,int left,int right){
        if (left<right){
            int pivot = arr[right];//选当前数组的最后一个元素作为主元
            int i = left;
            int j = left;
            while(j<right){
                if (arr[j]<pivot){
                    int temp = arr[i];
                    arr[i++] = arr[j];
                    arr[j] = temp;
                }
                j++;
            }
            int temp = arr[i];
            arr[i] = pivot;
            arr[right] = temp;
            quickSort(arr,left,i-1);
            quickSort(arr,i+1,right);
        }
        return arr;
    }

7.堆排序

大顶堆的堆顶是最大值，小顶堆的堆顶是最小值。
这篇文章讲的很清晰
堆排序就是把堆顶的元素和最后一个元素交换，交换之后破坏了堆的特性，再把剩余的元素构成一个大顶堆，然后再把堆顶元素和最后第二个元素交换，如此反复，等到剩余的元素只有一个的时候，数组就是有序的了。
①先初始化堆。从最后一个非叶子节点（arr.length/2-1）开始调整，从左至右，从下到上进行调整。到根元素时要注意其子根是否还保持堆特性。
②将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。
Time：O(nlogn)，Space:O(1）
代码如下：

 public static int[] heapSort(int[] arr){
        int n = arr.length;
        for (int i = arr.length / 2 - 1; i >=0 ; i--) {
            adjustHeap(arr,i,n-1);
        }
        System.out.println("初始堆为"+Arrays.toString(arr));
        for (int j=n-1;j>=1;j--){
            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            adjustHeap(arr,0,j-1);
        }
        return arr;
    }
    public static void adjustHeap(int[] arr,int parent,int n){
        int temp = arr[parent];
        int child = 2*parent+1;
        while (child<=n){
            //如果左孩子<右孩子，定位到右孩子
            if (child+1<=n && arr[child]<arr[child+1]){
                child++;
            }
            if (temp>=arr[child]){
                break;
            }
            arr[parent] = arr[child];
            parent = child;
            child = 2*parent+1;
        }
        arr[parent] = temp;
    }

看到牛客上的一句话：不稳定排序算法是：快些（希）选堆吧。