算法代码题——模板

已于 2023-03-05 00:35:10 修改
阅读量867 收藏 1
点赞数 1
分类专栏： 算法 文章标签： 算法 数据结构 leetcode 贪心算法 蓝桥杯
于 2023-03-04 17:04:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43338969/article/details/129336203
版权

文章目录

1. 双指针: 只有一个输入, 从两端开始遍历

def fn(arr):
    left = ans = 0
    right = len(arr) - 1

    while left < right:
        # 一些根据 letf 和 right 相关的代码补充
        if CONDITION:
            left += 1
        else:
            right -= 1
    
    return ans

int fn(vector<int>& arr) {
    int left = 0;
    int right = int(arr.size()) - 1;
    int ans = 0;

    while (left < right) {
        // 一些根据 letf 和 right 相关的代码补充
        if (CONDITION) {
            left++;
        } else {
            right--;
        }
    }

    return ans;
}

2. 双指针: 有两个输入, 两个都需要遍历完

def fn(arr1, arr2):
    i = j = ans = 0

    while i < len(arr1) and j < len(arr2):
        # 根据题意补充代码
        if CONDITION:
            i += 1
        else:
            j += 1
    
    while i < len(arr1):
        # 根据题意补充代码
        i += 1
    
    while j < len(arr2):
        # 根据题意补充代码
        j += 1
    
    return ans

int fn(vector<int>& arr1, vector<int>& arr2) {
    int i = 0, j = 0, ans = 0;

    while (i < arr1.size() && j < arr2.size()) {
        // 根据题意补充代码
        if (CONDITION) {
            i++;
        } else {
            j++;
        }
    }

    while (i < arr1.size()) {
        // 根据题意补充代码
        i++;
    }

    while (j < arr2.size()) {
        // 根据题意补充代码
        j++;
    }

    return ans;
}

3. 滑动窗口

def fn(arr):
    left = ans = curr = 0

    for right in range(len(arr)):
        # 根据题意补充代码来将 arr[right] 添加到 curr

        while WINDOW_CONDITION_BROKEN:
            # 从 curr 中删除 arr[left]
            left += 1

        # 更新 ans
    
    return ans


int fn(vector<int>& arr) {
    int left = 0, ans = 0, curr = 0;

    for (int right = 0; right < arr.size(); right++) {
        // 根据题意补充代码来将 arr[right] 添加到 curr

        while (WINDOW_CONDITION_BROKEN) {
            // 从 curr 中删除 arr[left]
            left++;
        }

        // 更新 ans
    }

    return ans;
}

4. 构建前缀和

def fn(arr):
    prefix = [arr[0]]
    for i in range(1, len(arr)):
        prefix.append(prefix[-1] + arr[i])
    
    return prefix

vector<int> fn(vector<int>& arr) {
    vector<int> prefix(arr.size());
    prefix[0] = arr[0];

    for (int i = 1; i < arr.size(); i++) {
        prefix[i] = prefix[i - 1] + arr[i];
    }

    return prefix;
}

5. 高效的字符串构建

# arr 是一个字符列表
def fn(arr):
    ans = []
    for c in arr:
        ans.append(c)
    
    return "".join(ans)

string fn(vector<char>& arr) {
    return string(arr.begin(), arr.end())
}

6. 链表: 快慢指针

def fn(head):
    slow = head
    fast = head
    ans = 0

    while fast and fast.next:
        # 根据题意补充代码
        slow = slow.next
        fast = fast.next.next
    
    return ans


int fn(ListNode* head) {
    ListNode* slow = head;
    ListNode* fast = head;
    int ans = 0;

    while (fast != nullptr && fast->next != nullptr) {
        // 根据题意补充代码
        slow = slow->next;
        fast = fast->next->next;
    }

    return ans;
}

7. 反转链表

def fn(head):
    curr = head
    prev = None
    while curr:
        next_node = curr.next
        curr.next = prev
        prev = curr
        curr = next_node 
        
    return prev

ListNode* fn(ListNode* head) {
    ListNode* curr = head;
    ListNode* prev = nullptr;
    while (curr != nullptr) {
        ListNode* nextNode = curr->next;
        curr->next = prev;
        prev = curr;
        curr = nextNode;
    }

    return prev;
}

8. 找到符合确切条件的子数组数

from collections import defaultdict

def fn(arr, k):
    counts = defaultdict(int)
    counts[0] = 1
    ans = curr = 0

    for num in arr:
        # 根据题意补充代码来改变 curr
        ans += counts[curr - k]
        counts[curr] += 1
    
    return ans

int fn(vector<int>& arr, int k) {
    unordered_map<int, int> counts;
    counts[0] = 1;
    int ans = 0, curr = 0;

    for (int num: arr) {
        // 根据题意补充代码来改变 curr
        ans += counts[curr - k];
        counts[curr]++;
    }

    return ans;
}

9. 单调递增栈

def fn(arr):
    stack = []
    ans = 0

    for num in arr:
        # 对于单调递减的情况，只需将 > 翻转到 <
        while stack and stack[-1] > num:
            # 根据题意补充代码
            stack.pop()
        stack.append(num)
    
    return ans


int fn(vector<int>& arr) {
    stack<integer> stack;
    int ans = 0;

    for (int num: arr) {
        // 对于单调递减的情况，只需将 > 翻转到 <
        while (!stack.empty() && stack.top() > num) {
            // 根据题意补充代码
            stack.pop();
        }

        stack.push(num);
    }
}

10. 二叉树: DFS (递归)]

def dfs(root):
    if not root:
        return
    
    ans = 0

    # 根据题意补充代码
    dfs(root.left)
    dfs(root.right)
    return ans

int dfs(TreeNode* root) {
    if (root == nullptr) {
        return 0;
    }

    int ans = 0;
    // 根据题意补充代码
    dfs(root.left);
    dfs(root.right);
    return ans;
}

11. 二叉树: DFS (迭代)

def dfs(root):
    stack = [root]
    ans = 0

    while stack:
        node = stack.pop()
        # 根据题意补充代码
        if node.left:
            stack.append(node.left)
        if node.right:
            stack.append(node.right)

    return ans


int dfs(TreeNode* root) {
    stack<TreeNode*> stack;
    stack.push(root);
    int ans = 0;

    while (!stack.empty()) {
        TreeNode* node = stack.top();
        stack.pop();
        // 根据题意补充代码
        if (node->left != nullptr) {
            stack.push(node->left);
        }
        if (node->right != nullptr) {
            stack.push(node->right);
        }
    }

    return ans;
}

12. 二叉树: BFS

from collections import deque

def fn(root):
    queue = deque([root])
    ans = 0

    while queue:
        current_length = len(queue)
        # 做一些当前层的操作

        for _ in range(current_length):
            node = queue.popleft()
            # 根据题意补充代码
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

    return ans

int fn(TreeNode* root) {
    queue<TreeNode*> queue;
    queue.push(root);
    int ans = 0;

    while (!queue.empty()) {
        int currentLength = queue.size();
        // 做一些当前层的操作

        for (int i = 0; i < currentLength; i++) {
            TreeNode* node = queue.front();
            queue.pop();
            // 根据题意补充代码
            if (node->left != nullptr) {
                queue.push(node->left);
            }
            if (node->right != nullptr) {
                queue.push(node->right);
            }
        }
    }

    return ans;
}

13. 图: DFS (递归)

以下图模板假设节点编号从 0 到 n - 1 ，并且图是以邻接表的形式给出的。

  • 根据问题的不同，可能需要在使用模板之前将输入转换为等效的邻接表。
def fn(graph):
    def dfs(node):
        ans = 0
        # 根据题意补充代码
        for neighbor in graph[node]:
            if neighbor not in seen:
                seen.add(neighbor)
                ans += dfs(neighbor)
        
        return ans

    seen = {START_NODE}
    return dfs(START_NODE)


unordered_set<int> seen;

int fn(vector<vector<int>>& graph) {
    seen.insert(START_NODE);
    return dfs(START_NODE, graph);
}

int fn dfs(int node, vector<vector<int>>& graph) {
    int ans = 0;
    // 根据题意补充代码
    for (int neighbor: graph[node]) {
        if (seen.find(neighbor) == seen.end()) {
            seen.insert(neighbor);
            ans += dfs(neighbor, graph);
        }
    }

    return ans;
}

14. 图: DFS (迭代)

def fn(graph):
    stack = [START_NODE]
    seen = {START_NODE}
    ans = 0

    while stack:
        node = stack.pop()
        # 根据题意补充代码
        for neighbor in graph[node]:
            if neighbor not in seen:
                seen.add(neighbor)
                stack.append(neighbor)
    
    return ans

int fn(vector<vector<int>>& graph) {
    stack<int> stack;
    unordered_set<int> seen;
    stack.push(START_NODE);
    seen.insert(START_NODE);
    int ans = 0;

    while (!stack.empty()) {
        int node = stack.top();
        stack.pop();
        // 根据题意补充代码
        for (int neighbor: graph[node]) {
            if (seen.find(neighbor) == seen.end()) {
                seen.insert(neighbor);
                stack.push(neighbor);
            }
        }
    }
}

15. 图: BFS

from collections import deque

def fn(graph):
    queue = deque([START_NODE])
    seen = {START_NODE}
    ans = 0

    while queue:
        node = queue.popleft()
        # 根据题意补充代码
        for neighbor in graph[node]:
            if neighbor not in seen:
                seen.add(neighbor)
                queue.append(neighbor)
    
    return ans


int fn(vector<vector<int>>& graph) {
    queue<int> queue;
    unordered_set<int> seen;
    queue.add(START_NODE);
    seen.insert(START_NODE);
    int ans = 0;

    while (!queue.empty()) {
        int node = queue.front();
        queue.pop();
        // 根据题意补充代码
        for (int neighbor: graph[node]) {
            if (seen.find(neighbor) == seen.end()) {
                seen.insert(neighbor);
                queue.push(neighbor);
            }
        }
    }
}

16. 找到堆的前 k 个元素

import heapq

def fn(arr, k):
    heap = []
    for num in arr:
        # 做根据题意补充代码，根据问题的条件来推入堆中
        heapq.heappush(heap, (CRITERIA, num))
        if len(heap) > k:
            heapq.heappop(heap)
    
    return [num for num in heap]


vector<int> fn(vector<int>& arr, int k) {
    priority_queue<int, CRITERIA> heap;
    for (int num: arr) {
        heap.push(num);
        if (heap.size() > k) {
            heap.pop();
        }
    }

    vector<int> ans;
    while (heap.size() > 0) {
        ans.push_back(heap.top());
        heap.pop();
    }

    return ans;
}

17. 二分查找

def fn(arr, target):
    left = 0
    right = len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            # 根据题意补充代码
            return
        if arr[mid] > target:
            right = mid - 1
        else:
            left = mid + 1
    
    # left 是插入点
    return left


int binarySearch(vector<int>& arr, int target) {
        int left = 0;
        int right = int(arr.size()) - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target) {
                // 根据题意补充代码
                return mid;
            }
            if (arr[mid] > target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        
        // left 是插入点
        return left;
    }
18. 二分查找: 重复元素，最左边的插入点
def fn(arr, target):
    left = 0
    right = len(arr)
    while left < right:
        mid = (left + right) // 2
        if arr[mid] >= target:
            right = mid
        else:
            left = mid + 1

    return left


int binarySearch(vector<int>& arr, int target) {
    int left = 0;
    int right = arr.size();
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] >= target) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}
19. 二分查找: 重复元素，最右边的插入点
def fn(arr, target):
    left = 0
    right = len(arr)
    while left < right:
        mid = (left + right) // 2
        if arr[mid] > target:
            right = mid
        else:
            left = mid + 1

    return left


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

20. 二分查找: 贪心问题

寻找最小值：
def fn(arr):
    def check(x):
        # 这个函数的具体实现取决于问题
        return BOOLEAN

    left = MINIMUM_POSSIBLE_ANSWER
    right = MAXIMUM_POSSIBLE_ANSWER
    while left <= right:
        mid = (left + right) // 2
        if check(mid):
            right = mid - 1
        else:
            left = mid + 1
    
    return left

int fn(vector<int>& arr) {
    int left = MINIMUM_POSSIBLE_ANSWER;
    int right = MAXIMUM_POSSIBLE_ANSWER;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (check(mid)) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }

    return left;
}

bool check(int x) {
    // 这个函数的具体实现取决于问题
    return BOOLEAN;
}
寻找最大值：
def fn(arr):
    def check(x):
        # 这个函数的具体实现取决于问题
        return BOOLEAN

    left = MINIMUM_POSSIBLE_ANSWER
    right = MAXIMUM_POSSIBLE_ANSWER
    while left <= right:
        mid = (left + right) // 2
        if check(mid):
            left = mid + 1
        else:
            right = mid - 1
    
    return right


int fn(vector<int>& arr) {
    int left = MINIMUM_POSSIBLE_ANSWER;
    int right = MAXIMUM_POSSIBLE_ANSWER;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (check(mid)) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return right;
}

bool check(int x) {
    // 这个函数的具体实现取决于问题
    return BOOLEAN;
}

21. 回溯

def backtrack(curr, OTHER_ARGUMENTS...):
    if (BASE_CASE):
        # 修改答案
        return
    
    ans = 0
    for (ITERATE_OVER_INPUT):
        # 修改当前状态
        ans += backtrack(curr, OTHER_ARGUMENTS...)
        # 撤消对当前状态的修改
    
    return ans


int backtrack(STATE curr, OTHER_ARGUMENTS...) {
    if (BASE_CASE) {
        // 修改答案
        return 0;
    }

    int ans = 0;
    for (ITERATE_OVER_INPUT) {
        // 修改当前状态
        ans += backtrack(curr, OTHER_ARGUMENTS...)
        // 撤消对当前状态的修改
    }

    return ans;
}

22. 动态规划: 自顶向下法

def fn(arr):
    def dp(STATE):
        if BASE_CASE:
            return 0
        
        if STATE in memo:
            return memo[STATE]
        
        ans = RECURRENCE_RELATION(STATE)
        memo[STATE] = ans
        return ans

    memo = {}
    return dp(STATE_FOR_WHOLE_INPUT)


unordered_map<STATE, int> memo;

int fn(vector<int>& arr) {
    return dp(STATE_FOR_WHOLE_INPUT, arr);
}

int dp(STATE, vector<int>& arr) {
    if (BASE_CASE) {
        return 0;
    }

    if (memo.find(STATE) != memo.end()) {
        return memo[STATE];
    }

    int ans = RECURRENCE_RELATION(STATE);
    memo[STATE] = ans;
    return ans;
}

23. 构建前缀树（字典树）

  • 注意:只有需要在每个节点上存储数据时才需要使用类。
  • 否则，您可以只使用哈希映射实现一个前缀树。
# 注意:只有需要在每个节点上存储数据时才需要使用类。
# 否则，您可以只使用哈希映射实现一个前缀树。
class TrieNode:
    def __init__(self):
        # you can store data at nodes if you wish
        self.data = None
        self.children = {}

def fn(words):
    root = TrieNode()
    for word in words:
        curr = root
        for c in word:
            if c not in curr.children:
                curr.children[c] = TrieNode()
            curr = curr.children[c]
        # 这个位置上的 curr 已经有一个完整的单词
        # 如果你愿意，你可以在这里执行更多的操作来给 curr 添加属性
    
    return root

// 注意:只有需要在每个节点上存储数据时才需要使用类。
// 否则，您可以只使用哈希映射实现一个前缀树。
struct TrieNode {
    int data;
    unordered_map<char, TrieNode*> children;
    TrieNode() : data(0), children(unordered_map<char, TrieNode*>()) {}
};

TrieNode* buildTrie(vector<string> words) {
    TrieNode* root = new TrieNode();
    for (string word: words) {
        TrieNode* curr = root;
        for (char c: word) {
            if (curr->children.find(c) == curr->children.end()) {
                curr->children[c] = new TrieNode();
            }
            curr = curr->children[c];
            // 这个位置上的 curr 已经有一个完整的单词
            // 如果你愿意，你可以在这里执行更多的操作来给 curr 添加属性
        }
    }

    return root;
}
HHHTTY-
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
常见算法题代码c++常见算法题代码c++常见算法题代码c++常见算法题代码c++
03-06
常见算法题代码c++ 常见算法题代码c++ 常见算法题代码c++ 常见算法题代码c++ 常见算法题代码c++ 常见算法题代码c++
算法代码题
yanlingyun0210的博客
09-26 137
一些代码
算法代码题总结
咒术高专
03-09 125
一、合并两个有序链表 二、合并k个有序链表 三、计算auc 四、1e个整数，范围在[1-3e]，求其中最大的100w个 快排，最小堆
这11道经典算法题，1行代码就能搞定！
十指波课堂的博客
01-11 1758
笔者在这里准备了11道算法题，全部都是1行代码就能搞定的算法题，其中大部分题目来源于leetcode网站，有兴趣的小伙伴们可以看看哦~一、2的幂问题：如何判断一个数字是2的n次方。解答：public static boolean isPowerOfTow(int n) { return (n > 0) && (n & (n - 1)) == 0; ...
几个常见算法题代码
x15696576570的博客
03-22 233
list链表、迭代器遍历 #include&amp;amp;lt;iostream&amp;amp;gt; #include&amp;amp;lt;list&amp;amp;gt; using namespace std; bool comp(const int &amp;amp;amp;a,const int &amp;amp;amp;b) { return a&amp;amp;gt;b; } int main() {
算法题代码模板——滑动窗口
SmiledrinkCat的博客
04-19 357
【代码】算法题代码模板——滑动窗口。
建议收藏算法基础课模板大全
08-12
基础算法 —— 代码模板链接 常用代码模板1——基础算法 排序 二分 高精度 前缀和与差分 双指针算法 位运算 离散化 区间合并 数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 ...
AcWing算法基础课模板大全
07-14
基础算法 —— 代码模板链接 常用代码模板1——基础算法 排序 二分 高精度 前缀和与差分 双指针算法 位运算 离散化 区间合并 数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 ...
算法模板（Java版）——leetcode刷题与复习指南.zip
03-14
面向对象：Java全面支持面向对象的特性，如封装、继承和多态，使得代码更易于维护和扩展。 安全：Java提供了丰富的安全特性，如禁止指针运算、自动内存管理和异常处理机制，以减少程序错误和恶意攻击的可能性。 可...
经典算法题大全
04-22
这是本人考蓝桥杯的时候收集的各种算法题，有小伙伴知道蓝桥杯吗，哈哈，虽然比赛不怎么样，可是资源可都是经典算法大集合欧
笔试强训-day17_T2 十字爆破
weixin_46186903的博客
05-03 440
模拟即可，但是由于数据量过⼤，我们可以提前把每⼀⾏以及每⼀列的和存起来，⽅便统计总和。解法二：提前把每⼀⾏以及每⼀列的和存起来，然后输入输出使用快速的IO方式，解答如下所示。解法一：暴力遍历，这种方法很容易想到，并且也容易编写出代码，但是会超时。因为1+2+3=6，1+2+4=7，1+3+4=8，2+3+4=9。牛牛选择一个方格，可以得到和这个方格同行、同列的所有数之和的得分。现在牛牛想知道下一步选择每个格子的得分情况，你可以帮帮他吗？m个方格，每个方格中有一个整数。
leetcode16-3Sum Closest
我的程序人生
04-29 299
这道题目和那道3Num的题目很类似，解题思路也是类似的，我们先对数组排序，然后固定一个元素，通过双指针遍历剩下的元素，用一个哨兵记录三个元素的和与target的diff，分别处理三个元素的和小于target，大于target，等于target这三种情况即可。请你从 nums 中选出三个整数，使它们的和与 target 最接近。解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)。输入：nums = [-1,2,1,-4], target = 1。假定每组输入只存在恰好一个解。
Python机器学习项目开发实战：在数据分析竞赛平台遴选最佳算法模型
最新发布
一个好知识的传播者
05-03 706
在Python机器学习项目开发实战中，数据分析竞赛平台为我们提供了一个实践和验证算法模型性能的理想场所。在这些平台上，参赛者需要面对各种真实世界的数据集，通过选择和应用合适的算法模型，来解决各种复杂的数据分析问题。下面将详细阐述如何在数据分析竞赛平台上遴选最佳的算法模型。
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 629
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
代码随想录算法训练营第三十八天
weixin_41902984的博客
04-28 234
又又又欠两天债，不过回家了，一切可以按部就班，明天慢慢补吧，今天先做一课的内容。然后就是如果一次可以上m个阶梯的话应该怎么做，先把伪代码放上来。其实就是斐波那契数，不过需要理解一下过程。还好还好，动态规划第一天不太难。746. 使用最小花费爬楼梯。509. 斐波那契数。
Golang | Leetcode Golang题解之第56题合并区间
weixin_66442839的博客
04-28 536
Golang | Leetcode Golang题解之第56题合并区间
第六章 图
qq_44419734的博客
04-27 632
带权有向图中，顶点表示事件，有向边表示活动，边上的权值表示完成该活动的开销（如完成活动所需要的时间），称之为用边表示活动的网络。
c入门基础题（3）
梦昼初
04-26 934
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
【算法刷题 | 贪心算法08】4.29（划分字母区间、合并区间）
个银二粒的成长之路
04-29 583
4.29（划分字母区间、合并区间）
最近，小明同学学习了泛型编程技术——模板，了解了函数模板与类模板的设计，并且设计了不少基于模板技术实现的函数和类，你特别羡慕小明掌握了这些编程的技术，于是你用了几顿饭的代价，从小明那里学到了相关的知识，并想尝试一下。数学上，我们学过集合（元素不重复），现在请你用一个动态有序数组来表示集合，并能动态增加集合的大小(容量)。经过前期的实验，你基本熟悉了相关知识，并已经设计好了类模板框架，设计了几个简单的成员函数，在此基础上，请你实现类模板的如下成员函数，具体要求： (1) 成员函数find，从集合中查找某元素e，返回该元素在集合中的位序(数组下标)，若不存在，则返回-1；因集合有序，为提高查找效率，建议使用折半查找(二分查找)。 (2) 成员函数insert，向集合中插入元素e，根据集合的特性(元素不重复)，若该元素已存在，则不插入该元素；否则，若集合已满，则需调整集合容量，再插入。因集合有序，并不是将元素插入到集合末尾！ (3) 实现成员函数print，输出集合中的所有元素，所有元素之间以空格分隔，最后一个元素后不输出空格，输出结束后换行；空集输出一个空行即可。
06-09
以下是实现集合类模板的关键代码： ```cpp template class Set { public: Set() : data(nullptr), size(0), capacity(0) {}; ~Set() { if (data != nullptr) { delete[] data; } } int find(const T& e) ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HHHTTY-

你的鼓励将是我创作的最大动力~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值