labuladong算法学习笔记---基础数据结构

前缀和

【 适⽤于快速、频繁地计算⼀个索引区间内的元素之和， 原始数组的元素不发生变化】

在初始化的时候定义一个数组用来存储每个节点对应的元素之和，在需要求解特定索引区间时只需要用简单的加减法就可以得到结果。可以大大降低时间复杂度。

差分数组

【适⽤于频繁对原始数组的某个区间的元素进⾏增减，原始数组的元素发生变化】

Difference()：初始化差分数组diff，diff中存储的是相邻元素之间的差值（后一个减去前一个）；

increment()：根据题目要求对diff进行调整；

如：对区间[i, j]（要注意题目中改变的元素是否包括右边界的元素）的元素增加1，则只需要

diff[i] += 1；

        根据j的索引位置不同，有不同的情况，如果j + 1 >= diff.length，表示对i之后的所有元素都增加1，只需要执行上面那一条语句就可以；如果j + 1 <  diff.length，表示还需要对j后面的元素进行处理，否则j后面的元素也会增加1。

if (j + 1 < diff.length) {
    diff[j + 1] -= 1;
}

result()：根据差分数组diff复原数组nums。

// 差分数组⼯具类
class Difference {
    // 差分数组
    private int[] diff;
 
    /* 输⼊⼀个初始数组，区间操作将在这个数组上进⾏ */
    public Difference(int[] nums) {
        if (nums.length == 0) return ;
        diff = new int[nums.length];
        // 根据初始数组构造差分数组
        diff[0] = nums[0];
        for (int i = 1; i < nums.length; i++) {
            diff[i] = nums[i] - nums[i - 1];
        }
    }
    /* 给闭区间 [i,j] 增加 val（可以是负数）*/
    public void increment(int i, int j, int val) {
        diff[i] += val;
        if (j + 1 < diff.length) {
            diff[j + 1] -= val;
        }
    }
    /* 返回结果数组 */
    public int[] result() {
        int[] res = new int[diff.length];
        // 根据差分数组构造结果数组
        res[0] = diff[0];
        for (int i = 1; i < diff.length; i++) {
            res[i] = res[i - 1] + diff[i];
        }
        return res;
    }
}

滑动窗口

大佬给出的框架：

/* 滑动窗⼝算法框架 */
void slidingWindow(string s, string t) {
    unordered_map<char, int> need, window;
    for (char c : t) need[c]++;
 
    int left = 0, right = 0;
    int valid = 0; 
    while (right < s.size()) {
        // c 是将移⼊窗⼝的字符
        char c = s[right];
        // 右移窗⼝
        right++;
        // 进⾏窗⼝内数据的⼀系列更新
        ...
        /*** debug 输出的位置 ***/
        printf("window: [%d, %d)\n", left, right);
        /********************/
 
        // 判断左侧窗⼝是否要收缩
        while (window needs shrink) {
            // d 是将移出窗⼝的字符
            char d = s[left];
            // 左移窗⼝
            left++;
            // 进⾏窗⼝内数据的⼀系列更新
            ...
        }
    }
}

自己改了一个Java版本的：

/* 滑动窗⼝算法框架 */
void slidingWindow(string s, string t) {
    Map<Character, Integer> need = new HashMap<>();
    Map<Character, Integer> window = new HashMap<>();
    char[] ct = t.toCharArray();
    //先把t中的字符及个数存入need中
    for (char c : ct) need.put(c, need.getOrDefault(c, 0) + 1);
 
    int left = 0, right = 0;
    int valid = 0; 
    while (right < s.size()) {
        // c 是将移⼊窗⼝的字符
        char c = s.charAt(right);
        // 右移窗⼝
        right++;
        // 进⾏窗⼝内数据的⼀系列更新
        ...
        /*** debug 输出的位置 ***/
        System.out.println("window: [" + left + "," + right + "]");
        /********************/
 
        // 判断左侧窗⼝是否要收缩
        while (window needs shrink) {
            // d 是将移出窗⼝的字符
            char d = s.charAt(left);
            // 左移窗⼝
            left++;
            // 进⾏窗⼝内数据的⼀系列更新
            ...
        }
    }
}

如果不用Map存储，选择用数据存储，总结了一个大致的框架

/* 滑动窗⼝算法框架 */
void slidingWindow(string s, string t) {
    // 长度定位128是因为使用ASCII码存储字符
    int[] need = new int[128];
    char[] ct = t.toCharArray();
    //先把t中的字符及个数存入need中
    for (char c : ct) need[c]++;
 
    int left = 0, right = 0;
    int cnt = t.length(); 
    while (right < s.length()) {
        // c 是将移⼊窗⼝的字符
        char c = s.charAt(right);
        // 如果c是需要的字符
        if (need[c] > 0) {
            cnt--;
        }
        need[c]--;
        
        // 进⾏窗⼝内数据的⼀系列更新
        ...
        if (cnt == 0) {
            // 此时说明字符达到了要求
            while (left < right && need[s.charAt(left)] < 0) {
                // 此时是在收缩窗口，先去除不是t中的字符
                need[s.charAt(left)]++;
                left++;
            }
            if (// 通常这里是判断当前窗口是否符合题意) {
                ...
            }
            // 不是t中的都处理完后，当前left指向的就是t中需要的，所以cnt也要变化
            need[s.charAt(left)]++;
            left++;
            cnt++;
        }
        right++;
    }
}

二分搜索

大佬的框架

int binarySearch(int[] nums, int target) {
    int left = 0, right = ...;
    while(...) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            ...
        } else if (nums[mid] < target) {
            left = ...
        } else if (nums[mid] > target) {
            right = ...
        }
    }
    return ...;
}

在while()中，如果写的是left <= right，则更新right时，需要令right = mid - 1,因为查找区间时左闭右闭[left, right]；如果写的是left < right，则right = mid，因为此时是左闭右开的区间[left, right)

1.当需要查找特定元素时

while(left < right) {
    int mid = left + (right - left) / 2;
    if (nums[mid] == target) {
        return mid;
    }...

2.当需要查找左侧边界时（假设数据是升序排列的，所以调整right，如果是降序的，应该调整left）

while(left < right) {
    int mid = left + (right - left) / 2;
    if (nums[mid] == target) {
        right =  mid;
    }...

在末尾检验一下

if (left >= nums.length || nums[left] != target) return -1;
return left;

3.当需要查找右侧边界时（假设数据是升序排列的，所以调整right，如果是降序的，应该调整left）

while(left < right) {
    int mid = left + (right - left) / 2;
    if (nums[mid] == target) {
        left =  mid + 1;
    }...

在末尾检验一下(循环退出时left == right，所以写left或者right都一样，return left - 1是因为调整left时是mid + 1，即mid = left - 1,）

if (left < 0 || nums[left - 1] != target) return -1;
return left - 1;

二分搜索问题的泛化

（非常顶）

⾸先，你要从题⽬中抽象出⼀个⾃变量 x ，⼀个关于 x 的函数 f(x) ，以及⼀个⽬标值 target 。

同时， x, f(x), target 还要满⾜以下条件：

1、 f(x) 必须是在 x 上的单调函数（单调增单调减都可以）。

2、题⽬是让你计算满⾜约束条件 f(x) == target 时的 x 的值。

可以理解为把典型二分搜索问题中的数组nums[ ]变成了f(x)，这个f(x)需要自己找出逻辑关系

双指针

定义两个指针，分别为慢指针slowIndex，快指针fastIndex。

在删除数组/链表中元素，判断链表是否有环，合并链表等问题中非常适用，具体可以看算法小抄

递归反转链表

ListNode reverse(ListNode head) {
    if (head.next == null) return head;
    ListNode last = reverse(head.next);
    head.next.next = head;
    head.next = null;
    return last;
}

单纯看代码有点绕，举了一个简单的例子，比较容易理解。

 (大佬在原文中建议是从函数的定义去理解，相当于图里的r(1）的单层逻辑)

 

 

算法小抄https://labuladong.gitee.io/algo/https://labuladong.gitee.io/algo/