八大排序算法java

本文只介绍算法实现的代码，默认都这一已经理解算法思想，若不理解可以参考八大排序算法思想

  //交换两个数
    public static void swap(int[] arr,int i,int j){
        arr[i]=arr[i]^arr[j];
        arr[j]=arr[i]^arr[j];
        arr[i]=arr[i]^arr[j];
    }

    //冒泡排序
    public static void bubbleSort(int[] arr){
        if (arr == null || arr.length == 0) {
            return;
        }
        for (int i=0;i<arr.length;i++){
            for (int j=0;j<arr.length-i-1;j++){
                if (arr[j]>arr[j+1])
                swap(arr,j,j+1);
            }
        }
    }

    //选择排序
    public static void selectSort(int[] arr){
        if (arr == null || arr.length == 0) {
            return;
        }
        for (int i=0;i<arr.length-1;i++){
            int index=i;
            for (int j=i+1;j<arr.length;j++){
                if (arr[j]<arr[index])
                    index=j;
            }
            if (index!=i)
                swap(arr,i,index);
        }
    }

    //插入排序
    public static void insertSort(int[] arr){
        if (arr == null || arr.length == 0) {
            return;
        }
        for (int i=0;i<arr.length;i++){
            int tmp=arr[i],j;
            for (j = i-1 ; j >= 0 && arr[j] > tmp ; j--){
                arr[j+1]=arr[j];
            }
            arr[j+1]=tmp;
        }
    }

    //快速排序:礼尚往来
    public static void quickSort(int[] arr,int low,int high){
        if (arr == null || arr.length == 0) {
            return;
        }

        int start=low;
        int end=high;
        int key=arr[low];
        while (end > start) {
            //从后往前比较
            while (end > start && arr[end] >= key)
                end--;
            if (arr[end] < key)
                swap(arr,start,end);

            //从前往后比较
            while (end > start && arr[start] <= key)
                start++;
            if (arr[start] > key)
                swap(arr,start,end);
        }

        //递归
        if (start > low)
            quickSort(arr,low,start-1);
        if (end < high)
            quickSort(arr,end+1,high);
    }


    //堆排序
    //构建大根堆:将arr看成完全二叉树的顺序存储结构
    private static   int[] buildMaxHeap(int[] arr){
        //从最后一个节点arr.length-1的父节点(arr.length-1-1)/2开始，开始知道根节点，反复调整堆
        for(int i=(arr.length-2)/2;i>=0;i--){
            adjustDownToUp(arr,i,arr.length);
        }
        return arr;
    }

    //将元素arr[k]自下往上逐步调整树形结构
    private static void adjustDownToUp(int[] arr,int k,int length){
        int tmp=arr[k];
        for (int i=2*k+1;i<=length-1;i=2*i+1){      //i为初始化为节点k的左孩子，沿节点较大的子节点向下调整
            if (i<length-1 && arr[i]<arr[i+1])      //取节点较大的子节点的下标
                i++;                                //如果节点的右孩子>左孩子，则取右孩子节点的下标
            if (tmp>=arr[i])                        //根节点 >=左右子女中关键字较大者，调整结束
                break;
            else {                                  //根节点 <左右子女中关键字较大者
                arr[k]=arr[i];                      //将左右子结点中较大值array[i]调整到双亲节点上
                k=i;                                //【关键】修改k值，以便继续向下调整
            }

        }
        arr[k]=tmp;                                 //被调整的结点的值放人最终位置
    }

    //堆排序
    public static void heapSort(int[] arr){
        if (arr == null || arr.length == 0) {
            return;
        }

        arr=buildMaxHeap(arr);                      //初始建堆，array[0]为第一趟值最大的元素
        for (int i=arr.length-1;i>=1;i--){
            swap(arr,0,i);
            adjustDownToUp(arr,0,i);
        }
    }


    //希尔排序
    public static void shellSort(int arr[]){
        if (arr == null || arr.length == 0) {
            return;
        }

        //设置增量
        int increment=arr.length/2;
        while (increment >= 1) {
            for (int i=0;i<arr.length;i++){
                //进行插入排序
                for (int j=i;j<arr.length-increment;j+=increment){
                    if (arr[j]>arr[j+increment])
                        swap(arr,j,j+increment);
                }
            }
            //设置新的增量
            increment/=2;
        }
    }

    //归并排序
    public static void mergeSort(int[] arr,int low,int high){
        int mid=(low+high)>>1;
        if (low < high) {
            //左边
            mergeSort(arr,low,mid);
            //右边
            mergeSort(arr,mid+1,high);
            //左右归并
            merge(arr,low,mid,high);
        }
    }

    public static void merge(int[] arr,int low,int mid,int high){
        int[] tmpArr=new int[high-low+1];
        int i=low;      //左指针
        int j=mid+1;    //右指针
        int k=0;

        //把较小的数先移到新数组中
        while (i <= mid && j <= high) {
            if (arr[i]<arr[j])
                tmpArr[k++]=arr[i++];
            else
                tmpArr[k++]=arr[j++];
        }
        //把左边剩余的数移入数组
        while (i <= mid)
            tmpArr[k++]=arr[i++];
        //把右边剩余的数移入数组
        while (j <= high)
            tmpArr[k++]=arr[j++];
        //把新数组中的数覆盖到原数组
        for (int k2=0;k2<tmpArr.length;k2++)
            arr[k2+low]=tmpArr[k2];
    }