排序、查找算法

//插入排序（把第一个当作也排好序，然后对后面的依次插入到已排好序的队列中）平均时间复杂度0（n^2）
    public void insertSort(int[] a){
        for(int i = 1;i<a.length;i++){
            for(int j = i;j > 0;j--){
                if(a[j] < a[j-1]){
                    int tmp = a[j];
                    a[j] = a[j-1];
                    a[j-1] = tmp;
                }
            }
        }
    }

/*希尔排序:平均时间复杂度O(n^2)
    先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，
    然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，
    再对全体元素进行一次直接插入排序*/
    public void shellSort(int[] a){
        int i,j,gap,tmp,k;
        int n = a.length;
        for(gap = n/2;gap > 0;gap /=2){ //分组，直到增量足够小
            for(i = 0;i<gap;i++){
                
                for(j = i + gap;j < n;j += gap){
                    if (a[j] < a[j - gap]){  
                       tmp = a[j];  
                       k = j - gap;  
                       while (k >= 0 && a[k] > tmp)  
                        {  
                            a[k + gap] = a[k];  
                            k -= gap;  
                        }  
                        a[k + gap] = tmp;  
                    }
                }
            }
        }
    }

 //冒泡排序：将第i个元素，进行n遍比较，移到最后；平均时间复杂度：O(n^2);
    public void bubbleSort(int[] a){
        int n = a.length;
        for(int i = 0;i<n;i++){
            for(int j = 0;j < n -i-1;j++){
                if(a[j] > a[j + 1]){
                    int tmp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = tmp;
                }
            }
        }
    }

/*选择排序：
    在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；
    然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，
    依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。
    */
    public void selectSort(int[] a){
        int index,tmp;
        int n = a.length;
        for(int i = 0;i<n-1;i++){
            index = i;
            for(int j=i+1;j<n;j++){
                if(a[j] < a[index]){
                    index = j;
                }
            }
            tmp = a[i];
            a[i] = a[index];
            a[index] = tmp;
        }
    }

/*快速排序:平均时间复杂度：O(N*logN).
    1．先从数列中取出一个数作为基准数。
    2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
    3．再对左右区间重复第二步，直到各区间只有一个数。
    */
    void fastSort(int[] a, int left, int right){  
    if (left < right)  
    {    
        int low = left, height = right, x = a[left];  
        while (low < height)  
        {  
            while(low < height && a[height] >= x) // 从右向左找第一个小于x的数  
                height--;
            a[low] = a[height];
              
            while(low < height && a[low] < x) // 从左向右找第一个大于等于x的数  
                low++;    
            //if(i < j)   
                //s[j--] = s[i];
            a[height] = a[low];
        }  
        a[low] = x;
        fastSort(a, low, low - 1); // 递归调用   
        fastSort(a, low + 1, right);  
    }

 public int find(int[] a ,int x){
        for(int i=0;i<a.length;i++){
            if(a[i] == x){
                return i;
            }
        }
        return -1;
    }

//二分查找,前提为有序。
    public int binaryFind(int[] a ,int x){
        int begin = 0;
        int end = a.length;
        while(begin < end){
            int middle = (begin + end)/2;
            if(a[middle] == x){
                return middle;
            }
            if(a[middle] < x){
                begin = middle + 1;
            }
            if(a[middle] > x){
                begin = middle - 1;
            }
        }
        return -1;
    }