数据结构之排序查找

主要介绍二分查找，插值查找，斐波那契查找，起泡排序，归并排序
算法描述请见注释
归并排序算法描述可以参考http://www.cnblogs.com/jillzhang/archive/2007/09/16/894936.html

/** * 数组结构 * 先排序，后查找 * @author asdc * */public class Array {     public final static int MAXSIZE = 20;    /**     * 二分查找,返回key的位置，没查到返回<0  时间复杂度为O(logN)     * @param a     * @param key     * @return     */    public static int binarySearch(long[] a, long key){        int lo = 0;//起始位置        int hi = a.length - 1;//终止位置        while(lo < hi){            int mid = (lo + hi)/2;//中间位置            if(key == a[mid]){                return mid;            }else if(key > a[mid]){                lo = mid + 1;            }else if(key < a[mid]){                hi = mid - 1;            }        }        return -1;    }    /**     * 插值查找     * @param a     * @param key     * @return     */    public static int interpolationSearch(long[] a, long key){        //插值查找其实跟二分查找差不多，适合大数据量的查找，数据量小的话采用二分查找或者顺序查找效率更高，差值插找主要使用一个公式        //二分查找公式   mid = (lo + hi)/2        //公式转换  mid = lo/2 + hi/2    ---->    mid = lo + hi/2 - lo/2  ----> mid = lo + (hi - lo)/2        //mid = lo + (1/2)(hi - lo)  将1/2换成插值公式    (key - a[lo])/(a[hi] - a[lo])        //得出结果   mid = lo + (hi - lo) * (key - a[lo])/(a[hi] - a[lo])  这就是插值查找的算法  替换到二分查找中即可        int lo = 0;//起始位置        int hi = a.length - 1;//终止位置        while(lo < hi){            int mid = (int) (lo + (hi - lo) * (key - a[lo])/(a[hi] - a[lo]));//中间位置            if(key == a[mid]){                return mid;            }else if(key > a[mid]){                lo = mid + 1;            }else if(key < a[mid]){                hi = mid - 1;            }        }        return -1;    }    /**     * 斐波那契查找     * @param a     * @param key     * @return     */    public static int fibonacciSearch(long[] a,long key){        int lo = 0;        int hi = a.length - 1;        int[] f = fibonacci();        int k = 0;//黄金分割下标        while(a.length > f[k] - 1){            k++;        }        long[] temp = new long[f[k] - 1];        for(int i = 0; i < a.length; i++){            temp[i] = a[i];        }        // 序列补充至f[k]个元素          // 补充的元素值为最后一个元素的值         for (int i = a.length; i < f[k] - 1; i++) {              temp[i] = temp[hi];          }          while (lo <= hi) {              // low：起始位置              // 前半部分有f[k-1]个元素，由于下标从0开始              // 则-1 获取 黄金分割位置元素的下标              int mid = lo + f[k - 1] - 1;              if (temp[mid] > key) {                  // 查找前半部分，高位指针移动                  hi = mid - 1;                  // （全部元素） = （前半部分）+（后半部分）                  // f[k] = f[k-1] + f[k-2]                  // 因为前半部分有f[k-1]个元素，所以 k = k-1                  k = k - 1;              } else if (temp[mid] < key) {                  // 查找后半部分，高位指针移动                  lo = mid + 1;                  // （全部元素） = （前半部分）+（后半部分）                  // f[k] = f[k-1] + f[k-2]                  // 因为后半部分有f[k-1]个元素，所以 k = k-2                  k = k - 2;              } else {                  // 如果为真则找到相应的位置                  if (mid <= hi) {                      return mid;                  } else {                      // 出现这种情况是查找到补充的元素                      // 而补充的元素与high位置的元素一样                      return hi;                  }              }          }          return -1;      }     /**     * 构建斐波那契数列     * @return     */    public static int[] fibonacci(){        int[] f = new int[MAXSIZE];        f[0] = 1;        f[1] = 1;        for(int i = 2; i < MAXSIZE; i++){            f[i] = f[i - 1] + f[i - 2];        }        return f;    }    //查找总结    //折半查找：进行加法与除法的运算mid = (lo + hi)/2    //插值查找:进行复杂的四则运算mid = lo + (hi - lo)*(key-a[lo])/(a[hi]-a[lo])    //斐波那契查找:进行最简单的加减法运算mid = low + f[k-1] - 1 又称换进分割   比值    //在海量数据查找过程中，这种细微的差别可能会影响最终的效率    //三种查找方式本质区别为分割点选择不同，各有优劣，实际开发时可根据数据特点进行选择    /**     * 气泡排序 低效版     * @param a     * @return     */    public static void bubbleSort(long[] a){        boolean isSort = true;//判断是否还有紧邻逆序对        for(int j = a.length - 1; j > 0; j--){            for(int i = 0; i < j; i++){                if(a[i] > a[i + 1]){                    isSort = false;                    //交换                    long temp = a[i + 1];                    a[i + 1] = a[i];                    a[i] = temp;                }            }            if(isSort == true){                break;            }        }    }    /**     * 归并排序 算法     * @param a     * @param lo     * @param hi     */    public static void Merger(long[] a, int lo, int hi, int mid){        long[] temp = new long[hi - lo];//临时数组  存放归并比较时的值        int indexA = lo;        int indexB = mid;//两端的启示值        //从两端开始比较大小  将小的值放入temp数组中        int i = 0;        while(indexA < mid && indexB < hi){            if(a[indexA] > a[indexB]){                temp[i++] = a[indexB++];            }else{                temp[i++] = a[indexA++];            }        }        //将剩余的值放入temp中        while(indexA < mid){            temp[i++] = a[indexA++];        }        while(indexB < hi){            temp[i++] = a[indexB++];        }        //更改a数组        for (int k2 = 0; k2 < temp.length; k2++) {              a[k2 + lo] = temp[k2];          }      }    public static void MergerSort(long[] a, int lo, int hi){        if (hi > lo) //hi - lo > 1        {            int mid = (lo + hi) / 2;            System.out.println("左" + lo + "," + mid);            MergerSort(a, lo, mid);            System.out.println("右" + (mid+1) + "," + hi);            MergerSort(a, mid + 1, hi);            Merger(a, lo, hi, mid);        }    } }