面试中常用的六种排序算法及其Java实现

常见排序算法的时间复杂度以及稳定性：

  1 public class Sort {
    public static void main(String[] args){
        int[] nums=new int[]{2,6,9,4,1,8,5,5,6};
        //SelectSort(nums);
        //BubbleSort(nums);
        //InsertSort(nums);
        //FastSort(nums,0,nums.length-1);
        //MergeSort(nums,0,nums.length-1);
        HeapSort(nums);
        for(int i=0;i<nums.length;i++){
            System.out.print(nums[i]+" ");
        }

    }

    private static void Swap(int[] nums,int i,int j){
        int val=nums[i];
        nums[i]=nums[j];
        nums[j]=val;
    }
    /*
    选择排序
     */
    private static void SelectSort(int[] nums){
        for(int i=0;i<nums.length;i++){
            int index=i;
            for(int j=i+1;j<nums.length;j++){
                if(nums[j]<nums[index]) index=j;
            }
            Swap(nums,i,index);
        }
    }

    /*冒泡排序*/
    private static void  BubbleSort(int[] nums){
        for(int i=nums.length-1;i>0;i--){   //外层循环控制排序的轮数
            boolean isSorted=true;
            for(int j=0;j<i;j++){        //内层循环每次将未排序序列中最大的数冒泡到最后端
                if(nums[j]>nums[j+1]){
                    Swap(nums,j,j+1);
                    isSorted=false;
                }
            }
            if(isSorted) break;
        }
    }

    /*插入排序*/

    private static void InsertSort(int[] nums){
        for(int i=1;i<nums.length;i++){
            int val=nums[i];
            int j=i;
            while(j>0&&nums[j-1]>val){
                nums[j]=nums[j-1];
                j--;
            }
            nums[j]=val;
        }
    }

    /*快速排序*/
    private static void FastSort(int[] nums,int start,int end){
        if(start>=end) return ;
        int val=nums[start];
        int i=start,j=end;
        while(i<j){
            while(i<j&&nums[j]>val){
                j--;
            }
            if(i<j){
                nums[i]=nums[j];
                i++;
            }
            while(i<j&&nums[i]<val){
                i++;
            }
            if(i<j){
                nums[j]=nums[i];
                j--;
            }
        }
        nums[i]=val;
        FastSort(nums,start,i-1);
        FastSort(nums,i+1,end);
    }

    /*归并排序*/
    private static void MergeSort(int[] nums,int start,int end){
        if(start>=end||nums.length==1) return ;
        int mid=start+(end-start)/2;
        MergeSort(nums,start,mid);
        MergeSort(nums,mid+1,end);
        Merge(nums,start,mid,end);
    }
    private static void Merge(int[] nums,int start,int mid,int end){
        int len1=mid-start+1,len2=end-mid;
        int[] left=new int[len1];
        int[] right=new int[len2];
        int i=0,j=0,k=0;
        for(k=start;i<len1;i++,k++){
            left[i]=nums[k];
        }
        for(k=mid+1;j<len2;j++,k++){
            right[j]=nums[k];
        }
        for(k=start,i=0,j=0;i<len1&&j<len2;k++){
            if(left[i]<=right[j]){
                nums[k]=left[i];
                i++;
            }else{
                nums[k]=right[j];
                j++;
            }
        }
        if(i<len1){
            while(i<len1){
                nums[k++]=left[i++];
            }
        }else{
            while(j<len2){
                nums[k++]=right[j++];
            }
        }
    }

    /*堆排序*/
    private static void HeapSort(int[] nums){
        //1.建立堆
        for(int i=nums.length/2-1;i>=0;i--){
            adjustHeap(nums,i,nums.length-1);
        }
        //2.调整堆
        for(int i=nums.length-1;i>0;i--){
            int val=nums[i];
            nums[i]=nums[0];
            nums[0]=val;
            adjustHeap(nums,0,i-1);
        }
    }
    private static void adjustHeap(int[] nums,int pos,int end){
        int temp=nums[pos];
        int child=0;
        for(;2*pos+1<=end;pos=child){
            child=2*pos+1;
            if(child<end&&nums[child+1]>nums[child]){
                child++;
            }
            if(nums[child]>temp){
                nums[pos]=nums[child];
            }
            else break;
        }
        nums[child]=temp;
    }
}