排序查找算法集合

排序查找算法集合

	//冒泡排序  主要是交换位置
    public void bubbleSort(Integer[] arr, int n) {
        if (n <= 1) {
            return;       //如果只有一个元素就不用排序了
        }

        for (int i = 0; i < n; ++i) {
            // 提前退出冒泡循环的标志位,即一次比较中没有交换任何元素，这个数组就已经是有序的了
            boolean flag = false;
            for (int j = 0; j < n - i - 1; ++j) {        //此处你可能会疑问的j<n-i-1，因为冒泡是把每轮循环中较大的数飘到后面，
                // 数组下标又是从0开始的，i下标后面已经排序的个数就得多减1，总结就是i增多少，j的循环位置减多少
                if (arr[j] > arr[j + 1]) {        //即这两个相邻的数是逆序的，交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if (!flag) {
                break;//没有数据交换，数组已经有序，退出排序
            }
        }
    }
    //选择我排序   主要是假定最小值是arr[j]
    private void select(Integer[] arr) {
        //选择排序的优化
        for (int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
            int k = i;
            for (int j = k + 1; j < arr.length; j++) {// 选最小的记录
                if (arr[j] < arr[k]) {
                    k = j; //记下目前找到的最小值所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if (i != k) {  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }
    }
    //快速排序   主要是以是更换start和end的位置
    private void quickSort(Integer[] arr, int start, int end) {
        int i = start;//左边哨兵的索引
        int j = end;//右边哨兵的索引
        int temp = arr[start];//以最左边哨兵为  基准位
        while (i < j) {
            //先看右边，依次往左递减
            /*
             * 1.先从右往左找一个小于 基准位的数
             * 2.当右边的哨兵位置所在的数 > 基准位的数 时
             * 3.续从右往左找（同时 j 索引 - 1）
             * 4.找到小于基准位后会跳出 while循环
             * */
            while (temp <= arr[j] && i < j) {
                j--;
            }

            //再看左边，依次往右递增  同右边一样
            while (temp >= arr[i] && i < j) {
                i++;
            }
            //如果满足条件则交换
            int z = arr[i];
            int y = arr[j];
            //左右哨兵 交换数据（互相持有对方的数据）
            arr[i] = y;
            arr[j] = z;
        }
        //这时 跳出了 “while (i<j) {}” 循环
        //说明 i=j 左右在同一位置
        //最后将基准为与i和j相等位置的数字交换
        arr[start] = arr[i];//或 arr[start] = arr[j];
        arr[i] = temp;//或 arr[j] = temp;

     /**   #i=j
      * 这时  左半数组<(i或j所在索引的数)<右半数组
      * 也就是说(i或j所在索引的数)已经确定排序位置， 所以就不用再排序了，
      * 只要用相同的方法 分别处理  左右数组就可以了
      * */

        //递归调用左半数组
        quickSort(arr, start, j - 1);
        //递归调用右半数组
        quickSort(arr, j + 1, end);

    }

    /**
     * 二分查找又称折半查找，它是一种效率较高的查找方法。 【二分查找要求】：1.必须采用顺序存储结构 2.必须按关键字大小有序排列。
     *
     * @param array     有序数组
     * @param searchKey 查找元素
     * @return searchKey的数组下标，没找到返回-1
     * 主要是找到middle的值
     */
    public static int binarySearch(int[] array, int searchKey) {

        int low = 0;
        int high = array.length - 1;
        while (low <= high) {
            int middle = (low + high) / 2;
            if (searchKey == array[middle]) {
                return middle;
            } else if (searchKey < array[middle]) {
                high = middle - 1;
            } else {
                low = middle + 1;
            }
        }
        return -1;
    }