常见算法模板汇总

free-9d

于 2025-01-17 14:35:00 发布

阅读量741

点赞数 26

文章标签：算法数据结构

本文链接：https://blog.youkuaiyun.com/CNew333/article/details/145207153

版权

一、前缀和

1.1 定义

前缀和是一种重要的预处理，能大大降低查询的时间复杂度。它可以简单理解为 “数列的前 n 项的和”。对于给定的数列 A，其前缀和数列 S 定义为： $\cdots + A[i]$ ，其中 $S [0] = 0$ （为了方便计算）。

1.2 应用场景

常用于快速计算数列中某一段的和。例如，要计算数列 A 中从第 l 项到第 r 项的和，即 $\cdots + A[r]$ ，就可以通过 $S [r] - S [l - 1]$ 快速得到。

1.3 代码示例

1.3.1 Python 代码

nums = [1, 3, 5, 7, 9]
n = len(nums)
prefix_sum = [0] * (n + 1)
for i in range(1, n + 1):
    prefix_sum[i] = prefix_sum[i - 1] + nums[i - 1]
# 计算区间[2, 4]的和
l, r = 2, 4
print(prefix_sum[r] - prefix_sum[l - 1])

1.3.2 C++ 代码

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {1, 3, 5, 7, 9};
    int n = nums.size();
    vector<int> prefixSum(n + 1, 0);
    for (int i = 1; i <= n; ++i) {
        prefixSum[i] = prefixSum[i - 1] + nums[i - 1];
    }
    // 计算区间[2, 4]的和
    int l = 2, r = 4;
    cout << prefixSum[r] - prefixSum[l - 1] << endl;
    return 0;
}

1.3.3 Java 代码

import java.util.ArrayList;
import java.util.List;

public class PrefixSum {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        nums.add(1);
        nums.add(3);
        nums.add(5);
        nums.add(7);
        nums.add(9);
        int n = nums.size();
        int[] prefixSum = new int[n + 1];
        for (int i = 1; i <= n; ++i) {
            prefixSum[i] = prefixSum[i - 1] + nums.get(i - 1);
        }
        // 计算区间[2, 4]的和
        int l = 2, r = 4;
        System.out.println(prefixSum[r] - prefixSum[l - 1]);
    }
}

二、差分

2.1 定义

差分是前缀和的逆运算。对于给定的数列 A，其差分数列 B 定义为： $B [1] = A [1]$ ， $B [i] = A [i] - A [i - 1] (i > 1)$ 。

2.2 应用场景

常用于对数列的区间进行多次修改操作，最后再查询某个位置的值。通过对差分数列进行修改，然后再求前缀和就可以得到修改后的原数列。比如，要对数列 A 中从第 l 项到第 r 项都加上一个值 x，只需要对差分数列 B 的 B [l] 加上 x，B [r + 1] 减去 x，最后通过 B 的前缀和得到修改后的 A。

2.3 代码示例

2.3.1 Python 代码

nums = [1, 3, 5, 7, 9]
n = len(nums)
diff = [0] * n
diff[0] = nums[0]
for i in range(1, n):
    diff[i] = nums[i] - nums[i - 1]
# 对区间[2, 4]加上3
l, r, x = 2, 4, 3
diff[l - 1] += x
if r + 1 < n:
    diff[r] -= x
new_nums = [0] * n
new_nums[0] = diff[0]
for i in range(1, n):
    new_nums[i] = new_nums[i - 1] + diff[i]
print(new_nums)

2.3.2 C++ 代码

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {1, 3, 5, 7, 9};
    int n = nums.size();
    vector<int> diff(n);
    diff[0] = nums[0];
    for (int i = 1; i < n; ++i) {
        diff[i] = nums[i] - nums[i - 1];
    }
    // 对区间[2, 4]加上3
    int l = 2, r = 4, x = 3;
    diff[l - 1] += x;
    if (r + 1 < n) {
        diff[r] -= x;
    }
    vector<int> newNums(n);
    newNums[0] = diff[0];
    for (int i = 1; i < n; ++i) {
        newNums[i] = newNums[i - 1] + diff[i];
    }
    for (int num : newNums) {
        cout << num << " ";
    }
    return 0;
}

2.3.3 Java 代码

import java.util.ArrayList;
import java.util.List;

public class Difference {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        nums.add(1);
        nums.add(3);
        nums.add(5);
        nums.add(7);
        nums.add(9);
        int n = nums.size();
        int[] diff = new int[n];
        diff[0] = nums.get(0);
        for (int i = 1; i < n; ++i) {
            diff[i] = nums.get(i) - nums.get(i - 1);
        }
        // 对区间[2, 4]加上3
        int l = 2, r = 4, x = 3;
        diff[l - 1] += x;
        if (r + 1 < n) {
            diff[r] -= x;
        }
        int[] newNums = new int[n];
        newNums[0] = diff[0];
        for (int i = 1; i < n; ++i) {
            newNums[i] = newNums[i - 1] + diff[i];
        }
        for (int num : newNums) {
            System.out.print(num + " ");
        }
    }
}

三、二分查找

3.1 定义

二分查找是一种在有序数组中查找特定元素的搜索算法。每次比较中间元素，如果中间元素等于目标值，则查找成功；如果中间元素大于目标值，则在左半部分继续查找；如果中间元素小于目标值，则在右半部分继续查找。

3.2 应用场景

常用于在有序数组中快速查找某个元素是否存在，或者查找某个元素的位置。时间复杂度为 $O (l o g n)$ 。

3.3 代码示例

3.3.1 Python 代码

def binary_search(nums, target):
    left, right = 0, len(nums) - 1
    while left <= right:
        mid = left + (right - left) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1


nums = [1, 3, 5, 7, 9]
target = 5
print(binary_search(nums, target))

3.3.2 C++ 代码

#include <iostream>
#include <vector>
using namespace std;

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

int main() {
    vector<int> nums = {1, 3, 5, 7, 9};
    int target = 5;
    cout << binarySearch(nums, target) << endl;
    return 0;
}

3.3.3 Java 代码

import java.util.ArrayList;
import java.util.List;

public class BinarySearch {
    public static int binarySearch(List<Integer> nums, int target) {
        int left = 0, right = nums.size() - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums.get(mid) == target) {
                return mid;
            } else if (nums.get(mid) < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        nums.add(1);
        nums.add(3);
        nums.add(5);
        nums.add(7);
        nums.add(9);
        int target = 5;
        System.out.println(binarySearch(nums, target));
    }
}

四、位运算

4.1 定义

位运算是直接对整数在内存中的二进制位进行操作。常见的位运算有与（&）、或（|）、非（~）、异或（^）、左移（<<）和右移（>>）。

4.2 应用场景

在很多算法和编程场景中都有应用，例如快速计算、状态压缩、加密等。比如，使用位运算可以快速判断一个数是否为 2 的幂次方（n & (n - 1) == 0 则 n 是 2 的幂次方）。

4.3 代码示例

4.3.1 Python 代码

# 判断一个数是否为2的幂次方
n = 8
if n & (n - 1) == 0:
    print(f"{n} 是2的幂次方")
else:
    print(f"{n} 不是2的幂次方")

4.3.2 C++ 代码

#include <iostream>
using namespace std;

int main() {
    int n = 8;
    if ((n & (n - 1)) == 0) {
        cout << n << " 是2的幂次方" << endl;
    } else {
        cout << n << " 不是2的幂次方" << endl;
    }
    return 0;
}

4.3.3 Java 代码

public class PowerOfTwo {
    public static void main(String[] args) {
        int n = 8;
        if ((n & (n - 1)) == 0) {
            System.out.println(n + " 是2的幂次方");
        } else {
            System.out.println(n + " 不是2的幂次方");
        }
    }
}

五、离散化

5.1 定义

离散化是将数据按照大小关系映射到一个较小的连续整数集合中，而不改变数据之间的相对大小关系。

5.2 应用场景

当数据范围很大，但数据的个数相对较小时，使用离散化可以降低空间复杂度，同时也能加快一些算法的运行速度。比如在处理坐标范围很大但点的数量有限的几何问题时。

5.3 代码示例

5.3.1 Python 代码

nums = [1000, 2000, 3000, 4000, 5000]
sorted_nums = sorted(set(nums))
discrete_dict = {value: index for index, value in enumerate(sorted_nums)}
discrete_nums = [discrete_dict[num] for num in nums]
print(discrete_nums)

5.3.2 C++ 代码

#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_map>
using namespace std;

int main() {
    vector<int> nums = {1000, 2000, 3000, 4000, 5000};
    vector<int> sortedNums = nums;
    sort(sortedNums.begin(), sortedNums.end());
    sortedNums.erase(unique(sortedNums.begin(), sortedNums.end()), sortedNums.end());
    unordered_map<int, int> discreteMap;
    for (int i = 0; i < sortedNums.size(); ++i) {
        discreteMap[sortedNums[i]] = i;
    }
    vector<int> discreteNums;
    for (int num : nums) {
        discreteNums.push_back(discreteMap[num]);
    }
    for (int num : discreteNums) {
        cout << num << " ";
    }
    return 0;
}

5.3.3 Java 代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Discretization {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        nums.add(1000);
        nums.add(2000);
        nums.add(3000);
        nums.add(4000);
        nums.add(5000);
        List<Integer> sortedNums = new ArrayList<>(nums);
        sortedNums.sort(null);
        sortedNums = new ArrayList<>(new HashSet<>(sortedNums));
        Map<Integer, Integer> discreteMap = new HashMap<>();
        for (int i = 0; i < sortedNums.size(); i++) {
            discreteMap.put(sortedNums.get(i), i);
        }
        List<Integer> discreteNums = new ArrayList<>();
        for (int num : nums) {
            discreteNums.add(discreteMap.get(num));
        }
        System.out.println(discreteNums);
    }
}

六、算法对比

算法	应用场景	时间复杂度	空间复杂度
前缀和	快速计算区间和	单次查询 $O (1)$ ，预处理 $O (n)$	$O (n)$
差分	多次区间修改后查询	单次修改 $O (1)$ ，查询 $O (n)$ （需计算前缀和）	$O (n)$
二分查找	在有序数组中查找元素	$O (l o g n)$	$O (1)$
位运算	快速计算、状态压缩等	取决于具体操作，一般为 $O (1)$	$O (1)$
离散化	数据范围大但数量有限时	排序 $O (n l o g n)$ ，离散化 $O (n)$	$O (n)$ （用于存储映射关系）