排序

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 n^{} n);
  • 最坏:O( n 2 n^{2} n2);
  • 平均:O( n 2 n^{2} n2);

空间复杂度: O( 1 1 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 n^{} n);
  • 原始序列倒序,此时为最坏时间复杂度:O( n 2 n^{2} n2);
  • 平均时间复杂度:O( n 2 n^{2} n2);

空间复杂度: O( 1 1^{} 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 n^{2} n2)

空间复杂度: O( 1 1^{} 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 + 12 * i + 2

时间复杂度: O( N l o g N Nlog{N} NlogN)

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

稳定性: 不稳定

建堆的时间复杂度: O( N {N} 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 n^{2} n2)
最好:O( n l o g n n{logn} nlogn)
平均:O( n l o g n n{logn} nlogn)

空间复杂度:

O(log2n),最坏O(n)

稳定性: 不稳定


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

(未完待续)

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值