基本排序算法-java

import java.util.Arrays;
import java.util.Scanner;

import com.sun.scenario.effect.Merge;
import com.sun.xml.internal.ws.dump.LoggingDumpTube.Position;
/
public class SortUtils {
	/**
	 * 简单插入排序   内部排序 稳定
	 * 平均时间复杂度 O(n^2)  最好时间复杂度  O(n)  最坏时间复杂度  O(n^2)
	 * 空间复杂度O(1):辅助存储
	 * @param array
	 * @return
	 */
	public static int[] insertSort(int[] array){
		for (int i = 1; i < array.length; i++) {
			int temp = array[i];
			int j = i-1;
			for (; j >= 0 && array[j] > temp; j--) {
				array[j+1] = array[j];//将大于temp的元素统一后移一个位置
			}
			array[j+1] = temp;
		}
		return array;
	}
	/**
	 * 对简单插入排序的改进，算法竞赛推荐用该函数
	 * 希尔排序  内部排序  不稳定
	 * 平均时间复杂度O(n^1.3)  最好时间复杂度  O(n)  最坏时间复杂度  O(n^2)
	 * 空间复杂度O(1):辅助存储
	 * @param array
	 * @return
	 */
	public static int[] shellSort(int[] array){
		int k = array.length/2;
		int temp = 0;
		while(k > 0){
			for (int i = k; i < array.length; i++) {
				temp = array[i];
				int j = i-k;
				for (; j>=0 && array[j] > temp; j-=k) {
					array[j+k] = array[j];
				}
				array[j+k] = temp;
			}
			k /= 2;
		}
		return array;
	}
/
	/**
	 * 简单选择排序  内部排序  不稳定
	 * 平均时间复杂度  O(n^2) 最好时间复杂度  O(n^2)  最坏时间复杂度  O(n^2)
	 * 空间复杂度O(1):辅助存储
	 * @param array
	 * @return
	 */
	public static int[] selectSort(int[] array){
		for (int i = 0; i < array.length; i++) {
			int postion = i;
			int j = i+1;
			int temp = array[i];
			for(;j < array.length;j ++){
				if(array[j] < temp){//找出当前最小值并标记对应位置
					postion = j;
					temp = array[j];
				}
			}
			array[postion] = array[i];
			array[i] = temp;
		}
		return array;
	}
	/**
	 * 对简单选择排序的改进
	 * 堆排序  内部排序  不稳定
	 * 平均时间复杂度O(nlog(n))  最好时间复杂度O(nlog(n))  最坏时间复杂度O(nlog(n))
	 * 空间复杂度O(1):辅助存储
	 * @param array
	 * @return
	 */
	public  static int[] heapSort(int[] array){
	       System.out.println("开始排序");
	       int arrayLength=array.length;
	       //循环建堆
	       for(int i=0;i<arrayLength-1;i++){
	           //建堆
	           buildMaxHeap(array,arrayLength-1-i);
	           //交换堆顶和最后一个元素
	           swap(array,0,arrayLength-1-i);
	           System.out.println(Arrays.toString(array));
	       }
	       return array;
	}
    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;
                }
            }
        }
    }
/
    /**
     * 冒泡排序  内部排序  稳定
     * 平均时间复杂度O(n^2)  最好时间复杂度O(n)  最坏时间复杂度O(n^2)
	 * 空间复杂度O(1):辅助存储
     * @param array
     * @return
     */
    public static int[] bubbleSort(int[] array){
    	for (int j = 1; j < array.length; j++) {
    		for(int i = 0;i < array.length-j;i++){
    			if(array[i]>array[i+1]){
    				swap(array, i,i+1);
    			}
    		}
		}
    	return array;
    }
    /**
     * 快速排序  内部排序  不稳定
     * 平均时间复杂度O(nlog(n)) 最好时间复杂度O(nlog(n)) 最坏时间复杂度O(n^2) 
     * 空间复杂度O(nlog(n)) 
     * @param array  待排序数组
     * @param low  数组左指针
     * @param hight 数组右指针
     * @return
     */
    public static int[] quickSort(int[] array,int low,int hight){
    	if(low < hight){
    		int position = Position(array,low,hight);
    		quickSort(array, low, position-1);
    		quickSort(array, position+1, hight);
    	}
    	return array;
    }
	private static int Position(int[] array, int low, int hight) {
		int sentry = array[low];//设置哨兵
		while(low < hight){
			while(low < hight && array[hight] >= sentry)hight--;
			array[low] = array[hight];
			while(low < hight && array[low] <= sentry)low++;
			array[hight] = array[low];
		}
		array[low] = sentry;
		return low;
	}
	/**
	 * 归并排序 内部排序 稳定
	 * 平均时间复杂度O(nlog(n)) 最好时间复杂度O(nlog(n)) 最坏时间复杂度O(nlog(n)) 
     * 空间复杂度O(n) 
	 * @param array1 待排序数组
	 * @param start 排序起始位置
	 * @param end 排序终止位置
	 * @return 返回排序后的数组
	 */
	public static int[] mSort(int[] array,int start,int end){
		int pos = (start+end)>>1;
		if(start < end){
			mSort(array, start, pos);//左边
			mSort(array, pos+1, end);//右边
			merge(array,start,pos,end);//左右归并
		}
		return array;
	}
	private static void merge(int[] array, int start, int pos, int end) {
		int[] tmp = new int[end-start+1];
		int k = 0;//临时数组下标起始位置
		int i = start;//左路数组下标起始位置
		int j = pos + 1;//右路数组下边起始位置
		while(i <= pos && j <= end){//把较小的数移新数组中
			if(array[i] < array[j]){
				tmp[k++] = array[i++];
			}else{
				tmp[k++] = array[j++];
			}
		}
		while(i <= pos){//归并左边剩余数组元素
			tmp[k++] = array[i++];
		}
		while(j <= end){//归并右边剩余数组元素
			tmp[k++] = array[j++];
		}
		for(int k1 = 0;k1 < tmp.length;k1++){
			array[k1+start] = tmp[k1];//将临时数组元素覆盖到排序数组中
		}
	}
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int N = 0;
		while(scan.hasNext()){
			N = scan.nextInt();
			int[] array = new int[N];
			for (int i = 0; i < array.length; i++) {
				array[i] = scan.nextInt();
			}
			for (int i = 0; i < array.length; i++) {
				System.out.print(array[i]);
			}
//			insertSort(array);
//			shellSort(array);
//			selectSort(array);
//			heapSort(array);
//			bubbleSort(array);
//			quickSort(array, 0, array.length-1);
			mSort(array, 0, array.length-1);
			for (int i = 0; i < array.length; i++) {
				System.out.print(array[i]);
			}
		}
		scan.close();
	}

}