【剑指offer】二叉树刷题

已于 2023-11-23 17:53:10 修改
阅读量560 收藏
点赞数
文章标签： 数据结构 java
于 2023-09-03 18:23:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43747691/article/details/132652865
版权

文章目录

二叉树遍历

先序遍历
class Solution {
    public List<Integer> preOrderRecursively(TreeNode root){
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        res.add(root.val);
        preOrderRecursively(root.left);
        preOrderRecursively(root.right);
        return res;
    }

    public List<Integer> preOrderIteratively(TreeNode tree){
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        TreeNode root = tree;
        Stack<TreeNode> stack = new Stack<>();
        while(root != null || !stack.isEmpty()){
            if(root != null){
                res.add(root.val);
                stack.push(root);
                root = root.left;
            }else{
                root = stack.pop().right;
            }
        }
        return res;
    }
}
中序遍历
    public List<Integer> inOrderRecursively(TreeNode root){
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        preOrderRecursively(root.left);
        res.add(root.val);
        preOrderRecursively(root.right);
        return res;
    }

    public List<Integer> inOrderIteratively(TreeNode tree){
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        TreeNode root = tree;
        Stack<TreeNode> stack = new Stack<>();
        while(root != null || !stack.isEmpty()){
            if(root != null){
                stack.push(root);
                root = root.left;
            }else{
                res.add(root.peek());
                root = stack.pop().right;
            }
        }
        return res;
    }
}
后序遍历
class Solution {
    public List<Integer> postOrderRecursively(TreeNode root){
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        preOrderRecursively(root.left);
        preOrderRecursively(root.right);
        res.add(root.val);
        return res;
    }

    public List<Integer> postOrderIteratively(TreeNode tree){
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        TreeNode root = tree;
        TreeNode prevVisted = null;
        Stack<TreeNode> stack = new Stack<>();
        while(root != null || !stack.isEmpty()){
            if(root != null){
                stack.push(root);
                root = root.left;
            }else{
                root = stack.peek().right;
                if(root != null && root != prevVisted){
                    stack.push(root);
                    root = root.left;
                }else{
                    prevVisted = stack.pop();
                    res.add(prevVisted.val);
                    root = null;
                }
            }
        }
        return res;
    }
}
层序遍历
class Solution {
    public List<Integer> levelOrder1(TreeNode tree) {
        List<Integer> res = new ArrayList<>();
        if(tree == null){
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(tree);
        TreeNode temp = null;
        while (!queue.isEmpty()) {
            temp = queue.poll();
            res.add(temp.val);
            if (temp.left != null) {
                queue.offer(temp.left);
            }
            if (temp.right != null) {
                queue.offer(temp.right);
            }
        }
        return res;
    }

    public List<Integer> levelOrder2(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(tree == null){
            return res;
        }
        Queue queue = new LinkedList();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = size - 1; i >= 0; i--) {
                TreeNode temp = (TreeNode) queue.poll();
                res.add(temp.val);
                if (temp.left != null) {
                    queue.offer(temp.left);
                }
                if (temp.right != null) {
                    queue.offer(temp.right);
                }
            }
            return res;
        }
    }
}

JZ55 二叉树的深度

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度，根节点的深度视为 1 。

例

输入：{1,2,3,4,5,#,6,#,#,7}

输出：4

1、递归
public class Solution {
    public int TreeDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int left = TreeDepth(root.left);
        int right = TreeDepth(root.right);
        return Math.max(left , right) + 1;
    }
}

2、层序遍历
public class Solution {
    public int TreeDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int depth = 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            depth++;
        }
        return depth;
    }
}

JZ79 判断是不是平衡二叉树

输入一棵节点数为 n 二叉树，判断该二叉树是否是平衡二叉树。

例

输入：{1,2,3,4,5,6,7}

输出：true

class Solution {
    public boolean isBalanced(TreeNode root) {
        if(deep(root) == -1){
            return false;
        }
        return true;
    }

    public int deep(TreeNode root){
        if(root == null){
            return 0;
        }
        int left = deep(root.left);
        if(left == -1){
            return -1;
        }
        int right = deep(root.right);
        if(right == -1){
            return -1;
        }
        if(Math.abs(left - right) > 1){
            return -1;
        }
        return left > right? left+1 : right+1;
    }
}

JZ27 二叉树的镜像

操作给定的二叉树，将其变换为源二叉树的镜像。

例

输入：{8,6,10,5,7,9,11}

输出：{8,10,6,11,9,7,5}

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if(root == null){
            return null;
        }
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
        mirrorTree(root.left);
        mirrorTree(root.right);
        return root;
    }
}
// 层次遍历
class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if(root == null){
            return null;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        TreeNode node = null;
        queue.add(root);
        while(!queue.isEmpty()){
            node = queue.poll();
            if(node.left != null){
                queue.add(node.left);
            }
            if(node.right != null){
                queue.add(node.right);
            }
            TreeNode tmp = node.left;
            node.left = node.right;
            node.right = tmp;
        }

        return root;
    }
}

JZ28 对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例

输入：{1,2,2,3,4,4,3}

输出：true

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null){
            return true;
        }
        return isEqual(root.left, root.right);
    }

    public boolean isEqual(TreeNode left, TreeNode right){
        if(left == null && right == null){
            return true;
        }
        if(left == null || right == null){
            return false;
        }
        if(left.val == right.val){
            return isEqual(left.left, right.right) && isEqual(left.right, right.left);
        }else{
            return false;
        }
    }
}

JZ26 树的子结构

输入两棵二叉树A，B，判断B是不是A的子结构。（我们约定空树不是任意一个树的子结构）

例

输入：{8,8,7,9,2,#,#,#,#,4,7},{8,9,2}

输出：true

class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        if(A == null || B == null){
            return false;
        }
    return isSubStructure(A.left, B) || isSubStructure(A.right, B) || hasSubTree(A, B);
        

    }
    public boolean hasSubTree(TreeNode A, TreeNode B){
        if(B == null){
            return true;
        }
        if(A == null){
            return false;
        }
        if(A.val == B.val){
            return hasSubTree(A.left, B.left) && hasSubTree(A.right, B.right);
        }else{
            return false;
        }
    }
}

JZ32 从上往下打印二叉树 Ⅰ

不分行从上往下打印出二叉树的每个节点，同层节点从左至右打印。

例

输入：{8,6,10,#,#,2,1}

输出：[8,6,10,2,1]

class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            if(node.left != null){
                queue.offer(node.left);
            }
            if(node.right != null){
                queue.offer(node.right);
            }
            res.add(node.val);
        }
        return res;
    }
}

JZ78 从上往下打印二叉树 Ⅱ

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

例

输入：{8,6,10,#,#,2,1}

输出：[[8],[6,10],[2,1]]

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
                list.add(node.val);
            }
            res.add(list);
        }
        return res;
    }
}

JZ77 从上往下打印二叉树 Ⅲ

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

例

输入：{1,2,3,#,#,4,5}

输出：[[1],[3,2],[4,5]]

说明：如题面解释，第一层是根节点，从左到右打印结果，第二层从右到左，第三层从左到右。

public class Solution {
    public ArrayList<ArrayList<Integer>> Print (TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (pRoot == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(pRoot);
        boolean flag = false;
        while (!queue.isEmpty()) {
            int size = queue.size();
            ArrayList<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
                if(flag){
                    list.add(0, node.val);
                }else{
                    list.add(node.val);
                }
            }
            res.add(list);
            flag = !flag;
        }
        return res;
    }
}

JZ7 重建二叉树

给定节点数为 n 的二叉树的前序遍历和中序遍历结果，请重建出该二叉树并返回它的头结点。

例

输入：[1,2,4,7,3,5,6,8],[4,7,2,1,5,3,8,6]

输出：{1,2,3,4,#,5,6,#,7,#,#,8}

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length == 0 || inorder.length == 0){
            return null;
        }
        TreeNode root = new TreeNode(preorder[0]);
        int len = preorder.length;
        for(int i=0; i<len; i++){
            if(inorder[i] == preorder[0]){
                root.left = buildTree(Arrays.copyOfRange(preorder, 1, i+1), Arrays.copyOfRange(inorder, 0, i));
                root.right = buildTree(Arrays.copyOfRange(preorder, i+1, len), Arrays.copyOfRange(inorder, i+1, len));
            }
        }
        return root;
    }
}

JZ33 二叉搜索树的后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则返回 true ,否则返回 false 。假设输入的数组的任意两个数字都互不相同。

例

输入：[1,3,2]

输出：true

public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence.length == 0){
            return false;
        }
        return verify(sequence);
    }

    public boolean verify(int[] sequence){
        int len = sequence.length;
        if(len == 0){
            return true;
        }
        int root = sequence[len-1];
        int index = 0;
        while(index < len-1){
            if(sequence[index] > root){
                break;
            }
            index++;
        }
        int temp = index;
        while(temp < len-1){
            if(sequence[temp] < root){
                return false;
            }
            temp++;
        }
        return verify(Arrays.copyOfRange(sequence, 0, index)) && verify(Arrays.copyOfRange(sequence, index, len-1));
    }
}

JZ54 二叉搜索树的第k个节点

给定一棵二叉搜索树，请找出其中第 k 大的节点的值。

例

输入：root = [3,1,4,null,2], k = 1

输出：4

class Solution {
    public int kthLargest(TreeNode proot, int k) {
        if(proot == null){
            return -1;
        }
        Stack<TreeNode> stack = new Stack<>();
        while(proot != null || !stack.isEmpty()){
            if(proot != null){
                stack.push(proot);
                proot = proot.right;
            }else{
                if(--k == 0){
                    return stack.peek().val;
                }
                proot = stack.pop().left;
            }
        }
        return -1;
    }

JZ68 二叉搜索树的最近公共祖先

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

例

输入：root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8

输出：6

1、递归
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(p.val < root.val && q.val < root.val){
            return lowestCommonAncestor(root.left, p, q);
        }else if(p.val > root.val && q.val > root.val){
            return lowestCommonAncestor(root.right, p, q);
        }else{
            return root;
        }
    }
}
2、非递归
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        while(root != null){
            if(root.val < p.val && root.val < q.val){
                root = root.right;
            }else if(root.val > p.val && root.val > q.val){
                root = root.left;
            }else{
                break;
            }
        }
        return root;
    }
}

JZ37 序列化二叉树

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

例

输入：{1,2,3,#,#,6,7}

输出：{1,2,3,#,#,6,7}

public class Solution {
    String Serialize(TreeNode root) {
        if (root == null) {
            return "[]";
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        StringBuilder res = new StringBuilder("[");
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node != null) {
                res.append(node.val + ",");
                queue.offer(node.left);
                queue.offer(node.right);
            } else {
                res.append("null,");
            }
        }
        res.deleteCharAt(res.length()-1);
        res.append("]");
        return res.toString();
    }
    TreeNode Deserialize(String str) {
        if (str.equals("[]")) {
            return null;
        }
        String[] arr = str.substring(1, str.length() - 1).split(",");
        Queue<TreeNode> queue = new LinkedList<>();
        TreeNode root = new TreeNode(Integer.parseInt(arr[0]));
        queue.offer(root);
        int index = 1;
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (!arr[index].equals("null")) {
                node.left = new TreeNode(Integer.parseInt(arr[index]));
                queue.offer(node.left);
            }
            index++;
            if (!arr[index].equals("null")) {
                node.right = new TreeNode(Integer.parseInt(arr[index]));
                queue.offer(node.right);
            }
            index++;
        }
        return root;
    }
}

补充1 二叉树的直径

给你一棵二叉树的根节点，返回该树的 直径 。二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。两节点之间路径的 长度 由它们之间边数表示。

例

输入：root = [1,2,3,4,5]

输出：3

说明：3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。

class Solution {
    int res = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        dfs(root);
        return res;
    }

    public int dfs(TreeNode node){
        if(node == null){
            return 0;
        }
        int left = dfs(node.left);
        int right = dfs(node.right);
        res = Math.max(left + right, res);
        return Math.max(left, right) + 1;
    }
}

补充2 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

例

输入：[1,2,3,null,5,null,4]

输出：[1,3,4]

1、层序遍历
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i=0; i<size; i++){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
                if(i == size-1){
                    res.add(node.val);
                }
            }
        }
        return res;
    }
}
2、深度优先
class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> rightSideView(TreeNode root) {
        dfs(root, 0);
        return res;
    }
    public void dfs(TreeNode root, int depth){
        if(root == null){
            return;
        }
        if(depth == res.size()){
            res.add(root.val);
        }
        depth++;
        dfs(root.right, depth);
        dfs(root.left, depth);
    }
}
AltmanChan
关注
《剑指Offer》刷题笔记——面试题07. 重建二叉树打印链表
01-20
1、剑指解析： 2、代码实现： from typing import List ###### 代码主体 ###### class Solution: def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode: if not preorder: return None ...
《剑指Offer》刷题笔记——面试题55-II. 平衡二叉树
12-22
《剑指Offer》是针对程序员面试的一本经典书籍，其中的面试题55-II主要讨论的是平衡二叉树。平衡二叉树是一种特殊的二叉树结构，它的左右两个子树的高度差不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树...
13.剑指offer 二叉树刷题
chenkaibsw的专栏
03-28 163
1.对称二叉树： 题目描述 请实现一个函数，用来判断一棵二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。 public class Solution { boolean isSymmetrical(TreeNode pRoot) { if(pRoot == null){ return true; } return isSymme(pRoot.left, pRoot.right);
剑指offer 分类刷题记录
秀秀的奇妙旅行
03-06 1190
树 剑指 Offer 68 - II. 二叉树的最近公共祖先 BST中两节点的最近公共祖先 67 子树最大深度55 最小深度111 平衡二叉树55 另一个树的子树 572 树的子结构 26 镜像二叉树 子树和子结构，都是写一个函数 判断子树和root节点 二叉树的锯齿形层次遍历（按之字顺序打印二叉树） 103 二叉树的层序遍历（把二叉树打印成多行 二维数组输出） 102 需要具体到每层，size for循环 两个容器即可 二叉树的层次遍历 II（从底向上依次按行输出各层节点）107 ..
剑指offer刷刷题
爱胡椒的小白兔呢
07-18 720
1、编程实现设计模式：Singleton（单例模式） public class Singleton { private Singleton(){} private static Singleton s = new Singleton(); public static Singleton getSingleton() { return s; } }
剑指offer刷题笔记
夏尔的小木屋
05-30 296
剑指offer,4-5章
剑指offer刷题汇总
守得云开见月明
06-02 5572
前言      从今天开始在牛客刷剑指offer，希望每天打卡几个算法，提高自己的编程水平。在CSDN做一下记录，随时更新，一起学习吧。 目录大全 数组 剑指offer ( 一 )：二维数组中的查找 剑指offer ( 六 )：旋转数组的最小数字 剑指offer ( 十三 )：调整数组顺序使奇数位于偶数前面【代码完整性】 剑指offer（二十八）：数组中出现次数超过一半的数字【 时间效率】...
剑指offer之刷题总结
Jane_JXR的博客
04-20 276
剑指 Offer 49. 丑数 题目描述：我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。 如：n=10时 , 输出12 思路：刚开始只有1 ，然后对当前值分别*【2,3,5】，得到第二层的值，对第二层的值分别*【2,3,5】递归得到全部的丑数，但这样存在好多重复值的问题，因此，我们维护类似三个指针，这三个指针分别*【2,3,5】，每次取最小的数放入数组，这样就可以啦~ 注意：这里不能用else if哦，否则还是会出现重复的问题 va.
剑指Offer系列刷题笔记汇总
Candy_GL的博客
02-28 325
版权声明：本文为博主原创文章，未经博主允许不得转载。个人网站：http://cuijiahua.com。 https://blog.csdn.net/c406495762/article/details/79247243 本文转自：个人网站：点击查看 一前言 二总结 链表-8道 二叉树12道 二叉搜索树3道 数组11道 字符串8道 栈3道 递归4道 回溯法2道 其他15道 一、前言 本系列文章...
LeetCode刷题——剑指offer二叉树题目汇总
艾醒的博客
01-22 4527
Leetcode 剑指offer中的二叉树题目汇总， 题目列表： 剑指 Offer 07. 重建二叉树 剑指 Offer 26. 树的子结构（中等）、 剑指 Offer 27. 二叉树的镜像（简单）、 剑指 Offer 28. 对称的二叉树（简单）、 剑指 Offer 33. 二叉搜索树的后序遍历序列、(中等) 剑指 Offer 68 - I. 二叉搜索树的最近公共祖先
剑指 offer 刷题集
ミカミミミ博客
09-27 898
剑指 offer 刷题集
《剑指offer》刷题记录汇总篇
郑德帅
06-24 589
《剑指offer》刷题汇总1 前言2 刷题网站3 刷题笔记汇总 1 前言   最近啃了个把月的数据结构与算法，有点飘了，准备拿牛客网的剑指offer模块练练手，个人觉得自己刚入门(或许还没入)，所以这篇博客比较适合想学习数据结构或者刚接触数据机构的新手朋友朋友们，当然，大佬们也可以看看，一是指导，二是差缺补漏。   刷题顺序即题目顺序，时间的话大概一周 2 刷题网站 点击直达:剑指offer 3 刷题笔记汇总 题号 题目 知识点 JZ1 二维数组中的查找 数组、查找 JZ2 替换空格 字
《剑指Offer》刷题笔记——面试题37. 序列化二叉树
12-22
《剑指Offer》是面试题集中的经典之作，其中第37题——“序列化二叉树”是一个常被问到的问题，旨在考察开发者对于数据结构和递归算法的理解。本题要求实现一个二叉树的序列化和反序列化功能，即能够将二叉树的结构...
《剑指Offer》刷题笔记——面试题32-II. 从上到下打印二叉树II
12-22
《剑指Offer》是许多程序员在准备面试时的重要参考资料，其中包含了各种经典的编程问题，旨在提升面试者在算法和数据结构方面的技能。本题“面试题32-II. 从上到下打印二叉树II”是一道关于二叉树层次遍历的问题，...
《剑指Offer》刷题笔记——面试题68-II. 二叉树的最近公共祖先
12-22
难度：简单 一、题目描述： 二、解题分析： # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution: ...
数据结构------队列（Java语言描述）
2402_82356599的博客
11-14 280
队列是一种数据结构，它遵循先进先出的原则。就像排队买东西一样，先到的人先得到服务，先进入队列的数据元素先被取出。例如，在一个银行排队系统中，顾客按照到达的先后顺序排队等待办理业务。第一个进入队列（排队）的顾客会第一个被服务并离开队列。
Redis简介、数据结构、高性能读写、持久化机制、分布式架构
weixin_42267411的博客
11-14 1247
Redis简介、数据结构、高性能读写、持久化机制、分布式架构
初级数据结构——栈
最新发布
ycs66的博客
11-14 1338
数据结构栈（Stack）是一种线性的数据结构，它只允许在序列的一端（称为栈顶）进行插入和删除操作。这种特性使得栈成为许多算法和问题解决中的有力工具。栈是一种简单而强大的数据结构，它遵循后进先出的原则，并通过数组或链表等数据结构实现。栈在多种算法和场景中都有广泛应用，包括函数调用、递归、表达式求值、深度优先搜索、括号匹配等。理解栈的基本概念和操作对于掌握计算机科学和数据结构的基础知识至关重要。同时，栈的变体也为解决特定问题提供了更多可能性。
数据结构中的抽象数据类型、逻辑结构、存储结构等到底是什么？
XuanRan的博客
11-13 955
在学习数据结构的过程中，我们经常会遇到一些抽象的术语，例如“抽象数据类型”（Abstract Data Type，简称ADT）、“逻辑结构”以及“存储结构”。这些概念对非计算机专业的小白来说或许有些难以理解，因此本篇文章将会深入浅出地讲解它们的含义、作用，以及它们在数据结构中的使用。
《剑指Offer》精华思路总结：42道经典算法题
"《剑指offer》思路汇总---简化版的原书思路共42页，涵盖了数组、字符串、链表、树与二叉树、栈和队列、递归与循环六大主题的算法题目及解题思路，旨在帮助求职者准备面试和提升编程能力。" 这篇文档是《剑指Offer...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值