算法学习之排序算法(java版)

算法学习之排序算法(java版)

排序算法是高级算法的基础，因此我们有必要掌握并且熟练的写出各种排序算法的代码

冒泡排序

public void bubbleSort(int[] nums){
  int len = nums.length;
  for(int i =0;i<len;i++){
    for(int j = i; j<len; j++){
      if(nums[j]>nums[j+1]){
        int temp = nums[j];
        nums[j] = nums[j+1];
        nums[j+1] = temp;
      }
    }
  }
}

空间复杂度：O(1)

时间复杂度: O(n^2)

思想：后面的数是排好序的
优化过的冒泡排序的最佳时间复杂度可以达到O(n)

public void bubbleSort(int arr[]) { 
    boolean didSwap;  
    int len = nums.length;
    for(int i =0;i<len;i++){
    	didSwap = false;
    for(int j = i; j<len; j++){
      if(nums[j]>nums[j+1]){
        int temp = nums[j];
        nums[j] = nums[j+1];
        nums[j+1] = temp;
        didSwap = true;
      }
    }
    if(didSwap == false)
            return;
  }
}

插入排序

public void insertSort(int[] nums){
	int len = nums.length;
  for(int i = 1,j,current;i<len;i++){
    current = nums[i];
    // 把大的往后推，留出正确的位置给current
    for(j=i-1;j>=0&&nums[j]>current;j--){
      nums[j+1]=nums[j];
    }
    nums[j+1]=current;
  }
}

空间复杂度：O(1)

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

思想：前面的数是排好序的

归并排序

public void sort(int[] A, int lo, int hi){
  if(lo>=hi)return;
  int mid = lo + (hi-lo)/2;
  sort(A, lo, mid);
  sort(A, mid+1, hi);
  merge(A, lo, mid, hi);
}

public void merge(int[] nums, int lo, int mid, int hi){
  int[] copy = nums.clone();
  
  int k=lo,i=lo,j=mid+1;
  while(k<=hi){
    // 如果左半边已经没了，那么就直接把右半边拿来
    if(i>mid){
      nums[k++]=copy[j++];
    }else if(j>hi){ // 如果右半边没了，直接把左半边拿来
      nums[k++]=copy[i++];
    }else if(copy[j]<copy[i]){ //如果右边小于左边
      nums[k++]=copy[j++];
    }else{ // 如果左边小于右边
      nums[k++]=copy[i++];
    }
  }
}

空间复杂度：O(n)

时间复杂度：O(nlogn)

思想：分治。递归的把子数组分成更小的数组，直到只剩一个。然后依次递归的合并

快速排序

public void fastSort(int[] nums, int lo, int hi){
  if(lo>=hi) return;
  int p = partition(nums, lo, hi);
  sort(nums, lo, p-1);
  sort(nums, p+1,hi);
}

public int partition(int[] nums, int lo, int hi){
  swap(nums, randRange(lo, hi), hi); //随机取的话，可以避免最差的情况
  int i,j;
  // 把比基准值小的都放到i左边
  for(i=lo,j=lo;j<hi;j++){
    if(nums[j]<=nums[hi]){
      swap(nums,i++,j);
    }
  }
  swap(nums, i,j);
  return i;
}

时间复杂度：O(nlogn)

空间复杂度：O(logn)，每次递归中需要开辟O(1)的空间来达到交换的功能，所以总的就是O(logn)

思想：递归的把数组分成较小和较大，小的放左边，大的放右边

拓扑排序

前提：

1. 有向图
2. 没有环

做法：

1. 统计所有节点的入度，将入度为0的当做第一个点，当做结果输出。同时删除与这个点有关的出度，更新入度表
2. 重复1

使用广度优先搜索的办法

public void sort(int[] indegree){
  Queue<Integer> q = new LinkedList();
  int V = indegree.length;
  for(int v = 0;v<V;v++){
    if(indegree[v]==0) q.add(v);
  }
  
  while(!q.isEmpty()){
    int v = q.poll();
    // 输出结果
    print(v);
    
    // 找到与v点相邻的节点，减掉入度
    for(int u=0;u<adj[v].length;u++){
      if(--indegree[u]==0){
        q.add(u);
      }
    }
  }
}

时间复杂度O(n)