排序算法总结

1冒泡排序（Bubble Sort）

   private int[] bubbleSort(int[] arr) {
        for (int i = 0 ; i < arr.length - 1 ; i++) { // 比较的趟数
            for (int j = 0 ; j< arr.length - 1 - i ; j++) { // 每趟比较的次数
                if (arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }

2选择排序（Selection Sort）

首先在未排序序列中找到最小（大）元素，与未排序第一个位置的元素交换位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，与未排序第一个位置的元素交换位置。以此类推，直到所有元素均排序完毕。

 private int[] selectionSort(int[] arr) {
        for (int i = 0 ; i < arr.length - 1 ; i++) { // 确定第i位置的元素
            int minIndex=i; // 记录最小元素索引位置
            int temp = arr[i];
            for (int j = i+1 ; j < arr.length ; j++) {
                if (arr[minIndex] > arr[j]) {
                    minIndex = j;
                }
            }
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        return arr;
    }

3插入排序（Insertion Sort）

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

private int[] insertSort(int[] arr) {
        for (int i = 1 ; i < arr.length ; i++) {
            int temp = arr[i];
            int j = i-1;
            while (j >= 0 && arr[j] > temp) {
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = temp;
        }
        return arr;
    }

4希尔排序（Shell Sort）

简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量的插入排序。

private int[] shellSort(int[] arr) {
        int len = arr.length;
        for (int gap = len/2 ; gap > 0 ; gap = gap/2) {
            for (int i = gap ; i < len ; i++) {
                int j = i;
                int temp = arr[i];
                while (j - gap >= 0 && temp < arr[j - gap]) {
                    arr[j] = arr[j - gap];
                    j = j - gap;
                }
                arr[j] = temp;
            }
        }
        return arr;
    }

5归并排序（Merge Sort）

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

 private static void mergeSort(int[] arr) {
      int [] temp = new int[arr.length];
      sort(arr , 0 , arr.length - 1 , temp);
    }

    private static void sort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;
            sort(arr , left , mid , temp); // 左边排序
            sort(arr , mid + 1 , right , temp); // 右边排序
            merge(arr , left , mid , right , temp); // 合并排序
        }
    }

    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left;
        int j = mid + 1;

        int  t = 0;
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }

        while (i <= mid) {//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }

        while (j <= right) {//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        //将temp中的元素全部拷贝到原数组中
        t = 0;
        while (left <= right) {
            arr[left++] = temp[t++];
        }
    }

6快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

1 从数列中挑出一个元素，称为 “基准”（pivot）；

2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

 private void quickSort(int[] arr, int left, int right) {
        int partitionIndex;
        if (left < right) {
            partitionIndex = partition(arr , left , right);
            quickSort(arr , left , partitionIndex - 1);
            quickSort(arr , partitionIndex + 1 , right);
        }
    }
private int partition(int[] arr, int left, int right) {
        int k = arr[left];
        int len = arr.length;
        if (len == 0 ) return 0;
        
        int first = left;
        while (left < right) {
            while (left < right && arr[right] >= k) {
                right--;
            }
            while (left < right && arr[left] <= k){
                left++;
            }
            if (left <= right) {
                swap(arr , left ,right);
            }
        }
        swap(arr , left , first);
        return left;
    }
public void swap(int []arr , int left , int right){
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
 }

7堆排序（Heap Sort）

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序
堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆

同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子

该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是：
大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了

步骤一 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。

a.假设给定无序序列结构如下

2.此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。

找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。

这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6。

此时，我们就将一个无需序列构造成了一个大顶堆。

步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

将堆顶元素9和末尾元素4进行交换

重新调整结构，使其继续满足堆定义

再将堆顶元素8与末尾元素5进行交换，得到第二大元素8。

后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序

再简单总结下堆排序的基本思路：
　　a.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
　　b.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
　　c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

    private static void HeapSort(int[] arr) {
        // 1构建大顶堆
        // 第一个非叶子节点的位置公式 ：int i = arr.length/2-1
        for (int i = arr.length/2-1 ; i >= 0 ; i--) {
            // 第一个非叶节点开始调整
            adjustHeap(arr , i , arr.length);
        }
        // 2调整堆结构+交换元素
        for (int j = arr.length-1 ; j > 0 ; j--) {
            swap(arr , 0 , j);
            adjustHeap(arr , 0 , j);
        }
    }

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

    private static void adjustHeap(int[] arr, int i, int length) {
        for(int k=i*2+1 ; k<length ; k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(arr[k] >arr[i]){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                swap(arr , i , k);
                i = k;
            }else{
                break;
            }
        }
    }