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

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

  1 public class Sort {
  2     public static void main(String[] args){
  3         int[] nums=new int[]{2,6,9,4,1,8,5,5,6};
  4         //SelectSort(nums);
  5         //BubbleSort(nums);
  6         //InsertSort(nums);
  7         //FastSort(nums,0,nums.length-1);
  8         //MergeSort(nums,0,nums.length-1);
  9         HeapSort(nums);
 10         for(int i=0;i){
 11             System.out.print(nums[i]+" ");
 12         }
 13 
 14     }
 15 
 16     private static void Swap(int[] nums,int i,int j){
 17         int val=nums[i];
 18         nums[i]=nums[j];
 19         nums[j]=val;
 20     }
 21     /*
 22     选择排序
 23      */
 24     private static void SelectSort(int[] nums){
 25         for(int i=0;i){
 26             int index=i;
 27             for(int j=i+1;j){
 28                 if(nums[j]j;
 29             }
 30             Swap(nums,i,index);
 31         }
 32     }
 33 
 34     /*冒泡排序*/
 35     private static void  BubbleSort(int[] nums){
 36         for(int i=nums.length-1;i>0;i--){   //外层循环控制排序的轮数
 37             boolean isSorted=true;
 38             for(int j=0;j//内层循环每次将未排序序列中最大的数冒泡到最后端
 39                 if(nums[j]>nums[j+1]){
 40                     Swap(nums,j,j+1);
 41                     isSorted=false;
 42                 }
 43             }
 44             if(isSorted) break;
 45         }
 46     }
 47 
 48     /*插入排序*/
 49 
 50     private static void InsertSort(int[] nums){
 51         for(int i=1;i){
 52             int val=nums[i];
 53             int j=i;
 54             while(j>0&&nums[j-1]>val){
 55                 nums[j]=nums[j-1];
 56                 j--;
 57             }
 58             nums[j]=val;
 59         }
 60     }
 61 
 62     /*快速排序*/
 63     private static void FastSort(int[] nums,int start,int end){
 64         if(start>=end) return ;
 65         int val=nums[start];
 66         int i=start,j=end;
 67         while(i<j){
 68             while(ival){
 69                 j--;
 70             }
 71             if(i<j){
 72                 nums[i]=nums[j];
 73                 i++;
 74             }
 75             while(ival){
 76                 i++;
 77             }
 78             if(i<j){
 79                 nums[j]=nums[i];
 80                 j--;
 81             }
 82         }
 83         nums[i]=val;
 84         FastSort(nums,start,i-1);
 85         FastSort(nums,i+1,end);
 86     }
 87 
 88     /*归并排序*/
 89     private static void MergeSort(int[] nums,int start,int end){
 90         if(start>=end||nums.length==1) return ;
 91         int mid=start+(end-start)/2;
 92         MergeSort(nums,start,mid);
 93         MergeSort(nums,mid+1,end);
 94         Merge(nums,start,mid,end);
 95     }
 96     private static void Merge(int[] nums,int start,int mid,int end){
 97         int len1=mid-start+1,len2=end-mid;
 98         int[] left=new int[len1];
 99         int[] right=new int[len2];
100         int i=0,j=0,k=0;
101         for(k=start;i){
102             left[i]=nums[k];
103         }
104         for(k=mid+1;j){
105             right[j]=nums[k];
106         }
107         for(k=start,i=0,j=0;i){
108             if(left[i]<=right[j]){
109                 nums[k]=left[i];
110                 i++;
111             }else{
112                 nums[k]=right[j];
113                 j++;
114             }
115         }
116         if(i<len1){
117             while(i<len1){
118                 nums[k++]=left[i++];
119             }
120         }else{
121             while(j<len2){
122                 nums[k++]=right[j++];
123             }
124         }
125     }
126 
127     /*堆排序*/
128     private static void HeapSort(int[] nums){
129         //1.建立堆
130         for(int i=nums.length/2-1;i>=0;i--){
131             adjustHeap(nums,i,nums.length-1);
132         }
133         //2.调整堆
134         for(int i=nums.length-1;i>0;i--){
135             int val=nums[i];
136             nums[i]=nums[0];
137             nums[0]=val;
138             adjustHeap(nums,0,i-1);
139         }
140     }
141     private static void adjustHeap(int[] nums,int pos,int end){
142         int temp=nums[pos];
143         int child=0;
144         for(;2*pos+1<=end;pos=child){
145             child=2*pos+1;
146             if(childnums[child]){
147                 child++;
148             }
149             if(nums[child]>temp){
150                 nums[pos]=nums[child];
151             }
152             else break;
153         }
154         nums[child]=temp;
155     }
156 }