public class Test {
public static void main(String[] args){
Sort sort = new Sort();
sort.sortTest();
}
}
public class Sort {
public void sortTest() {
int[] r = new int[]{,,,,,,,,};
int[] r1 = new int[]{-,,,,,,,,,};
insertSortTest(r);
shellSortTest(r);
bubbleSortTest(r);
quickSortTest(r);
selectSortTest(r);
heapSortTest(r1);
mergeSortTest(r1);
ElemNode[] elemNodes = new ElemNode[];
for(int i = ; i < elemNodes.length; i++){
elemNodes[i] = new ElemNode();
elemNodes[i].key = 9 - i;
elemNodes[i].next = ;
}
KeyNode[] keyNodes = new KeyNode[]; //key为0-9
for(int j = ;j < keyNodes.length; j++){
keyNodes[j] = new KeyNode();
}
bucketSortTest(elemNodes,keyNodes);
}
public void insertSortTest(int[] r){
insertSort(r);
System.out.print("Insertion Sort : ");
for(int i = ; i < r.length; i++){
System.out.print( r[i] + " ");
}
System.out.println();
}
public void shellSortTest(int[] r){
shellSort(r);
System.out.print("Shell Sort : ");
for(int i = ; i < r.length; i++){
System.out.print( r[i] + " ");
}
System.out.println();
}
public void bubbleSortTest(int[] r){
bubbleSort(r);
System.out.print("Bubble Sort : ");
for(int i = ; i < r.length; i++){
System.out.print(r[i] + " ");
}
System.out.println();
}
public void quickSortTest(int[] r){
quickSort(r, , r.length - );
System.out.print("Quicksort : ");
for(int i = ; i < r.length; i++){
System.out.print(r[i] + " ");
}
System.out.println();
}
public void selectSortTest(int[] r){
selectSort(r);
System.out.print("Selection Sort : ");
for(int i = ; i < r.length; i++){
System.out.print( r[i] + " ");
}
System.out.println();
}
//下标从1开始
public void heapSortTest(int[] r){
heapSort(r, r.length - ); //下标从1开始
System.out.print("Heap Sort : ");
for(int i = ; i < r.length; i++){
System.out.print( r[i] + " ");
}
System.out.println();
}
//下标从1开始
public void mergeSortTest(int[] r){
int[] r1 = new int[r.length];
mergeSort(r, r1, r.length - ); //下标从1开始
System.out.print("Merge Sort : ");
for(int i = ; i < r.length; i++){
System.out.print(r[i] + " ");
}
System.out.println();
}
public void bucketSortTest(ElemNode[] r, KeyNode[] q){
int index = bucketSort(r, r.length, q, q.length);
System.out.print("Bucket Sort : ");
for(int i = ; i < r.length; i++){
System.out.print(r[index].key + " ");
index = r[index].next;
}
System.out.println();
}
//////////////////////////////////////////具体实现////////////////////////////////////////////
//////////////////////////////////////////直接插入排序////////////////////////////////////////////
public void insertSort(int[] r){
int temp, i ,j;
for( i = ; i < r.length; i++){
temp = r[i];
for(j = i - ; j >= 0 && temp < r [j]; j-- )
r[j+] = r[j];
r[j+] = temp;
}
}
//////////////////////////////////////////希尔实现////////////////////////////////////////////
public void shellSort(int[] r){
int temp, d, i , j;
for(d = r.length/; d >= ; d = d/){
for(i = d ; i < r.length; i++){
temp = r[i];
for(j = i - d; j >= 0 && temp < r[j]; j = j-d)
r[j+d] = r[j];
r[j+d] = temp;
}
}
}
//////////////////////////////////////////冒泡排序////////////////////////////////////////////
public void bubbleSort(int[] r){
int exchange = r.length - ;//动态记录过程
int bound = r.length - ;//冒泡边界初始化
while (exchange != -){
bound = exchange;//冒泡排序边界
exchange = -; //交换过程记录
for(int i = ; i < bound; i++){
if (r[i] > r[i+]){
int temp = r[i];
r[i] = r[i+];
r[i+] = temp;
exchange = i;
}
}
}
}
//////////////////////////////////////////快速排序////////////////////////////////////////////
public int partition(int[] r, int first, int end){
int i = first, j = end ,temp;
while (i < j){
while (i < j && r[i] < r[j]) j--;
if (i < j ) {
temp = r[i];
r[i] = r[j];
r[j] = temp;
i++;
}
while (i < j && r[i] < r[j]) i++;
if(i < j){
temp = r[i];
r[i] = r[j];
r[j] = temp;
j--;
}
}
return i;
}
public void quickSort(int[] r, int first, int end){
if (first < end){
int p = partition(r,first, end);
quickSort(r,first,p - );
quickSort(r,p + ,end);
}
}
//////////////////////////////////////////选择排序////////////////////////////////////////////
public void selectSort(int[] r){
int index;//记录临时最小值序号
for(int i = ;i < r.length - ; i++){
index = i; //初始化最小序号为当前位置序号
for(int j = i + ; j < r.length; j++)//从当前序号后（无序区）选最小值
if(r[j] < r[index]) index = j;
if (index != i){ //根据最小值下标与当前位置交换
int temp = r[index];
r[index] = r[i];
r[i] = temp;
}
}
}
//////////////////////////////////////////堆排序////////////////////////////////////////////
//堆存储结构：元素在数组中按层序遍历顺序排序（下标从1开始）
//（子堆已经建好后）调整堆顶
public void sift(int[] r, int k, int m){ //从小到大排：建立最大堆
//k：堆顶序号 m：最后节点序号
int i = k , j = 2 * i; //i：堆顶序号 j：堆顶孩子节点序号
while(j <= m){
if(j < m && r[j] < r[j+]) j++; //j为左右子节点中较大的
if(r[i] < r[j]){ //交换父子节点
int temp = r[i];
r[i] = r[j];
r[j] = temp;
i = j; j = 2 * i; //调整改变堆顶后的子堆
}
else break;
}
}
//堆排序：由下至上建立堆，堆顶元素交换到数组尾部
public void heapSort(int[] r, int n){
for(int i = n/; i >= ; i--){ //由下至上建立堆
sift(r,i,n);
}
for(int i = ; i < n; i++){ //i:第i次取顶
//堆顶元素交换到数组尾部（排序）
int temp = r[];
r[] = r[n - (i - )];
r[n - (i - )] = temp;
sift(r,,n - i);//对堆顶重新建堆（未排序）
}
}
//////////////////////////////////////////归并排序////////////////////////////////////////////
public void merge(int[] r, int[] r1, int s, int m, int t)//一节
{
int i = s, j = m + ; //r下标
int k = s; //r1下标
while(i <= m && j <= t) //取两子序列r[i] r[j]中较小者放入r1
{
if(r[i] < r[j]) r1[k++] = r[i++];
else r1[k++] = r[j++];
}
//收尾处理
if(i <= m)
while(i <= m) r1[k++] = r[i++];
else
while(j <= t) r1[k++] = r[j++];
}
public void mergePass(int r[], int r1[], int n, int h)//一趟（总长n,子序列长h）
{
int i = ; //下标从1开始
while(i < n - *h + ) //归并{h, h}
{
merge(r, r1, i, i+h-, i+*h-);
i = i + *h;
}
if(i < n - h + ) //归并{h, <h}
merge(r, r1, i, i+h-, n);
else //归并 <h
for(int k = i; k <= n ;k++) r1[k] = r[k];
}
public void mergeSort(int r[], int r1[], int n)
{
int h = ;
while(h < n){
mergePass(r, r1, n, h); //r -> r1
h = *h;
mergePass(r1, r, n, h); //r1 -> r
h = *h;
}
}
//////////////////////////////////////////桶排序////////////////////////////////////////////
public class ElemNode //静态链表
{
ElemNode(){}
public int key; //排序索引
// int value; //具体值
public int next; //静态链表的next index
}
public class KeyNode //key桶
{
public int front; //桶首的静态链表index
public int rear; //桶尾的静态链表index
}
//分配
public void distribute(ElemNode[] r, int n, KeyNode[] q, int m)
{
int i = 0 ; //静态链表从0开始
while(i < n) //扫描静态链表
{
int k = r[i].key;
if(q[k].front == -) q[k].front = i; //key桶为空：设置key桶头部
else r[q[k].rear].next = i; //key桶非空：静态链表连接桶元素
q[k].rear = i; //设置key桶尾部
i++; //i后移，处理静态链表下一个元素
}
}
//收集
public int collect(ElemNode[] r, int n, KeyNode[] q, int m)
{
int k = ; //key桶从0开始
while(q[k].front == -) k++; //找到第一个非空key桶
int first = q[k].front; //静态链表首部index
int last = q[k].rear; //静态链表尾部index
while (k < m) //扫描key桶
{
k++;
if (k < m && q[k].front != -) //找到下一个非空key桶
{
r[last].next = q[k].front; //静态链表连接
last = q[k].rear; //修改静态链表尾部index
}
}
r[last].next = -; //设置静态链表排序后尾部标志
return first; //返回排序后的静态链表首部index
}
public int bucketSort(ElemNode[] r, int n, KeyNode[] q, int m)
{
//初始化静态链表
for(int i = ; i < n; i++) r[i].next = i + ;
r[n - ].next = -; //尾标志为-1
//初始化key桶
for(int j = ; j < m; j++){
q[j].front = -;
q[j].rear = -;
}
distribute(r,n,q,m);
return collect(r,n,q,m);
}
}
