Java学习笔记-简单排序算法、二分查找法原理（折半查找）

冒泡排序算法

比较相邻的元素，如果第一个比第二个大，就交换他们两个。

对每一组相邻元素做同样的工作，从开始第一对到结尾的最后一对，最后的元素应该会是最大的树。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定的排序算法。

public static void main(String[] args) {
        int[] nums = {13, 99, 53, 32, 46, 61};
        int len = nums.length;

        // 外循环控制轮数
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    nums[j] = nums[j] + nums[j + 1];
                    nums[j + 1] = nums[j] - nums[j + 1];
                    nums[j] = nums[j] - nums[j + 1];
                }
            }
        }

        for (int x : nums) {
            System.out.println(x);
        }
    }

选择排序算法

每一趟从待排序的数据元素中选出最小（或者最大）的一个元素，顺序放在已排好序的最后，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。

public static void main(String[] args) {
        int[] nums = {13, 99, 53, 32, 46, 61};  // 需要排序的数列
        int len = nums.length;  // 数组长度
        int minIndex = 0;
    	// 排序
        for (int i = 0; i < len - 1; i++) {
            minIndex = i;
            for (int j = (i + 1); j < len; j++) {
                // 如果当前的下标的值小于假设的最小值就记录这个最小值的下标
                if (nums[j] < nums[minIndex]) {
                    minIndex = j;
                }
            }
			// 交换假设最小值和实际最小值的位置
            if (minIndex != i) {
                nums[i] = nums[i] + nums[minIndex];
                nums[minIndex] = nums[i] - nums[minIndex];
                nums[i] = nums[i] - nums[minIndex];

            }
        }
		// 打印
        for(int x: nums){
            System.out.println(x);
        }
    }

直接插入排序算法

基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置(从后向前找到合适位置后)，直到全部插入排序完为止。

public static void main(String[] args) {
        int[] nums = {34, 4, 56, 17, 90, 65};  // 待排序的数组

        for (int i = 0; i < nums.length; i++) {
            int temp = nums[i];  // 记录假定的最小值
            int j = 0;

            // 依次对假定的最小值的前面的元素进行比较
            for (j = i - 1; j >= 0; j--) {
                if (nums[j] > temp) {
                    // 如果前面的元素大于假定最小值就往后移动一位
                    nums[j + 1] = nums[j];
                } else {
                    // 如果假定最小值比前面的数大则说明比前面所有的数都大
                    break;
                }
            }
            // 插入temp的值
            if (nums[j + 1] != temp) {
                nums[j + 1] = temp;
            }
        }
        // 打印
        for (int x : nums) {
            System.out.println(x);
        }
    }

二分查找算法

二分法查找又叫做折半查找，前提是在已经排好序的数组中，通过将待查找的元素与中间索引值对应的元素进行比较，若大于中间索引值对应的元素，去右半部分查找，否则，去左半部分查找。以此类推，直到找到为止，找不到返回一个负数。

    public static void main(String[] args) {
        // 必须保证数列是有序的
        int[] nums = {10, 20, 50, 65, 88, 90};
        int index = binarySearch(nums, 100);
        System.out.println(index);
    }

    /***
     * 二分查找算法
     * @param nums 数列集合
     * @param key 关键字
     * @return 查找到的位置下标
     */
    public static int binarySearch(int[] nums, int key) {
        int start = 0; // 开始下标
        int end = nums.length - 1; // 结束下标
        while (start <= end) {
            // 得到两个数的的中间值
            int middle = (start + end) / 2;
            if (nums[middle] > key) {
                // 如果要查找的数小于中间值就去左半边查找
                end = middle - 1;
            } else if (nums[middle] < key) {
                // 如果要查找的数大于中间值就去右半边查找
                start = middle + 1;
            } else {
                // 如果要查找的数等于中间值，直接返回middle 下标
                return middle;
            }
        }
        // 循环结束也没找到，返回-1
        return -1;
    }