这篇文章是复习所有排序的,参考了 http://www.cnblogs.com/huangxincheng/archive/2011/11/16/2251196.html ,在此表示感谢
一:冒泡
冒泡一般想着每一轮都会有一个数到最终的位置,可以是最大也可以是最小,性质都一样
public static void bubbleSort(List<Integer> arr){
for(int i=0;i<arr.size()-1;i++){
for(int j=arr.size()-1;j>i;j--){
if(arr.get(j-1) > arr.get(j)){
int temp = arr.get(j-1);
arr.set(j-1, arr.get(j));
arr.set(j, temp);
}
}
}
}
40 | 20 | 30 | 10 | 50 |
10 | 40 | 20 | 30 | 50 |
10 | 20 | 40 | 30 | 50 |
10 | 20 | 30 | 40 | 50 |
10 | 20 | 30 | 40 | 50 |
二:快排
快排的思想是:一个串,选取一个基础值base,将大于base全放在base的右侧,小于base的放在左侧,这样一轮下来base到了固定的位置上并且将一个大串分成了两个小串,用递归的思想继续做下去
延伸:这种思想可以用来选取一个数组中的前k个大的数~~
private int division(List<Integer> list,int left,int right){
int base = list.get(left);
while(right > left){
while(right > left && list.get(right) >= base){
right -= 1;
}
list.set(left, list.get(right));
while(right > left && list.get(left) <= base){
left += 1;
}
list.set(right, list.get(left));
}
list.set(left, base);
return left;
}
public void quickSort(List<Integer> list,int left,int right){
if(left < right){
int i = division(list, left, right);
quickSort(list, left, i-1);
quickSort(list, i+1, right);
}
}
时间复杂度:平均O(nlogn),最差O(n^2)
三:直接选择排序
思想:直接选择排序其实非常简单,就是从前向后遍历,每一轮都选择剩余数中最小的值放在前端
public static List<Integer> selectionSort(List<Integer> list){
if(list == null)
return null;
for(int i=0;i<list.size()-1;i++){
int minIndex = i;
for(int j=i+1;j<list.size()-1;j++){
if(list.get(j) < list.get(minIndex)){
minIndex = j;
}
}
if(list.get(minIndex) < list.get(i)){
int temp = list.get(minIndex);
list.set(minIndex, list.get(i));
list.set(i, temp);
}
}
return list;
}
40 | 20 | 30 | 10 | 50 |
10 | 20 | 30 | 40 | 50 |
10 | 20 | 30 | 40 | 50 |
10 | 20 | 30 | 40 | 50 |
10 | 20 | 30 | 40 | 50 |
时间复杂度是O(n^2)
四:堆排序
堆排序一般分为大堆和小堆,堆一般除了用于排序之外也用于选取top K值,上文中说了快排也是可以选取top K的
所谓大堆:指根节点比所有的子节点大的堆,小堆相反,图示如下:
static void heapAdjust(int[] arr,int parent,int length){
if (arr == null) {
return;
}
int temp = arr[parent];
int child = 2*parent+1;
while(child < length){
if(child+1 < length && arr[child] < arr[child+1]){
child += 1;
}
if(temp > arr[child]){
break;
}
arr[parent] = arr[child];
parent = child;
child = 2*parent + 1;
}
arr[parent] = temp;
}
public static void heapSort(int[] arr,int top){
if(arr == null || top > arr.length || top <0){
return;
}
for(int i=arr.length/2-1;i>=0;i--){
heapAdjust(arr, i, arr.length);
}
for(int i=arr.length-1;i>=arr.length-top;i--){
System.out.println("arr[0] = "+arr[0]);
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
heapAdjust(arr, 0, i);
}
}
堆排序时间复杂度O(nlogn)
五:插入排序
思想,插入排序就是将一个数组分为两段,以段是有序的,另一段是无序的,然后每次从无序段里选取一个数与有序段中的数字依次比较,插入合适的位置
public static void insertSort(int[] arr){
if(arr == null){
return;
}
for(int i = 1;i < arr.length;i++){
int temp = arr[i];
int j;
for(j = i-1;j>=0 && temp < arr[j];j--){
arr[j+1] = arr[j];
}
arr[j+1] = temp;
}
}
时间复杂度:最好情况下O(n),最坏O(n^2)
六:希尔排序
思想:希尔排序和插入排序本质是相同的,只是将一个大的数组按照一定的规则step(初始值为arr.length/2)来分割成多个小数组
随着step的逐步减小(默认为每次缩小一半),最终step减为1的时候则对整个数组进行插入排序,不过此时的数组已经基本有序
public static void shellSort(int[] arr){
int step = arr.length/2;
while(step >= 1){
for(int i = step;i<arr.length;i++){
int j;
int temp = arr[i];
for(j = i-step;j>=0 && temp<arr[j];j-=step){
arr[j+step] = arr[j];
}
arr[j+step] = temp;
}
step /= 2;
}
}
时间复杂度:平均为O(n^3/2)
七:归并排序
思想:归并排序的思想简单说起来就是大的分成小的,无限分下去,然后对小的进行排序,然后再合并这些小的
public static void mergeSort(int[] arr,int[] tempArr,int left,int right){
if(left<right){
//取分割的位置
int middle = (left + right)/2;
mergeSort(arr, tempArr, left, middle);
mergeSort(arr, tempArr, middle+1, right);
merge(arr, tempArr, left, middle+1, right);
}
}
/**
*
* <p>Title: merge</p>
* <p>Description: </p>
* <p>描述:我们借用零时数组进行合并</p>
* @param arr
* @param left
* @param middle
* @param right
*/
public static void merge(int[] arr,int[] tempArr,int left,int middle,int right){
int leftEnd = middle-1;
int rightStart = middle;
int tempLength = right-left+1;
int tempIndex = left;
while(left <= leftEnd && rightStart <= right){
if(arr[left] < arr[rightStart]){
tempArr[tempIndex++] = arr[left++];
}
else {
tempArr[tempIndex++] = arr[rightStart++];
}
}
while(left <= leftEnd){
tempArr[tempIndex++] = arr[left++];
}
while(rightStart <= right){
tempArr[tempIndex++] = arr[rightStart++];
}
for(int i=0;i<tempLength;i++){
arr[right] = tempArr[right];
right--;
}
}
时间复杂度:O(nlogn)
空间复杂度:O(n)