排序有几种方法
内部排序和外部排序：
  若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序；
  反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。
排序算法是数据结构的东西
冒泡：依次比较相邻的两个数，将小数放在前面，大数放在后面，重复以上过程，仍从第一对数开始比较，优化：当没有移动时就说明已排序好了。直接终止就行了。
优点：稳定，比较次数已知；
  缺点：慢，每次只能移动相邻两个数据，移动数据的次数多。
Java代码
1. public class BubbleSort { 
2.     public static void bubbleSort(int[] array) { 
3.         int length = array.length - 1; 
4.         for (int out = length; out > 0; out--) { 
5.             for (int in = 0; in < out; in++) { 
6.                 if (array[in] > array[in + 1]) { 
7.                     int s = array[in]; 
8.                     array[in] = array[in + 1]; 
9.                     array[in + 1] = s; 
10.                 } 
11.             } 
12.         } 
13.     } 
14.  
15. } 
16.
public class BubbleSort {
    public static void bubbleSort(int[] array) {
        int length = array.length - 1;
        for (int out = length; out > 0; out--) {
            for (int in = 0; in < out; in++) {
                if (array[in] > array[in + 1]) {
                    int s = array[in];
                    array[in] = array[in + 1];
                    array[in + 1] = s;
                }
            }
        }
    }
}

插入：已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需
将二者合并成一个升序数列。首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。b[2]~b[m]用相同方法插入。（若无数组a，可将b[1]当作n=1的数组a）
优点：稳定，快；
  缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。
Java代码
1. public class InsertSort { 
2.     public static void sort(int[]array){ 
3.         int length=array.length; 
4.         for(int out=1;out<length;out++){ 
5.             int temp=array[out]; 
6.             int in=out; 
7.             while(in>0&&array[in-1]>temp){ 
//向后移 
8.                 array[in]=array[in-1]; 
9.                 --in; 
10.             } 
//在适当的位置插入
11.             array[in]=temp; 
12.         } 
13.     } 
14. }  public class InsertSort {
    public static void sort(int[]array){
        int length=array.length;
        for(int out=1;out<length;out++){
            int temp=array[out];
            int in=out;
            while(in>0&&array[in-1]>temp){
                array[in]=array[in-1];
                --in;
            }
            array[in]=temp;
        }
    }
}

选择：首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。再比较a[1]与a[3]的值，若a[1]大于a[3]则交换两者的值（其实并不用交换只要记录现在最小的序列，最后一起交换），否则不变。再比较a[1]与a[4]，以此类推，。这样处理一轮后，a[1]的值一定是这组数据中最小的。再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是a[2]~a[n]中最小的。再将a[3]与a[4]~a[n]以相同方法比较一轮，以此类推。便可以排序出来了。
优点：稳定，比较次数与冒泡排序一样；
缺点：相对之下还是慢。
Java代码
1. public class SelectSort { 
2.     public static void sort(int[]array){ 
3.         for(int out=0;out<array.length-1;out++){ 
4.             int min=out; 
5.             for(int in=out+1;in<array.length;in++){ 
6.                 if(array[in]<array[min]){ 
//记录下现在最小的元素的索引 
7.                     min=in; 
8.                 } 
9. 冒泡排序java代码详解            } 
//最后统一进行交换
10.             int t =array[out]; 
11.             array[out]=array[min]; 
12.             array[min]=t; 
13.         } 
14.     } 
15. } 
public class SelectSort {
    public static void sort(int[]array){
        for(int out=0;out<array.length-1;out++){
            int min=out;
            for(int in=out+1;in<array.length;in++){
                if(array[in]<array[min]){
                    min=in;
                }
            }
            int t =array[out];
            array[out]=array[min];
            array[min]=t;
        }
    }
}

希尔：已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。发现当n不大时，插入排序的效果很好。首先取一增量d(d<n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、a[2+2d]……列为第二组……，a[d]、a[2d]、a[3d]……列为最后一组以次类推，在各组内用插入排序，然后取d'<d，重复上述操作，直到d=1。
  优点：快，数据移动少；
  缺点：不稳定，d的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取
Java代码
1. public class SheelSort { 
2.     private int[] hs; 
3.  
4.     private int[] a; 
5.      
6.     public void sort(){ 
7.         for(int h:hs){ 
8.             for(int i=h;i<a.length;i++){ 

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。