面试常用排序算法

public class Sort {
	// 插入排序
	public void insertSort(int array[], int length) {
		// 从1开始遍历
		for (int i = 1; i < length; i++) {
			int j = i - 1;
			//temp用来记录需要插入的值
			int temp = array[i];
			for (; j >= 0 && temp < array[j]; j--) {
				// 整体后移
				array[j + 1] = array[j];
			}
			//因为最后结束的时候，j又被剪了一次，所以j要加1
			// 插入
			array[j + 1] = temp;
		}
	}

	// 冒泡排序
	public void bubbleSort(int array[], int length) {
		for (int i = 0; i < length; i++) {
			// 核心点在于j < length - 1 - i
			for (int j = 0; j < length - 1 - i; j++) {
				if (array[j] > array[j + 1]) {
					int temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
	}

	// 直接选择排序
	public void selectSort(int array[], int length) {
		// 外层循环是n-1次
		for (int i = 0; i < length - 1; i++) {
			int min = i;
			// 从i+1到最后选择出一个最小的
			for (int j = i + 1; j < length; j++) {
				if (array[j] < array[min]) {
					min = j;
				}
			}
			// 互换
			if (min != i) {
				int temp = array[i];
				array[i] = array[min];
				array[min] = temp;
			}
		}
	}

	// 快速排序之分组
	public int partition(int array[], int low, int high) {
		int pivot = array[low];
		// 双while结构
		while (low < high) {
			//右侧的比pivot大，high指针向左移动
			while (low < high && array[high] >= pivot)
				high--;
			//此时右侧的比pivot小了
			if (low < high)
				//互换，并且low指针向右移动
				array[low++] = array[high];
			while (low < high && array[low] <= pivot)
				low++;
			if (low < high)
				array[high--] = array[low];
		}
		array[low] = pivot;
		return low;
	}

	// 快速排序
	public void quickSort(int array[], int low, int high) {
		int dp;
		if (low < high) {
			// 分治法
			dp = partition(array, low, high);
			//快排左侧
			quickSort(array, low, dp - 1);
			//快排右侧
			quickSort(array, dp + 1, high);
		}
	}

	public void buildMaxHeap(int array[]) {
		int half = array.length / 2;
		for (int i = half; i >= 0; i--) {
			//每个非叶子结点都要建一个大顶堆
			maxHeap(array, array.length, i);
		}
	}

	//建立大顶堆的过程
	private void maxHeap(int[] array, int length, int i) {
		int left = i * 2 + 1;
		int right = i * 2 + 2;

		int largest = i;
		if (left < length && array[left] > array[i]) {
			largest = left;
		}
		if (right < length && array[right] > array[largest]) {
			largest = right;
		}
		// 大的换上去
		if (i != largest) {
			int temp = i;
			i = largest;
			largest = temp;
			// 此刻的largest就是被换下来的i
			maxHeap(array, length, largest);
		}
	}

	// 堆排序
	public void heapSort(int array[]) {
		// 建立大顶堆
		buildMaxHeap(array);

		for (int i = array.length - 1; i >= 1; i--) {
			// 把最大的放到最后
			int tmp = array[0];
			array[0] = array[i];
			array[i] = tmp;

			//i是数组长度，出去已经排完序的，0是要被调整的结点的index
			maxHeap(array, i, 0);
		}
	}

	//希尔排序
	public void shellSort(int array[]) {
		//增量每次变为原来的0.5
		for (int increment = array.length/2; increment > 0; increment /= 2) {
			//每一个分组里的每个数都要比较
			for(int i = 0;i<increment;i++){
				//插入排序--本质
				for(int j = i + increment;j<array.length;j+=increment){
					if(array[j]<array[j-increment]){
						//存下来需要插入的数
						int temp = array[j];
						int k = j-increment;
						for(;k>=0 && temp < array[k];k-=increment){
							array[k+increment] = array[k];
						}
						array[k+increment] = temp;
					}
				}
			}
		}
	}

	//排序
	public int[] sort(int array[],int low,int high){
		int mid = (low + high) /2;
		sort(array,low,mid);
		sort(array,mid + 1,high);
		//将排完序的左侧和右侧合并起来
		merge(array,low,mid,high);
		return array;
	}
	//归并
	public void merge(int array[],int low,int mid,int high){
		int temp[] = new int[high -low +1];
		int i = low;
		int j = mid + 1;
		int k = 0;
		
		//小的进去
		while (i <= mid && j <= high) {  
            if (array[i] < array[j]) {  
                temp[k++] = array[i++];  
            } else {  
                temp[k++] = array[j++];  
            }  
        }  
		
		while(i<= mid){
			temp[k++] = array[i++];
		}
		
		while(j<= high){
			temp[k++] = array[j++];
		}
		
		for(int m = 0;m<temp.length;m++){
			array[low + m] = temp[m];
		}
	}
	
	//二分查找法 必须是对已经排好序的进行
	public int binarySearch(int array[],int des){
		int low = 0;
		int upper = array.length-1;
		while(low <= upper){
			int mid = (low + upper) / 2;
			if(array[mid] <des){
				low = mid + 1;
			}else if(array[mid]>des){
				upper = mid - 1;
			}else
				return mid;
		}
		return -1;
	}
}