Java中高级问题整理-数据结构和算法

本系列目录

数组

数组随即读取为什么快？
数组所开辟的空间在内存里是连续分布的，可以直接寻找索引对应的偏移，如果是基本类型，数组原则保存的就是原数据，如果是引用类型保存的是引用，可以通过引用直接获取堆中的数据

限流算法

1. 令牌桶算法

令牌桶的容量是c（个），令牌以速度r（个/秒）均匀的放入桐中，上个请求的时间为at（时间戳），上个请求后剩余的令牌数目为w（个），现在有个请求b对象进来了，现在请求的时间bt=now()，伪代码如上图，其中wb代表从at到bt时间段内产生的令牌数，产生的令牌数加上上次剩余的令牌数是不能大于桶容量的
令牌桶限流-java实现

排序算法

1. 冒泡排序（Bubble Sort）

两层for循环，外层控制循环比较次数，需要循环n-1次，内层进行数值比较，大的往后放。第一遍比较会将最大数值移到最后面；第二遍比较除了最后一个数值之外的其它数值，会将倒数第二大的数值移到倒数第二的位置，以此类推，大数值随着比较往后移动，就像冒泡一样。平均时间复杂度为O(n²)，参考
Java实现

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;
            }
        }
    }
}

2. 选择排序(Selection sort)

一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。外层for循环控制循环次数.参考

public static void selectionSort(int[] arr){
    for(int i = 0; i < arr.length - 1; i++){
        // 交换次数
        // 先假设每次循环时，最小数的索引为i
        int minIndex = i;
        // 每一个元素都和剩下的未排序的元素比较
        for(int j = i + 1; j < arr.length; j++){
            //寻找最小数
            if(arr[j] < arr[minIndex]){
                //将最小数的索引保存
                minIndex = j;
            }
        }
        //经过一轮循环，就可以找出第一个最小值的索引，然后把最小值放到i的位置
        swap(arr, i, minIndex);
    }
}

private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

查找

1. 二分法查找

1. 保证数据有序，假设是升序
2. 确定该区间的中间位置K
3. 将查找的值T与array[k]比较。
   1. 若相等，查找成功返回此位置；
   2. 否则确定新的查找区域，继续二分查找。区域确定如下：

      1. array[k]>T 由数组的有序性可知array[k,k+1,……,high]>T;故新的区间为array[low,……，K-1]
      2. array[k]<T 类似上面查找区间为array[k+1,……，high]。
      3. 每一次查找与中间值比较，可以确定是否查找成功，不成功当前查找区间将缩小一半，递归查找即可。时间复杂度为:O(log2n)。

public static void dichotomySearch(int[] arr, int target) {
    Arrays.sort(arr);
    for (int i = 0; i < arr.length; i++) {
        int low = i;
        int high = arr.length - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (target==arr[mid]) {
                System.out.println("true");
                return;
            }
            if (target>arr[mid]) {
                low = mid + 1;
            }
            if (target<arr[mid]) {
                high = mid - 1;
            }
        }
    }
    System.out.println("false");
}