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

/**
* 冒泡排序（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;
}