通俗理解四大排序算法

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

冒泡  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 tint 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);    /*基线右边的递归*/}}}