归并排序、快速排序、堆排序

一、自顶向下的归并排序：

public class Merge
{
private static Comparable[] aux;
public static void merge(Comparable[] a, int lo, int mid, int hi)
{
//aux = new Comparable[a.length];
for (int k = lo; k <= hi; k++)
aux[k] = a[k];
int i = lo;
int j = mid + 1;
for (int k = lo; k <= hi; k++)
{
if (i > mid) a[k] = aux[j++];
else if (j > hi) a[k] = aux[i++];
else if (less(aux[i],aux[j])) a[k] = aux[i++];
else a[k] = aux[j++];
}
return;
}
public static void sort(Comparable[] a)
{
//int N = a.length;
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}
public static void sort(Comparable[] a, int lo, int hi)
{
if (lo >= hi) return;
int mid = lo + (hi - lo) / 2;
sort(a, lo, mid);
sort(a, mid+1, hi);
merge(a, lo, mid, hi);
}
public static boolean less(Comparable v, Comparable w)
{
return v.compareTo(w) < 0;
}
public static void exch(Comparable[] a, int i, int j)
{
Comparable t = a[i];
a[i] = a[j];
a[j] = t;

}
private static void show(Comparable[] a)
{
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
System.out.println();
}
public static boolean isSorted(Comparable[] a)
{
for (int i = 1; i < a.length; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}
public static void main(String[] args)
{
// TODO Auto-generated method stub
String[] a = {"abc", "bbb", "ad", "fa", "ccc"};
sort(a);
assert isSorted(a);
show(a);
}

}

二、自低向上的归并排序：

public class MergeBU
{
private static Comparable[] aux;
public static void merge(Comparable[] a, int lo, int mid, int hi)
{
//aux = new Comparable[a.length];
for (int k = lo; k <= hi; k++)
aux[k] = a[k];
int i = lo;
int j = mid + 1;
for (int k = lo; k <= hi; k++)
{
if (i > mid) a[k] = aux[j++];
else if (j > hi) a[k] = aux[i++];
else if (less(aux[i],aux[j])) a[k] = aux[i++];
else a[k] = aux[j++];
}
return;
}
public static void sort(Comparable[] a)
{
int N = a.length;
aux = new Comparable
;
for (int sz = 1; sz < N; sz = 2 * sz)
for (int i = 0; i < N - sz; i += 2 * sz)
merge(a, i, i + sz - 1, Math.min(i + 2 * sz - 1, N - 1));
return;
}

public static boolean less(Comparable v, Comparable w)
{
return v.compareTo(w) < 0;
}
public static void exch(Comparable[] a, int i, int j)
{
Comparable t = a[i];
a[i] = a[j];
a[j] = t;

}
private static void show(Comparable[] a)
{
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
System.out.println();
}
public static boolean isSorted(Comparable[] a)
{
for (int i = 1; i < a.length; i++)
if (less(a[i], a[i - 1])) return false;
ret
4000
urn true;
}
public static void main(String[] args)
{
// TODO Auto-generated method stub
String[] a = {"abc", "bbb", "ad", "fa", "ccc"};
sort(a);
assert isSorted(a);
show(a);
}
}

三、快速排序：

import java.util.Random;

public class Quick
{

public static void sort(Comparable[] a)
{
//打乱a的顺序()
sort(a, 0, a.length - 1);
}
public static void sort(Comparable[] a, int lo, int hi)
{
if (lo >= hi) return;
int j = partition(a, lo, hi);
sort(a, lo, j-1);
sort(a, j+1, hi);
}
public static int partition(Comparable[] a, int lo, int hi)
{
Comparable v = a[lo];
int i = lo;
int j = hi + 1;
while(true)
{
while(less(a[++i], v)) if (i == hi) break;
while(less(v, a[--j])) if (j == lo) break;
if (i >= j) break;
exch(a, i, j);

}
exch(a, j, lo);
return j;

}

public static boolean less(Comparable v, Comparable w)
{
return v.compareTo(w) < 0;
}
public static void exch(Comparable[] a, int i, int j)
{
Comparable t = a[i];
a[i] = a[j];
a[j] = t;

}
private static void show(Comparable[] a)
{
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
System.out.println();
}
public static boolean isSorted(Comparable[] a)
{
for (int i = 1; i < a.length; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}
public static void main(String[] args)
{
// TODO Auto-generated method stub
String[] a = {"abc", "bbb", "ad", "fa", "ccc"};
sort(a);
assert isSorted(a);
show(a);
}
}

四、三向切分的快速排序：

public class Quick3way
{
public static void sort(Comparable[] a)
{
//打乱a的顺序()
sort(a, 0, a.length - 1);
}
public static void sort(Comparable[] a, int lo, int hi)
{
if (lo >= hi) return;
int lt = lo;
int i = lo + 1;
int gt = hi;
Comparable v = a[lo];
while (i <= gt)
{
int cmp = a[i].compareTo(v);
if (cmp < 0) exch(a, i++, lt++);
else if (cmp > 0) exch(a, i, gt--);
else i++;
}
sort(a, lo, lt-1);
sort(a, gt+1, hi);
}

public static boolean less(Comparable v, Comparable w)
{
return v.compareTo(w) < 0;
}
public static void exch(Comparable[] a, int i, int j)
{
Comparable t = a[i];
a[i] = a[j];
a[j] = t;

}
private static void show(Comparable[] a)
{
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
System.out.println();
}
public static boolean isSorted(Comparable[] a)
{
for (int i = 1; i < a.length; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}
public static void main(String[] args)
{
// TODO Auto-generated method stub
String[] a = {"abc", "bbb", "ad", "fa", "ccc"};
sort(a);
assert isSorted(a);
show(a);
}
}

五、堆排序：

public class DuiSort
{

public static void sort(Comparable[] a)
{
int N = a.length - 1;
for (int k = N/2; k >= 1; k--)
sink(a, k, N);
while (N > 1)
{
exch(a, 1, N--);
sink(a, 1, N);
}
}
public static void exch(Comparable[] a, int i, int j)
{
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
private static void show(Comparable[] a)
{
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
System.out.println();
}
public static boolean isSorted(Comparable[] a)
{
for (int i = 1; i < a.length; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}
public static void sink(Comparable[] a, int k, int N)
{
while (2 * k <= N)
{
int j = 2 * k;
if (j < N && less(a[j], a[j+1])) j = j + 1;
if (!less(a[k], a[j])) break;
exch(a, k, j);
k = j;
}
}

public static boolean less(Comparable v, Comparable w)
{
return v.compareTo(w) < 0;
}
public static void main(String[] args)
{
// TODO Auto-generated method stub
String[] a = {"abc", "bbb", "ad", "fa", "ccc"};
sort(a);
assert isSorted(a);
show(a);
}
}