两大常用排序和二分查找

一、排序

1.1 冒泡排序

1.1.1 概念

通过对待排序序列从前向后（从下标较小的元素开始）,依次对相邻两个元素的值进行两两比较，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就如同水底下的气泡一样逐渐向上冒。

1.1.2 步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

1.1.3 图形演示

1.1.4 代码实现

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = { 7, 5, 4, 6, 9, 8, 1, 2 };
        bubbleSort(arr);
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    // 冒泡排序
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

1.2 选择排序

1.2.1 概念

选择排序（ Selection sort）是一种简单直观的排序算法。它的工作原理是每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。

1.2.2 步骤

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。

1.2.3 图形演示

1.2.4 代码实现

public static void main(String[] args) {
    int[] arr = { 7, 5, 4, 6, 9, 8, 1, 2 };
    selectSort(arr);
    // 遍历数组		
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
public static void selectSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        //
        int min = i;
        for (int j = i + 1; j < arr.length; j++) {
            //与数组中的数据进行比较，如果有更小的值，把下标赋给min
            if (arr[min] > arr[j]) {
                min = j;
            }
        }
        if (min != i) {
            int temp = arr[min];
            arr[min] = arr[i];
            arr[i] = temp;
        }
    }
}

二、排序

2.1 顺序查找

从表的一段开始，依次将记录的关键字和给定的值进行比较，若某个记录的关键字和给定值相等，则查找成功；反之，若扫描整个表后，仍未找到关键字和给定值相等的记录，则查找失败。
缺点：不稳定，数据靠前就快，数据靠后就慢。数据很多的时候，性能相对较低。

public static int search(int[] arr ,int target){
    for(int i = 0;i < arr.length;i++){
        if(arr[i] == target){
            return i;
        }
    }
    return -1;
}

2.2 二分查找

二分查询,又称为折半查询,但是 数据必须有序
由于数据保证有序,所以添加和删除相对麻烦,因为要考虑数据移位
相对比较稳定,随机性查询性能较好
算法实现 : 每次都和中间数据比较

public static int binarySearch(int[] arr, int target) {
    // 起始索引
    int startIndex = 0;
    // 结束索引
    int endIndex = arr.length - 1;
    // 中间数据
    int m = (startIndex + endIndex) / 2;
    // 当起始索引 大于 结束索引时,说明不存在 返回-1
    while (startIndex <= endIndex) {
        // 如果目标数据=中间数据 则返回m即可
        if (target == arr[m]) {
            return m;
        }
        // 如果目标数据大于中间数据,则取后半截, 起始索引 = 中间+1 , 结束索引 不变 , 重新生成中间数据
        if (target > arr[m]) {
            startIndex = m + 1;
            // 如果目标数据小于中间数据,则取前半截,起始索引不变 , 结束索引 = 中间-1 , 重新生成中间数据
        } else if (target < arr[m]) {
            endIndex = m - 1;
        }
        m = (startIndex + endIndex) / 2;
    }
    // 到这里 说明不存在,则返回-1
    return -1;
}