排序 冒泡排序 快排 堆排序

package com.example.testdemo.test;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

public class SortTest {


    /**
     * 优化后的冒泡排序
     * @param array
     */
    public static void sort1(int[] array){
        for (int i = 0; i < array.length; i++) {
            int lastExchangeIndex = 0;
            int sortBorder = array.length-1;
            for (int j = 0; j < sortBorder; j++) {
                if(array[j]>array[j+1]){
                    int tmp = array[j];
                    array[j]= array[j+1];
                    array[j+1]=tmp;
                    lastExchangeIndex = j;
                }
            }
            sortBorder=lastExchangeIndex;
        }
    }


    /**
     * 冒泡排序
     */
    public static void sort(int[] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                int tmp = 0;
                if(array[j]> array[j+1]){
                    tmp = array[j];
                    array[j]= array[j+1];
                    array[j+1]=tmp;
                }
            }

        }
    }

    /**
     * 快排 递归方式
     * @param arr
     * @param startIndex
     * @param endIndex
     */
    public static void quickSort(int[] arr,int startIndex,int endIndex){
        //结束递归的条件
        if(startIndex>=endIndex){
            return;
        }
        //得到基准元素的位置
        int pivotIndex = partition(arr,startIndex,endIndex);
        quickSort(arr,startIndex,pivotIndex-1);
        quickSort(arr,pivotIndex+1,endIndex);
    }

    private static int partition(int[] arr, int startIndex, int endIndex) {
        //取第一个的位置的元素作为基准元素（也可以随机取）
        int pivot = arr[startIndex];
        int mark = startIndex;
        //从第二个元素开始比较，如果大于基准元素，则不动，否则要把mark+1，将mark位置的元素和i位置的元素交换位置
        for(int i=startIndex+1;i<=endIndex;i++){
            if(arr[i]<pivot){
                mark++;
                int tmp = arr[mark];
                arr[mark] = arr[i];
                arr[i] = tmp;

            }
        }
        //一轮比较完成后，将基准元素和mark位置的元素交换位置
        arr[startIndex] = arr[mark];
        arr[mark] = pivot;
        return mark;
    }

    /**
     * 快排栈方式实现
     * @param arr
     * @param startIndex
     * @param endIndex
     */
    public static void quickSortStack(int[] arr,int startIndex,int endIndex){
        //用一个集合栈来代替递归函数栈
        Stack<Map<String,Integer>> quickSortStack = new Stack<Map<String,Integer>>();
        //整个数列的起止下标，以hash的形式入栈
        Map rootParam = new HashMap();
        rootParam.put("startIndex",startIndex);
        rootParam.put("endIndex",endIndex);
        quickSortStack.push(rootParam);
        //循环结束条件：栈为空时
        while(!quickSortStack.isEmpty()){
            //栈顶元素出栈，得到起止上下标
            Map<String,Integer> param = quickSortStack.pop();
            //得到基准元素的位置
            int povitIndex = partition(arr,param.get("startIndex"),param.get("endIndex"));
            //把基准元素分成两部分，把每一部分的起止下标入栈
            if(param.get("startIndex")<povitIndex-1){
                Map<String,Integer> leftParam = new HashMap<String, Integer>();
                leftParam.put("startIndex",param.get("startIndex"));
                leftParam.put("endIndex",povitIndex-1);
                quickSortStack.push(leftParam);
            }
            if(povitIndex+1 < param.get("endIndex")){
                Map<String,Integer> rightParam = new HashMap<String, Integer>();
                rightParam.put("startIndex",povitIndex+1);
                rightParam.put("endIndex",param.get("endIndex"));
                quickSortStack.push(rightParam);

            }
        }
    }

    /**
     * 二叉堆 下沉调整
     * @param array
     * @param parentIndex
     * @param length
     */
    public static void downAdjust(int[] array,int parentIndex,int length){
        //tmp保存父节点的值，用于最后的赋值
        int tmp = array[parentIndex];
        int childIndex = 2*parentIndex+1;
        while(childIndex<length){
            //如果有右孩子，且右孩子的值大于左孩子的值，则定位到右孩子
            if (childIndex + 1 < length && array[childIndex+1]>array[childIndex]) {
                childIndex++;
            }
            //如果父节点大于任何一个孩子的值，则直接跳出
            if(tmp>=array[childIndex]){
                break;
            }
            //无须真正交换，单向赋值即可
            array[parentIndex] = array[childIndex];
            parentIndex = childIndex;
            childIndex = 2*childIndex+1;

        }
        array[parentIndex] = tmp;
    }

    /**
     * 堆排序
     * @param array
     */
    public static void heapSort(int[] array){
        //把无序数组构建成最大堆
        for(int i=(array.length-2)/2;i>=0;i--){
            downAdjust(array,i,array.length);
        }
        System.out.println(Arrays.toString(array));
        //循环删除堆顶元素，移到集合尾部，调整堆产生的新的堆顶
        for(int i=array.length-1;i>0;i--){
            //最后一个元素和第一个元素进行交换
            int temp = array[i];
            array[i] = array[0];
            array[0] = temp;
            //下沉调整最大堆
            downAdjust(array,0,i);
        }
    }

    public static void main(String[] args) {
        int[] array = new int[]{5,2,4,3,0,55,66,88,44,65,34,82};
//        sort1(array);
//        quickSortStack(array,0,array.length-1);
        heapSort(array);
        System.out.println(Arrays.toString(array));
    }

}