各种常见排序算法（复习）

1.插入排序

import java.util.Scanner;

/**
 * 
 * 作者：张宇翔
 * 创建日期：2017年7月19日 下午12:57:18
 * 描述：插入排序
 * 时间复杂度：
 *       平均情况:O(n^2)
 *       最坏情况:O(n^2)
 *       最好情况:O(n)
 * 空间复杂度：O(1)
 * 稳定性：稳定
 * 复杂性:简单
 */
public class Main {

	private static final int Max=(int) (1e5+10);
	private static int n;
	public static void main(String[] args) {
		InitData();
	}
	private static void InitData(){
		Scanner cin=new Scanner(System.in);
		n=cin.nextInt();
		int []a=new int[n];
		for(int i=0;i<n;i++){
			a[i]=cin.nextInt();
		}
		insert_sort(a);
		for(int i=0;i<n;i++){
			System.out.print(a[i]+" ");
		}
		System.out.println();
	}
	
	//插入排序
	//思想:插入排序法的排序思想就是从数组的第二个元素开始,
	//将数组中的每一个元素按照规则插入到已排好序的数组中以达到排序的目的.
	//一般情况下将数组的第一个元素作为启始元素,从第二个元素开始依次插入.
	//由于要插入到的数组是已经排好序的,
	//所以只是要从右向左找到比插入点(下面程序中的insertNote)小(对升序而言)的第一个数组元素就插入到其后面.
	//直到将最后一个数组元素插入到数组中,整个排序过程就算完成.
	private static int[] insert_sort(int []a){
		int arr[]=a;
		int len=arr.length;
		for(int i=0;i<len;i++){
			int insertnode=arr[i];
			int j=i-1;
			while(j>=0&&insertnode<arr[j]){
				arr[j+1]=arr[j];
				j--;
			}
			arr[j+1]=insertnode;
		}
		return arr;
	}
}

2.希尔排序

import java.util.Scanner;
/**
 * 
 * 作者：张宇翔
 * 创建日期：2017年7月19日 下午8:54:19
 * 描述：希尔排序:
 * 时间复杂度：
 *    最好情况:O(n*log2n)
 *    最坏情况:O(n*log2n)
 * 空间复杂度:O(1)
 * 稳定性:不稳定
 * 复杂性:较复杂
 */
public class Main {

	public static void main(String[] args) {
		
	    Scanner cin=new Scanner(System.in);
	    int n=cin.nextInt();
	    int []a=new int[n];
	    for(int i=0;i<n;i++){
	    	a[i]=cin.nextInt();
	    }
	    int []arr=shell_sort(a);
	    for(int i=0;i<n;i++){
	    	System.out.print(arr[i]+" ");
	    }
	    System.out.println();
	}
	
	//希尔排序：
//	希尔排序也是一种插入排序方法,实际上是一种分组插入方法。
//	先取定一个小于n的整数d1作为第一个增量,把表的全部记录分成d1个组,
//	所有距离为d1的倍数的记录放在同一个组中,在各组内进行直接插入排序；
//	然后,取第二个增量d2(＜d1),重复上述的分组和排序,
//	直至所取的增量dt=1(dt<dt-1<…<d2<d1),
//	即所有记录放在同一组中进行直接插入排序为止。    
	private static int[] shell_sort(int []a){
		int[] arr=a;
		int len=arr.length;
		int gap=len/2;
		while(gap>=1){
			for(int i=gap;i<len;i++){
				int j=i-gap;
				int temp=arr[i];
				while(j>=0&&temp<a[j])
				{
					a[j+gap]=a[j];
					j-=gap;
				}
				a[j+gap]=temp;
			}
			gap/=2;
		}
		return arr;
	}
}

3.冒泡排序

import java.util.Scanner;
/**
 * 
 * 作者：张宇翔
 * 创建日期：2017年7月19日 下午9:02:41
 * 描述：冒泡排序
 * 时间复杂度：
 *       最好情况:O(n)
 *       最坏情况:O(n^2)
 *       平均情况：O(n^2)
 * 空间复杂度:O(1)
 * 稳定性：稳定
 * 复杂性：简单
 */
public class Main {

	public static void main(String[] args) {
		
	    Scanner cin=new Scanner(System.in);
	    int n=cin.nextInt();
	    int []a=new int[n];
	    for(int i=0;i<n;i++){
	    	a[i]=cin.nextInt();
	    }
	    int []arr=bubble_sort(a);
	    for(int i=0;i<n;i++){
	    	System.out.print(arr[i]+" ");
	    }
	    System.out.println();
	}
	//冒泡排序
	//思想：通过无序区中相邻记录关键字间的比较和位置的交换,
	//使关键字最小的记录如气泡一般逐渐往上“漂浮”直至“水面”。 
	private static int[] bubble_sort(int []a){
		int len=a.length;
		for(int i=0;i<len;i++){
			for(int j=i+1;j<len;j++){
				if(a[i]>a[j]){
					int temp=a[j];
					a[j]=a[i];
					a[i]=temp;
				}
			}
		}
		return a;
	}
}

4.选择排序

import java.util.Scanner;
/**
 * 
 * 作者：张宇翔
 * 创建日期：2017年7月19日 下午9:02:41
 * 描述：选择排序
 * 时间复杂度：
 *       最好情况:O(n^2)
 *       最坏情况:O(n^2)
 *       平均情况：O(n^2)
 * 空间复杂度:O(1)
 * 稳定性：不稳定
 * 复杂性：简单
 */
public class Main {

	public static void main(String[] args) {
		
	    Scanner cin=new Scanner(System.in);
	    int n=cin.nextInt();
	    int []a=new int[n];
	    for(int i=0;i<n;i++){
	    	a[i]=cin.nextInt();
	    }
	    int arr[]=select_sort(a);
	    for(int i=0;i<n;i++){
	    	System.out.print(arr[i]+" ");
	    }
	    System.out.println();
	}
	
	//选择排序
	//首先在未排序序列中找到最小元素，
//	存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，
//	然后放到排序序列末尾。以此类推，直到所有元素均排序完毕。
//	具体做法是：选择最小的元素与未排序部分的首部交换，使得序列的前面为有序。  
	private static int[] select_sort(int []a){
		int len=a.length;
		for(int i=0;i<len;i++){
			int k=i;
			for(int j=i+1;j<len;j++){
				if(a[j]<a[k]){
					k=j;
				}
			}
			if(k!=i){
				int temp=a[k];
				a[k]=a[i];
				a[i]=temp;
			}
		}
		return a;
	}
	

5.快速排序

/**
 * 
 * 作者：张宇翔
 * 创建日期：2017年7月19日 下午9:02:41
 * 描述：快速排序
 * 时间复杂度：
 *       最好情况:O(n*log2n)
 *       最坏情况:O(n^2)
 *       平均情况：O(n*log2n)
 * 空间复杂度:O(logn)~O(n)
 * 稳定性：不稳定
 * 复杂性：较复杂
 */
public class Main {

	public static void main(String[] args) {
		
	    Scanner cin=new Scanner(System.in);
	    int n=cin.nextInt();
	    int []a=new int[n];
	    for(int i=0;i<n;i++){
	    	a[i]=cin.nextInt();
	    }
	    quick_sort(a,0,a.length-1);
	    for(int i=0;i<n;i++){
	    	System.out.print(a[i]+" ");
	    }
	    System.out.println();
	}
	//快速排序
	//它是由冒泡排序改进而来的。
//	在待排序的n个记录中任取一个记录(通常取第一个记录),把该记录放入适当位置后,
//	数据序列被此记录划分成两部分。所有关键字比该记录关键字小的记录放置在前一部分,
//	所有比它大的记录放置在后一部分,
//	并把该记录排在这两部分的中间(称为该记录归位),这个过程称作一趟快速排序。
	//说明：最核心的思想是将小的部分放在左边，大的部分放到右边，实现分割。         
	private static void quick_sort(int []a,int left,int right){
		if(left<right){
			int temp=a[left];
			int low=left;
			int high=right;
			while(low<high){
				while(low<high&&a[high]>temp){
					high--;
				}
			    if(low<high){
			    	a[low++]=a[high];
			    }
			    while(low<high&&a[low]<temp){
			    	low++;
			    }
			    if(low<high){
			    	a[high--]=a[low];
			    }
			}
			a[low]=temp;
			quick_sort(a, left, low-1);
			quick_sort(a, low+1, right);
		}
	}
	
}

6.基数排序

import java.util.Scanner;
/**
 * 
 * 作者：张宇翔
 * 创建日期：2017年7月24日 上午8:43:44
 * 描述：基数排序
 * 时间复杂度：最好情况O(d(n+r)
 *         最坏情况：O(d(n+r))
 *         平均情况：O(d(n+r))
 * 空间复杂度：O（n+r）
 * 稳定性:稳定
 */
public class Main{

	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);
		int n;
		n=cin.nextInt();
		int []a=new int [n];
		for(int i=0;i<n;i++){
			a[i]=cin.nextInt();
		}
		int len=a.length;
		int []t=Sort(a);
		for(int i=0;i<t.length;i++){
			System.out.print(t[i]+" ");
		}
	}
	
	private static int[] Sort(int []array){
		if(array==null){
			return null;
		}
		int MAXLENGTH=MaxLength(array);
		return sortcore(array,0,MAXLENGTH);
	}
	
	private static int[] sortcore(int []array,int digit,int Maxlength){
		if(digit>=Maxlength){
			return array;
		}
		int arraylength=array.length;
		int radix=10;
		int []count=new int[radix];
		int []bucket=new int[arraylength];
		for(int i=0;i<arraylength;i++){
			count[getDigit(array[i], digit)]++;
		}
		for(int i=1;i<radix;i++){
			count[i]+=count[i-1];
		}
		for(int i=arraylength-1;i>=0;i--){
			int number=array[i];
			int d=getDigit(number, digit);
			bucket[count[d]-1]=number;
			count[d]--;
		}
		return sortcore(bucket, digit+1, Maxlength);
	}
	private static int MaxLength(int []array){
		int len=array.length;
		int MAX=Integer.MIN_VALUE;
		for(int i=0;i<len;i++){
			MAX=Math.max(MAX, length(array[i]));
		}
		return MAX;
	}
	private static int length(int x){
		return String.valueOf(x).length();
	}
	private static int getDigit(int x,int d){
		int []a=new int[]{1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
		return ((x/a[d])%10);
	}
}

7.堆排序

/**
 * 
 * 作者：张宇翔 创建日期：2017年8月12日 下午2:42:10 描述：ACM
 * 时间复杂度：O（n*logn）
 * 空间复杂度:O(1)
 * 稳定性:不稳定
 * 
 */
public class AndroidTest {

	public static void main(String[] args) {
		int array[]=new int[]{1,5,3,4,2,6,7};
		sort(array);
		for(int i=0;i<array.length;i++){
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	private static void adjustHeap(int []array,int parent,int length){
		int temp=array[parent];
		int child=parent*2+1;
		while(child<length){
			if(child+1<length&&array[child]<array[child+1]){
				child++;
			}
			if(array[child]<=temp){
				break;
			}
			array[parent]=array[child];
			parent=child;
			child=parent*2+1;
		}
		array[parent]=temp;
	}
	private static void sort(int array[]){
		int length=array.length;
		int size=length/2-1;
		for(int i=size;i>=0;i--){
			adjustHeap(array, i, length);
		}
		for(int i=length-1;i>=1;i--){
			int temp=array[i];
			array[i]=array[0];
			array[0]=temp;
			adjustHeap(array, 0, i);
		}
	}
}