（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/74058248冷血之心的博客）

温故而知新，可以为师矣

“深入理解”—选择排序算法

“深入理解”—交换排序算法

“深入理解”—插入排序算法

“深入理解”—归并排序算法

    二分查找算法

不对之处请各位指出，感谢。

import org.junit.Test;
/**
 * 总结排序算法：
 * 冒泡排序、快速排序
 * 直接插入排序、折半插入排序、希尔排序
 * 选择排序、堆排序
 * 归并排序
 * 二分查找算法(递归、迭代)
 * @author ywq
 *
 *
 */
public class Solution {
    @Test
    public void sort(){
        int[] num = {10,2,3,1,67,49,38,65,97,76,13,27,0};
//		for (int i : num) {
//			System.out.print(i+" ");
//		}
//		System.out.println();
        bubbleSort(num);
//		quickSort(num, 0, num.length-1);
        
//		insertSort(num);
//		shellSort(num);
//		halfinsertSort(num);
        
//		selectSort(num);
//		heapSort(num);
        
//		mergeSort(num, 0, num.length-1);
        
        System.out.println(halfSearch2(num,0,num.length-1,3));
        for (int i : num) {
            System.out.print(i+" ");
        }
    }
    
    /**
     * 从后往前的冒泡排序
     * @param num
     */
    public void bubbleSort(int[] num){
        if(num==null)
            return;
        // 设置标志位
        boolean flag = true;
        for (int i = 0; i < num.length&&flag; i++) {
            flag = false;
            for (int j = num.length-1; j > 0; j--) {
                if(num[j]<num[j-1]){
                    int temp = num[j];
                    num[j] = num[j-1];
                    num[j-1] = temp;
                    flag = true; // 有交换时，将标志位重置为true
                }
            }
        }
    }
    /**
     * 快速排序
     * @param num
     * @param left
     * @param right
     */
    public void quickSort(int[] num, int left, int right) {
        if (num == null)
            return;
        //如果左边大于右边，则return，这里是递归的终点，需要写在前面。
        if (left >= right) {
            return;
        }
        int i = left;
        int j = right;
        int temp = num[i];
        //此处开始进入遍历循环
        while (i < j) {
            //从右往左循环
            while (i < j && num[j] >= temp) {//如果num[j]大于temp值，则pass，比较下一个
                j--;
            }
            num[i] = num[j];
            while (i < j && num[i] <= temp) {
                i++;
            }
            num[j] = num[i];


            num[i] = temp; // 此处不可遗漏，将基准值插入到指定位置
        }
        quickSort(num, left, i - 1);
        quickSort(num, i + 1, right);
    }
    
    
    /**
     * 直接插入排序算法
     * @param num
     */
    public void insertSort(int[] num){
        if(num==null)
            return ;
        for (int i = 1; i < num.length; i++) {
            int temp = num[i] ;
            int j ;       // 记得是j>=0不要忘记等号，否则，前两个将不参与比较
            for (j = i-1; j >= 0&&num[j]>temp; j--) {
                num[j+1] = num[j];  //将前面的较大元素往后移动
            }
                num[j+1] = temp;  // 将num[i]放在指定位置
        }
    }
    /**
     * 希尔排序，分组的直接插入排序
     * 多加了一成循环，增量d的初始值为数组长度的一半
     * @param num
     */
    public void shellSort(int[] num){
        if(num==null)
            return ;
        for(int d = num.length/2 ; d > 0 ; d=d/2){
            for(int i = d;i<num.length;i+=d){
                int temp = num[i];
                int j;
                for(j = i-d;j>=0&&num[j]>temp;j-=d){
                    num[j+d] = num[j];
                }
                    num[j+d] = temp;
            }
        }
    }
    /**
     * 折半插入排序:
     * left = 0;
     * right = i-1; 目标是将第i个元素插入到前面的某个位置，所以right为i-1
     * @param num
     */
    public void halfinsertSort(int[] num){
        if(num==null)
            return ;
        for (int i = 1; i < num.length; i++) {
            int left = 0;
            int right = i-1;
            int temp = num[i] ;
            while(left<=right){
                int mid = (left+right)/2;
                if(num[mid]>temp){
                    right = mid-1;
                }else if(num[mid]<temp){
                    left = mid+1;
                }
            }
            // 经过上边的循环，知道num[i]应该插入到left位置
            int j ;      
            for (j = i-1; j >= left; j--) {
                num[j+1] = num[j];  //将前面的较大元素往后移动
            }
                num[left] = temp;  // 将num[i]放在指定位置
        }
    }
    
    
    
    /**
     * 选择排序：外层循环控制着趟数，每趟的num[i]我们认为是最小值
     * @param num
     */
    public void selectSort(int[] num){
        if(num==null)
            return ;
        for(int i = 0;i<num.length;i++){
            // 内层循环j=i+1,外层循环控制着循环次数。
            // 即每趟中num[i]这个值就是本趟的最小值。i位置上是最小值 
            for (int j = i+1; j < num.length; j++) {
                if(num[i]>num[j]){
                    int temp = num[i];
                    num[i] = num[j];
                    num[j] = temp;
                }
            }
        }
    }
    /**
     * 堆排序：
     * 1、构建大顶堆
     * 2、交换堆顶和末尾元素
     * 3、继续构建大顶堆
     * @param num
     */
    public void heapSort(int[] num){
        if(num==null)
            return ;
        // 构建大顶堆
        for (int parent = (num.length)/2; parent>=0; parent--) {
            getMaxHeap(num,parent,num.length-1);
        }
        // 取堆顶元素进行交换，重新构建大顶堆
        for(int t = num.length-1;t>0;t--){
            swap(num,0,t);
            getMaxHeap(num, 0, t-1);
        }
    }
    /**
     * 交换数组中的两个位置的元素
     * @param num
     * @param i
     * @param t
     */
    private void swap(int[] num, int i, int t) {
        if(num==null)
            return ;
        int temp = num[i];
        num[i] = num[t];
        num[t] = temp;
    }
    /**
     * 构建大顶堆的方法  
     * s 代表拥有左右孩子节点的节点，即本次要调整位置的节点  
     * length 代表当前堆的长度
     * @param num
     * @param s
     * @param length
     */
    private void getMaxHeap(int[] num, int s, int length) {
        if(num==null)
            return ;
        int temp = num[s];
         // j=2*j+1是要找到j的孩子节点 
        for(int j = 2*s+1;j<length;j=2*j+1){ // j=2*s+1为s节点的左孩子，j+1为s节点的右孩子 
            // 将j指向子节点中较大值
            if(num[j]<num[j+1])
                j++;
            // 判断父节点和子节点最大值的关系
            if(temp>=num[j])
                break ; // 如果s节点的值大于其最大的孩子节点值，则，循环结束，本次不做任何改变
            // 否则
            num[s] = num[j]; // 否则将较大的孩子节点的值赋值给父节点   
            s = j; // 将j的值赋值给s，即j成为了下一波的父节点，继续比较
        }
        num[s] = temp; // 将temp放在指定位置
    }
    
    
    
    /**
     * 归并排序：
     * 将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列， 
     *     每个子序列是有序的。然后再把有序子序列合并为整体有序序列  
     * @param num
     * @param left
     * @param right
     */
    public void mergeSort(int[] num,int left,int right){
        if(num==null)
            return ;
        int mid = (left+right)/2;
        if(left<right){
            // 处理左边
            mergeSort(num, left, mid);
            // 处理右边
            mergeSort(num, mid+1, right);
            // 左右归并
            merge(num, left, mid, right);
        }
    }
    private void merge(int[] num, int left, int mid, int right) {
        // 定义一个辅助数组，所以该算法的空间复杂度为O(N)
        int[] temp = new int[right-left+1];
        int i = left;
        int j = mid+1;
        int k = 0;
        // 找出较小值元素放入temp数组中
        while(i<=mid&&j<=right){
            if(num[i]<num[j])
                temp[k++] = num[i++];
            else
                temp[k++] = num[j++];
        }
        // 处理较长部分
        while(i<=mid){
            temp[k++] = num[i++];
        }
        while(j<=right){
            temp[k++] = num[j++];
        }
        // 使用temp中的元素覆盖num中的元素
        for(int k2 = 0;k2<temp.length;k2++){
            num[k2+left] = temp[k2];
        }
    }
    
    /**
     * 基于循环的二分查找实现算法
     * @param num
     * @param target
     * @return
     */
    public int halfSearch(int[] num,int target){
        if(num==null)
            return -1;
        int left = 0;
        int right = num.length-1;
        while(left<=right){
            int mid = (left+right)/2;
            int midValue = num[mid];
            if(midValue>target)
                right = mid-1;
            else if(midValue<target)
                left = mid+1;
            else
                return mid;
        }
        return -1;
    }
    /**
     * 基于递归实现的二分查找算法
     * @param num
     * @param left
     * @param right
     * @param target
     * @return
     */
    public int halfSearch2(int[] num,int left,int right,int target){
        if(num==null)
            return -1;
        int mid = (left+right)/2;
        int midValue = num[mid];
        if(left<=right){
            if(midValue>target)
                return halfSearch2(num, left, mid-1, target);
            else if (midValue<target) 
                return halfSearch2(num, mid+1, right, target);
            else
                return mid;
        }
        return -1;
    }
}