简单排序算法

闲来无事，把最近找的简单的排序算法研究了一下，桶排序，基数排序等等都还没开始研究的。

随手分享。

算法大多来自于网络，

import java.util.Arrays;

public class test {

	public static void main(String[] args)
	{
		int [] array={49,38, 65, 97, 76, 13, 27, 12, 11,100, 11, 49,3};
		//程序还有问题.比如当数据为49,38, 65, 97, 76, 13, 27,12,11 的时候,第一次就把最小一位放到第一位,,而出现问题 　　
		//test.method2(arry);
		//QuickSort (array, 0, array.length-1);
		//Arrays.sort(arry, 0, arry.length);
		//ShellSortArray(array);
		MergeSort(array, 0, array.length-1);
		//heapSort(array);
		for (int i = 0; i < array.length; i++)
		{
			System.out.println("result:"+array[i]);
		}
		
	} 
	
	public static void QuickSort(int [] R,int low,int high)
	{ //对R[low..high]快速排序
		 int pivotpos;      //划分后的基准记录的位置
		 if(low<high)
		 {      //仅当区间长度大于1时才须排序
			 pivotpos=partion(R,low,high); //对R[low..high]做划分
			 QuickSort(R,low,pivotpos-1); //对左区间递归排序
			 QuickSort(R,pivotpos+1,high); //对右区间递归排序
		 }
	}
	public static int partion(int []array, int i, int j)
	{
	    int pivot = array[i];
	    while (i<j)
	    {
	    	while (i<j && array[j]>pivot)
	    	{
	    		j--;
	    	}
	    	if (i<j)
	    	{
	    	    array[i++] = array [j];
	    	}
	    	while (i<j && array[i] <pivot)
	    	{
	    		i++;
	    	}
	    	
	    	if (i<j)
	    	{
	    		array[j--] = array[i];
	    	}
	    }
	    array[i] = pivot;
	    return i;
	}
	
	public static void InsertSortArray(int [] arr)
	{
		int n = arr.length;
	    for(int i=1;i<n;i++)//循环从第二个数组元素开始，因为arr[0]作为最初已排序部分 
	    { 
	        int temp=arr[i];//temp标记为未排序第一个元素 
	        int j=i-1; 
	        while (j>=0 && arr[j]>temp)/*将temp与已排序元素从小到大比较，寻找temp应插入的位置*/ 
	        { 
	            arr[j+1]=arr[j]; 
	            j--; 
	        }
	        arr[j+1]=temp; 
	     } 
	 }
	
	
         public static void Bubblesort(int[] arr)
         {
            int i,j;
            int n= arr.length;
            for (i=n; i>0; i--)
            {
                for (j=1; j<i; j++)
               {
                   if (arr[j-1]>arr[j])
                   {
                       swap(arr, j, j-1);
                   }
               }
            }
     
        }	

        public static void ShellSortArray(int [] arr)
	{
		int n = arr.length;
	    for(int incr=n/3;incr>0;incr/=3)//增量递减，以增量3，2，1为例 
	    { 
	      for(int L=0;L<(n-1)/incr;L++)//重复分成的每个子列表 
	      { 
	          for(int i=L+incr;i<n;i+=incr)//对每个子列表应用插入排序 
	          { 
	             int temp=arr[i]; 
	             int j=i-incr; 
	             while(j>=L&&arr[j]>temp) 
	             { 
	                arr[j+incr]=arr[j]; 
	                j-=incr; 
	             } 
	             arr[j+incr]=temp; 
	          } 
	      } 
	    } 
	}
	
	public static void MergeSort(int[] arr, int low,int high) 
	{ 
	    if(low>=high)
	    {
	    	return;//每个子列表中剩下一个元素时停止 
	    }
	    else
	    {  
	       int mid=(low+high)/2;/*将列表划分成相等的两个子列表,若有奇数个元素，则在左边子列表大于右侧子列表*/ 
	       MergeSort(arr, low, mid);//子列表进一步划分 
	       MergeSort(arr, mid+1, high);
	       int [] B=new int [high-low+1];//新建一个数组，用于存放归并的元素 
	       int i,j,k;
	       for(i=low,j=mid+1,k=0;i<=mid && j<=high;k++)/*两个子列表进行排序归并，直到两个子列表中的一个结束*/ 
	       { 
	           if (arr[i]<=arr[j]) 
	           { 
	             B[k]=arr[i]; 
	             i++; 
	           } 
	           else
	           { 
	               B[k]=arr[j]; 
	        	   j++;
	           } 
	       }
           for(   ;j<=high;j++,k++)//如果第二个子列表中仍然有元素，则追加到新列表 
               B[k]=arr[j]; 
           for(   ;i<=mid;i++,k++)//如果在第一个子列表中仍然有元素，则追加到新列表中 
               B[k]=arr[i]; 
           i = low;
           for(int z=0;z<high-low+1;z++, i++)//将排序的数组B的 所有元素复制到原始数组arr中 
           arr[i]=B[z];
	    }
    } 
	
    public static void heapSort(int[] data){
        System.out.println("开始排序");
        int arrayLength=data.length;
        //循环建堆
        for(int i=0;i<arrayLength-1;i++)
        {
            //建堆
            buildMaxHeap(data,arrayLength-1-i);
            //交换堆顶和最后一个元素
            swap(data,0,arrayLength-1-i);
            System.out.println(Arrays.toString(data));
        }
    }
    
    private static void swap(int [] data, int i, int j) 
    {
        // TODO Auto-generated method stub
    	int  tmp=data[i]; 
        data[i]=data[j];
        data[j]=tmp;
    }
    
    //对data数组从0到lastIndex建大顶堆
    private static void buildMaxHeap(int[] data, int lastIndex) 
    {
        // TODO Auto-generated method stub
        //从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;
                }
                
            }
        }
    }

}

 可以用于面试忽悠，哈哈，:)