剑指Offer刷题笔记--Num03-10

已于 2023-11-12 16:17:12 修改
阅读量107 收藏
点赞数
分类专栏： 数据结构&LeetCode 文章标签： 数据结构
于 2023-05-06 18:03:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43863869/article/details/130532717
版权

目录

1--数组中重复的数字（03）

2--二维数组中的查找（04）

3--替换空格（05）

4--从尾到头打印链表（06）

5--重建二叉树（07）

6--用两个栈实现队列（09）

7--斐波拉契数列（10）

8--青蛙跳台阶问题（10）

1--数组中重复的数字（03）

解决方法1：

        基于哈希表，将数组中的元素视为 Key，其对应的 Value 设为 True；遍历每一个元素，查询元素 Key 对应的 Value，若为 True 表示之前已经出现了它的重复元素；否则将元素 Key 对应的 Value 设为 True，保存在哈希表中；

C++ 版本:

#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_map>
 
// 基于哈希表
class Solution {
public:
    int findRepeatNumber(std::vector<int>& nums) {
        std::unordered_map<int, bool> map;
        for(int num : nums) {
            if(map[num]) return num;
            map[num] = true;
        }
        return -1;
    }
};
 
int main(int argc, char *argv[]){
    std::vector<int> v1 = {2, 3, 1, 0, 2, 5, 3};
    Solution s1;
    int num = s1.findRepeatNumber(v1);
    std::cout << "num: " << num << std::endl;
    return 0; 
}

Python 版本:

from typing import List

class Solution:
    def duplicate(self, numbers: List[int]) -> int:
        hash_set = set()
        for number in numbers:
            if(number in hash_set):
                return number
            else:
                hash_set.add(number)
        return -1
    
if __name__ == "__main__":
    test = [2, 3, 1, 0, 2, 5, 3]
    S1 = Solution()
    res = S1.duplicate(test)
    print(res)

解决方法2：        

        利用原地交换，将索引位置 i 与位置上的值 nums[i] 匹配上；

题解的一个易懂解释：

        这个原地交换法就相当于分配工作，每个索引代表一个工作岗位，每个岗位必须专业对口，既0索引必须0元素才能上岗。而我们的目的就是找出溢出的人才，既0索引岗位有多个0元素竞争。

        我们先从0索引岗位开始遍历，首先我们看0索引是不是已经专业对口了，如果已经专业对口既nums[0]=0，那我们就跳过0岗位看1岗位。如果0索引没有专业对口，那么我们看现在0索引上的人才调整到他对应的岗位上，比如num[0]=2，那我们就把2这个元素挪到他对应的岗位上既num[2]，这个时候有两种情况:1、num[2]岗位上已经有专业对口的人才了，既num[2]=2，这就说明刚刚那个在num[0]上的2是溢出的人才，我们直接将其返回即可。2、num[2]上的不是专业对口的人才，那我们将num[0]上的元素和num[2]上的元素交换，这样num[2]就找到专业对口的人才了。之后重复这个过程直到帮num[0]找到专业对口的人才，然后以此类推帮num[1]找人才、帮num[2]找人才，直到找到溢出的人才。

C++ 版本：

#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_map>

// 核心思路是使索引位置i 与 位置i上的值nums[i]相等
class Solution {
public:
    int findRepeatNumber(std::vector<int>& nums) {
        int i = 0;
        while(i < nums.size()){
            if(nums[i] == i){ // 当前索引的位置i 与 位置的值nums[i] 相等
                i++;
                continue; // 无须进行后面的交换操作
            }
            if(nums[nums[i]] == nums[i]) return nums[i];
            else std::swap(nums[i], nums[nums[i]]); // 交换
        }
        return -1;
    }
};

int main(int argc, char *argv[]){
    std::vector<int> v1 = {2, 3, 1, 0, 2, 5, 3};
    Solution s1;
    int num = s1.findRepeatNumber(v1);
    std::cout << "num: " << num << std::endl;
    return 0; 
}

Python版本：

from typing import List

class Solution:
    def duplicate(self, numbers: List[int]) -> int:
        for i in range(len(numbers)):
            if(numbers[i] == i): continue
            elif(numbers[numbers[i]] == numbers[i]):
                return numbers[i]
            else:
                self.swap(numbers, i, numbers[i])
        return -1
    
    #交换函数
    def swap(self, numbers: List[int], a: int, b: int):
        temp = numbers[a]
        numbers[a] = numbers[b]
        numbers[b] = temp
    
if __name__ == "__main__":
    test = [2, 3, 1, 0, 2, 5, 3]
    S1 = Solution()
    res = S1.duplicate(test)
    print(res)

2--二维数组中的查找（04）

暴力法求解：        

        遍历每一个一维数组，通过STL标准库 find() 函数寻找目标整数；

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    bool findNumberIn2DArray(std::vector<std::vector<int>>& matrix, int target) {
        for(auto it1 = matrix.begin(); it1 != matrix.end(); it1++){
            auto loc = find((*it1).begin(), (*it1).end(), target);
            if(loc != (*it1).end())
                return true;
        }
        return false;
    }
};

int main(int argc, char *argv[]){
    std::vector<int> m1 = {1, 4, 7, 11, 15};
    std::vector<int> m2 = {2, 5, 8, 12, 19};
    std::vector<int> m3 = {3, 6, 9, 16, 22};
    std::vector<int> m4 = {10, 13, 14, 17, 24};
    std::vector<int> m5 = {18, 21, 23, 26, 30};
    std::vector<std::vector<int>> matrix = {m1, m2, m3, m4, m5};
    Solution s1;
    bool stat1 = s1.findNumberIn2DArray(matrix, 5);
    bool stat2 = s1.findNumberIn2DArray(matrix, 20);
    std::cout << "stat1: " << stat1 << std::endl;
    std::cout << "stat2: " << stat2 << std::endl;
    return 0; 
}

搜索树解法：

        将矩阵逆时针旋转 45°，将其转化为图的形式，其搜索等价于二叉搜索树，具体见题解；

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    bool findNumberIn2DArray(std::vector<std::vector<int>>& matrix, int target) {
        int i = matrix.size() - 1, j = 0;
        while(i >= 0 && j < matrix[0].size())
        {
            if(matrix[i][j] > target) i--;
            else if(matrix[i][j] < target) j++;
            else return true;
        }
        return false;
    }
};

int main(int argc, char *argv[]){
    std::vector<int> m1 = {1, 4, 7, 11, 15};
    std::vector<int> m2 = {2, 5, 8, 12, 19};
    std::vector<int> m3 = {3, 6, 9, 16, 22};
    std::vector<int> m4 = {10, 13, 14, 17, 24};
    std::vector<int> m5 = {18, 21, 23, 26, 30};
    std::vector<std::vector<int>> matrix = {m1, m2, m3, m4, m5};
    Solution s1;
    bool stat1 = s1.findNumberIn2DArray(matrix, 5);
    bool stat2 = s1.findNumberIn2DArray(matrix, 20);
    std::cout << "stat1: " << stat1 << std::endl;
    std::cout << "stat2: " << stat2 << std::endl;
    return 0; 
}

Python版本：

from typing import List

class Solution:
    def Find(self , target: int, array: List[List[int]]) -> bool:
        n = len(array)
        m = len(array[0])
        start_i = 0
        start_j = m -1
        while(start_i < n and start_j >= 0):
            if(array[start_i][start_j] == target): return True
            elif(array[start_i][start_j] > target): start_j -= 1
            else: start_i += 1

        return False 
    
if __name__ == "__main__":
    # 7, [[1,2,8,9],[2,4,9,12],[4,7,10,13],[6,8,11,15]]
    target = 7
    array = [[1,2,8,9],[2,4,9,12],[4,7,10,13],[6,8,11,15]]
    S1 = Solution()
    res = S1.Find(target, array)
    print(res)

3--替换空格（05）

原地修改：

        不新建字符串，遍历输入的字符串，判断字符是否等于空格，是空格则删除，并插入“%20”，遍历后移3位，最后返回原字符串；

#include <iostream>
#include <string>

class Solution {
public:
    std::string replaceSpace(std::string s) {
        for (int i = 0; i < s.size(); i++){
            if (s[i] ==  ' '){
                s.erase(i, 1);
                s.insert(i, "%20");
                i = i + 2;
            }
        }
        return s;
    }
};

int main(int argc, char *argv[]){
    std::string s1 = "We are happy.";
    Solution Func;
    std::string s2 = Func.replaceSpace(s1);
    std::cout << "s2: " << s2 << std::endl;
}

新建字符串：

        遍历输入的字符串，判断当前字符是否等于空格，是空格则新字符串添加“%20”，否则添加当前字符，最后返回新字符串；

#include <iostream>
#include <string>

class Solution {
public:
    std::string replaceSpace(std::string s) {
        std::string s1;
        for(auto item : s){
            if (item == ' ') s1 = s1 + "%20";
            else s1 = s1 + item;
        }
        return s1;
    }
};

int main(int argc, char *argv[]){
    std::string s1 = "We are happy.";
    Solution Func;
    std::string s2 = Func.replaceSpace(s1);
    std::cout << "s2: " << s2 << std::endl;
}

Python版本：

class Solution:
    def replaceSpace(self , s: str) -> str:
        res = ""
        for char in s:
            if char == ' ':
                res += "%20"
            else: res += char
        return res
    
if __name__ == "__main__":
    str = "We Are Happy"
    S1 = Solution()
    res = S1.replaceSpace(str)
    print(res)

4--从尾到头打印链表（06）

        借助STL中 vector 的 insert() 函数，遍历链表时每次都在开头插入新的元素：

#include <iostream>
#include <vector>

struct ListNode {
    ListNode(){}; // 构造函数

    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    std::vector<int> reversePrint(ListNode* head) {
        std::vector<int> v1;
        ListNode* pos = head;
        while(pos != NULL){
            v1.insert(v1.begin(), pos->val);
            pos = pos -> next; 
        } 
        return v1;
    }
};

int main(int argc, char *argv[]){
    ListNode *head = new ListNode(1);
    ListNode *node1 = new ListNode(3);
    ListNode *node2 = new ListNode(2);
    head->next = node1;
    node1->next = node2;
    Solution s1; 
    std::vector<int> v1 = s1.reversePrint(head);
    for(auto item : v1){
        std::cout << "item: " << item << std::endl;
    }
}

        分析题目，先遍历出现的元素后返回，即先进后出，符合栈的规律，可借助递归实现，递归终止的条件是当前结点的指针为空；

#include <iostream>
#include <vector>

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    std::vector<int> reversePrint(ListNode* head) {
        if(!head)
            return {};
        std::vector<int> a = reversePrint(head->next);
        a.push_back(head->val);
        return a;
    }
};

int main(int argc, char *argv[]){
    ListNode *head = new ListNode(1);
    ListNode *node1 = new ListNode(3);
    ListNode *node2 = new ListNode(2);
    head->next = node1;
    node1->next = node2;
    Solution s1; 
    std::vector<int> v1 = s1.reversePrint(head);
    for(auto item : v1){
        std::cout << "item: " << item << std::endl;
    }
}

Python版本：

import sys
from typing import List

#设置递归深度
sys.setrecursionlimit(100000)

class ListNode:
    def __init__(self, val=0, next = None):
        self.val = val
        self.next = next
        
class Solution:
    def recursion(self, head: ListNode, res: List[int]):
        if head:
            self.recursion(head.next, res)
            res.append(head.val)
    def printListFromTailToHead(self , listNode: ListNode) -> List[int]:
        res = []
        self.recursion(listNode, res)
        return res
    
if __name__ == "__main__":
    # {1,2,3}
    Node1 = ListNode(1)
    Node2 = ListNode(2)
    Node3 = ListNode(3)
    
    Node1.next = Node2
    Node2.next = Node3
    
    S1 = Solution()
    res = S1.printListFromTailToHead(Node1)
    print(res)

5--重建二叉树（07）

主要思路：

        前序遍历第一个肯定是根节点，中序遍历根节点左边是左子树，右边是右子树；

        因此，在中序遍历定位根节点的位置后，可以递归处理左子树和右子树；

        左子树和右子树的起始和结束位置可以根据左子树的大小确定；

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        for(int i = 0; i < n; i++){
            m1[inorder[i]] = i; 
        }
        TreeNode* Tree = mybuildTree(preorder, inorder, 0, n-1, 0, n-1);
        return Tree;
    }

    TreeNode* mybuildTree(vector<int>& preorder, vector<int>& inorder, int p_start, int p_end, 
                                            int i_start, int i_end){
        if( p_start > p_end){
            return nullptr;
        }
        TreeNode *Root = new TreeNode(preorder[p_start]);
        int Root_idx = m1[preorder[p_start]]; 
        int left_tree_size = Root_idx - i_start;
        Root->left = mybuildTree(preorder, inorder, p_start+1, p_start+left_tree_size, 
                                            i_start, Root_idx-1);
        Root->right = mybuildTree(preorder, inorder, p_start+1+left_tree_size, p_end, Root_idx+1, i_end);
        return Root;
    }
    std::map<int, int> m1;
};

Python版本:

from typing import List
from queue import Queue

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    def reConstructBinaryTree(self , preOrder: List[int], vinOrder: List[int]) -> TreeNode:
        return self.dfs(preOrder, vinOrder, 0, len(preOrder) - 1, 0, len(vinOrder) - 1)
    
    def dfs(self, preOrder: List[int], vinOrder: List[int], pre_start: int, pre_end: int, vin_start: int, vin_end: int) -> TreeNode:
        if(pre_start > pre_end): return None
        root = TreeNode(preOrder[pre_start]) # 取根节点

        i = vin_start # 中序遍历中计算根节点的位置
        while(i <= vin_end):
            if(vinOrder[i] == root.val): 
                break # 根节点的位置
            i += 1
        
        # 计算左子树的长度
        left_num = i - vin_start
        # 递归构建左子树和右子树
        root.left = self.dfs(preOrder, vinOrder, pre_start + 1, pre_start + left_num, vin_start, i - 1)
        root.right = self.dfs(preOrder, vinOrder, pre_start + left_num + 1, pre_end, i + 1, vin_end)

        return root

if __name__ == "__main__":
    # [1, 2, 4, 7, 3, 5, 6, 8], [4, 7, 2, 1, 5, 3, 8, 6]
    S1 = Solution()
    pre = [1, 2, 4, 7, 3, 5, 6, 8]
    vin = [4, 7, 2, 1, 5, 3, 8, 6]
    res = S1.reConstructBinaryTree(pre, vin)
    q1 = Queue()
    q1.put(res)
    while(not q1.empty()):
        cur = q1.get()
        print(cur.val)
        if(cur.left != None):
            q1.put(cur.left)
        if(cur.right != None):
            q1.put(cur.right)

6--用两个栈实现队列（09）

 建立两个栈，一个作为输入栈，一个作为输出栈；输出队列时，直接返回输出栈的栈顶元素；当输出栈为空时，如果输入栈不会空，就把输入栈的元素移动到输出栈中；如果输入栈也为空则表示队列为空，返回-1；

class CQueue {
public:
    CQueue() {

    }
    
    void appendTail(int value) {
        in_stack.push(value);
    }
    
    int deleteHead() {
        if (out_stack.size() != 0){
            elem = out_stack.top();
            out_stack.pop();
            return elem;
        } 
        else{
            if(in_stack.size() == 0){
                return -1;
            }
            else{
                int instack_size = in_stack.size();
                for(int i = 0; i < instack_size; i++){
                    elem = in_stack.top();
                    out_stack.push(elem);
                    in_stack.pop();
                }
                elem = out_stack.top();
                out_stack.pop();
                return elem;
            }
        }
    }
    std::stack<int> in_stack;
    std::stack<int> out_stack;
    int elem;
};

Python版本：

class Solution:
    def __init__(self):
        self.stack1 = [] # 输入栈
        self.stack2 = [] # 输出栈
    def push(self, node):
        self.stack1.append(node)
    def pop(self):
        if(len(self.stack2) == 0):
            if(len(self.stack1) == 0): return -1
            else:
                for i in range(len(self.stack1)):
                    self.stack2.append(self.stack1.pop())
                
        return self.stack2.pop()
        
    
if __name__ == "__main__":
    S1 = Solution()
    S1.push(1)
    S1.push(2)
    print(S1.pop())
    print(S1.pop())
    print("all done!")

7--斐波拉契数列（10）

        经典动态规划题目，使用递归会导致内存消耗大、运行时间长等问题，利用递推的方式实现求解：从 F(2) = F(1) + F(0) 开始递推，利用变量记录当前的F(N-1)和F(N-2)；

class Solution {
public:
    int fib(int n) {
        if (n < 2){
            return n;
        }
        int f_1 = 0, f_2 = 0, sum = 1;
        for(int i = 2; i <= n; i++){
            f_2 = f_1;
            f_1 = sum;
            sum = (m1 + m2) % 1000000007;
        }
        return sum;
    }
};

Python版本：

class Solution:
    def Fibonacci(self , n: int) -> int:
        if(n == 1 or n == 2): return 1
        res = 1
        pre1 = 1
        pre2 = 1
        for i in range(n - 2):
            res = pre1 + pre2
            pre2 = pre1
            pre1 = res
        return res
        
if __name__ == "__main__":
    S1 = Solution()
    print(S1.Fibonacci(4))
    print("all done!")

8--青蛙跳台阶问题（10）

设 n 阶台阶有 f(n) 种跳法，假设最后一步只跳一阶，则剩下的 n-1 个台阶有 f(n-1) 种跳法；假设最后一步跳两阶，则剩下的 n-2 个台阶有 f(n-2) 种跳法；即 f(n) = f(n-1) + f(n-2)；

边界条件：f(0) = 1；f(1) = 1；f(2) = 2；

class Solution {
public:
    int numWays(int n) {
        int f1 = 1, f2 = 0, sum = 1;
        for(int i = 0; i < n; i++){
            sum = (f1 + f2) % 1000000007;
            f2 = f1;
            f1 = sum;           
        }
        return sum; 
    }
};

晓晓纳兰容若
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《剑指Offer》刷题笔记——面试题46. 把数字翻译成字符串
12-22
1、剑指解析 2、代码实现 class Solution: def translateNum(self, num: int) -> int: if num9 and 10*num[-2]+num[-1]9 and 10*num[i]+num[i+1]<26: g = 1 else: g = 0 f[i] = f[i+1] + g * f[i+2] ...
《剑指Offer》刷题笔记——面试题22. 链表中倒数第k个节点
12-22
1、剑指解析 2、测试用例 3、代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def getKthFromEnd(self, head: ...
剑指offer刷题笔记--Num51-60
牵一只蜗牛去散步
07-19 1267
考虑到题目给定的数组是递增有序的，因此可以考虑使用双指针法，分别指向数组的左右两端，并计算双指针指向值的和，当和小于 target 时，左指针右移，当和大于 target 时，右指针左移，当和等于 target 时，返回结果；出现三次的数字，在二进制位中其对应位肯定是 3 的倍数，因此只需统计 32 位整型中 1 出现的次数，并将其整除 3，就可以得到只出现1次的数字在该位的数值；相同的两个数进行异或，其结果为零（与顺序无关），因此在题目的数组中，遍历所有元素进行异或，得到的最终结果为。
剑指offer刷题笔记--Num61-68
牵一只蜗牛去散步
08-02 392
1--扑克牌中的顺子（61）1--扑克牌中的顺子（61）
剑指offer刷题笔记--Num41-50
牵一只蜗牛去散步
07-10 541
使用快排对字符串数组进行排序，要确保由字符串数组组成的数最小，即strs[0]strs[1]strs[2]...最小，必须连续满足strs[0] < strs[1], strs[1] < strs[2];基于无序哈希表，key为字符，value 为该字符是否唯一，遍历字符串，当字符唯一时，value 设为 true，否则设为 false；转移方程：dp[i][j] = grid[i][j] + max(dp[i-1][j], dp[i][j-1]);维护两个优先队列，Q1大数优先，存储比中位数小的数；
剑指offer刷题笔记--Num31-40
牵一只蜗牛去散步
07-04 593
直观思路：用两个指针 i 和 j 指向压入和弹出的 vector，终止条件是：所有元素都压入了辅助栈（i > len），且辅助栈当前的栈顶元素与弹出的元素 popped[j] 不相等；模拟栈的压入顺序，依次压入 pushed 里的所有元素，用一个指针 j 指向需要弹出的元素，当符合弹出要求时就弹出对应的元素；二叉搜索树的定义：左子树的结点均小于根节点，右子树的结点均大于根结点；，不同的是为了打印每一层的结点，需要循环当前层的结点数次，每一次。，因此只需要循环队列的长度次，并记录对应的结点值即可；
剑指offer刷题笔记--Num11-20
牵一只蜗牛去散步
05-29 601
对于一段长度为 n 的绳子，将其最大乘积定义为 dp[n]，当裁剪出一段长度为 2 或 3 的绳子后，有两种情况：继续裁剪，则 dp[n] = 2 * dp[n - 2] 或 3 * dp[n - 3]；基于动态规划，则状态转移方程为：dp[n] = max(max(2 * dp[n-2], 2 * (n -2)), max(3*dp[n - 3], 3 * (n - 3)))；每段绳子的长度 k 必须是 2 或 3，因为当 k>= 4时，可以进一步裁剪，例如长度 5 可以拆分为 2*3 大于 5；
剑指offer刷题笔记--Num21-30
牵一只蜗牛去散步
06-26 504
想象成环形链表，反转链表的实质上结点指向上一个结点，则只需遍历链表，将当前结点指向上一个结点，不断更新当前结点和上一个结点即可；由于左右指针的间距为k，则左指针指向原链表的倒数第 k 个节点，直接返回即可；双指针法，左指针从 0 开始遍历，直到遇到偶数，右指针从 len - 1 开始遍历，直到遇到奇数；递归判断左子树的左子树与右子树的右子树是否相等，左子树的右子树与右子树的左子树是否相等；这时左指针指向偶数，右指针指向奇数，交换两个指针的数值，并继续判断下一组数；4--合并两个排序的链表（25）
剑指offer刷题笔记-篇2
qq_45966201的博客
05-08 1157
按照《剑指offer》顺序的刷题笔记，每周积累算法题，主要刷题平台为牛客网，部分题目使用的刷题平台为LeetCode和Acwing，每题均包含主要思路、详细注释、时间复杂度和空间复杂度分析，每题均是尽可能最佳的解决办法。
剑指offer刷题笔记-Java实现
Skeletonz的博客
06-05 608
1.找出数组中重复的数字 给定一个长度为 n 的整数数组 nums，数组中所有的数字都在 0∼n−1 的范围内。 数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。 请找出数组中任意一个重复的数字。 注意：如果某些数字不在 0∼n−1 的范围内，或数组中不包含重复数字，则返回 -1； 样例 给定 nums = [2, 3, 5, 4, 3, 2, 6, 7]。 返回 2...
剑指offer刷题笔记-不晓得第几天了
寻宝游戏
03-30 280
矩阵中的路径（medium） 请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。 [["a","b","c","e"], ["s","f","c",...
《剑指Offer》刷题笔记——面试题41. 数据流中的中位数
12-22
难度：困难 一、题目描述： 二、解题分析： 1、 使用大根堆和小根堆   假想我们现在有两个容器 A, B 这两个容器将我们的整体数据分成两部分,且 A 中的数据都小于 B 中的数据,并且 A 中的最后一个数据是 A 里面...
C++笔记18•数据结构:AVL树•
qq_64446190的博客
09-06 344
AVL树
MATLAB 中双引号 ““ 和单引号 ‘‘ 的区别详解
2202_75569688的博客
09-03 490
在 MATLAB 中，双引号""和单引号''都可以用来表示字符串，但它们的作用和底层类型是不同的。理解它们之间的区别，对于正确使用字符串处理功能非常重要。本文将深入探讨 MATLAB 中""和''的区别，以及在实际编程中的应用场景。
栈—数据结构
最新发布
weixin_63722559的博客
09-06 719
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
【数据结构-二维前缀和】力扣1277. 统计全为 1 的正方形子矩阵
sjsjs11的博客
09-06 232
该题和力扣221.最大正方形类似，以某一格为右下角能形成最大正方形的边长，就是以该格为右下角的正方形数量。给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的 正方形 子矩阵的个数。正方形的总数 = 10 + 4 + 1 = 15.正方形的总数 = 6 + 1 = 7.边长为 1 的正方形有 10 个。边长为 2 的正方形有 4 个。边长为 3 的正方形有 1 个。边长为 1 的正方形有 6 个。边长为 2 的正方形有 1 个。输入：matrix =
【数据结构初阶】——栈和队列
2302_78420373的博客
09-03 971
小伙伴们，大家好呀，今天我们学习的是数据结构中的栈和队列之前我们写过【栈和队列的OJ题】，但是有很多小伙伴不知道栈和队列讲的是什么，咱们就好好聊聊这些就是栈和队列(初阶)的全部内容了，要是想做一点题的可以看看这篇哦【栈和队列OJ题】
数据结构（1）数据结构基础（单向链表）
weixin_68239724的博客
09-03 599
数据结构是一组用来保存一种或多种特定关系的数据的集合。其主要目的是组织和存储数据，以便于高效的访问和修改。程序 = 数据结构 + 算法单向链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的指针。它是一种灵活的存储方式，相比于数组，单向链表不需要连续的内存空间。
"剑指Offer刷题：二维数组中查找问题解析
剑指offer是一本非常经典的面试书籍，其中的编程题目常常被用于各种面试中。而在剑指offer中的第一道题目就是关于在二维数组中查找某个整数的问题。 题目要求我们从一个二维数组中查找是否存在某个整数。这个二维...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值