通俗理解四大排序算法

/*
排序：分为内部排序和外部排序
内部排序：处理的所有数据都加载到内部存储器中进行排序（交换式、选择式、插入式）
交换式排序分为：冒泡排序、快速排序
外部排序：数据量过大，无法全部加载到内部存储器，需借助外部存储进行排序（合并排序、直接合并排序）
*/

冒泡  79 56 90 4 32 27 16 88 35

1. 79 90 56 32 27 16 88 35 4    i和i+1比较，小的向后放，一趟选出一个最小的。
2. 90 79 56 32 27 88 35 16 4
3. 90 79 56 32 88 35 27 16 4
4. 90 79 56 88 35 32 27 16 4
5. 90 79 88 56 35 32 27 16 4
6. 90 88 79 56 35 32 27 16 4

选择 79 56 90 4 32 27 16 88 35

1. 4 56 90 79 32 27 16 88 35   在整个序列中找到最小的，然后与假定的min交换位置，min一般是a[i]。
2. 4 16 90 79 32 27 56 88 35
3. 4 16 27 79 32 90 56 88 35
4. 4 16 27 32 79 90 56 88 35
5. 4 16 27 32 35 90 56 88 79
6. 4 16 27 32 35 56 90 88 79
7. 4 16 27 32 35 56 79 88 90

插入  79 56 90 4 32 27 16 88 35

1. 56 79 90 4 32 27 16 88 35    a[i]和前面的有序数列比较，比它大的就替换位置，坐标前移一位，继续比较最后插入
2. 56 79 90 4 32 27 16 88 35
3. 4 56 79 90 32 27 16 88 35
4. 4 32 56 79 90 27 16 88 35
5. 4 27 32 56 79 90 16 88 35
6. 4 16 27 32 56 79 90 88 35
7. 4 16 27 32 56 79 88 90 35
8. 4 16 27 32 35 56 79 88 90  

快速 79 56 90 4 32 27 16 88 35

1. 35 56 16 4 32 27 79 88 90     一趟完成以79为基线，左右填坑，
2. 27 32 16 4 35 56 79 88 90      递归进行逐渐小范围的排序
3. 4 16 27 32 35 56 79 88 90 

/*20161210*/

import java.util.Calendar;

public class Sort{

	public static void main ( String[] args){
		/*	int len=100000;
			int[] arr=new int[len];;
			for(int i=0;i<len;i++){
				//random number(0-1) is t
				int t=(int)(Math.random()*100000);
				arr[i]=t;
			}
		*/	int[] arr={79,56,90,4,32,27,16,88,35};
			Bubble bub=new Bubble();
		/*	Calendar cal=Calendar.getInstance();
			System.out.println("begin"+cal.getTime());
			bub.bubblesort(arr);
			cal=Calendar.getInstance();
			System.out.println("end"+cal.getTime());
			
			cal=Calendar.getInstance();
			System.out.println("begin"+cal.getTime());
			bub.selectsort(arr);
			cal=Calendar.getInstance();
			System.out.println("end"+cal.getTime());
			
			Calendar cal=Calendar.getInstance();
			System.out.println("begin"+cal.getTime());
			bub.insertsort(arr);
			cal=Calendar.getInstance();
			System.out.println("end"+cal.getTime());
		*/
			bub.quicksort(0,arr.length-1,arr);
			
			
	}
}

/*冒泡排序算法*/

class Bubble{
		public void bubblesort(int arr[])
		{
			int temp=0;
			for(int i=0;i<arr.length-1;i++)
			{
				for(int j=0;j<arr.length-1-i;j++)
				{
					if (arr[j]<arr[j+1])   /*一趟中通过两两比较，将最小的数放在最右*/
					{
						temp=arr[j];
						arr[j]=arr[j+1];
						arr[j+1]=temp;					
					}
				}
  /*下面函数是为了打印出每一趟过后，序列的状态，方便理解各个排序算法*/
		/*	System.out.print(i+1+":"+" ");	
				for(int y=0;y<arr.length;y++)
				{
					System.out.print(arr[y]);
					System.out.print(" ");   
				}		
			System.out.println(" ");
			*/
			}
		}

/*选择排序算法*/

		public void selectsort(int arr[])
		{

			for(int i=0;i<arr.length;i++)
			{
				int min=arr[i];
				int flag=i;
				for (int j=i+1;j<arr.length;j++)    /*假设第i个数是最小，然后找到序列中最小的数，与i替换*/
				{
					if (min>arr[j]) 
					{
						min=arr[j];
						flag=j;
					}
				}
				arr[flag]=arr[i];
				arr[i]=min;
/*下面的函数是为了打印出每一趟所排列的序列，方便理解各个算法*/

			/*	System.out.print(i+1+":"+" ");	
				for(int y=0;y<arr.length;y++)
				{
					System.out.print(arr[y]);
					System.out.print(" ");   
				}		
			System.out.println(" ");
			*/
			}			
		}

/*插入算法*/

		public void insertsort(int arr[]){

			for (int i=0;i<arr.length;i++ ) {
					int insertnum=arr[i];
					int index=i-1;
				while(index>=0&&insertnum<arr[index]){  /*从第i个数，开始插入前面的有序数列*/
				
				 arr[index+1]=arr[index];
				 index--;
				}
				
				

				arr[index+1]=insertnum;
			/*		System.out.print(i+1+":"+" ");	
				for(int y=0;y<arr.length;y++)
				{
					System.out.print(arr[y]);
					System.out.print(" ");   
				}		
			System.out.println(" ");
			*/
			}
		}

/*快速排序算法*/

		public void quicksort(int left , int right, int arr[]){
			if(left<right){
			int flag=arr[left];
			int i=left;
			int j=right;
			while(i<j)
			{

				while(i<j&&flag<=arr[j])    /*从右边开始寻找比基数小的数，去填基数占的坑*/
				{
					j--;
				}
				if(i<j){
					arr[i++]=arr[j];
				}
				
				while(i<j&&flag>=arr[i])    /*从刚才填的坑左边开始寻找比基数大的数，去填上边留下的坑*/
				{
					i++;
				}
				if(i<j){
					arr[j--]=arr[i];
				}				
			}
			arr[i]=flag;                        /*最后将基数插入该放的位置*/

/*打印出每一趟的序列状态*/
		/*	System.out.print(i+1+":"+" ");	
				for(int y=0;y<arr.length;y++)
				{
					System.out.print(arr[y]);
					System.out.print(" ");   
				}		
			System.out.println(" ");
                 */
			quicksort( left, i-1,arr);      /*基线左边的递归*/
			quicksort( i+1, right, arr);    /*基线右边的递归*/
		}
	}
}