七.排序算法

分类：毛选入耳块归队，计数，桶，基数

一.冒泡排序：BubbleSort

(1)普通版

　　i：1~n，j：0~n-i

1     public void bubbleSort(int[] array) {
2         for(int i=1;i<array.length;i++)
3             for(int j=0;j<array.length-i;j++) 
4                 if(array[j]>array[j+1]) {
5                     int temp=array[j];
6                     array[j]=array[j+1];
7                     array[j+1]=temp;
8                 }
9     }

(2)优化版

View Code

2.选择排序：SelectionSort

　　i：1~n；j：i~n　　开始时：minIndex=i-1

 1     public static void selectSort(int[] array) {        
 2         for(int i=1;i<array.length;i++) {
 3             int minIndex=i-1;
 4             for(int j=i;j<array.length;j++) {
 5                 if(array[j]<array[minIndex]) {
 6                     minIndex=j;
 7                 }        
 8             }
 9             if(minIndex!=i-1) {        //可有可无
10                 int temp=array[i-1];
11                 array[i-1]=array[minIndex];
12                 array[minIndex]=temp;
13             }
14         }
15     }

3.插入排序：insertSort

(1)普通版

　　　　也是n-1轮循环。有几个小点需要注意

 1     public static void insertSort(int[] array) {
 2         for(int i=1;i<array.length;i++) {
 3             int insertVal=array[i];
 4             int prevIndex=i-1;
 5             while(prevIndex>=0 && array[prevIndex]>insertVal) {
 6                 array[prevIndex+1]=array[prevIndex];
 7                 prevIndex--;
 8             }
 9             array[prevIndex+1]=insertVal;    
10         }
11     }

4.希尔排序:shellSort

希尔排序是简单插入排序的改进版，又叫缩小增量排序，分组排序。

间隔序列:8个数：{4,2,1}

 1     //增量为几，就有几组
 2     public static void shellSort(int[] array) {
 3         int incre=array.length;
 4         while(incre>=1) {
 5             incre=incre/2;
 6             for(int gnum=0;gnum<incre;gnum++) {                            //控制第几组
 7                 for(int i=gnum+incre;i<array.length;i=i+incre) {        //对一组元素排序
 8                     int insertValue=array[i];
 9                     int prevIndex=i-incre;
10                     while(prevIndex>=0 && array[prevIndex]>insertValue) {
11                         array[prevIndex+incre]=array[prevIndex];
12                         prevIndex=prevIndex-incre;
13                     }
14                     array[prevIndex+incre]=insertValue;
15                 }
16             }
17         }
18     }

5.快速排序：quickSort

原理：快速排序就是将数组划分成两部分，右边大于等于基准元素，左边小于等于基准元素；然后递归的划分

过程：比较交换

步骤：先划分，再递归排序。划分操作是关键

 1     public static void quicksort(int[] nums,int startIndex,int endIndex) {
 2          if(startIndex>=endIndex)     return;
 3          
 4          int pivotIndex=partition(nums, startIndex, endIndex);
 5          quicksort(nums, startIndex, pivotIndex-1);
 6          quicksort(nums, pivotIndex+1, endIndex);
 7     }
 8     
 9     //while，while while if
10     static int partition(int[] nums,int startIndex,int endIndex) {
11         int pivot=nums[startIndex];
12         int left=startIndex;
13         int right=endIndex;
14         
15         while(left<right) {
16             while(left<right && nums[right]>=pivot)     right--;
17             while(left<right && nums[left]<=pivot)         left++;
18             if(left<right) {
19                 int temp=nums[left];
20                 nums[left]=nums[right];
21                 nums[right]=temp;
22             }
23         }
24         
25         nums[startIndex]=nums[left];
26         nums[left]=pivot;
27         
28         return left;
29     }

6.归并排序

 1     //利用了递归，比较经典
 2     public static void mergeSort(int[] array,int start,int end) {    //分割成两个有序数组，再把这两个有序数组合并
 3         if(start<end) {
 4             int mid=(start+end)/2;
 5             mergeSort(array, start, mid);
 6             mergeSort(array, mid+1, end);
 7             
 8             merge(array, start, mid, end);
 9         }
10     }
11     
12     private static void merge(int[] array,int start,int mid,int end) {
13         int[] tempArray=new int[end-start+1];
14         int p1=start;
15         int p2=mid+1;
16         int p=0;
17         while((p1<=mid) && (p2<=end)) {
18             if(array[p1] <= array[p2]) 
19                 tempArray[p++]=array[p1++];            //先放，再自加
20             else 
21                 tempArray[p++]=array[p2++];
22         }
23         
24         while(p1<=mid)
25             tempArray[p++]=array[p1++];
26         while(p2<=end)
27             tempArray[p++]=array[p2++];
28         for(int i=0;i<tempArray.length;i++)
29             array[i+start]=tempArray[i];            //i+sart
30     }

7.堆排序：heapSort

步骤：构建堆。首尾元素交换，下沉。重复以上步骤

 1     public static void heapSort(int[] arr) {
 2         buildHeap(arr);
 3 
 4         for(int i=arr.length-1;i>0;i--) {
 5             int temp=arr[0];
 6             arr[0]=arr[i];
 7             arr[i]=temp;
 8             downAdjust(arr, 0,i);
 9         }    
10     }
11     
12     //构建堆
13     public static void buildHeap(int[] arr) {
14         for(int i=(arr.length-2)/2;i>=0;i--)
15             downAdjust(arr,i,arr.length);
16     }
17     
18     public static void downAdjust(int[] arr,int parentIndex,int length) {
19         int childIndex=2*parentIndex+1;
20         int temp=arr[parentIndex];
21         while(childIndex<length) {
22             if(childIndex+1<length && arr[childIndex+1]>arr[childIndex])
23                 childIndex++;
24             if(temp>=arr[childIndex])
25                 break;
26             arr[parentIndex]=arr[childIndex];
27             parentIndex=childIndex;
28             childIndex=2*childIndex+1;
29         }
30         arr[parentIndex]=temp;
31     }

8.计数排序

 1     public static void countSort(int[] array) {
 2         int max=array[0];
 3         for(int i=1;i<array.length;i++)
 4             if(array[i]>max)
 5                 max=array[i];
 6         int[] countArray=new int[max+1];
 7         for(int i=0;i<array.length;i++) {
 8             countArray[array[i]]++;
 9         }
10         int index=0;        //index很重要
11         for(int i=0;i<countArray.length;i++) {
12             for(int j=0;j<countArray[i];j++) {
13                 array[index++]=i;
14             }        
15         }
16     }