堆排序、归并排序、快速排序java代码

//堆排序
public class HeapSort {
    //把数组构建成堆结构
    public static void buildHeap(int[] tree,int n){
        int lastnode = tree.length-1;
        int parent = (lastnode - 1 ) / 2;
        for (int i = parent; i >= 0; i--) {  //开始一直往前做heapify()
            heapify(tree, n, i);
        }
    }
    public static void heapify(int[] tree,int n,int nodeindex){
        if(nodeindex>= n ){
            return;
        }
        int leftson = 2 * nodeindex +1 ;
        int rightson = 2 * nodeindex +2;
        int maxindex = nodeindex;
        if(leftson<n&&tree[leftson]>tree[maxindex]){
            maxindex = leftson;
        }
        if ((rightson < n) && (tree[rightson] > tree[maxindex]))
            maxindex = rightson;
        if (maxindex != nodeindex) {
            swap(tree, maxindex, nodeindex);
            heapify(tree, n, maxindex);
        }
    }
    public static void swap(int[] tree,int i,int j){
        int tmp = tree[i];
        tree[i] = tree[j];
        tree[j] = tmp;
    }

    public static void heapSort(int[] tree,int n){
        buildHeap(tree,n);
        for (int i = n - 1; i >= 0; i--) {
            swap(tree, i, 0);
            heapify(tree, i, 0);
        }
    }
    public static void main(String[] args) {
        int arr[]=new int[]{15,29,53,8,4,9,15,86};
        heapSort(arr,arr.length);
        for (int t:
                arr) {
            System.out.print(t+" ");
        }
    }

}
//归并排序
public class MergeSort {

    public static void mergeSort(int[] data){
        sort(data,0,data.length-1);
    }

    public static void sort(int[] arr,int left,int right){
        if(left>=right){
            return;
        }
        //找出中间索引
        int center = (left+right)/2;
        //最左边进行递归
        sort(arr,left,center);
        //对右边进行递归
        sort(arr,center+1,right);
        //合并
        merger(arr,left,center,right);
    }

    /**
     * 将两个数组进行归并，
     * @param data
     * @param left
     * @param center
     * @param right
     */
    public static void merger(int[] data,int left,int center,int right){
        //临时组数
        int tmpArr[] = new int[data.length];
        //右边数组的第一个索引的位置
        int mid = center+1;
        //third记录临时索引的位置
        int third = left;
        //缓存左数组第一个元素的索引
        int temp = left;
        while (left <= center && mid <= right) {
            // 从两个数组中取出最小的放入临时数组
            if (data[left] <= data[mid]) {
                tmpArr[third++] = data[left++];
            } else {
                tmpArr[third++] = data[mid++];
            }
        }
        // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
        while (mid <= right) {
            tmpArr[third++] = data[mid++];
        }
        while (left <= center) {
            tmpArr[third++] = data[left++];
        }
        // 将临时数组中的内容拷贝回原数组中
        // （原left-right范围的内容被复制回原数组）
        while (temp <= right) {
            data[temp] = tmpArr[temp++];
        }
    }

    public static void main(String[] args) {
        int arr[]=new int[]{15,29,53,8,4,9,15,86};
        mergeSort(arr);
        for (int t:
                arr) {
            System.out.print(t+" ");
        }
    }
}
//快速排序
public class QuickSort {
    public static void sort(int[] arr,int low,int high){
        int i,j,temp,t;
        if (low>high){
            return;
        }
        i = low;
        j = high;
        temp = arr[low];//基准位
        while (i<j){
            while (temp<=arr[j]&&i<j){
                j--;
            }
            while (temp>=arr[i]&&i<j){
                i++;
            }
            if (i<j){
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
        }
        arr[low] = arr[i];
        arr[i] = temp;
        sort(arr,low,j-1);
        sort(arr,j+1,high);
    }

    public static void main(String[] args) {
        int arr[]=new int[]{15,29,53,8,4,9,15,86};
        sort(arr,0,arr.length-1);
        for (int t:
                arr) {
            System.out.print(t+" ");
        }
    }
}