归并排序
- 采用分治的思想,将数组进行等分,将分成的两个数组分别进行排序,merge两个数组
- 时间复杂度:O(nlogn)
- 空间复杂度:O(logn)
- 稳定性:稳定
package Sort;
public class MergeSort {
public static void swap(int[] vec, int i, int j){
int tmp = vec[i];
vec[i] = vec[j];
vec[j] = tmp;
}
public static void mergeSort(int[] vec){
if(vec.length < 2)
return;
mergeSort(vec, 0, vec.length-1);
}
public static void mergeSort(int[] vec, int l, int r){
if(l == r)
return;
int m = l + ((r - l) >> 1);
mergeSort(vec, l, m);
mergeSort(vec, m+1, r);
merge(vec, l, m, r);
}
public static void merge(int[] vec, int l, int m, int r){
int[] help = new int[r - l + 1];
int i = 0;
int p1 = l;
int p2 = m+1;
while(p1 <= m && p2 <= r){
help[i++] = vec[p1] < vec[p2] ? vec[p1++] : vec[p2++];
}
while(p1 <= m){
help[i++] = vec[p1++];
}
while(p2 <= r){
help[i++] = vec[p2++];
}
for(i = 0; i < help.length; i++){
vec[l + i] = help[i];
}
}
public static void main(String[] args) {
int[] vec = {5,2,0,7,-3,8,12};
mergeSort(vec);
for(int x : vec){
System.out.print(x + " ");
}
}
}
堆排序
- 基本思想:建立一个大顶堆,每次将堆顶与末尾元素进行交换,对堆顶元素做一个heapify
- 时间复杂度:O(nlogn)
- 空间复杂度:O(1)
- 稳定行:不稳定
package Sort;
public class HeapSort {
public static void swap(int[] vec, int i, int j){
int tmp = vec[i];
vec[i] = vec[j];
vec[j] = tmp;
}
public static void heapSort(int[] vec){
if(vec.length < 2)
return;
int size = vec.length;
for(int i = size/2; i >= 0; i--){
heapify(vec, i, size);
}
swap(vec, 0, --size);
while(size > 0){
heapify(vec, 0, size);
swap(vec, 0, --size);
}
}
public static void heapify(int[] vec, int index, int size){
int left = 2 * index + 1;
while(left < size){
int largest = left + 1 < size && vec[left] < vec[left + 1] ? left + 1 : left;
largest = vec[largest] > vec[index] ? largest : index;
if(largest == index)
break;
swap(vec, largest, index);
index = largest;
left = 2 * index + 1;
}
}
public static void main(String[] args) {
int[] vec = {5,2,0,7,-3,8,12};
heapSort(vec);
for(int x : vec){
System.out.print(x + " ");
}
}
}
快速排序
- 采用分治的思想,随机选取数组中的一个数,以它为基准进行partition,分成左(小于基准数)中(等于基准数)右(大于基准数),对左,右重复进行该操作
- 时间复杂度:O(nlogn)
- 空间复杂度:O(logn)
- 稳定性:不稳定
package Sort;
public class QuickSort {
public static void swap(int[] vec, int i, int j){
int tmp = vec[i];
vec[i] = vec[j];
vec[j] = tmp;
}
public static void quickSort(int[] vec){
if(vec.length < 2)
return;
quickSort(vec, 0, vec.length - 1);
}
public static void quickSort(int[] vec, int l, int r){
if(l < r){
int m = l + (int)(Math.random() * (r - l + 1));
swap(vec, m, r);
int[] p = partition(vec, l, r);
quickSort(vec, l, p[0] - 1);
quickSort(vec, p[1] + 1, r);
}
}
public static int[] partition(int[] vec, int l, int r){
int less = l - 1;
int more = r;
while(l < more){
if(vec[l] < vec[r]){
swap(vec, l++, ++less);
}
else if(vec[l] > vec[r]){
swap(vec, l, --more);
}
else{
l++;
}
}
swap(vec, more, r);
return new int[]{less+1, more};
}
public static void main(String[] args) {
int[] vec = {5,2,0,7,-3,8,12};
quickSort(vec);
for(int x : vec){
System.out.print(x + " ");
}
}
}