java实现常见的排序算法

下面的代码使用java实现几种常见的排序算法。

package com.yxc.sort;

import sun.security.util.Length;

/**
 * 介绍各种排序算法的java实现、
 * 所以的实现都默认递增排序
 */
public class SortDemo {
    public static void main(String[] args) {
        //所有的排序都是会对下面数组进行排序
        int[] a = new int[]{5,8,9,1,3,0,2,8,7,15,2};
        //swap1(10,7);
        //测试冒泡排序
        //bubblingSort(a);
        //print(a);

        //测试直接插入排序
        //insertSort(a);
        //print(a);

        //测试选择排序
        //selectSort(a);
        //print(a);

         //快速排序
        //quickSort(a,0,a.length-1);
       // print(a);

        shellSort(a);
        print(a);

    }

    /**
     * 冒泡排序
     * 思想：元素从头到尾遍历，一个一个比较，如果前一个元素大于后面一个元素就交换元素
     */
    public static void bubblingSort(int[] a) {
        //循环遍历每一个元素
        for (int i = 0; i < a.length; i++) {
            //内循环从下一个元素开始比较
            for (int j = i + 1; j < a.length; j++) {
                //如果前一个元素大于后面一个元素就交换值
                if (a[i] > a[j]) {
                    swap(a, i, j);  //调用函数
                }
            }
        }
    }

    /**
     * 直接插入排序
     * 思想：每一次选一个待排的元素，然后和前面已经排好序的比较，将它插入到合适的位置
     */
    public static void insertSort(int[] a) {
        //我们从一号元素考试找，因为第一个元素我们默认就是有序的
        int temp = 0;//用来保存待插入的元素
        for (int i = 1; i < a.length; i++) {
            //然后取出a[i]就是待插入的元素，和它前面已经排好序的进行比较
            temp = a[i];
            int j = i - 1;
            //从后往前遍历，如果小于的话，就将当前位置的值往后挪一位
            while (j >= 0 && temp < a[j]) {
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = temp;//最后将待插的元素插在正确的位置
        }
    }

    /**
     * 简单选择排序
     * 思想：每一次从没有排列的元素中选出最大或者最小的元素，然后从前面往后面放置
     */
    public static void selectSort(int[] a){
        for(int i=0;i<a.length;i++){
            int position=i;
            int min=a[i];//首先选定一个最小值
            //后面没有排序的逐个和最小值比较，找到更新 然后记录下标
            for(int j=i+1;j<a.length;j++){
                if(a[j]<min){
                    min=a[j];   //更新最小值
                    position=j; //保存最小值下标
                }
            }
            //将最小值和i位置元素兑换
            a[position]=a[i];
            a[i]=min;
        }
    }

    /***
     * 快速排序
     * 思路：选取一个基准的值，比基准值小的放左边，比基准值大的放右边
     * @param a
     * @param first
     * @param last
     */
    public static void quickSort(int[] a,int first,int last){
        int begin=first;
        int end=last;
        int key=a[begin];//将首元素作为基准值
        while(end>begin){
            //如果基准值在左侧，就从最后开始遍历
            //如果后面的元素一直大于基准值，那么将末尾指针往前挪
            while(begin<end&&(key<=a[end])){
                end--;
            }
            //如果不小于那么就要换位置
            if(key>=a[end]){
                int temp=a[begin];
                a[begin]=a[end];
                a[end]=temp;
            }

            while(begin<end&&(key>=a[begin])){
                begin++;
            }
            if(a[begin]>=key){
                int temp=a[begin];
                a[begin]=a[end];
                a[end]=temp;
            }
        }
        //接下来递归左右两边
       if(first<begin){
           quickSort(a,first,begin-1);
       }
       if(last>end){
           quickSort(a,end+1,last);
       }
    }

    /***
     * 希尔排序 每一次按组排序，不断缩小组的间距，最后一次必须是1
     * 每两个值进行比较大小 交换
     * 当然这是没有优化的，效率不高
     */
    public static void shellSort(int[] a){
        //分组
        for(int r=a.length/2;r>=1;r=r/2){
            //对一组使用直接插入排序
           insertSort(a);
        }

    }

    /**
     * 交换两个数的值,最简单的实现方法
     * 为了实现真正的值交换，而不是在局部实现
     * 我们参数需要传进来一个数组引用
     * @param a
     * @param i
     * @param j
     */
    public static void swap(int[] a,int i,int j){
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }

    /**
     * 使用异或交换两个数的值
     * 如果想要真正的交换，也只是把数组引用传进来，和上面的交换一样
     * @param a
     * @param b
     */
    public static void swap1(int a,int b){
        a=a^b;
        b=a^b;
        a=a^b;
        System.out.println(a);
        System.out.println(b);
    }

    /**
     * 因为排序以后都要打印元素，所以我们定义一个方法来打印元素
     */
    public static void print(int[] a){
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
    }
}