再看冒泡和选择排序以及折半查找（二分查找）

/**
* 冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
* 冒泡排序算法的运作如下:
*1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 
*2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 
*3. 针对所有的元素重复以上的步骤，除了最后一个。 
*4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
 * */
package com.basic.array;

public class bubble {
	public void bubblesort(int[] arr){
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length-i-1; j++) {
				if(arr[j]>arr[j+1]){
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
			System.out.println("第"+(i+1)+"次排序的结果为：");
			for (int k = 0; k < arr.length; k++) {
				System.out.print(arr[k]+" ");
			}
			System.out.println();
		}
	}
	public static void main(String[] args) {
		int arr[]={23,34,45,23,3,4};
		System.out.println("未排序的数组为：");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
		System.out.println();
		bubble b=new bubble();
		b.bubblesort(arr);;
	}
}

</pre><pre code_snippet_id="1785855" snippet_file_name="blog_20160726_1_7209912" name="code" class="java"><pre name="code" class="java">package com.basic.sort;

public class Sort {

	public static void main(String[] args) {
		int arr[]=new int[]{12,34,5,6,3,2};
		Sort s=new Sort();
		System.out.println("原数组为：");
		output(arr);
		//s.bubbleSort(arr);
		s.selectSort(arr);
		//s.output(arr);
	}
	/**
	 *1、先比较数组中第一个元素和第二个元素，如果第一个元素的值比第二个元素的值大，就交换两个元素的值。
	 *2、如果不符合就拿第一个元素与第三个元素的值相比较，以此类推，这样，第一次循环就能把最小的值排在整个数组的零角标的位置。
	 *3、第一个元素的值不动，拿第二个元素与第三个元素进行比较，进行以上两个步骤。
	 *4、持续每次越来越少的元素重复上面的步骤，直到没有任何一对元素需要比较，结束。
	 * */
	public void selectSort(int arr[]){
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if(arr[i]>arr[j]){
					swap(arr,i,j);
				}
			}
			System.out.println();
			System.out.println("第"+(i+1)+"次排序的结果：");
			output(arr);
		}
	}
	public static void output(int arr[]){
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
	}
	public void swap(int arr[],int a,int b){
		int t=arr[a];
		arr[a]=arr[b];
		arr[b]=t;
	}
}

结果如下图：

冒泡结果图：     选择结果图：

//折半查找
	/**
	 * 折半查找适合数据较少的数组，而且必须是有序的数组。
	 * 取数组中第一个元素的角标值 min=0,再取数组中最后一个元素的角标值 max=arr.length-1;
	 * 再获取min和max的中间值 mid=(min+max)/2;
	 * 然后用数组中的值 arr[mid]和要查找的值key进行比较。
	 * 如果 arr[mid]<key 则 min的值变成 mid+1,否则max变成 mid-1,然后计算mid=(min+max)/2;
	 * */
	public int halfSearch1(int arr[],int key){
		int min=0,max=arr.length-1;
		int mid=(min+max)/2;
		while(arr[mid]!=key){
			if(arr[mid]<key){
				min=mid+1;
			}else if(arr[mid]>key){
				max=mid-1;
			}
			if(min>max){
				return -1;
			}
			mid=(min+max)/2;
		}
		return mid;
	}
	public int halfSearch2(int arr[],int key){
		int min=0,max=arr.length-1,mid;
		while(min<=max){
			mid=(min+max)>>1;
			if(arr[mid]<key){
				min=mid+1;
			}else if(arr[mid]>key){
				max=mid-1;
			}else
				return mid;
		}
		return -1;
	}