常见排序算法

插入排序

//将第i个数一直与左边的数进行对比，如果nums[i] < nums[i - 1],
//则交换两数位置,直到第i个数到最左或者出现num[i] > nums[i - 1],
//则说明已经插入到正确的位置了。
//插入排序适用于待排序数据大部分已经有序的情况，这样比较的次数就变少了。
  private void swap(int[] nums, int j, int i) {
      int temp = nums[i];
      nums[i] = nums[j];
      nums[j] = temp;
  }
  private void insertSort(int[] nums) {
      for(int i = 1; i < nums.length; i++){
          int j = i;
          while (j > 0 && nums[j] < nums[j - 1]){
              swap(nums, j, j - 1);
              j--;
          }
      }
  }

//插入排序优化，不使用swap函数，将元素往后移，再补空位
    private void insertSort(int[] nums) {
        for(int i = 1; i < nums.length; i++){
            int temp = nums[i];
            int j = i;
            for(; j > 0 && temp < nums[j - 1]; j--){
                nums[j] = nums[j - 1];
            }
            nums[j] = temp;
        }
    }

时间复杂度（最好）：待排序数据已经是有序的，这样不需要进行第二层循环的比较，复杂度是O(n)
时间复杂度（最坏）：待排序数据是倒序的，需要两层循环，复杂度是O(n^2)
时间复杂度（平均）：O(n^2)
空间复杂度：在原数组上进行交换，复杂度是O(1)
稳定性：判断当nums[i] == nums[i - 1]时，不进行交换，也就是说原来nums[i - 1]在nums[i]前面，排序后也没有改变两数的相对位置，所以是稳定的。
稳定性定义：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，A1=A2，且A1在A2之前，而在排序后的序列中，A1仍在A2之前，则称这种排序算法是稳定的；否则称为不稳定的。

选择排序

  //从当前位置向后寻找，找到最小的值，与当前位置比较并交换。每次都是选择最小的数，称为选择排序
  private void choiceSort(int[] nums) {
      for(int i = 0; i < nums.length - 1; i++){
          int minPos = i;
          for(int j = i + 1; j < nums.length; j++){
              if(nums[j] < nums[minPos]){
                  minPos = j;
              }
          }
          swap(nums, minPos, i);
      }
  }

  //选择排序优化，每次循环将最小的向左交换，最大的向右交换。
  private void choiceSort(int[] nums) {
      for(int i = 0, j = nums.length - 1; i < j; i++, j--){
          int minPos = i;
          int maxPos = j;
          for(int k = i + 1; k <= j; k++){
              if(nums[k] < nums[minPos]) minPos = k;
              if(nums[k] > nums[maxPos]) maxPos = k;
          }
          swap(nums, i, minPos);
          swap(nums, j, maxPos);
      }
  }

时间复杂度（最好）：在待排序序列有序的情况下，还是会扫描当前位置后面的数据，进入第二层循环，所以复杂度O(n^2)
时间复杂度（最坏）：O(n^2)
时间复杂度（平均）：O(n^2)
空间复杂度：在原数组上进行交换，复杂度是O(1)
稳定性：不稳定。比如序列【3*，3，2，1】，第一次排序时，将3* 与1进行交换，变成【1，3，2，3*】，两个3的相对位置发送变化，所以不稳定。

冒泡排序

	//像水泡从水中向上由小变大，冒泡排序每一趟都将待排序元素两两比较
	//最后将最大的数放到待排序序列的最右边
	//需要n - 1趟冒泡排序，因为最后一趟只剩一个待排元素，每一趟都排好一个元素
	//利用n - 1 - i 控制待排序列范围
   private void bulleSort(int[] nums) {
       int n = nums.length;
       for(int i = 0; i < n - 1; i++){
           for(int j = 0; j < n - 1 - i; j++){
               if(nums[j] > nums[j + 1]){
                   swap(nums, j, j + 1);
               }
           }
       }
   }

//冒泡排序优化，利用一个计数器，发现未发生交换情况则序列有序，直接退出。
    private void bulleSort1(int[] nums) {
        int n = nums.length;
        for(int i = 0; i < n - 1; i++){
            int cnt = 0;
            for(int j = 0; j < n - 1 - i; j++){
                if(nums[j] > nums[j + 1]){
                    swap(nums, j, j + 1);
                    cnt++;
                }
            }
            if(cnt == 0) break;
        }
    }

时间复杂度（最好）：在待排序序列有序的情况下，只需要一层循环，复杂度O(n)
时间复杂度（最坏）：O(n^2)
时间复杂度（平均）：O(n^2)
空间复杂度：在原数组上进行交换，复杂度是O(1)
稳定性：判断两数相等时，不会进行交换，所以是稳定的。

堆排序

public class HeapSort {
    public static void main(String[] args) {
        int[] nums = new int[]{2,5,1,9,4,7,3,8};
        int len = nums.length;
        HeapSort hs = new HeapSort();
        hs.buildHeap(nums, len);
        for(int i = len - 1; i > 0; i--){
            swap(nums, 0, len - 1);
            len--;
            //0是大根堆堆顶，交换之后索引0的元素不是最大值，所以需要进行堆化
            hs.heapify(nums, 0, len);
        }
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }

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

    private void buildHeap(int[] nums, int len) {
        for(int i = len / 2 - 1; i >= 0; i--){
            heapify(nums, i, len);
        }
    }

    private void heapify(int[] nums, int i, int len) {
        int maxIdx = i;
        int left = i * 2 + 1;
        int right = i * 2 + 2;
        // 如果有左节点，并且左节点的值更大，更新最大值的索引
        if(left < len && nums[left] > nums[maxIdx]) maxIdx = left;
        // 如果有右节点，并且右节点的值更大，更新最大值的索引
        if(right < len && nums[right] > nums[maxIdx]) maxIdx = right;
        if(i != maxIdx) {
            // 如果最大值不是当前非叶子节点的值，那么就把当前节点和最大值的子节点值互换
            swap(nums, i, maxIdx);
            // 因为互换之后，子节点的值变了，如果该子节点也有自己的子节点，仍需要再次调整。
            heapify(nums, maxIdx, len);
        }
    }
}

时间复杂度（最好）：O(nlogn)
时间复杂度（最坏）：O(nlogn)
时间复杂度（平均）：O(nlogn)，初始建堆时间复杂度O(n)，一次重建堆时间复杂度O(logn)，每排好一个数都有一次堆化的过程。
空间复杂度：在原数组上进行交换，复杂度是O(1)
稳定性：不稳定，例如序列【5*，5，4，3，2】，第一次swap(nums, 0, len - 1)交换5* 与2，变成【2，5，4，3，5*】，两个5的相对位置变化，不稳定。

快速排序

public class QuickSort {
    public void swap(int[] nums, int i, int j){
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
    public void quickSort(int[] nums, int l, int r){
        if(l >= r) return;
        int i = l, j = r;
        while (i < j){
            while (nums[i] <= nums[r] && i < j) i++;
            while (nums[j] >= nums[r] && i < j) j--;
            swap(nums, i, j);
        }
        swap(nums, i, r);
        quickSort(nums, l, i - 1);
        quickSort(nums, i + 1, r);
    }
    public static void main(String[] args) {
        int[] nums = new int[]{2,5,1,9,4,7,3,8};
        QuickSort qs = new QuickSort();
        qs.quickSort(nums, 0, nums.length - 1);
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }
}

时间复杂度（最好）：O(nlogn)
时间复杂度（最坏）：O(n^2)
时间复杂度（平均）：O(nlogn)
空间复杂度：主要是递归造成的栈空间的使用，最好情况，递归树的深度为O(logn)，最坏情况下是O(n)，平均情况是O(logn)
稳定性：不稳定。 例如序列【2，3，6，5，6*，7，5*】，第一次排序后变成【2，3，5*，5，6*，7，6】，发生相对位置变化，不稳定。

归并排序

public class MergeSort {
    public static void main(String[] args) {
        int[] nums = new int[]{2,5,1,9,4,7,3,8};
        MergeSort ms = new MergeSort();
        ms.sort(nums, 0, nums.length - 1);
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }

    private void sort(int[] nums, int i, int j) {
        if(i >= j) return;
        int mid = i + (j - i) / 2;
        sort(nums, i, mid);
        sort(nums, mid + 1, j);
        merge(nums, i, mid + 1, j);
    }

    private void merge(int[] nums, int leftPtr, int rightPtr, int rightBound) {
        if(rightBound <= leftPtr) return;
        int[] temp = new int[rightBound - leftPtr + 1];
        int k = 0;
        int left =leftPtr, right = rightPtr;
        while(leftPtr < right && rightPtr <= rightBound){
            if(nums[leftPtr] < nums[rightPtr]){
                temp[k++] = nums[leftPtr++];
            }else{
                temp[k++] = nums[rightPtr++];
            }
        }
        while(leftPtr < right) temp[k++] = nums[leftPtr++];
        while (rightPtr <= rightBound) temp[k++] = nums[rightPtr++];
        for(int i = 0; i < temp.length; i++){
            nums[i + left] = temp[i];
        }
    }
}

时间复杂度（最好）：O(nlogn)
时间复杂度（最坏）：O(nlogn)
时间复杂度（平均）：O(nlogn)
空间复杂度：O(n)
稳定性：稳定

计数排序

public class CountSort {
    public static void main(String[] args) {
        int[] nums = new int[]{2,5,1,9,4,7,3,8,1,2,3,9,5,3};
        CountSort cs = new CountSort();
        cs.countSort(nums);
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }

    private void countSort(int[] nums) {
        int maxVal = Integer.MIN_VALUE, minVal = Integer.MAX_VALUE;
        for(int n: nums){
            if(n > maxVal) maxVal = n;
            if(n < minVal) minVal = n;
        }
        int[] count = new int[maxVal - minVal + 1];
        for(int i = 0; i < nums.length; i++){
            count[nums[i] - minVal]++;
        }
        int k = 0;
        for(int i = 0; i < count.length; i++){
            if(count[i] != 0){
                while (count[i]-- > 0){
                    nums[k++] = i + minVal;
                }
            }
        }
    }
}

时间复杂度（最好）：O(n+k)，先扫描原来的序列，再扫描额外的数组。
时间复杂度（最坏）：O(n+k)
时间复杂度（平均）：O(n+k)
空间复杂度：最好的情况是O(k)，只创建了（maxVal - minVal + 1）这k个数的额外数组空间。如果是new int[maxVal + 1]，则是O(k + n)。
稳定性：稳定。

不稳定的排序：快 些 选 堆（快速排序，希尔排序，选择排序，堆排序）