冒泡排序/快速排序/二分(折半)查找法

代码部分:

public class Sort {

    /**
     * 冒泡排序
     *
     * @param arr
     * @return
     */
    public static void bubbleSort(int[] arr) {
        int tem = 0;
        //内循环要遍历的长度
        int sortLength = arr.length - 1;
        //最后交换的位置
        int lastChange = 0;
        //是否产生了交换,默认未产生
        boolean notChange = true;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < sortLength; j++) {
                //左边数比右边打,交换位置
                if (arr[j] > arr[j + 1]) {
                    tem = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tem;
                    //最后一次元素交换的位置
                    lastChange = j;
                    //有元素交换
                    notChange = false;
                }
            }
            //遍历长度修改为最后一次交换的位置坐标
            sortLength = lastChange;
            //无元素交换,代表已排序完毕
            if (notChange) {
                break;
            }
        }
    }

    /**
     * 快排
     *
     * @param arr   要排序的数组
     * @param left  最小index
     * @param right 最大index
     */
    public static void quickSort(int[] arr, int left, int right) {
        //数组长度小于等于1,直接结束
        if (left >= right) {
            return;
        }
        //key为基准值(第0个元素)
        int key = arr[left];
        int i = left;
        int j = right;
        int tem = 0;
        while (i < j) {
            //从右往左判断,直到遇到比key小的数
            while (arr[j] >= key && i < j) {
                j--;
            }
            //从左往右判断,直到遇到比key大的数
            while (arr[i] <= key && i < j) {
                i++;
            }
            //将比key大和比key小的数交换位置
            if (i < j) {
                tem = arr[i];
                arr[i] = arr[j];
                arr[j] = tem;
            }
        }
        //交换完毕后,基准值key就在数组的中间了,左边都比他小,右边都比他大
        arr[left] = arr[i];
        arr[i] = key;
        //递归为左半边排序
        quickSort(arr, left, i - 1);
        //递归为右半边排序
        quickSort(arr, i + 1, right);
    }

    /**
     * 折半查找
     *
     * @param arr 要检索的数组
     * @param key 要查找的数
     * @return key所在的index
     */
    public static int bisearch(int[] arr, int key) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int middle = (left + right) / 2;
            if (arr[middle] == key) {
                return middle;
            } else if (arr[middle] < key) {
                left = middle + 1;
            } else {
                right = middle - 1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        System.out.println("冒泡排序");
        int[] bubbleSort = {5, 4, 8, 3, 7, 1, 9, 2, 6};
        System.out.println("排序前:" + Arrays.toString(bubbleSort));
        bubbleSort(bubbleSort);
        System.out.println("排序后:" + Arrays.toString(bubbleSort));
        System.out.println("========================================================================================");

        System.out.println("快排");
        int[] quickSort = {9, 5, 1, 3, 4, 8, 7, 6, 2};
        System.out.println("排序前:" + Arrays.toString(quickSort ));
        quickSort(quickSort, 0, quickSort.length - 1);
        System.out.println("排序后:" + Arrays.toString(quickSort));
        System.out.println("========================================================================================");

        int[] arr1 = {1, 9};
        System.out.println("折半查找");
        System.out.println("0 ==> " + bisearch(arr1, 0));
        System.out.println("1 ==> " + bisearch(arr1, 1));
        System.out.println("8 ==> " + bisearch(arr1, 8));
        System.out.println("9 ==> " + bisearch(arr1, 9));
        System.out.println("10 ==> " + bisearch(arr1, 10));
        System.out.println("========================================================================================");
    }
}

运行结果:

冒泡排序
排序前:[5, 4, 8, 3, 7, 1, 9, 2, 6]
排序后:[1, 2, 3, 4, 5, 6, 7, 8, 9]
========================================================================================
快排
排序前:[9, 5, 1, 3, 4, 8, 7, 6, 2]
排序后:[1, 5, 2, 3, 4, 6, 7, 8, 9]
========================================================================================
折半查找
0 ==> -1
1 ==> 0
8 ==> -1
9 ==> 1
10 ==> -1
========================================================================================