java常见的几种排序

package com.wx.wxlogin.util;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class SortUtil {

    private static Integer[] initArray = {34, 45, 1, 5, 67, 8, 10,2};


    // 冒泡排序
    public static void bubbleSort(Integer[] array) {

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                int pre = array[j];
                int next = array[j + 1];
                if (pre > next) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }

    // 插入排序
    public static void insertSort(Integer[] array) {

        for (int i = 1; i < array.length; i++) {
            //默认i=1 为最大值
            int maxValue = array[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if (array[j] > maxValue) {
                    array[j + 1] =  array[j];
                } else {
                    break;
                }
            }
            array[j + 1] = maxValue;
        }
    }

    // 快排
    public static void quickSort(Integer[] array, Integer low, Integer heigh) {

        if (low > heigh) return;

        Integer left = low, right = heigh, temp = array[low];

        while (right > left) {
            //以左边为基准，右边的先走
            while (right > left && array[right] >= temp) {

                right--;
            }

            while (right > left && array[left] <= temp) {

                left++;
            }

            if (right > left) {
                int a = array[left];
                array[left] = array[right];
                array[right] = a;
            }
        }

        //和基准调换位置
        array[low] = array[right];
        array[right] = temp;

        quickSort(array,low,right - 1);
        quickSort(array,right + 1, heigh);

    }

    /**
     * 堆排序
     * @param array
     */
    public static void heapSort( Integer[] array,int length){

        //1. 计算堆中最后一个非叶子结点
        int node = length / 2 - 1;
        for (int i = node; i >=0 ; i--) {
            headAdJust(array,i,length);
        }
        System.out.println(Arrays.toString(array));

    }

    // 调整堆结构 （堆化）
    public static void headAdJust(Integer[] array,int node,Integer length){
        // 节点值
        int temp = array[node];
        // 左子节点
        int leftNode = node * 2 + 1;

        while (leftNode < length){

            // 判断是否有右子节点，判断左右子节点大小
            if (leftNode + 1 < length && array[leftNode] < array[leftNode + 1]){
                leftNode ++;
            }
            // 判断叶子结点值和当前节点大小
            if (array[leftNode] > temp){
                array[node] = array[leftNode];
                // 节点转换
                node = leftNode;
                array[leftNode] = temp;
                leftNode = 2 * node + 1;
            }else {
                break;
            }
        }

    }

    public static void main(String[] args) {
//        insertSort(initArray);
//        quickSort(initArray,0,initArray.length-1);
//        Stream.of(initArray).forEach(System.out::println);
        heapSort(initArray,initArray.length);
    }
}