常见的排序算法

这段时间刷题总结的排序算法，由于自己是练习，基本没有注释

package com.mzz;

public class Sort {
    public static void main(String[] args) {
        int[] nums=new int[]{11,4,28,6,32,42,34,15,65,23,56,3,87,95,34,1};
        //冒泡排序
        //Main.bubbleSort(nums);
        //选择排序
        //Main.selectSort(nums);
        //插入排序
        //Main.insertSort(nums);
        //归并排序
        //希尔排序
        //Main.shellSort(nums);
        //归并排序
        //Mian.mergeSort(nums, 0, nums.length);
        //快排
        //Main.quickSort(nums, 0, nums.length-1); 
        //Main.showNums(nums);
        //二叉树元素插入
        // Node root=new Node(10);
        // for(int i=0;i<nums.length;i++){
        //     //Node newNode=new Node(nums[i]);
        //     Main.insert(root, nums[i]); 
        // }
        // Main.printBTree(root);
        // System.out.println();
        //堆排序
        // Main.heapSort(nums);
        // Main.showNums(nums);
    }

    public static void showNums(int[] nums){
        for(int i=0;i<nums.length;i++){
            System.out.print(nums[i]+" ");
        }
        System.out.println();
    }
    public static void bubbleSort(int[] nums){
        for(int i=0;i<nums.length;i++){
            for(int j=0;j<nums.length-i-1;j++){
                if(nums[j]>nums[j+1]){
                    int temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
        return;
    }
    public static void selectSort(int[] nums){
        
        for(int i=nums.length-1;i>=0;i--){
            int index=0;
            for(int j=0;j<=i;j++){
                if(nums[index]<nums[j]) index=j;
            }
            int temp=nums[index];
            nums[index]=nums[i];
            nums[i]=temp;
        }
    }
    public static void insertSort(int[] nums){
        for(int i=1;i<nums.length;i+=1){
            int temp=nums[i];
            int j;
            for(j=i-1;j>=0;j-=1){
                if(nums[j]>temp)nums[j+1]=nums[j];
                else break; 
            }
            nums[j+1]=temp;
        }

    }
    public static void shellSort(int[] nums) {
        int h=1;
        while(h<nums.length)h=h*3+1;
        h=(h-1)/3;
        while(h>0){
            for(int i=h;i<nums.length;i+=h){
                int j;
                int temp=nums[i];
                for(j=i-h;j>=0;j-=h){
                    if(nums[j]>temp){
                        nums[j+h]=nums[j];
                    }else{
                        break;
                    }
                }
                nums[j+h]=temp;
            }
            h=(h-1)/3;
        }
    }    
    public static void mergeSort(int[] nums, int low,int high){
        if(high-low==1)return;
        int mid=(high+low)/2;
        mergeSort(nums, low, mid);
        mergeSort(nums, mid, high);
        merge(nums, low, mid, high);

    }
    public static void merge(int[] nums,int low,int mid,int high){
        int left=low;
        int right=mid;
        int index=0;
        int[] temp=new int[high-low];
        while(left<mid&&right<high){
            if(nums[left]<nums[right]){
                temp[index++]=nums[left++];
            }else{
                temp[index++]=nums[right++];
            }
        }
        while(left<mid){
            temp[index++]=nums[left++];
        }
        while(right<high){
            temp[index++]=nums[right++];
        }
        for(int i=0;i<index;i++){
            nums[low++]=temp[i];
        }
        return;
    }
    public static void quickSort(int[] nums,int leftBound,int rightBound){
        int left=leftBound;
        int right=rightBound;
        if(left>=right) return;
        int pivot=nums[rightBound];
        while(left<right){
            while(left<right&&nums[left]<pivot)left++;
            while(left<right&&nums[right]>=pivot)right--;
            if(left>=right)break;
            else{
                int temp=nums[left];
                nums[left]=nums[right];
                nums[right]=temp;
            }
        }
        nums[rightBound]=nums[left];
        nums[left]=pivot;
        quickSort(nums, leftBound, left-1);
        quickSort(nums, left+1, rightBound);
    }
    public static void insert(Node root,int value){
        Node newNode=new Node(value);
        if(root==null){
            root=newNode;
            return;
        }
        Node currentNode=root;
        Node parent;
        while(true){
            parent=currentNode;
            if(currentNode.value<newNode.value){
                currentNode=currentNode.rightNode;
                if(currentNode==null){
                    parent.rightNode=newNode;
                    return;
                }
            }else{
                currentNode=currentNode.leftNode;
                if(currentNode==null){
                    parent.leftNode=newNode;
                    return;
                }
            }
        }
    }
    public static void printBTree(Node root){
        if(root==null)return;
        printBTree(root.leftNode);
        System.out.print(root.value+" ");
        printBTree(root.rightNode);
    }
    public static void insertIntoHeap(int value,int lastIndex,Node[] heapArray){
        Node newNode=new Node(value);
        
        heapArray[lastIndex]=newNode;
        int index=lastIndex;
        while(index>0){
            int parentIndex=(index-1)/2;
            if(heapArray[index].value>heapArray[parentIndex].value){
                int temp=heapArray[index].value;
                heapArray[index].value=heapArray[parentIndex].value;
                heapArray[parentIndex].value=temp;
            }else{
                return;
            }
            index=parentIndex;
        }
    }
    public static void heapSort(int[] nums){
        for(int i=nums.length/2-1;i>=0;i--){//从第一个非叶子节点，依次向首元素方向前进，开始构建大顶堆
            adjustHeap(nums,i,nums.length);
        }//所有循环完毕，说明每个节点的值都大于等于其左右子节点值
        for(int j=nums.length-1;j>=0;j--){
            int temp=nums[j];//将构建的大顶堆的根节点与最后一个节点调换位置
            nums[j]=nums[0];
            nums[0]=temp;
            adjustHeap(nums, 0,j);//由于此时从跟节点到已经排好序节点前的节点中，根节点不满足大顶堆条件，因此需要依次调整
        }
        //每循环完一次，都会将最大元素放到其排完序的最后位置
    }
    private static void adjustHeap(int[] nums, int i,int length) {
        int temp=nums[i];
        for(int j=i*2+1;j<length;j=2*j+1){//从i节点的左子节点开始，即2*i+1开始，向尾元素方向前进
            if(j+1<length&&nums[j]<nums[j+1])//右子节点存在且右子节点大于左子节点时
            {
                j++;
            }
            if(nums[j]>temp){//如果两个子节点最大值大于其父节点
                nums[i]=nums[j];//则将子节点值赋给父节点，相当于最大值子节点向上移
                i=j;//此时最大值子节点变为下一次循环的父节点
            }else{//如果父节点大于子节点，就跳出循环，跳出后将原始开始节点的值方法最后的父节点上
                break;
            }
        }
        nums[i]=temp;//将原始开始节点值放入最后父节点位置。
        //本次循环完，相当于开始的i节点存储的是该节点及左右子树节点中最大值。
    }
   
}
	class Node{
    public int value;
    public Node leftNode;
    public Node rightNode;
    public Node(int value){
        this.value=value;
    }
}