简单的排序

码农不允许你不知道的简单排序。

快速排序

✨时间复杂度O(nlbn)，最好O(nlbn)，最坏O(n^2)

✨空间复杂度O(nlbn)

✨不稳定

👏经典版

public class QuickSort {
	public static void quickSort(int[] a, int left, int right){
		int i, j,temp;
		i = left;
		j = right;
		if(left>right)return;//排序完成
		temp = a[left]; 			//取第一个元素为标准数据元素
		while(i < j){
		    while(i < j && temp <= a[j])
		    	j--;//在数组的右端扫描
		   while(i < j && a[i] <= temp)  
			   i++;//在数组的左端扫描
		    if(i < j){ //i、j没有相遇时交换
		    	int t=a[i];
		    	 a[i]=a[j]; 
		    	 a[j]=t; } 
	}
		a[left] = a[i];//i、j相遇后把该位置传回给初始基准数的位置
		a[i] = temp;//基准数归位
		quickSort(a, left, i-1); 	//对左端子集合递归
		quickSort(a, i+1, right); 	//对右端子集合递归
	}
public static void main(String[] args) {
	  int[]list= {6,1,2,7,9,3,4,5,10,8};
	   quickSort(list,0,9);
	   for(int i=0;i<list.length;i++) {
		System.out.print(list[i]+" ");
	   }
   }
}

 

👏挖坑版 

public class QuickSort {
	public static void quickSort(int[] a, int low, int high){
		int i, j,temp;
		i = low;
		j = high;
		if(low>high)return;//排序完成
		temp = a[low]; 			//取第一个元素为标准数据元素
		while(i < j){
		    while(i < j && temp <= a[j]) j--;//在数组的右端扫描
		    if(i < j){
		    	a[i] = a[j]; 
		    	i++; 
		    	}//找到比标准量小的交换
		   while(i < j && a[i] <= temp)  i++;//在数组的左端扫描
		    if(i < j){ 
		    	a[j] = a[i];
		    	j--; 
		    	} //找到比标准量大的交换
	   }
		a[i] = temp;
		quickSort(a, low, i-1); 	//对左端子集合递归
		quickSort(a, i+1, high); 	//对右端子集合递归
	}
public static void main(String[] args) {
	 int[]list= {6,1,2,7,9,3,4,5,10,8};
	   quickSort(list,0,9);
		for(int i=0;i<list.length;i++) {
			System.out.print(list[i]+" ");
		}	
	}
}

 

冒泡排序 

✨时间复杂度O(n^2)，最好O(n)，最坏O(n^2)

✨空间复杂度O(1)

✨稳定

      int i,j;
       for (i = 1; i < n; i++) {//趟数n-1趟
			int flag = 0;//标记
			for (j = 0; j < n-i; j++) {
				if (a[j] > a[j + 1]) {//比较大小并交换这两个数
					flag = 1;
					int temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
				}
			}
			if (flag == 0)//找不到要交换的数，就退出循环
				break;
		}
		for ( i = 0; i < n; i++) {
			System.out.print(a[i] + " ");
		}

 

直接插入排序 

✨时间复杂度O(n^2)，最好O(n)，最坏O(n^2)

✨空间复杂度O(1)

✨稳定

        int i,j,temp;
        for(i=1;i<n;i++){//趟数
			temp=a[i];//待插的数
			j=i-1;
			while(j>=0&&a[j]>temp){//待插的数比前一个数小就插入到前面去
					a[j+1]=a[j];
					j--;
			}	
			a[j+1]=temp;	//后往前找，找到已排好的序列中比它小的数，在后面插入
		}
		for ( i = 0; i < n; i++) {
			System.out.print(a[i] + " ");
		}

 

简单选择排序

✨时间复杂度O(n^2)，最好O(n^2)，最坏O(n^2)

✨空间复杂度O(1)

✨不稳定

     for(int i=0;i<n-1;i++){//趟数n-1趟
			        int min = i;
			for (int j=i+1;j<n;j++) {
			            if (a[j] < a[min]) {     // 寻找最小的数
			                min=j;               // 将最小数的保存
			            }
			        }
			        int temp = a[i];
			        a[i] = a[min];
			        a[min] = temp;
			    }
		for ( int i = 0; i <n; i++) {
			System.out.print(a[i] + " ");
		}

 

小结

在原序列接近有序的情况下，最好的情况下直接插入排序与冒泡排序为O(n)，算法效率更高。在原序列无序时，最好的情况下快速排序有着明显的效率优势，尤其是在数据量很大很大的时候，O(nlbn)比O(n^2)快很多。以上为简单的排序算法，多练岂非手撕快排。