1、接口
package cn.ac.ihep.sort;
public interface ISort {
public int[] InsertSort(int[] a);
public int[] BubbleSort(int[] a);
public int[] SelectSort(int[] a);
public int[] ShellSort(int[] a);
public int[] QuickSort(int[] a);
public int[] HeapSort(int[] a);
public int[] MergeSort(int[] a);
public int[] CountingSort(int[] a);
}
2、实现
package cn.ac.ihep.sort;
import java.util.Arrays;
public class Sort implements ISort {
final int MAXVALUE = 1000000;
@Override
public int[] InsertSort(int[] a) {
// TODO Auto-generated method stub
int length = a.length;
int i, j, temp;
System.out.println("=================InsertSort Begin=======================");
System.out.println("Before Sort:");
System.out.println(Arrays.toString(a));
// System.out.println("========================================================");
for (i = 1; i < length; i++) {
for (j = i-1; j >= 0; j--) {
if (a[j] > a[j+1]) {
temp = a[j+1];
a[j+1] = a[j];
a[j] = temp;
}
}
//System.out.println(Arrays.toString(a));
}
// System.out.println("========================================================");
System.out.println("After Sort:");
System.out.println(Arrays.toString(a));
System.out.println("=================InsertSort End=======================");
return a;
}
@Override
public int[] BubbleSort(int[] a) {
// TODO Auto-generated method stub
int length = a.length;
int i, j, temp;
// System.out.println("=================BubbleSort Begin=======================");
// System.out.println("Before Sort:");
// System.out.println(Arrays.toString(a));
// System.out.println("========================================================");
for (i = length-1; i > 0; i--) {
for (j = 0; j < i; j++) {
if (a[j] > a[j+1]) {
temp = a[j+1];
a[j+1] = a[j];
a[j] = temp;
}
}
//System.out.println(Arrays.toString(a));
}
// System.out.println("========================================================");
// System.out.println("After Sort:");
// System.out.println(Arrays.toString(a));
// System.out.println("==================BubbleSort End=======================");
return a;
}
@Override
public int[] SelectSort(int[] a) {
// TODO Auto-generated method stub
int length = a.length;
int i, j, k, temp;
// System.out.println("=================SelectSort Begin=======================");
// System.out.println("Before Sort:");
// System.out.println(Arrays.toString(a));
//System.out.println("========================================================");
for (i = 0; i < length; i++) {
k = i;
for (j = i+1; j < length; j++) {
if (a[j] < a[k]) {
k = j;
}
}
temp = a[i];
a[i] = a[k];
a[k] = temp;
//System.out.println(Arrays.toString(a));
}
//System.out.println("========================================================");
// System.out.println("After Sort:");
// System.out.println(Arrays.toString(a));
// System.out.println("===============SelectSort End=======================");
return a;
}
@Override
public int[] ShellSort(int[] a) {
// System.out.println("=================ShellSort Begin=======================");
// System.out.println("Before Sort:");
// System.out.println(Arrays.toString(a));
int gap = a.length/2;
int temp;
while(gap>0){
for(int i=gap;i<a.length;i++){
temp = a[i];
int j = i - gap;
while(j>=0 && temp < a[j]){
a[j+gap] = a[j];
j = j - gap;
}
a[j+gap] = temp;
}
gap = gap/2;
}
// System.out.println("After Sort:");
// System.out.println(Arrays.toString(a));
// System.out.println("=================ShellSort End=======================");
return a;
}
@Override
public int[] QuickSort(int[] a) {
// System.out.println("=================QuickSort Begin=======================");
// System.out.println("Before Sort:");
// System.out.println(Arrays.toString(a));
MyQuickSort(a, 0, a.length-1);
// System.out.println("After Sort:");
// System.out.println(Arrays.toString(a));
// System.out.println("=================QuickSort End=========================");
return a;
}
public void MyQuickSort(int[] a, int p, int r) {
if (p < r) {
int q = partiton(a, p, r);
MyQuickSort(a, p, q-1);
MyQuickSort(a, q+1, r);
}
}
public int partiton(int[] a, int p, int r) {
int i = p-1;
int x = a[r];
for (int j = p; j < r; j++) {
if (a[j] <= x) {
i++;
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
int temp = a[r];
a[r] = a[i+1];
a[i+1] = temp;
return i+1;
}
@Override
public int[] HeapSort(int[] a) {
// TODO Auto-generated method stub
// System.out.println("=================HeapSort Begin=======================");
// System.out.println("Before Sort:");
// System.out.println(Arrays.toString(a));
int heapsize = a.length;
BuildMaxHeap(a);
//System.out.println(Arrays.toString(a));
for (int i = heapsize-1; i > 0; i--) {
int temp = a[0];
a[0] = a[i];
a[i] = temp;
MaxHeapify(a, 0, i);
}
// System.out.println("After Sort:");
// System.out.println(Arrays.toString(a));
// System.out.println("=================HeapSort End=======================");
return a;
}
public void BuildMaxHeap(int[] a) {
int heapsize = a.length;
for (int i = heapsize/2; i >= 0; i--) {
MaxHeapify(a, i, heapsize);
}
}
public void MaxHeapify(int[] a, int i, int heapsize) {
int lChild = 2*i + 1;
int rChild = 2*i + 2;
int largest = i;
if (lChild < heapsize && a[lChild] > a[i]) {
largest = lChild;
}
if (rChild < heapsize && a[rChild] > a[largest]) {
largest = rChild;
}
if (largest != i) {
int temp = a[i];
a[i] = a[largest];
a[largest] = temp;
MaxHeapify(a, largest, heapsize);
}
}
@Override
public int[] MergeSort(int[] a) {
// System.out.println("=================MergeSort Begin=======================");
// System.out.println("Before Sort:");
// System.out.println(Arrays.toString(a));
MyMergeSort(a, 0, a.length-1);
// System.out.println("After Sort:");
// System.out.println(Arrays.toString(a));
// System.out.println("=================MergeSort End=======================");
return a;
}
public void MyMergeSort(int[] a, int begin, int end) {
if (begin < end) {
int mid = (begin + end) / 2;
MyMergeSort(a, begin, mid);
MyMergeSort(a, mid+1, end);
Merge(a, begin, mid, end);
}
}
/*
* Merge()
*
*/
public void Merge(int[] a, int begin, int mid, int end) {
int nL = mid - begin + 1;
int nR = end - mid;
int[] L = new int[nL+1];
int[] R = new int[nR+1];
for (int i = 0; i < nL; i++) {
L[i] = a[begin+i];
}
L[nL] = MAXVALUE;
for (int i = 0; i < nR; i++) {
R[i] = a[mid+1+i];
}
R[nR] = MAXVALUE;
int i = 0;
int j = 0;
for (int k = begin; k <= end; k++) {
if (L[i] < R[j]) {
a[k] = L[i];
i++;
}
else {
a[k] = R[j];
j++;
}
}
}//end Merge()
@Override
public int[] CountingSort(int[] a) {
// System.out.println("=================CountingSort Begin=======================");
// System.out.println("Before Sort:");
// System.out.println(Arrays.toString(a));
int len = a.length;
int max = getArrayMax(a);
int[] result = new int[len];
int[] assist = new int[max+1];
for (int i = 0; i < max+1; i++ ) {
assist[i] = 0;
}
for (int i = 0; i < len; i++) {
assist[a[i]]++;
}
// System.out.println("assist:");
// System.out.println(Arrays.toString(assist));
for (int i = 1; i < max+1; i++) {
assist[i] += assist[i-1];
}
// System.out.println("assist:");
// System.out.println(Arrays.toString(assist));
for (int i = 0; i < len; i++) {
result[ assist[a[i]] - 1 ] = a[i];
assist[a[i]]--;
}
// System.out.println("After Sort:");
// System.out.println(Arrays.toString(result));
// System.out.println("=================CountingSort End=========================");
return result;
}
public int getArrayMax(int[] a) {
int len = a.length;
int max = a[0];
for (int i = 1; i < len; i++) {
if (a[i] > max) {
max = a[i];
}
}
return max;
}
}
3、测试
package cn.ac.ihep.sort;
import static org.junit.Assert.*;
import java.util.Arrays;
import java.util.Random;
import org.junit.Test;
public class SortTest {
final int COUNT = 10;
public int[] CreateArray() {
int[] a = new int[COUNT];
for (int i = 0; i < COUNT; i++) {
a[i] = new Random().nextInt(100);
}
return a;
}
public int[] CreateSortedArray(int [] a) {
int[] b = new int[COUNT];
for (int i = 0; i < COUNT; i++) {
b[i] = a[i];
}
Arrays.sort(b);
return b;
}
public boolean equalsIntArray(int[] a, int [] b) {
int lenA = a.length;
int lenB = b.length;
if (lenA != lenB) {
return false;
}
for (int i = 0; i < lenA; i++) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
ISort iSort = new Sort();
@Test
public void testInsertSort() {
int[] a = CreateArray();
int[] sortedArray = CreateSortedArray(a);
assertEquals(true, equalsIntArray(iSort.InsertSort(a), sortedArray));
}
@Test
public void testBubbleSort() {
int[] a = CreateArray();
int[] sortedArray = CreateSortedArray(a);
assertEquals(true, equalsIntArray(iSort.BubbleSort(a), sortedArray));
}
@Test
public void testSelectSort() {
int[] a = CreateArray();
int[] sortedArray = CreateSortedArray(a);
assertEquals(true, equalsIntArray(iSort.SelectSort(a), sortedArray));
}
@Test
public void testShellSort() {
int[] a = CreateArray();
int[] sortedArray = CreateSortedArray(a);
assertEquals(true, equalsIntArray(iSort.ShellSort(a), sortedArray));
}
@Test
public void testQuickSort() {
int[] a = CreateArray();
int[] sortedArray = CreateSortedArray(a);
assertEquals(true, equalsIntArray(iSort.QuickSort(a), sortedArray));
}
@Test
public void testHeapSort() {
int[] a = CreateArray();
int[] sortedArray = CreateSortedArray(a);
assertEquals(true, equalsIntArray(iSort.HeapSort(a), sortedArray));
}
@Test
public void testMergeSort() {
int[] a = CreateArray();
int[] sortedArray = CreateSortedArray(a);
assertEquals(true, equalsIntArray(iSort.MergeSort(a), sortedArray));
}
@Test
public void testCountingSort() {
int[] a = CreateArray();
int[] sortedArray = CreateSortedArray(a);
assertEquals(true, equalsIntArray(iSort.CountingSort(a), sortedArray));
}
}