算法：排序（java语言实现）

本文只给出几种基本排序方法的java代码实现。
几种排序算法稳定的有：插入排序、冒泡排序、归并排序、奇偶排序、计数排序
不稳定的有：希尔排序、快速排序、选择排序、堆排序
直接上代码

public class Sort 
{
	public int[] list;
	public int size;
	//插入排序的实现
	public void insertSort()
	{
		for(int i=1;i<size;i++)               //从第二个元素开始
		{
			int key = list[i];                //保留元素值
			while(i>0 && list[i-1]>key)   //与key比较，看有无比key大的值（比key的应该后移）
			{
				list[i] = list[i-1];           //将比自己大的向后移动
				i--;                           //向前找
			}
			list[i] = key;                     //将元素放在应该放的位置
		}
	}
	//希尔排序的实现
	public void shellSort()
	{
		for(int k = size/2;k>0;k/=2)         //确定间隔
		{
			for(int i=k;i<size;i+=k)         //类似插入排序
			{
				int key = list[i];
				while(i>0 && list[i-k] > key)
				{
					list[i] = list[i-k];
					i-=k;
				}
				list[i] = key;
			}
		}
	}
	//冒泡排序的实现
	public void bubbleSort()
	{
		for(int i=0;i<size-1;i++)             //总共需要进行size-1趟
		{
			for(int j = 0;j<size-1-i;j++)     //每比较完一趟，下一趟比较次数就少一次
			{
				if(list[j]>list[j+1])         //如果又逆序对，则交换
				{
					int temp = list[j];
					list[j] = list[j+1];
					list[j+1] = temp;
				}
			}
		}
	}
	//选择排序的实现
	public void selectSort()
	{
		for(int i=0;i<size-1;i++)
		{
			int min = i;                //假设此位置的元素是最小的
			for(int j=i+1;j<size;j++)   //向后面找到最小的元素
			{
				if(list[j] < list[min])
					min = j;
			}
			int temp = list[i];        //将最小的元素放到此位置
			list[i] = list[min];
			list[min] = temp;
		}
	}
	//快速排序的实现
	//单次划分
	public int partition(int i,int j)
	{
		int pivot = list[i];      //先确定pivot
		while(i<j)
		{
			while(i<j && list[i]>=pivot)
			{						  //从右向左
				j--;                  //找到比pivot小的元素
			}
			if(i<j)
			{
				list[i] = list[j];
				i++;
			}
			while(i<j && list[i]<pivot)
			{                           //从左向右找到比pivot大的元素
				i++;
			}
			if(i<j)
			{
				list[j] = list[i];
				j--;
			}
		}
		list[i] = pivot;
		return i;
	}
	public void quickSort(int low,int high)
	{
		if(low<high)                 //不要忘了这个if，递归基
		{
			int pivotloc = partition(low, high);
			quickSort(low,pivotloc-1);
			quickSort(pivotloc+1,high);
		}
	}
	//堆排序的实现
	public void Heapify(int i,int size)   //大根堆的堆化
	{
		int l = 2*i+1;                 //左孩子的索引
		int r = 2*i+2;                 //右孩子的索引
		int largest = i;
		if(list[l]>list[largest])largest = l;
		if(list[r]>list[largest])largest = r;
		if(largest!=i)
		{
			int temp = list[i];
			list[i] = list[largest];
			list[largest] = temp;       //交换位置
			Heapify(largest, size);     //递归向下堆化
		}
	}
	public void heapSort()
	{
		for(int i = size/2-1;i>=0;i--)
		{              //初始建堆过程，从第一个非叶子节点开始堆化
			Heapify(i, size);
		}
		for(int i = size-1;i>0;i--)
		{
			int temp = list[0];        //将堆顶元素与最后一个元素互换
			list[0] = list[i];
			list[i] = temp;
			Heapify(0, i);             //继续堆化
		}
	}
	//归并排序的实现
	public void merge(int low,int mid,int high)
	{   //将一个数组分成两部分
		int n1 = mid - low + 1;       //左部分的的元素个数
	    int n2 = high - mid;           //右部分
	    int i, j, k;
	    int[] L = new int[n1+1];
	    int[] R= new int[n2+1];
	    //分别将两个部分分到两个数组中
		for(i=0;i<n1;i++)             
	        L[i]=list[low+i];               //P+i ！！！！！！！ 
	    
		for(j=0;j<n2;j++)
	        R[j]=list[mid+j+1];
	    //将两个数组的最后一个元素设为很大的值
		L[n1]=99999;               
	    R[n2]=99999;
	    for(i=0,j=0,k=low;k<=high;k++)
	    {
	        if(L[i]<=R[j])
	            list[k]=L[i++];
	        else
	            list[k]=R[j++];
	    }
	}
	public void mergeSort(int low,int high)
	{
		if(low<high)                //不要忘了递归基
		{
			int mid = (high+low)/2;
			mergeSort(low,mid);
			mergeSort(mid+1,high);
			merge(low, mid, high);
		}
	}
	//奇偶排序的实现
	public void Odd_even_sort()
	{
		boolean sorted = false;
		while(!sorted)
		{
			sorted = true;
			for(int i = 0;i<size-1;i+=2)      //注意i<size-1
			{
				if(list[i]>list[i+1])
				{
					int temp = list[i];
					list[i] = list[i+1];
					list[i+1] = temp;
					sorted = false;
				}
			}
			for(int i = 1;i<size-1;i+=2)
			{
				if(list[i]>list[i+1])
				{
					int temp = list[i];
					list[i] = list[i+1];
					list[i+1] = temp;
					sorted = false;
				}
			}
		}
	}
	//计数排序的实现
	void countingSort() 
	{
		int maxNum = list[0];                          
		for (int i = 1; i < size; i++)
			if (list[i] > maxNum)maxNum = list[i];    //找到最大整数
		
		int[]c = new int[maxNum + 1];
		for(int ele:c)
			ele=0;
		for (int i = 0; i < size; i++)
			c[list[i]]++;       				   //统计每个元素有几个
		for (int i = 1; i <= maxNum; i++)
			c[i] += c[i - 1];   					//前缀和
		
		int b[] = new int[size];				   //反向填充
		for (int i = size - 1; i >= 0; i--) 
		{	
			b[--c[list[i]]] = list[i];
			//b[c[a[i]] - 1] = a[i];
			//--c[i];
		}
	}

}