排序

冒泡排序的思想：遍历数组的所有元素，比较相邻的2个元素，如果他们顺序错误，就交换他们，遍历第一次，最大的数字就移动到最后。下一次遍历剩下的元素，将第二最大的数字移动到倒数第二的位置上，依次遍历，直到最后数组有序。
选择排序的思想：遍历数组所有元素，记住最大元素的位置，然后将最大的元素和最后一个元素交换，再遍历余下的元素，找出余下元素的最大值，和倒数第二的位置进行交换，依次遍历，直到所有元素有序。不稳定。
插入排序的思想：遍历所有元素，每经过一个元素，就在前面的元素中找到该元素的正确位置，并把该元素插入该位置，遍历完成，数组变成有序。
希尔排序的思想：插入排序的扩展，通过允许相隔较远的元素进行交换，然后逐步缩小间隔，来提高速度。
计数排序的思想：将每个元素对应放到一个抽屉里，相同元素的计数增加。需要n个不同数字的抽屉，空间要求高。不稳定。
归并排序的思想：分而治之的思想，递归的拆分数组，直到拆分到包含2个元素为止，将这2个元素排序，然后依次回归，将拆分出来的数组进行合并排序，直到最后全部排序完成。
快速排序的思想：选定一个元素a，然后分别从数组的两端遍历元素，和元素a比较，从前端找到比a大的元素，从后端找到比a小的元素，然后交换这2个元素，继续遍历，直到前端位置和后端位置相交，此时将a与后端位置的元素交换。再继续按照以上方法分别处理a左右两边的元素，直到排序完成。

希尔排序程序如下：

	public void test3(int[] n){
	    //初始跨度为数组大小
		int gap = n.length;
		int len = n.length;
		int tmp = 0;
		while(gap > 0){
			for(int i=gap; i<len; i++){
				//以跨度大小进行循环处理数组
				for(int j=i; j>gap - 1; j=j - gap){
					//比较数值大小，并进行交换
					if(n[j - gap] > n[j]){
						tmp = n[j - gap];
						n[j - gap] = n[j];
						n[j] = tmp;
					}
				}
			}
			//将跨度减半
			if(gap == 2){
				gap = 1;
			} else {
				gap = gap / 2;
			}
		}
	}

将一个排序的数组，从某个位置断开，然后将前段放到最后，在新的数组中查找最小的数字。

public int search(int[] n,int dest){
    //判断是否空数组
    if(n.length == 0){
        return -1;
    }
    int left = 0;
    int mid = 0;
    int right = n.legth - 1;
    //循环遍历数组
    while(left + 1 < right){
        mid = left + (right - left) / 2;
        //如果中间的值等于目标值，直接返回中间位置索引
        if(n[mid] == dest){
            return mid;
        }
        //如果左边是有序的
        if(n[left] <= n[mid]){
            //若目标值在左边，继续在左边查找
            if(n[left] <= dest && dest <= n[mid]){
                right = mid;
            } else {
                left = mid;
            }
        } else {
            //如果目标值在右边，继续在右边查找
            if(n[mid] <= dest && dest <= n[right]){
                left = mid;
            } else {
                right = mid;
            }
        }
    }
    //如果左边的值等于目标值，返回左边的位置索引
    if(n[left] == dest){
        return left;
    }
    if(n[right] == dest){
        return right;
    }
    return -1;
}

归并排序程序

	public void sort(int[] n,int start,int end){
	    //计算数组的中间位置
	    int mid = start + (end - start) / 2;
	    if(start < end){
	        //前半段排序
	    	sort(n,start,mid);
	    	//后半段排序
	    	sort(n,mid+1,end);
	    	//合并
	    	merge(n,start,mid,end);
	    }

	}
	static void merge(int[] n,int start,int mid,int end){
		int[] tmp = new int[end - start + 1];
		int i = start;
		int j = mid+1;
		int k = 0;
		//遍历前后数组，并进行排序，将排序结果保存在临时数组中
		while(i <= mid && j <= end){
			if(n[i] > n[j]){
				tmp[k++] = n[j++];
			} else {
				tmp[k++] = n[i++];
			}
		}
		//将左边剩余数加到临时数组
		while(i <= mid){
			tmp[k++] = n[i++];
		}
		//将右边剩余数加到临时数组
		while(j <= end){
			tmp[k++] = n[j++];
		}
		//将临时数组的内容覆盖原来数组的内容
		for(int m=0; m<tmp.length; m++){
			n[m+start] = tmp[m];
		}
	}
	//测试案例
	public static void main(String[] args){
	    int[] d = new int[]{1,5,7,9,3,2};
	    sort(d,0,5);
	}