八种排序算法-Java实现

1.选择排序

基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

代码实现

public class SelectSort {

    /**
     * 选择排序算法
     * 在未排序序列中找到最小元素，存放到排序序列的起始位置  
     * 再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。 
     * 以此类推，直到所有元素均排序完毕。 
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a[]={23,12,45,10,32};
        selectSort(a);
        for (int i=0 ;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }

    }
    public static void selectSort(int num[]){
        int size=num.length;
        int temp=0;

        for(int i=0;i<size;i++){
            int k=i;
            for(int j=size-1;j>i;j--){
                if(num[j]<num[k]){//找到比第i个最小的元素
                    k=j;
                }
            }
            //将最小的元素与第i个交换
            temp=num[k];
            num[k]=num[i];
            num[i]=temp;
        }

    }

}

2.快速排序

• 基本思想：假设我们现在对“6 1 2 7 9 3 4 5 10 8”这个10个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数6作为基准数吧。接下来，需要将这个序列中所有比基准数大的数放在6的右边，比基准数小的数放在6的左边，类似下面这种排列：
  3 1 2 5 4 6 9 7 10 8
  在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位置，假设这个位置是k。现在就需要寻找这个k，并且以第k位为分界点，左边的数都小于等于6，右边的数都大于等于6。

public class QuickSort {

    /**
     * 快速排序算法
     * 开始以0位置为基准数
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a[]={23,12,45,10,32};
        quickSort(a,0,a.length-1);
        for (int i=0 ;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }

    }
    public static void quickSort(int num[],int left,int right){
        int i,j,t,temp;
        if(right<left) return;
        temp=num[left];
        i=left;
        j=right;
        while(i!=j){
            //右边一定要先走
            while(num[j]>=temp&j>i)
                j--;
            //左边开始向右走
            while(num[i]<=temp&j>i)
                i++;
            if(i<j){
                t=num[j];
                num[j]=num[i];
                num[i]=t;
            }
        }
        num[left]=num[i];
        num[i]=temp;
        quickSort(num, left, i-1);
        quickSort(num, i+1, right);     
    }

}

3.插入排序

基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。
**时间复杂度：**O（n^2）.

public class InsertSort {

    /**
     * 插入排序算法
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a[]={23,12,45,10,32};
        insertSort(a);
        for (int i=0 ;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }
    }
    public static void insertSort(int num[]){
        int size=num.length;
        int temp=0;
        int j=0;
        for(int i=0;i<size;i++){
            temp=num[i];
            for(j=i;j>0&&temp<num[j-1];j--){
                num[j]=num[j-1];//后移一位
            }
            num[j]=temp;

        }
    }

}

4.希尔排序

基本思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
**时间复杂度：**O（n^2）.　

public class ShellSort {
    /**希尔排序的原理:根据需求，如果你想要结果从大到小排列，它会首先将数组进行分组，然后将较大值移到前面，较小值
     * 移到后面，最后将整个数组进行插入排序，这样比起一开始就用插入排序减少了数据交换和移动的次数，可以说希尔排序是加强
     * 版的插入排序
     * 拿数组5, 2, 8, 9, 1, 3，4来说，数组长度为7，当increment为3时，数组分为两个序列
     * 5，2，8和9，1，3，4，第一次排序，9和5比较，1和2比较，3和8比较，4和比其下标值小increment的数组值相比较
     * 此例子是按照从大到小排列，所以大的会排在前面，第一次排序后数组为9, 2, 8, 5, 1, 3，4
     * 第一次后increment的值变为3/2=1,此时对数组进行插入排序，
     *实现数组从大到小排
     */
        public static void main(String arg[]){
            int a[]={23,12,45,10,32};
            shellSort(a);
            for (int i=0 ;i<a.length;i++) {
                System.out.print(a[i]+" ");
            }
        }
        public static void shellSort(int[] data) 
        {
            int j = 0;
            int temp = 0;
            //每次将步长缩短为原来的一半
            for (int increment = data.length / 2; increment > 0; increment /= 2)
            {
            for (int i = increment; i < data.length; i++) 
            {
                temp = data[i];
                for (j = i; j >= increment; j -= increment) 
                {
                if(temp > data[j - increment])//如想从小到大排只需修改这里
                {   
                    data[j] = data[j - increment];
                }
                else
                {
                    break;
                }

                } 
                data[j] = temp;
            }       
          }
        }
}

5.冒泡排序

基本思想：冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

public class FloatBallSort {

    /**
     *从小到大顺序排序
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a[]={23,12,45,10,32};
        floatBallSort(a);
        for (int i=0 ;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }
    }
    public static void floatBallSort(int num[]){
        int size=num.length;
        int temp=0;

        for(int i=0;i<size;i++){
            for(int j=size-1;j>i;j--){
                if(num[j]<num[i]){
                    temp=num[i];
                    num[i]=num[j];
                    num[j]=temp;
                }
            }
        }
    }
}

参考文献：
http://www.cnblogs.com/0201zcr/p/4764705.html