Java程序员面试笔记_第八章_数据结构和算法_排序

package Java_Interview_Book;

public class Order {
	//选择排序，选出最小的与第一个位置交换。。。。。。
	public static void selectSort(int[] a) {
		int temp;//临时变量
		int flag;//标记位置
		int length = a.length;//数组长度
		
		for(int i=0;i<length;i++) {
			temp = a[i];
			flag = i;
			for(int j=i+1;j<length;j++) {
				if(a[j] < temp) {
					temp =a[j];//存储当前最小位置值
					flag = j;//标记当前最小位置
				}
			}
			if (flag != i) {//将第i小位置进行数值交换
				a[flag] = a[i];
				a[i] = temp;
			}
		}
	}
	//插入排序，每次加入的数和当前值比较，如果小和当前位置交换
	public static void insertSort(int [] a) {
		for (int i = 1; i < a.length; i++) {
			int temp = a[i];
			int j =i;
			if(a[j-1] >  temp) {
				while(j >= 1 && a[j-1] > temp) {
					a[j]=a[j-1];
					j--;
				}
			}
			a[j] = temp;
		}
	}
	//(单向)冒泡排序，相邻两两比较，假设是小到大输出
	public static void bubbleSort(int [] a ) {
		int temp;
		for (int i = 0; i < a.length; i++) {
			for (int j = i+1; j < a.length; j++) {
				if(a[i]>a[j]) {
					temp  = a[j];
					a[j] = a[i];
					a[i] = temp;
				}
			}
		}
	}
	 //两路归并算法，两个排好序的子序列合并为一个子序列
    public static void merge(int []a,int left,int mid,int right){
        int []tmp=new int[a.length];//辅助数组
        int p1=left,p2=mid+1,k=left;//p1、p2是检测指针，k是存放指针

        while(p1<=mid && p2<=right){
            if(a[p1]<=a[p2])
                tmp[k++]=a[p1++];
            else
                tmp[k++]=a[p2++];
        }

        while(p1<=mid) tmp[k++]=a[p1++];//如果第一个序列未检测完，直接将后面所有元素加到合并的序列中
        while(p2<=right) tmp[k++]=a[p2++];//同上

        //复制回原数组
        for (int i = left; i <=right; i++) 
            a[i]=tmp[i];
    }

    public static void mergeSort(int [] a,int start,int end){
        if(start<end){//当子序列中只有一个元素时结束递归
            int mid=(start+end)/2;//划分子序列
            mergeSort(a, start, mid);//对左侧子序列进行递归排序
            mergeSort(a, mid+1, end);//对右侧子序列进行递归排序
            merge(a, start, mid, end);//合并
        }
    }
    //快排，以某个数作为基数，划分成数组，左边子数组每个元素都小于右边数组

    public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;    
        temp = arr[low];//temp就是基准位
        while (i<j) {
            //先看右边，依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边，依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
 
        }
        //最后将基准为与i和j相等位置的数字交换
         arr[low] = arr[j];
         arr[j] = temp;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
		
	}
    //希尔排序（缩小增量排序），分成几个子序列，对各个子序列之间进行直接插入排序
    //设定一个增量,先从array[0]开始以为增量的进行直接插入排序，直到数组末尾..z直到array[n]
    //然后取一个小于上一步增量的新的增量,直到增量小于1
    public static void shellSort(int [] a) {
    	int length = a.length;
    	//increNum增量设置，一般为数组一半
    	for(int increNum = length/2;increNum>0;increNum/=2) {
    		for(int i =0; i<length;i++) {
    			//插入排序,步长为increNum
    			for (int j = i; j < length-increNum; j+=increNum) {
					if(a[j]>a[j+increNum]) {
						int temp=a[j];
						a[j] = a[j+increNum];
						a[j+increNum] = temp;
					}
				}
    		}//end for i
    	}//end for increNum	
    }// end shellSort
    //堆排序，大顶堆（r[i]>=r[2i] && r[i]>=r[2i+1]）
    //构建堆，将堆顶元素和最后一个元素位置进行交换
    public static void maxHeapSort(int [] a) {
    	int length = a.length;
    	if(a == null || length <=2) {
    		return;
    	}
    	//变成大根堆
    	for(int i =0; i < length;i++) {
    		heapInsert(a,i);
    	}
    	for(int i =0; i < length;i++) {
    		System.out.println("大根堆"+a[i]);
    	}
    	// 删除堆顶  自上而下
    	swap(a, 0, --length);
    	while(length>0){
    		heapify(a,0,length);
    		swap(a, 0, --length);
    	}
    	
    } 
    public static void heapify(int []a,int index,int length) {
    	int left = 2*index+1;//左孩子索引值
    	while(left<length) {
    		int largest = left+1<length && a[left+1] > a[left]?left+1:left;
    		largest = a[largest]>a[index]?largest:index;
    		if(largest == index) break;
    		swap(a, largest, index);
    		left = 2*index+1;
    	}
    	
    }
    public static void heapInsert(int []a,int i) {
    	while(a[i]>a[(i-1)/2]) {
    		swap(a, i, (i-1)/2);
    		i=(i-1)/2;
    	}
    }
    public static  void swap(int [] a ,int i ,int j) {
		a[i] = a[i] ^ a[j];	
		a[j] = a[i] ^ a[j];	
		a[i] = a[i] ^ a[j];
    }
	public static void main(String [] args) {
		int a[] = {5,7,6,0,1,3,2};
//		selectSort(a);
//		insertSort(a);
//		bubbleSort(a);
//		mergeSort(a,0,a.length-1);
//		quickSort(a,0,a.length-1);
//		shellSort(a);
//		maxHeapSort(a);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+"  ");
		}
		System.out.println("\n");
	}
}