闲暇之余有必要再回顾一下经典排序，理一理哈。

冒泡排序：它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。代码中（flag标志是为了当遍历一遍没有比较就结束冒泡标志，而last则是为了第i趟中从前面n-i个元素进行冒泡）当然还有更好的冒泡排序-鸡尾酒排序，大家可以百度一下哈

package 排序方法;import java.util.Scanner;public class SelectBubble {public static void main(String[] args) {Scanner sc = new Scanner(System.in);while (sc.hasNext()) {int count = sc.nextInt();int num[] = new int[count];for (int i = 0; i < count; i++) {num[i] = sc.nextInt();}sort(num);for (int i : num) {System.out.print(i + ",");}}}public static int[] sort(int[] num) {int temp;boolean flag;int last = num.length-1;for (int i = 0; i < num.length; i++) {flag=true;for (int j = 0; j <last ; j++) {if (num[j] > num[j+1]) {// 交换temp = num[j];num[j] = num[j + 1];num[j + 1] = temp;flag = false;}}if (flag)break;last--;}return num;}}

=================================================================================================================================
插入排序：第i趟排序将序列中第i+1个元素K_i+1插入到一个已经按值有序的子序列（K₁，K₂...K_i）中的合适的位置，使得插入后的序列仍然保持按值有序。（注意标志位从已排好的序列最后往前寻找）

package 排序方法;import java.util.Scanner;public class SelectInsert {public static void main(String[] args) {Scanner sc = new Scanner(System.in);        while(sc.hasNext()){        int count = sc.nextInt();        int num[] = new int[count];        for(int i=0;i<count;i++){        num[i]=sc.nextInt();        }         sort(num);         for(int i:num){         System.out.print(i+",");         }        }}public static int[] sort(int[] num){int i,j,temp;for(i =1;i<num.length;i++){ temp =num[i];//j>=0&&temp<num[j]若为假则跳出循环语句 连j--都不执行！for(j=i-1;j>=0&&temp<num[j];j--){num[j+1]=num[j];}//最后j指针停留在比他小的数据num[j+1]=temp;}return num;}}

=====================================================================================================================================
选择排序：第i趟排序从序列的后n-i+1(i=1,2...n-1)个元素中选择一个最小或最大的元素，与该n-i+1个元素的最前面那个元素进行位置交换，直到i=n-1（每一趟的选择排序就是从序列中 未排序的元素中选择一个最小或最大的元素，将该元素与未排序元素的第一个元素交换位置）说白了就是每次从剩余数组中选择一个最小的。

package 排序方法;import java.util.Scanner;public class SelectSort {public static void main(String[] args) {Scanner sc = new Scanner(System.in);         while(sc.hasNext()){         int count = sc.nextInt();         int num[] = new int[count];         for(int i=0;i<count;i++){         num[i]=sc.nextInt();         }          sort(num);          for(int i:num){          System.out.print(i+",");          }         }}public static int[] sort(int[] num){for(int i=0;i<num.length;i++){int min=num[i];int temp =i;//找出最小值for(int j =i+1;j<num.length;j++){ if(min>num[j]){ min=num[j]; temp=j; }}//交换num[temp]=num[i];num[i]=min;}return num;}}

======================================================================================================================================

快速排序：在当前的排序序列(K₁，K_2......K_n)中任意选取一个元素，把该元素称为基准元素或支点，把小于等于基准元素的所有元素都移动到基准元素的前面，把大于基准元素的所有元素都移动到基准元素的后面，这样使得基准元素的位置正好处于排序后的最终位置，并且把当前参加排序的序列分为前后两个子序列，接下来分别对这两个子序列重复上述操作，直至子序列长度为1。（是冒泡排序的改进，此方法采用分治思想。当然基准元素也可以选择middle元素），当然重复操作我们采用递归方法，这样代码更加简洁。最后注意一下j和i的位置

package 排序方法;import java.util.Scanner;public class SelectQuick {/** * @param args */public static void main(String[] args) {Scanner sc = new Scanner(System.in);while (sc.hasNext()) {int count = sc.nextInt();int num[] = new int[count];for (int i = 0; i < count; i++) {num[i] = sc.nextInt();}sort(num,0,count);for (int i : num) {System.out.print(i + ",");}}}public static void sort(int[] num,int left,int right) {int k;if(left<right){k=Part(num,left,right);sort(num,left,k-1);sort(num,k+1,right);}}public static int Part(int [] num,int left,int right){int i=left,j=right;int zhou= num[left];int temp;do{do i++;while(i<j&&num[i]<zhou);//找到>=zhou的数do j--;while(num[j]>zhou);//找到<=zhou的数//交换 i,jif(i<j){temp =num[i];num[i]=num[j];num[j]=temp;}}while(i<j);//将轴与j兑换    num[left]=num[j];num[j]=zhou;return j;//返回中轴位置}}

===================================================================================================================

归并排序：是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。我们用递归将数组逐步二分成单个数据的数组，然后不断合并数组，这里牵涉到两个有序数组合合并成有序数组问题，可以分别用两个指针指向两个数组，比较a[i]和b[j] ，谁小谁指针++，并将小的放入临时数组。如此往下。

package 排序方法;import java.util.Scanner;public class SelectMerge {public static void main(String[] args) {Scanner sc = new Scanner(System.in);        while(sc.hasNext()){        int count = sc.nextInt();        int num[] = new int[count];        for(int i=0;i<count;i++){        num[i]=sc.nextInt();        }        sort(num,0,count-1);         for(int i:num){         System.out.print(i+",");          }        }}public static void sort(int[] num,int left,int right){if(left<right){int mid = (left+right)/2;sort(num,left,mid);sort(num,mid+1,right);//将left和right合并Merge(num,left,mid,right);}  }//将两个排好序的子串 合并成一个整串public static void Merge(int[] num,int left,int mid,int right){int i=left,j=mid+1;int m=0;int temp[] =new int[right-left+1];//等长度部分处理while((i<=mid)&&(j<=right)){if(num[i]<num[j]){   temp[m]=num[i];   i++;     }else{temp[m]=num[j];j++;}m++;}//余长处理while(i<=mid){temp[m++]=num[i++];}while(j<=right){    temp[m++]=num[j++];}//将temp排序好的复制到num中区int n=0;for(int x=left;x<=right;x++){num[x]=temp[n++];}}}

============================================================================================================================

堆排序：堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。（堆排序分为两个操作：（1）初始序列建堆（大根堆或者小根堆）操作（2）剔除到最小或者最大元素然后堆调整）

建堆过程_小顶堆（[49,38,65,97,76,13,27,49]也就是 i节点和2i+1和2i+2 比较，进行不断调整。如果有次不用调整了，则建堆完成，一般是从n/2个节点往前面调整，因为这个节点的孩子就是整个数组的最后一个）

调整堆的过程_小顶堆（根元素（最小）与最后一个元素交换，输出最后一个元素，然后对前面n-1个元素进行堆调整。重复（n-1）次操作）

package 排序方法;import java.util.Scanner;public class SelectDui {public static void main(String[] args) {Scanner sc = new Scanner(System.in);while (sc.hasNext()) {int count = sc.nextInt();int num[] = new int[count];for (int i = 0; i < count; i++) {num[i] = sc.nextInt();}JianDui(num, 0, count - 1);}}// 建最小堆语句 {16 4 10 14 7 9 3 2 8 1}public static void JianDui(int num[], int left, int right) {int l = right + 1;int i = left;int temp;boolean flag = true;//这个循环最坏时间为lognwhile (i <= (left + right) / 2) {// 将最小的数字放到根节点if ((2 * i + 1 < l) && (num[i] > num[2 * i + 1])) {temp = num[i];num[i] = num[2 * i + 1];num[2 * i + 1] = temp;flag = false;}if ((2 * i + 2 < l) && (num[i] > num[2 * i + 2])) {temp = num[i];num[i] = num[2 * i + 2];num[2 * i + 2] = temp;flag = false;}i++;}// 没有排好继续排//这个递归至多n次 故建堆操作最坏时间复杂度为（nlogn）if (!flag)JianDui(num, left, right);//正规方法 不需要多余辅助空间    // 正规方法：输出堆顶元素，然后将堆顶元素与最后一个元素兑换，减掉最后一个元素，对前一段进行从上等到下调整// 没输出一个元素又要调整堆，故复杂度仍然nlogn;else{System.out.print(num[left]+",");//交换到末尾if(right>=1){int temp1= num[left];num[left]=num[right];num[right]=temp1;JianDui(num, 0,--right);}}}}

=====================================================================================================================

好啦，还有一些排序方法时间问题就不罗列了，最后我们来看下算法的复杂度比较。