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

算法学习之排序算法(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)

你可能感兴趣的:(算法学习,算法,排序算法,数据结构)