排序算法总结整理

最新推荐文章于 2022-08-21 19:56:05 发布

原创最新推荐文章于 2022-08-21 19:56:05 发布 · 242 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #排序 #时间复杂度

Level 3: 算法专栏收录该内容

37 篇文章

订阅专栏

各种排序算法的稳定性和时间复杂度小结

目前不太清楚：时间复杂度考虑比较和移动的问题，分开考虑？

1. 冒泡排序的时间复杂度：平均O(n2) 最坏O(n2) 最好O(n) 空间复杂度 O(1) 稳定，简单

package test;

public class Index {

	public static void main(String[] args) {
		
		int[] arr = {3,1,5,63,14,13,9,7,6,4,8};
		
		// 调用函数
		BobbSort(arr);
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+",");
		}
	}
	/*
	 *	冒泡排序： 选择一个最大的数放到 后面 
	 * 		外循环： 循环多少次
	 * 		内循环：   循环的方式，从0开始，到 arr.length-i，结束
	 * */
	public static void BobbSort(int[] arr){
				
		if(arr == null || arr.length <2){
			return ;
		}
		   
		for(int i = 0;i < arr.length-1;i++){   // 因为涉及到比较操作，当倒数第二个数有序之后，最后一个数也是有序的。内循环需要多少次
			
			for(int j = 0;j < arr.length-i-1;j++){ // 获取所有未排序的 元素最大值，放到最右边，因为有j+1，所以j最大值length-1
				
				if(arr[j]>arr[j+1]){
					int temp = arr[j+1];
					arr[j+1] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}
}	public static void main(String[] args) {
		
		int[] arr = {3,1,5,63,14,13,9,7,6,4,8};
		
		// 调用函数
		BobbSort(arr);
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+",");
		}
	}
	/*
	 *	冒泡排序： 选择一个最大的数放到 后面 
	 * 		外循环： 循环多少次
	 * 		内循环：   循环的方式，从0开始，到 arr.length-i，结束
	 * */
	public static void BobbSort(int[] arr){
				
		if(arr == null || arr.length <2){
			return ;
		}
		   
		for(int i = 0;i < arr.length-1;i++){   // 因为涉及到比较操作，当倒数第二个数有序之后，最后一个数也是有序的。内循环需要多少次
			
			for(int j = 0;j < arr.length-i-1;j++){ // 获取所有未排序的 元素最大值，放到最右边，因为有j+1，所以j最大值length-1
				
				if(arr[j]>arr[j+1]){
					int temp = arr[j+1];
					arr[j+1] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}
}

时间复杂度：（n-1)+(n-2)+...+2+1 = n*((n-1)+1)/2 = (n^2）/2 然后 /2忽略不计。所以是 n^2

2.快速排序的时间复杂度：平均O(nlog2n) 最坏O(n2) 最好O(nlog2n) 空间复杂度 O(log2n) 不稳定，较复杂

package test;

public class Index {

	public static void main(String[] args) {
		
		int[] arr = {20,18,5,63,14,3,9,7,39,48,8};
		
		// 调用函数
		fastSort(arr, 0, arr.length-1);
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+",");
		}
	}
	/*
	 * 快速排序：将一个数组队列  一分为二
	 *     内部实现采用了 递归
	 * */
	public static void fastSort(int[] arr,int low,int high){
		
		int l = low;
		int h = high;
		int key = arr[low];
		
		while(l < h){   // 当满足时，才做操作
			// 向 末尾看
			while(l < h && key <= arr[h]){  // 内部有 自减操作，所以要时刻检测
				h--;
			}
			if(key > arr[h]){
				arr[l] = arr[h]; 		// 填坑
				l++;
			}
			// 向 开始看
			while(l < h && key >= arr[l]){  // 内部有 自增操作，所以要时刻检测
				l++;
			}
			if(key < arr[l]){			// 填坑
				arr[h] = arr[l];
				h--;
			}
		}
		arr[l] = key;		// 中间值归位，一次快排完成
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+",");
		}
		System.out.println();
		
		if(l > low) fastSort(arr, low, l-1); // 先执行，完成之后再向下一步
		if(h < high) fastSort(arr, l+1, high);
	}	
}	public static void main(String[] args) {
		
		int[] arr = {20,18,5,63,14,3,9,7,39,48,8};
		
		// 调用函数
		fastSort(arr, 0, arr.length-1);
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+",");
		}
	}
	/*
	 * 快速排序：将一个数组队列  一分为二
	 *     内部实现采用了 递归
	 * */
	public static void fastSort(int[] arr,int low,int high){
		
		int l = low;
		int h = high;
		int key = arr[low];
		
		while(l < h){   // 当满足时，才做操作
			// 向 末尾看
			while(l < h && key <= arr[h]){  // 内部有 自减操作，所以要时刻检测
				h--;
			}
			if(key > arr[h]){
				arr[l] = arr[h]; 		// 填坑
				l++;
			}
			// 向 开始看
			while(l < h && key >= arr[l]){  // 内部有 自增操作，所以要时刻检测
				l++;
			}
			if(key < arr[l]){			// 填坑
				arr[h] = arr[l];
				h--;
			}
		}
		arr[l] = key;		// 中间值归位，一次快排完成
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+",");
		}
		System.out.println();
		
		if(l > low) fastSort(arr, low, l-1); // 先执行，完成之后再向下一步
		if(h < high) fastSort(arr, l+1, high);
	}	
}

3. 选择排序的时间复杂度：平均O(n2) 最坏O(n2) 最好O(n2) 空间复杂度 O(1) 不稳定，简单

package test;

public class Index {

	public static void main(String[] args) {
		
		int[] arr = {3,1,5,63,14,1,9,7,6,4,8};
		
		// 调用函数
		selectSort(arr);
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+",");
		}
	}
	/*
	 * 选择排序 ： 选出最小的数 放到 最左边。
	 * 		外循环： 确定从哪里开始循环
	 * 		内循环： 依次遍历后续数组
	 * */
	public static void selectSort(int[] arr){
		
		for(int i = 0;i < arr.length-1;i++){      // 选择应该 被排序的位置，
      
			for(int j = i+1;j < arr.length;j++){  // 依次遍历后续数组，做比较
				
				if(arr[i]>arr[j]){
					int temp = arr[j];
					arr[j] = arr[i];
					arr[i] = temp;
				}
			}
		}
	}
}

4. 插入排序的时间复杂度：平均O(n2) 最坏O(n2) 最好O(n) 空间复杂度 O(1) 稳定，简单

package test;

public class Index {

	public static void main(String[] args) {
		
		int[] arr = {20,18,5,63,14,3,9,7,39,48,8};
		// 调用函数
		BobbSort(arr);
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+",");
		}
	}
	/*
	 * 插入排序：拿一个数插入到 已经排好顺序的 队列中
	 *     外循环： 获取 某一个数
	 * 	         内循环： 后移，并插入
	 * */
	public static void insertSort(int[] arr){
		
		if(arr == null || arr.length<2){
			return ;
		}
		
		for(int i = 1;i < arr.length;i++){   // 默认arr[0]为有序，从arr[1]开始取数据
			
			for(int j = i+1;j > 0;j--){		// 从已排序队列  末尾，向前比较，如果小于交换位置，大于
				
				if(arr[j]>=arr[j-1]){
					break;
				}
				if(arr[j]<arr[j-1]){
					int temp = arr[j];
					arr[j] = arr[j-1];
					arr[j-1] = temp;
				}
			}
		}
	}
}	public static void main(String[] args) {
		
		int[] arr = {20,18,5,63,14,3,9,7,39,48,8};
		// 调用函数
		BobbSort(arr);
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i]+",");
		}
	}
	/*
	 * 插入排序：拿一个数插入到 已经排好顺序的 队列中
	 *     外循环： 获取 某一个数
	 * 	         内循环： 后移，并插入
	 * */
	public static void insertSort(int[] arr){
		
		if(arr == null || arr.length<2){
			return ;
		}
		
		for(int i = 1;i < arr.length;i++){   // 默认arr[0]为有序，从arr[1]开始取数据
			
			for(int j = i+1;j > 0;j--){		// 从已排序队列  末尾，向前比较，如果小于交换位置，大于
				
				if(arr[j]>=arr[j-1]){
					break;
				}
				if(arr[j]<arr[j-1]){
					int temp = arr[j];
					arr[j] = arr[j-1];
					arr[j-1] = temp;
				}
			}
		}
	}
}

选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，

冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。