查找、排序算法

一.有序数组的折半查找

【步骤】

 ① low=0,high=length-1;     //初始值

 ② 当low>high时，返回查找失败信息

 ③ low<=high时，mid=(low+high)/2

     a.若key<a[mid],high=mid-1;    //查找在左半区

     b.若key>a[mid],low=mid+1;    //查找在右半区

     c.若key=a[mid],返回mid           //查找成功

【算法实现】

public int binarySearch(int[] a,int key) {
    int len=a.length;
    int low=0;
    int high=len-1;
    while(low<=high) {
        int mid=(low+high)/2;     
        if(a[mid]<key) {            //在右半区
            low=mid+1;    
        }else if(a[mid]>key) {   //在左半区
            high=mid-1;         
        }else {
            return mid;       //查找成功
        }  
    }
    return -1;             //查找失败
}

another:

public int binarySearch(int[] nums,int left,int right,int target) {
    if(left<=right) {
       int mid=(left+right)/2;
       if(nums[mid]==target)
           return mid;
       else if(nums[mid]<target) 
           return binarySearch(nums,mid+1,right,target);
       else
           return binarySearch(nums,left,mid-1,target);     
    }else {
       return -1;    
    }    
} 

二.快速排序

【基本思想】

1.选择一个基准元素，通常选择第一个或者最后一个元素

2.通过一趟排序将待排序的记录分成两个部分，其中一部分都比基准元素小，另一部分都比基准元素大

3.将基准元素放在排好序的正确位置

4.分别对两部分采取同样的排序，直到整个记录有序

【算法实现】

//完成一趟排序，并返回基准元素所在的索引
public int partition(int[] A,int low,int high) {
    int pivotKey=A[low];
    while(low<high) {
        while(low<high&&pivotKey>A[high])
             high--;
        if(low<high)
             A[low++] = A[high];
        while(low<high&&pivotKey<A[low])
             low++;
        if(low<high)
             A[high--] = A[low];            
    }
    A[low] = pivotKey;
    return low;    
}
//快速排序
public void quickSort(int[] A,int low,int high) {
　　if(left<right) {

　　    int pivot=partition(A,low,high);
       quickSort(A,low,pivot-1);
       quickSort(A,pivot+1,high); 

　　}
}

 三.归并排序

【算法实现】

public void mergeSort(int[] a,int left,int right) {
    if(left>=right)      
       return;
    int mid=(left+right)/2;
    mergeSort(a,left,mid);
    mergeSort(a,mid+1,right);
    merge(a,left,mid,right);  
}

public void merge(int[] a,int left,int mid,int right) {
    int tempArr=new int[a.length];
    int temp=left;
    int first=left;
    int second=mid+1;
    while(first<=mid&&second<=right) {
        if(a[first]<=a[second])
             tempArr[temp++]=a[first++];
        else
             tempArr[temp++]=a[second++];
    }
    while(first<=mid)
        tempArr[temp++]=a[first];
    while(second<=right)
        tempArr[temp++]=a[second++];
    while(left<=right) {
        a[left]=tempArr[left++];    
    }
}