（面试排序算法模板）冒泡，选择，插入，快排，归并

冒泡，选择，插入，快排，归并

public class Sort {
    public static void main(String[] args) {
        int[] arr = {3,2,5,1,5,7,4,3,9};
        mergeSort(arr,0 , arr.length-1);
        for(int i = 0 ; i < arr.length ; i++){
            System.out.print(arr[i]+ " ");
        }
    }

//快速排序模板
    public static void quickSort(int[] nums,int left, int  right ){
        if(left >=right) return;
        int pivot = nums[left];
        int i = left-1;
        int j = right+1;
        while(i<j){
            do{i++;}while(nums[i] < pivot);
            do{j--;}while(nums[j]>pivot);
            if(i<j){
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
            }else{
                quickSort(nums,left,j);
                quickSort(nums,j+1,right);
            }
        }
    }



//冒泡排序模板
    public  static void bubbuleSort(int[] nums){
        for(int i = nums.length -1;i >=0 ;i--){
            boolean flag = true;
            for(int j = 0 ; j+1 <= i ; j++){
                if(nums[j]>nums[j+1]){
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                    flag =false;
                }
            }
            if(flag) return;
        }
    }



//插入排序模板
    public  static void insertSort(int[] nums){
        //插入排序思想 比较当前数和前面的数的大小，比前面数字小的时候前面的数字向后移动
        for(int i = 1 ; i < nums.length ;i++){
            for(int j = i; j>=0 ; j--){
                int temp = nums[j];
                while(j>=1  &&  temp<nums[j-1]){
                    nums[j] = nums[j-1];
                    j--;
                }
                nums[j] = temp;
            }
        }
    }


//选择排序模板
    public  static void selectSort(int[] nums){
        //选择排序的思想：从前向后一遍遍历寻找最小的元素交换到第一个节点 ，，然后从前向后遍历寻找第二小的节点换到第二个位置
        for(int i = 0 ; i < nums.length ; i++){
            for(int  j = i+1 ; j< nums.length; j++){
                if(nums[i] > nums[j]){
                    int temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] = temp;
                }
            }
        }

    }



//归并排序模板
    public  static void mergeSort(int[] nums ,int start ,int end ){
        if(start >= end) return;
        int mid  = (start+end)>>1;
        mergeSort(nums,start ,mid);
        mergeSort(nums,mid+1,end);
        merge(nums,start,end,mid);
    }
    public  static void merge(int[] nums ,int start ,int end ,int mid ){
        //合并两个有序的数组
        int k   = start;
        int[] lefts = new int[mid - start +1] ;
        int []rights = new int[end -mid];

        //将原数组中的值拷贝到新的数组当中
        for(int i = start ; i<=mid ;i++){
            lefts[i-start] = nums[i];
        }
        for(int j = mid+1;j<=end;j++){
            rights[j-mid-1] = nums[j];
        }

        //进行两个数组的元素的合并
        int i = 0 ;
        int j = 0 ;

        while(i < lefts.length  && j< rights.length){
            if(lefts[i] > rights[j]){
                nums[k++] = rights[j++];
            }else{
                nums[k++] = lefts[i++];
            }
        }
        while (i<lefts.length){
            nums[k++] = lefts[i++];
        }
        while(j < rights.length){
            nums[k++] = rights[j++];
        }
    }
}