数据库的算法

非比较排序

基数排序 | 桶排序 | 计数排序 | 鸽巢排序 | Burstsort | Bead sort

法

其他 一、排序 1.冒泡法：

拓扑排序 | 排序网络 | Bitonic sorter | Batcher odd-even mergesort | Pancake sorting

使用冒泡排序为一列数字进行排序的过程分类排序算法数据结构数组最差时间复杂度O(n2)最优时间复杂度O(n)平均时间复杂度O(n2)最差空间复杂度O(n) total, O(1) auxiliary public static void sort(Comparable[] a) {

int N = a.length; for(int i=0;i0;j--)

if(a[j].compareTo(a[j-1])<=-1) exchange(a,j,j-1); else

break; }

交换位置：

public static void change(Comparable[] a,int from,int to) {

Comparable t = a[from]; a[from] = a[to]; a[to] = t; }

判断是否已经有序：

public static boolean isSorted(Comparable[] a) {

for(int i=1;i2.选择排序：

分类排序算法数据结构数组最差时间复杂度О(n²)最优时间复杂度О(n²)平均时间复杂度О(n²)最差空间复杂度О(n) total, O(1) auxiliary public static void change(Comparable[] a) {

int N = a.length; for(int i=0;iint min = i;

for(int j=i+1;jif(a[j].comparaeTo(a[min])<=-1) min = j; }

exchange(a,i,min); } }

时间复杂度：

比较的次数：(n-1)+(n-2)+..................+1+0~N^2/2 交换的次数：N

时间复杂度是：N^2/2+N~N^2/2 3.插入排序：

public static void change(Comparable[] a) {

int N = a.length; for(int i=0;ifor(int j=i;j>0;j--) {

if(a[j].compareTo(a[j-1])<=-1) exchange(a,j,j-1); else break; } } }

时间复杂度： 比较次数：N^2/4 交换次数：N^2/4 时间复杂度是：N^2/2 极端情况：

如果序列是排好序的，那么比较的次数是N-1 交换的次数是0 如果序列是随即的，那么比较的次数是N^2/2 交换的次数是N^2/2 4.希尔排序(shell sort)

public static void sort(Comparable[] a) {

int N = a.length;

int[] incs =

{1391376,463792,198768,86961,33936,13776,4592,1968,861,336,112,48,21,7,3,1};

for(int k=0;kint h = incs[k]; for(int i=h;ifor(int j=i;j>=h;j-=h) {

if(a[j].compareTo(a[j-h])) exchage(a,j,j-h); else break; } } } }

时间复杂度： n^(3/2)

5.堆排序

分类排序算法数据结构数组最差时间复杂度O(nlogn)最优时间复杂度O(nlogn)[1]平均时间复杂度Θ(nlogn)最差空间复杂度O(n) total, O(1) auxiliary 6.快速排序

使用快速排序法对一列数字进行排序的过程分类排序算法数据结构Varies 最差时间复杂度Θ(n2)最优时间复杂度Θ(nlogn)平均时间复杂度Θ(nlogn) comparisons 最差空间复杂度根据实现的方式不同而不同

public class Quicksort {

public static final Random RND = new Random();

private void swap(Object[] array, int i, int j) { Object tmp = array[i]; array[i] = array[j]; array[j] = tmp; }

private int partition(Object[] array, int begin, int end, Comparator cmp) { int index = begin + RND.nextInt(end - begin + 1);

Object pivot = array[index]; swap(array, index, end);

for (int i = index = begin; i < end; ++ i) { if (cmp.compare(array[i], pivot) <= 0) { swap(array, index++, i); } }

swap(array, index, end); return (index); }

private void qsort(Object[] array, int begin, int end, Comparator cmp) { if (end > begin) {

int index = partition(array, begin, end, cmp); qsort(array, begin, index - 1, cmp); qsort(array, index + 1, end, cmp); } }

public void sort(Object[] array, Comparator cmp) { qsort(array, 0, array.length - 1, cmp); } }