几种排序算法

package com.tydic;

import java.util.Arrays;

public class InsertSort {
	/**
	 * 1.直接插入排序:
	 * 基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已是排.
	 * 好顺序的，如今要把第n个数插到前面的有序数中，使得这n个数.
	 * 也是排好顺序的。如此反复循环，直到所有排好顺序.
	 */
	public static void insertSort() {
		int a [] = {49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
		int temp=0;
		for(int i=0;i<a.length;i++) {
			int j = i-1;
			temp = a[i];
			for(;j>=0&&temp<a[j];j--) {
				a[j+1]=a[j];
			}
			a[j+1]=temp;
		}
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+"->");
		}
	}
	/**
	 * 2.希尔排序（最小增量排序）:
	 * 基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分红若干组，每组中.
	 * 记录的下标相差d.对每组中所有元素进行直接插入排序，而后再用一个较小的增量（d/2）对它进行分组.
	 * 在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成.
	 */
	public static void shellSort() {
		int a [] = {1,54,6,3,78,34,12,45,56,100};
		double dl = a.length;
		int temp = 0;
		while(true) {
			dl = Math.ceil(dl/2);
			int d = (int) dl;
			for(int x=0;x<d;x++) {
				for(int i=x+d;i<a.length;i+=d) {
					int j=i-d;
					temp=a[i];
					for(;j>=0&&temp<a[j];j-=d) {
						a[j+d]=a[j];
					}
					a[j+d]=temp;
				}
			}
			 if(d==1) {
				 break;
			 }
		}
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+"->");
		}
	}
	/**
	 * 3.简单选择排序:
	 * 基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换
	 * 而后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
	 */
	public static void selectSort() {
		int a[]={1,54,6,3,78,34,12,45};  
		int position=0; 
		for(int i=0;i<a.length;i++) {
			int j=i+1;
			position=i;  
			int temp=a[i];  
			for(;j<a.length;j++){
				if(a[j]<temp){  
					temp=a[j];  
					position=j;
				}
			}
			a[position]=a[i];  
			a[i]=temp;
		}
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+"->");
		}
	}
	
	/**
	 * 4.堆排序:
	 * 基本思想：堆排序是一种树形选择排序，是对直接选择排序的有效改进。
	 * 堆的定义以下：具备n个元素的序列（h1,h2,...,hn),当且仅当知足（hi>=h2i,hi>=2i+1）或
	 *（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)时称之为堆。在这里只讨论知足前者条件的堆。由堆的定义可
	 * 以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。彻底二叉树能够很直观地表示堆的结构。堆 
	 * 顶为根，其它为左子树、右子树。初始时把要排序的数的序列看做是一棵顺序存储的二叉树，调整它们的存储序，
	 * 使之成为一个堆，这时堆的根节点的数最大。而后将根节点与堆的最后一个节点交换。
	 * 而后对前面(n-1)个数从新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们做交换，最后获得有n个节点的有序序列。
	 * 从算法描述来看，堆排序须要两个过程，一是创建堆，二是堆顶与堆的最后一个元素交换位置。因此堆排序有两个函数组成。
	 * 一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
	 */
	public static void heapSort() {
		int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};  
		int arrayLength=a.length;
		//循环建堆
		for(int i=0;i<arrayLength-1;i++){  
			//建堆
			buildMaxHeap(a,arrayLength-1-i);  
			//交换堆顶和最后一个元素 
			swap(a,0,arrayLength-1-i);  
			System.out.println(Arrays.toString(a));  
		}
		
	}
	private static void swap(int[] data, int i, int j) { 
		int tmp=data[i];  
		data[i]=data[j];  
		data[j]=tmp;
	}
	//对data数组从0到lastIndex建大顶堆  
	private static void buildMaxHeap(int[] data, int lastIndex) {
		//从lastIndex处节点（最后一个节点）的父节点开始  
		for(int i=(lastIndex-1)/2;i>=0;i--){  
			 //k保存正在判断的节点  
			 int k=i;
			 //若是当前k节点的子节点存在 
			 while(k*2+1<=lastIndex){  
				 //k节点的左子节点的索引 
				 int biggerIndex=2*k+1;  
				 //若是biggerIndex小于lastIndex，即biggerIndex+1表明的k节点的右子节点存
				 if(biggerIndex<lastIndex){  
					 //若果右子节点的值较大  
					 if(data[biggerIndex]<data[biggerIndex+1]){  
						 //biggerIndex老是记录较大子节点的索引  
						 biggerIndex++;  
					 }
				 }
				  //若是k节点的值小于其较大的子节点的值 
				 if(data[k]<data[biggerIndex]){  
					 //交换他们  
					 swap(data,k,biggerIndex); 
					//将biggerIndex赋予k，开始while循环的下一次循环，从新保证k节点的值大于其左右子节点的值  
					 k=biggerIndex;  
				 }else {
					 break; 
				 }
			 }
		}
	}
	
	/**5.冒泡排序:
	 * 基本思想：在要排序的一组数中，对当前还未排好序的范围内的所有数，自上而下对相邻的两个数依
	 * 次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排
	 * 序要求相反时，就将它们互换.
	 * 
	 */
	public static void bubbleSort() {
		int a[]={49,38,65,97,76,13,27,49,78,34};  
		int temp=0; 
		for(int i=0;i<a.length-1;i++){  
			for(int j=0;j<a.length-1-i;j++){  
				if(a[j]>a[j+1]){  
					temp=a[j];  
					a[j]=a[j+1];  
					 a[j+1]=temp;
				}
			}
		}
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+"->");
		}
	}
	
	/**
	 * 6.快速排序:
	 * 基本思想：选择一个基准元素,一般选择第一个元素或者最后一个元素,经过一趟扫描，将待排序列分
	 * 成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,而后再
	 * 用一样的方法递归地排序划分的两部分。
	 */
	public static void quickSort() {
		int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
		quick(a);  
		for(int i=0;i<a.length;i++)  {
			System.out.print(a[i]+"->");  
		}
		
	}
	private static void quick(int[] a2) {
		//查看数组是否为空    
		if (a2.length > 0) {
			_quickSort(a2, 0, a2.length - 1);     
		}
	}
	private static void _quickSort(int[] list, int low, int high) { 
		if (low < high) { 
			int middle = getMiddle(list, low, high);  //将list数组进行一分为二   
			 _quickSort(list, low, middle - 1);        //对低字表进行递归排序     
			 _quickSort(list, middle + 1, high);       //对高字表进行递归排序     
		}
	}
	private static int getMiddle(int[] list, int low, int high) {   
		int tmp = list[low];    //数组的第一个做为中轴     
		while (low < high) {
			while (low < high && list[high] >= tmp) {
				high--;
			}
			list[low] = list[high];   //比中轴小的记录移到低端 
			while (low < high && list[low] <= tmp) {    
				low++;     
			}
			list[high] = list[low];   //比中轴大的记录移到高端  
		}
		list[low] = tmp;              //中轴记录到尾     
		
		return low;     
	}
	public static void main(String [] args ) {
		//insertSort();
		//shellSort();
		//selectSort();
		//heapSort();
		//bubbleSort();
		quickSort();
	}
}