几种排序算法的Java实现

最近自己学习了一下排序算法，把代码贴在这里留个纪念！

代码大部分抄/改自---《Algorithms第四版》

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class HelloWorl 
{
    public static void main(String[] args)
    {
//    	String[] a = new String[10];
//    	Scanner scan =new Scanner(System.in);
//    	for(int i = 0; i < a.length; i++)
//    	{
//    		a[i] = scan.nextLine();
//    	}
//    	
    	String[] a = new String[]{"S","O","R","T","E","X","A","M","P","L","E"};
    	
//    	BubbleSort exsort = new BubbleSort();
    	HeapSort exsort = new HeapSort();
    	//System.out.println(exsort.isSorted(a));
    	exsort.sort(a);
    	//System.out.println(exsort.isSorted(a));
    	//exsort.show(a);	
    	for(int i = 0; i < a.length;i ++)
    	{
    		System.out.println(a[i]);
    	}
    }
}

class ExampleSort
{
	static void sort(Comparable[] a)
	{
		//在子类中将其重载
	}
	
	protected static boolean less(Comparable v,Comparable w)
	{
		return v.compareTo(w) < 0;
	}
	
	protected static void exch(Comparable a[],int i,int j)
	{
		Comparable t;
		t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
	
	public static void show(Comparable[] a)
	{
		for(Comparable i:a)
		{
			System.out.println(i);
		}
	}
	
	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;
	}
}


//选择排序
class SelectionSort extends ExampleSort
{
	public static void sort(Comparable[] a)
	{
		for(int i = 0; i < a.length; i++)
		{
			int min;
			min = i;
			for(int j = i+1; j < a.length; j++)
			{
				if(less(a[j],a[min]))
				{
					min = j;
				}
			}		
			exch(a,i,min);
		}
	}
}


//插入排序
class InsertionSort extends ExampleSort
{
	public static void sort(Comparable[] a)
	{
		for(int i = 1; i < a.length; i++)
		{
//			for(int j = 0; j < i; j++)		//自己实现的野路子，效率应该与书上比应该差不多
//			{
//				if(less(a[i],a[j]))
//				{
//					Comparable temp = a[i];
//					for(int k = i; k > j; k--)
//					{
//						a[k] = a[k-1];
//					}
//					a[j] = temp;
//				}
//			}		
			for(int j = i; j > 0 ;j--)
			{
				if(less(a[j],a[j-1]))
				{
					exch(a,j,j-1);
				}
			}
		}
	}
}


//希尔排序
class ShellSort extends ExampleSort		//希尔排序
{
	public static void sort(Comparable[] a)
	{
		int N = a.length;
		int h = 1;
		while(h < N/3)
		{
			h = h*3 + 1;
		}
		
		while(h >= 1)
		{
			for(int i = h; i <N; i++)
			{
				for(int j = i; j >= h; j -= h)
				{
					if(less(a[j],a[j-h]))
					{
						exch(a,j,j-h);
					}
				}
			}
			h = h/3;
			System.out.println("the h is: " +h);
		}
	}
}


//归并排序
class MergeSort extends ExampleSort
{
	private static Comparable[] aux;
//	public static void sort(Comparable[] a)
//	{
//		aux = new Comparable[a.length];
//		sort(a,0,a.length - 1);
//	}
//	
//	private 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 void sort(Comparable[] a)
	{
		aux = new Comparable[a.length];
		for(int sz = 1; sz < a.length ; sz *= 2)
		{
			for(int lo = 0; lo < a.length - sz; lo += sz+sz)
			{
				merge(a,lo,lo + sz - 1, Math.min(lo + sz + sz -1, a.length - 1));
			}
		}
	}
	
	private static void merge(Comparable[] a, int lo, int mid, int hi)
	{
		int i = lo;
		int j = mid +1;
		
		for(int k = lo; k <= hi; k++)
		{
			aux[k] = a[k];
		}
		
		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++];
			}
		}
	}
}


//快速排序
class QuickSort extends ExampleSort
{
	public static void sort(Comparable[] a)
	{
		sort(a,0,a.length-1);
	}
	private static void sort(Comparable[] a, int lo, int hi)
	{
//		//改进，当数组较小时进行插入排序
//		int M = 5;
//		if(lo + M >= hi)
//		{
//			InsertionSort.sort(a);
//			return;
//		}
//			
		if(lo >= hi)									//如果不能再切分了，就不切分了
			return;
		
		//切分成两个字串，递归
		int j = partition(a,lo,hi);						
		sort(a,lo,j-1);
		sort(a,j+1,hi);
	}
	private static int partition(Comparable[] a, int lo, int hi)
	{
		int i = lo;
		int j = hi +1;
		Comparable v = a[lo];			//最左边的
		while(true)
		{
			//从左边开始找到大于v的
			while(less(a[++i],v))
			{
				if(i == hi)
					break;
			}
			//从右边开始找到小于v的
			while(less(v,a[--j]))
			{
				if(j == lo)
					break;
			}
			//如果找完了就停止
			if(i >= j)
				break;
			//交换左边那个比v大的，右边那个比v小的
			exch(a,j,i);
			//这样交换后的i及左边都比v小，j及右边都比v大。
			//下一个循环的两端是i和j现在所处的位置
			//循环结束后，j左边都是比v小的，j右边都是比v大的
		}
		//交换a[j]和v，v就到了应该在的位置上。
		exch(a,lo,j);
		//返回j，用于将串分成两个字串。
		return j;
	}
}


//冒泡排序
class BubbleSort extends ExampleSort
{
	public static void sort(Comparable[] a)
	{
		for(int i = 0; i <= a.length - 1; i++)
		{
			for(int j = 0; j < a.length - i - 1; j++)
			{
				if(less(a[j+1],a[j]))
					exch(a,j,j+1);
			}
		}
	}
}


//冒泡改进，鸡尾酒算法    但是在乱数序列的状态下，鸡尾酒排序与冒泡排序的效率都很差劲
class CooktailSort extends ExampleSort
{
	public static void sort(Comparable[] a)
	{
		int left = 0;
		int right = a.length -1;
		while(left <= right)
		{
			for(int i = left; i < right; i ++)
			{
				if(less(a[i + 1],a[i]))
				{
					exch(a,i,i+1);
				}
			}
			right--;
			for(int i = right; i > left ; i--)
			{
				if(less(a[i],a[i - 1]))
				{
					exch(a,i,i-1);
				}
			}
			left++;
		}
	}
}


//堆排序
class HeapSort
{
	public void sort(Comparable[] a)
	{
		Comparable[] temp = new Comparable[a.length + 1];
		for(int i = 0; i < a.length; i++)
		{
			temp[i+1] = a[i];
		}
		
		int N = temp.length - 1;
		for(int k = N/2; k >= 1;k--)
		{
			sink(temp,k,N);
		}
		//System.out.println(temp.length);
		//System.out.println(temp[]);
		for(int k = N ; k >= 1; k--)
		{
			//System.out.println(temp[0]);			//这里错把temp写成了a，调了一晚上
			exch(temp,1,k);
			//System.out.println("fghj");
			sink(temp,1,k-1);
		}
		
		for(int i = 1; i < temp.length; i++)
		{
			a[i-1] = temp[i];
		}
	}
	
	private void sink(Comparable[] a,int m,int N)
	{
		//System.out.println("N= " + N);
		while(2*m <= N)
		{
			//System.out.println(m);
			int j = 2*m;
			if(j < N && less(a,j,j+1))  j++;
			if(!less(a,m,j)) break;
			exch(a,m,j);
			m = j;
		}
	}
	
	private boolean less(Comparable[] a, int i, int j)
	{	
		return a[i].compareTo(a[j]) < 0;	
	}
	
	private void exch(Comparable[] a, int i, int j)
	{
		Comparable temp;
		temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}
}