java基本排序和查找

基本排序：

一、冒泡排序：

原理：依次比较相邻的两个数，将小数放在前面，大数放到后面。即首先比较第一个和第二个数，将小数放前，大数放后。然后，比较第二个数和第三个数，

            将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复以上过程，仍从第一对数开始比较（因为可能由于第二个数

            和第三个数的交换，使第一个数不再小于第二个数），将小数放前，大数放后，一直比较到最大数前的一对相邻数，将小数放前，大数放后。

            第二次冒泡结束，在倒数第二个数中得到一个新的最大数。如此下去，直至最终完成排序。由于在排序过程中总是小数往前排，大数往后排，

            相当于气泡上升，所以称为冒泡排序。

/**
 * @param Bruce 冒泡排序
 */
	public static void BubbleSort(int a[]){
		for(int i=0;i<a.length-1;i++){
			for(int j=0;j<a.length-i-1;j++){
				if(a[j]>a[j+1]){
					a[j+1]=a[j]+a[j+1];
					a[j]=a[j+1]-a[j];
					a[j+1]=a[j+1]-a[j];
			        }
		        }
		}
	}

二、插入排序：

原理：顺序的把待排序的数据元素按其值的大小插入到已排序数据元素子集合的合适位置。所以，是经过排序而得到的局部有序。

/**
 *@param Bruce 插入排序
 */
public static void insertSort(int a[]){
		int j,i,k;
		for(i=0;i<a.length;i++){
			k=a[i];
			for(j=i-1;j>=0&&a[j]>k;j--){
				a[j+1]=a[j];
			}
		  a[j+1]=k;
		}
	}

三、选择排序：

原理：每次都找到当次最大的数，按大小顺序依次放入数组相应的位置。

/**
 * @param Bruce 选择排序
 */
	public  static  void SelectSort(int[]  a){
		int temp=0;
		  int max=0;  
		  	for(int i=0;i<a.length;i++){
		  		max=i;
		  		for(int d=0;d<a.length;d++){
		  			if(a[max]<a[d]){
		  				max=d;
		  			}
		  			if(i!=max){
		  				temp=a[i];
		  				a[i]=a[max];
		  				a[max]=temp;
		  			}
		  		}
		  	} 
	
		}

四、快速排序：

原理：通过一次排序将要排序的数据分割成独立的两个部分，其中一部分的所有数据都比另一部分所有数据要小，

            然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变为有序序列。

/**
 * @param Bruce 快速排序
 */
	public static void doQuickSort(int arr[],int left,int right){
		int middle,strTemp;
		int i=left;
		int j=right;//
		middle=arr[(left+right)/2];//中间值
		do{
			while(arr[i]<middle){
				i++;
			}
			while(arr[j]>middle){
				j--;
			}
			
			if(i<=j){
				strTemp=arr[i];
				arr[i]=arr[j];
				arr[j]=strTemp;
			        i++;
				j--;
			}
			
		}while(i<j);//知道i==j,也就是说两边扫描交错的时候
		
		if(left<j){
			doQuickSort(arr,left,j);
		}
		if(right>i){
			doQuickSort(arr,i,right);
		}			
	}

扩展：

        堆排序(选择排序的升级)

        希尔排序(插入排序的升级)

        快速排序(冒泡排序的升级)

        归并排序(高级排序)

查找

顺序查找：从数据序列中的第一个元素开始，从头依次逐个查找，直到找到所要的数据或搜索完整个数据序列。适用于少量，无规则的数据。

折半查找(Binary Search)：又称二分查找。要求数据序列呈现线性结构，也就是经过排序的。

public class Search {

	static int[] ary = { 99, 67, 12, 7, 30, 66, 10, 1, 98, 23, 44, 91, 26, 3, 48, 55, 77, 82, 20 };

	/* 折半查找 */
	static int binarySearch(final int[] ary, final int key) {
		int head = 0;
		int tail = ary.length - 1;
		int middle = 0;
		if (key == ary[head]) //当要查找的key位于数组头时,直接返回结果.这是二分查找最耗时的位置.
			return head;
		if (key == ary[tail]) //当要查找的key位于数组尾时,直接返回结果.这是二分查找最耗时的位置.
			return tail;
		while (head <= tail) {
			middle = (head + tail) >> 1;
			System.out.println("head:" + head + "_tail:" + tail + "_middle:" + middle);
			if (key > ary[middle]) {
				head = middle + 1;
			} else if (key < ary[middle]) {
				tail = middle - 1;
			} else {
				return middle;
			}
		}
		return -1;
	}

	public static void main(String[] args) {

		int[] t = Sort.quickSort(ary, 0, ary.length - 1);
		System.out.println(Arrays.toString(t));

		int result = binarySearch(t, 99);
		System.out.println("result:" + result);

	}

}

注：