面试中常用的六种排序算法及其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;
     }
 }