排序

1. 冒泡排序

public void Popsort(int[] nums){
  int n = nums.length;
  for(int i = 0; i < n - 1; i++){
    boolean flag = false;
    for(int j = 1; j <= n - 1 - i; j++){
       if(nums[j] < nums[j - 1]){
          swap(nums, j, j - 1);
          flag = true;
       }
    }
    if(flag == false)return;
  }
}


public void swap(int[] a, int i, int j){
  int temp = a[i];
  a[i] = a[j];
  a[j] = temp;
}

时间复杂度：

• 最好：原始序列为正序，O($n^{}$)；
• 最坏：O($n^2$)；
• 平均：O($n^2$)；

空间复杂度： O($1$)；

稳定性： 稳定

---

2. 直接插入排序

public static void insertSort(int[] a){
    for(int i = 1; i < a.length; i++){
        if(a[i] < a[i - 1]){//小的时候才插入
            int temp = a[i];
            int j = i - 1;
            while(j >= 0 && temp < a[j]){
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = temp;//插入
        }
    }
}

时间复杂度：

• 原始序列正序，此时为最好时间复杂度：O($n^{}$)；
• 原始序列倒序，此时为最坏时间复杂度：O($n^2$)；
• 平均时间复杂度：O($n^2$)；

空间复杂度： O($1^{}$)；

稳定性： 稳定

---

3. 简单选择排序

public void chooseMinSort(int[] nums){
  for(int i = 0; i < nums.length; i++){
     int k = i;
     for(int j = i + 1; j < nums.length; j++){
       if(nums[j] < nums[k])k = j;
     }
     if(i != k)swap(nums, i, k);
  }
}
public void sort(int[] nums, int i, int j){
   int t = nums[i];
   nums[i] = nums[j];
   nums[j] = t;
}

时间复杂度： O($n^2$)

空间复杂度： O($1^{}$)；

稳定性：

上面因为有判断i != k时才交换，所以是稳定的，但是如果没有这个判断，就是不稳定的。

---

4. 堆排序

public void heapSort(int[] nums, int n){//n表示有n个元素
    if(nums == null || nums.length == 0)return;
    //建堆
    for(int i = n / 2 - 1; i >= 0; i--){
       heapify(nums, n, i);
    }
    //排序
    for(int i = n - 1; i > 0; i--){
       swap(nums, i, 0);
       heapify(nums, i, 0);
    }
}

public void heapify(int[] nums, int n, int i){
   int leftChild = i * 2 + 1;
   int rightChild = i * 2 + 2;
   int maxIndexOfChild = i;
   if(leftChild < n && nums[maxIndexOfChild] < nums[leftChild])maxIndexOfChild= leftChild;
   if(rightChild < n && nums[maxIndexOfChild] < nums[rightChild])
   maxIndexOfChild= rightChild;
   if(maxIndexOfChild != i){   
      swap(nums, maxIndexOfChild, i);
      heapify(nums, n, maxIndexOfChild);
   }
}

public void swap(int[] nums, int i, int j){
  int t = nums[i];
  nums[i] = nums[j];
  nums[j] = t;
}

注意：

• 主要分2步：建堆，排序

• 建堆时，是从下往上建，如果有n个结点，建堆的第1个结点为 n / 2 - 1；

• 排序，就是将堆头部最大的元素和堆最下面的元素互换，然后再将其他的n-1个元素建堆。

• 建堆：查看当前节点的子节点，看有没有哪个子节点的val大于父节点，如果有，交换父子节点，如果没有，就不用交换，交换后，再次去建堆。

• 当前节点索引为i，则子节点索引为 2 * i + 1 和 2 * i + 2；

时间复杂度： O($NlogN$)

空间复杂度： O($1^{}$)

稳定性： 不稳定

建堆的时间复杂度： O($N$)

---

5. 快速排序

public void quickSort(int[] nums, int lower, int high){
  int i = lower;
  int j = high;
  if(lower < high){
    int temp = nums[lower];
    while(i != j){
       while(i < j && nums[j] >= temp)j--;
       if(i < j){
	  nums[i] = nums[j];
	  i++;
       }
       while(i < j && nums[i] <= temp)i++;
       if(i < j){
	   nums[j] = nums[i];
	   j--;
       }
    }
    nums[i] = temp;
    quickSort(nums, lower, i - 1);
    quickSort(nums, i + 1, high);
  }
}

时间复杂度：

最坏： O($n^2$)
最好：O($nlogn$)
平均：O($nlogn$)

空间复杂度：

O(log2n)，最坏O(n)

稳定性： 不稳定

---

最后附上之前总结的快速排序—跳转

(未完待续)