算法学习之排序算法(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)
思想：递归的把数组分成较小和较大，小的放左边，大的放右边
拓扑排序
前提：
- 有向图
- 没有环
做法：
- 统计所有节点的入度，将入度为0的当做第一个点，当做结果输出。同时删除与这个点有关的出度，更新入度表
- 重复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)