常见的排序算法可以分为两大类:
**非线性时间比较类排序**:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序。
线性时间非比较类排序:不通过比较来决定元素间的相对次序,它可以突破基于比较排序的时间下界,以线性时间运行,因此称为线性时间非比较类排序。
算法的复杂度
1 冒泡排序
在无序的区间里通过相邻数的比较,将最大的数的冒泡到无序空间的最后,持续这个过程,让数组整体有序
/*
* 冒泡排序
* 时间复杂度 为 O(n^2) 最坏的时间复杂度也是O(n^2) 最好的时间复杂度为o(n)
* 稳定排序 空间复杂度为O(1)
* */
public void bubbleSort(int[] array) {
for (int i = 0; i < array.length; i++) {
boolean isSorted = true;
for (int j = 0; j <array.length-1-i ; j++) {
if (array[j] > array[j+1]){
int tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
isSorted = false;
}
}
if (isSorted){
break;
}
}
}
2 选择排序
每一次从无序区间选出最大(或最小)的一个元素,存放在无序区间的最后(或最前),直到全部待排序的数据元
素排完
* 选择排序
* 时间复杂度为 O(n^2) 空间复杂的 为 O(1) 不稳定
* */
public void selectSort(int[] array){
for (int i = 0; i < array.length-1; i++) {
// 无序区间: [0, array.length - i)
// 有序区间: [array.length - i, array.length)
int max = 0;
for (int j = 1; j < array.length - i; j++) {
if (array[j] > max){
max = j;
}
}
int tmp = array[i];
array[i] = array[max];
array[max] = tmp;
}
}
3 插入排序整个区间被分为
把区间分为
- 有序区间
- 无序区间
每次选择无序区间的第一个元素,在有序区间内选择合适的位置插入
/*
* 插入排序
*第二位数字开始,每一个数字都试图跟它的前一个比较并交换,并重复;直到前一个数字不存在或者比它小或相等时停下来
* 最好的时间复杂度为O(n) 平均为O(n^2) 最坏为O(n^2) 稳定
* 初始数据越接近有序,时间效率越高
* */
public void insertSort(int[] array){
for (int i = 1; i < array.length ; i++) {
// 有序区间: [0, i)
// 无序区间: [i, array.length)
int j = i-1;
int key = array[i];
while (j >= 0 && array[j] > key ){
array[j+1] = array[j];
j--;
}
array[j+1] = key;
}
}
4 希尔排序
希尔排序法又称缩小增量法。希尔排序法的基本思想是:先选定一个整数,把待排序文件中所有记录分成个组,所
有距离为的记录分在同一组内,并对每一组内的记录进行排序。然后,取,重复上述分组和排序的工作。当到达=1
时,所有记录在统一组内排好序。
/*
* 希尔排序 最好是O(n) 平均是O(n^1.3) 最坏 O(n^2)
* */
public static void shellSort(int[] array){
int gap = array.length;
while (gap > 1){
insertSortGap(array,gap);
gap = (gap/3)+1;
}
}
private static void insertSortGap(int[] array, int gap) {
for (int i = 1; i < array.length; i++) {
int v = array[i];
int j = i - gap;
for (; j >= 0 && array[j] > v; j--) {
array[j+gap] = array[j];
}
array[j+gap] = v;
}
}
5 归并排序
/*
* 归并排序
* 归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and
Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使
子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。
* */
public void mergeSort(int[] array){
mergeSortInternal(array,0,array.length);
}
private void mergeSortInternal(int[] array, int low, int height) {
if (low >= height -1){
return;
}
int mid = (low + height) / 2;
mergeSortInternal(array,low,mid);
mergeSortInternal(array,mid,height);
merge(array,low,mid,height);
}
private void merge(int[] array, int low, int mid, int height) {
int i = low;
int j = mid;
int length = height - low;
int[] extra = new int[length];
int k = 0;
while (i < mid && j <height) {
if (array[i] <= array[j]){
extra[k++] = array[i++];
} else {
extra[k++] = array[j++];
}
}
while (i < mid){
extra[k++] = array[i++];
}
while (j < height){
extra[k++] = array[j++];
}
for (int l = 0; l < length ; l++) {
array[low + l] = extra[l];
}
}
海量数据的排序问题
外部排序:排序过程需要在磁盘等外部存储进行的排序
前提:内存只有 1G,需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下,所以需要外部排序,而归并排序是最常用的外部排序
- 先把文件切分成 200 份,每个 512 M
- 分别对 512 M 排序,因为内存已经可以放的下,所以任意排序方式都可以
- 进行 200 路归并,同时对 200 份有序文件做归并过程,最终结果就有序
6 堆排序
public static void heapSort(int[] array) {
createHeap(array);
for (int i = 0; i < array.length - 1; i++) {
// 交换前
// 无序区间: [0, array.length - i)
// 有序区间: [array.length - i, array.length)
swap(array, 0, array.length - 1);
// 交换后
// 无序区间: [0, array.length - i - 1)
// 有序区间: [array.length - i - 1, array.length)
// 无序区间长度: array.length - i - 1
shiftDown(array, array.length - i - 1, 0);
}
}
private void swap(int[] array, int i, int j) {
int t = array[i];
array[i] = array[j];
array[j] = t;
} p
rivate void createHeap(int[] array) {
for (int i = (array.length - 1) / 2; i >= 0; i--) {
shiftDown(array, array.length, i);
}
} p
ublic static void shiftDown(int[] array, int size, int index) {
int left = 2 * index + 1;
while (left < size) {
int max = left;
int right = 2 * index + 2;
if (right < size) {
if (array[right] > array[left]) {
max = right;
}
} i
f (array[index] >= array[max]) {
break;
} i
nt t = array[index];
array[index] = array[max];
array[max] = t;
index = max;
left = 2 * index + 1;
}
}
7 快速排序
public static void main(String[] args) {
Random rd = new Random();
int[] num = new int[10];
for (int i = 0; i < num.length; i++) {
num[i] = rd.nextInt(100)+1;
}
System.out.println(Arrays.toString(num));
quickSort(num,0,num.length-1);
System.out.println(Arrays.toString(num));
}
/**
* 实现快速排序
* @param num
* @param i
* @param j
*/
public static void quickSort(int[] num,int i,int j){
if(i >= j){//只剩一个元素不用处理直接结束。
return;
}
//选取基准数
int val =num[i];
int l = i;
int r = j;
while(l < r){//当l == r时,就是调整完成时
//从后往前找第一个小于val的数字
while (l < r && num[r] > val){
r --;
}
if(l < r){//找到了数字
num[l++] = num[r];
}
//从前往后找第一个大于val的数字
while (l < r && num[l] < val){
l ++;
}
if(l < r){//找到了数字
num[r--] = num[l];
}
}
//l==r,基准数放进去
num[l] = val;
quickSort(num,i,l-1);
quickSort(num,l+1,j);
}