排序算法详解-优快云博客

排序类型时间复杂度空间复杂度稳定性

插入O(n^2)O(1)稳定【PS:从当前位置开始向前找如果比前面的数比当前的数大，不断

的将这些数向后移动，最后把当前的数放到比他大的数之前即可]：

import java.util.Scanner;
public class test {
	public static void main(String[] args){
		Scanner cin = new Scanner(System.in);
		int tmp = cin.nextInt();
		int[] arr = new int[tmp];
		for(int i = 0;i < tmp;++ i){
			arr[i] = cin.nextInt();
		}
		insert_Sort(arr);
		
	}

	private static void insert_Sort(int[] arr) {
		// TODO Auto-generated method stub
		
		for(int i = 1;i < arr.length;++ i){
			int j = i-1;
			int tmp = arr[i];
			while(j>=0 && tmp < arr[j]){
				arr[j+1] = arr[j];
				j--;
			}
			arr[j+1] = tmp;
		}
		for(int i = 0;i < arr.length;++ i){
			System.out.print(arr[i]+" ");
		}
	}
}

希尔O(n^2)O(1)不稳定

冒泡O(n^2)O(1)稳定（归冒直插）【PS:n-1次的相邻两个数的相比】：

import java.util.Scanner;
public class test {
	public static void main(String[] args){
		Scanner cin = new Scanner(System.in);
		int tmp = cin.nextInt();
		int[] arr = new int[tmp];
		for(int i = 0;i < tmp;++ i){
			arr[i] = cin.nextInt();
		}
		System.out.println(arr.length+"***");
		bubble_Sort(arr);
		
	}

	private static void bubble_Sort(int[] arr) {
		// TODO Auto-generated method stub
		boolean flag = false;
		for(int i = 0;i < arr.length-1;++ i){
			int tmp;
			for(int j = 0;j<arr.length-1-i;++ j){
				
				if( (j<=arr.length-2)&&(arr[j]>arr[j+1]) ){
					tmp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = tmp;
					flag = true;
				}
			}
			if(!flag)
				break;
		}
		for(int i = 0;i < arr.length;++ i){
			System.out.print(arr[i]+" ");
		}
	}
}

选择O(n^2)O(1)不稳定【PS:和冒泡排序类似，但是交换次数上在冒泡的基础上做了优化

，将当前一趟查找最小的标记下来后再进行交换】：

import java.util.Scanner;
public class test {
	public static void main(String[] args){
		Scanner cin = new Scanner(System.in);
		int tmp = cin.nextInt();
		int[] arr = new int[tmp];
		for(int i = 0;i < tmp;++ i){
			arr[i] = cin.nextInt();
		}
		select_Sort(arr);
		
	}

	private static void select_Sort(int[] arr) {
		// TODO Auto-generated method stub
		
		for(int i = 0;i < arr.length-1;++ i){
			int min = arr[i];
			int vis = i;
			for(int j = i+1;j < arr.length;++ j){
				if(min > arr[j]){
					min = arr[j];
					vis = j;
				}
			}
			if(min != arr[i]){
				int t = arr[i];
				arr[i] = arr[vis];
				arr[vis] = t;
			}
		}
		for(int i = 0;i < arr.length;++ i){
			System.out.print(arr[i]+" ");
		}
	}
}

快排O(Nlongn)O(longn)不稳定[ps:注意在每次进入递归函数的时候都要进行保证

l<r,如果因为快排是不稳定的排序所以在从后向前或者从前向后和当前数字比较时，

要加上=( >= || <= )]:

import java.util.Scanner;

 class zz {
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		while(cin.hasNext()){
			int tmp = cin.nextInt();
			int[] arr = new int[tmp];
			for (int i = 0; i < tmp; ++i) {
				arr[i] = cin.nextInt();
			}
			quick_Sort(arr, 0, arr.length - 1);
			for (int i = 0; i < arr.length; ++i) {
				if(i==arr.length-1){
					System.out.println(arr[i]);
				}else
					System.out.print(arr[i]+" ");
			}
		}
	}
	private static void quick_Sort(int[] arr, int l, int r) {
		// 注意要有l<r的判断
		if(l < r){
			int i = l, j = r;
			int x = arr[i];
			while (i < j) {
				while (i < j && arr[j] >= x)
					j--;
				arr[i] = arr[j];
				while (i < j && arr[i] <= x)
					i++;
				arr[j] = arr[i];
			}
			arr[i] = x;
			quick_Sort(arr, l, i - 1);
			quick_Sort(arr, i + 1, r);
		}
	}
}

归并最坏nlong2nO(long2n)稳定

堆排最好=最坏nlongn O(1)不稳定【PS:通过数组来构造一颗完全二叉树，然后我们

来维护这颗树】：

import java.util.Scanner;
class zz {
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		while(cin.hasNext()){
			int tmp = cin.nextInt();
			int[] arr = new int[tmp];
			for (int i = 0; i < tmp; ++i) {
				arr[i] = cin.nextInt();
			}
			heap_Sort(arr);
			for (int i = 0; i < arr.length; ++i) {
				if(i == arr.length-1){
					System.out.println(arr[i]);
				}else
					System.out.print(arr[i]+" ");
			}
		}
	}
	private static void heap_Sort(int[] arr) {
		int len  = arr.length;
		/* 
	        这里从i = length / 2 -1开始调节，原理是： 
	   i = length /2 - 1是数组元素，以0为根，
	        顺序构造完全二叉树时，最后一个非叶节点 */
		for(int i = len/2 - 1;i >= 0;-- i){
			adjustHeap(arr,i,len);
		}
		for(int i = len-1; i > 0;--i){
			int t = arr[i];
			arr[i] = arr[0];
			arr[0] = t;
			adjustHeap(arr, 0,i-1);
		}
	}
	
	private static void adjustHeap(int[] arr, int i, int len){
		int tmp,child;
		for(tmp = arr[i];2*i+1 < len;i = child){
			//左孩子
			child = 2*i+1;
			//如果满足child + 1 < length 这个是确定不会越界  
	        //这样就观察左孩子与右孩子谁大，若右孩子大，则child 为右孩子，child + 1  
			if(child + 1 < len && arr[child + 1] > arr[child]){  
				child++;  
		    } 
			 //如果孩子节点比父节点大，因为刚才已经确定了arr[child]是左右孩子中的大着  
	        //更新父节点为大值  
	        if(arr[child] > tmp){  
	            arr[i] = arr[child];  
	        } else { //如果父节点是大者，则已经调整好，所以退出循环  
	            break;  
	        }  
	        arr[child] = tmp;
		}
	}
}

各种排序算法的比较