面试经典算法系列之二叉数6 -- 二叉树的右视图

最新推荐文章于 2024-04-30 20:06:58 发布
最新推荐文章于 2024-04-30 20:06:58 发布
阅读量728 收藏 10
点赞数 32
分类专栏： 面试经典算法系列 文章标签： 算法 面试 深度优先 leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44630255/article/details/137758960
版权

面试经典算法21 - 二叉树的右视图

LeetCode.199
公众号：阿Q技术站

问题描述

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

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

提示:

  • 二叉树的节点个数的范围是 [0,100]
  • -100 <= Node.val <= 100

思路

递归
  1. 递归遍历二叉树：从根节点开始，按照根右左的顺序递归遍历整棵二叉树。这样可以保证每一层最先访问到的节点是最右侧的节点。
  2. 记录每层最右侧节点的值：在遍历过程中，使用一个 map 或类似的数据结构来记录每一层最右侧节点的值。如果当前层级已经在 map 中存在，则更新该层级的值为当前节点的值。
  3. 按层级顺序输出结果：最后，将 map 中按层级存储的节点值按顺序存入结果数组，并返回该数组作为最终的结果。
非递归
  1. 定义一个队列 queue 用于层序遍历二叉树，一个数组 result 用于存储每层最右侧节点的值。
  2. 将根节点 root 入队。
  3. 在队列不为空的情况下，循环遍历每一层的节点：
    • 记录当前队列的大小 size，表示当前层级的节点数。
    • 遍历当前层级的节点，如果是当前层级的最后一个节点，则将其值加入 result 数组中。
    • 将当前节点的左右子节点入队。
  4. 返回 result 数组，其中存储了每层最右侧节点的值。

图解

  1. 定义一个队列 queue 用于层序遍历二叉树，一个数组 result 用于存储每层最右侧节点的值。将根节点 root 入队。

  1. 如果队列不为空，遍历当前层级的节点，获取队头，并将其弹出队列；如果是当前层级的最后一个元素，将其加入结果数组。当前层级遍历结束。

  1. 将当前节点的左右节点依次加入到队列中。

  1. 开始遍历当前层级在队列中的元素，获取队头的元素，弹出元素，并将当前节点的左右子节点入队。

  1. 继续遍历，如果是当前层级的最后一个元素，加入结果集。并将当前节点的左右子节点入队。当前层级结束。

  1. 遍历当前层级的元素，获取队头元素并弹出。

  1. 继续遍历当前层级，如果是最后一个节点，将其加入结果集中。

  1. 队列为空，退出循环。

参考代码

C++
递归
#include <iostream>
#include <vector>
#include <map>
#include <queue>

using namespace std;

// 二叉树节点的定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

void dfs(TreeNode* node, int level, map<int, int>& rightmost) {
    if (!node) return; // 如果节点为空，直接返回

    if (rightmost.find(level) == rightmost.end()) { // 如果当前层级不在map中，将当前节点的值存入map
        rightmost[level] = node->val;
    }

    // 递归遍历右子树和左子树，层级加一
    dfs(node->right, level + 1, rightmost);
    dfs(node->left, level + 1, rightmost);
}

vector<int> rightSideView(TreeNode* root) {
    vector<int> result; // 存储结果的数组
    map<int, int> rightmost; // 存储每层最右侧节点值的map
    dfs(root, 0, rightmost); // 调用递归函数开始遍历

    // 将map中的节点值按层级顺序存入结果数组
    for (auto& [level, val] : rightmost) {
        result.push_back(val);
    }

    return result;
}

// 创建二叉树
TreeNode* createTree(vector<int>& nodes, int index) {
    if (index >= nodes.size() || nodes[index] == -1) {
        return nullptr; // 如果节点为空，则返回nullptr
    }
    TreeNode* root = new TreeNode(nodes[index]); // 创建当前节点
    root->left = createTree(nodes, 2 * index + 1); // 创建左子树
    root->right = createTree(nodes, 2 * index + 2); // 创建右子树
    return root; // 返回当前节点
}

// 销毁二叉树
void destroyTree(TreeNode* root) {
    if (!root) return; // 如果根节点为空，直接返回
    destroyTree(root->left); // 递归销毁左子树
    destroyTree(root->right); // 递归销毁右子树
    delete root; // 删除当前节点
}

int main() {
    vector<int> nodes = {1, 2, 3, -1, 5, -1, 4}; // 定义二叉树的层序遍历序列
    TreeNode* root = createTree(nodes, 0); // 创建二叉树
    vector<int> result = rightSideView(root); // 进行右视图遍历
    for (int val : result) { // 输出遍历结果
        cout << val << " ";
    }
    cout << endl;

    destroyTree(root); // 销毁二叉树

    return 0;
}
非递归
#include <iostream>
#include <vector>
#include <queue>

using namespace std;

// 二叉树节点的定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

vector<int> rightSideView(TreeNode* root) {
    vector<int> result; // 存储结果的数组
    if (!root) {
        return result; // 如果根节点为空，直接返回空数组
    }

    queue<TreeNode*> q; // 辅助队列，用于层级遍历
    q.push(root); // 将根节点入队

    while (!q.empty()) {
        int level_size = q.size(); // 当前层级的节点数
        for (int i = 0; i < level_size; ++i) {
            TreeNode* node = q.front(); // 获取队头节点
            q.pop(); // 弹出队头节点

            // 如果是当前层级的最后一个节点，将其值加入结果数组
            if (i == level_size - 1) {
                result.push_back(node->val);
            }

            // 将当前节点的左右子节点入队
            if (node->left) {
                q.push(node->left);
            }
            if (node->right) {
                q.push(node->right);
            }
        }
    }

    return result; // 返回结果数组
}

// 创建二叉树
TreeNode* createTree(vector<int>& nodes, int index) {
    if (index >= nodes.size() || nodes[index] == -1) {
        return nullptr; // 如果节点为空，则返回nullptr
    }
    TreeNode* root = new TreeNode(nodes[index]); // 创建当前节点
    root->left = createTree(nodes, 2 * index + 1); // 创建左子树
    root->right = createTree(nodes, 2 * index + 2); // 创建右子树
    return root; // 返回当前节点
}

// 销毁二叉树
void destroyTree(TreeNode* root) {
    if (!root) return; // 如果根节点为空，直接返回
    destroyTree(root->left); // 递归销毁左子树
    destroyTree(root->right); // 递归销毁右子树
    delete root; // 删除当前节点
}

int main() {
    vector<int> nodes = {1, 2, 3, -1, 5, -1, 4}; // 二叉树的层序遍历序列
    TreeNode* root = createTree(nodes, 0); // 创建二叉树
    vector<int> result = rightSideView(root); // 获取从右侧所能看到的节点值
    for (int val : result) { // 输出结果
        cout << val << " ";
    }
    cout << endl;

    destroyTree(root); // 销毁二叉树

    return 0;
}
Java
import java.util.*;

// 二叉树节点的定义
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

public class RightSideView {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>(); // 存储结果的列表
        if (root == null) {
            return result; // 如果根节点为空，直接返回空列表
        }

        Queue<TreeNode> queue = new LinkedList<>(); // 辅助队列，用于层级遍历
        queue.add(root); // 将根节点入队

        while (!queue.isEmpty()) {
            int levelSize = queue.size(); // 当前层级的节点数
            for (int i = 0; i < levelSize; ++i) {
                TreeNode node = queue.poll(); // 获取队头节点

                // 如果是当前层级的最后一个节点，将其值加入结果列表
                if (i == levelSize - 1) {
                    result.add(node.val);
                }

                // 将当前节点的左右子节点入队
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
        }

        return result; // 返回结果列表
    }

    // 创建二叉树
    public TreeNode createTree(Integer[] nodes, int index) {
        if (index >= nodes.length || nodes[index] == null) {
            return null; // 如果节点为空，则返回null
        }
        TreeNode root = new TreeNode(nodes[index]); // 创建当前节点
        root.left = createTree(nodes, 2 * index + 1); // 创建左子树
        root.right = createTree(nodes, 2 * index + 2); // 创建右子树
        return root; // 返回当前节点
    }

    // 销毁二叉树
    public void destroyTree(TreeNode root) {
        if (root == null) return; // 如果根节点为空，直接返回
        destroyTree(root.left); // 递归销毁左子树
        destroyTree(root.right); // 递归销毁右子树
    }

    public static void main(String[] args) {
        Integer[] nodes = {1, 2, 3, null, 5, null, 4}; // 二叉树的层序遍历序列
        RightSideView solution = new RightSideView();
        TreeNode root = solution.createTree(nodes, 0); // 创建二叉树
        List<Integer> result = solution.rightSideView(root); // 获取从右侧所能看到的节点值
        for (int val : result) { // 输出结果
            System.out.print(val + " ");
        }
        System.out.println();

        solution.destroyTree(root); // 销毁二叉树
    }
}
Python
from typing import List
from collections import deque

# 二叉树节点的定义
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def rightSideView(root: TreeNode) -> List[int]:
    result = [] # 存储结果的列表
    if not root:
        return result # 如果根节点为空，直接返回空列表

    queue = deque([root]) # 辅助队列，用于层级遍历
    while queue:
        level_size = len(queue) # 当前层级的节点数
        for i in range(level_size):
            node = queue.popleft() # 获取队头节点

            # 如果是当前层级的最后一个节点，将其值加入结果列表
            if i == level_size - 1:
                result.append(node.val)

            # 将当前节点的左右子节点入队
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

    return result # 返回结果列表

# 创建二叉树
def createTree(nodes: List[int], index: int) -> TreeNode:
    if index >= len(nodes) or nodes[index] is None:
        return None # 如果节点为空，则返回None
    root = TreeNode(nodes[index]) # 创建当前节点
    root.left = createTree(nodes, 2 * index + 1) # 创建左子树
    root.right = createTree(nodes, 2 * index + 2) # 创建右子树
    return root # 返回当前节点

# 销毁二叉树
def destroyTree(root: TreeNode) -> None:
    if not root:
        return # 如果根节点为空，直接返回
    destroyTree(root.left) # 递归销毁左子树
    destroyTree(root.right) # 递归销毁右子树

# 测试代码
if __name__ == "__main__":
    nodes = [1, 2, 3, None, 5, None, 4] # 二叉树的层序遍历序列
    root = createTree(nodes, 0) # 创建二叉树
    result = rightSideView(root) # 获取从右侧所能看到的节点值
    print(result) # 输出结果
    destroyTree(root) # 销毁二叉树
阿Q技术站
关注
  • 32
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基础算法-python实现二叉树遍历
11-20
【基础算法】-python实现二叉树遍历 # -*- coding: gb2312 -*- class Queue(object): def __init__(self): self.q = [] def enqueue(self, item): self.q.append(item) def dequeue(self): # if self.q != []: if len(self.q)>0: return self.q.pop(0) else: return None def length(self): return len(self.q) def isempty(self):
二叉树和二叉查找树-基本方法.pdf
03-14
二叉查找树
算法面试通关40讲完整课件 18-20 树、二叉树、二叉搜索树
07-06
算法面试通关40讲完整课件 18-20 树、二叉树、二叉搜索树 算法面试通关40讲完整课件 18-20 树、二叉树、二叉搜索树 算法面试通关40讲完整课件 18-20 树、二叉树、二叉搜索树 算法面试通关40讲完整课件 18-20 树、...
Objective-C实现二叉树遍历算法（源代码）
04-30
本文展示了如何在Objective-C中实现一个简单的二叉树算法。首先，定义了一个二叉树节点的类BinaryTreeNode，用于存储数据和指向左右子节点的指针。接着，定义了一个二叉树类BinaryTree，该类包含一个根节点指针，并...
算法大全-面试题-链表-栈-二叉树-数据结构.docx
09-01
算法大全-面试题-链表-栈-二叉树-数据结构，C#版，主要三大块，一，单链表，二，栈和队列，三，二叉树。 每一大块又有许多新鲜好玩的玩法，你会很喜欢的会上瘾的。 适合玩算法的朋友。
【leetcode系列】【算法】【中等】二叉树的右视图
12-21
树的层序遍历，先放左节点，再放右节点 每次将一层都放完的时候，将最后一个放入的元素加入到结果集中，其余直接清空 然后继续遍历下一层 代码实现： # Definition for a binary tree node. # class TreeNode: # ...
Codeforces Round 941 (Div. 2) （A~D）
weixin_61825750的博客
04-28 697
然后考虑若此时存在两个堆，那么对于Alice而言，其操作可以使得小的那个堆只剩下1，下一步Bob必须选1，然后Alice就胜利了。相反，若小的那个堆一开始就是1，那么Alice就输了。接下来推广到若干堆的情况：对于任意一方而言，若最小堆不是1，那么便可以控制胜利，于是我们只需要枚举到最小堆不是1的情况即可，然后看是谁在操作就是谁赢。思路：若要使得所有方格同色，关键在于四个角上的颜色，若对角上的颜色一样就能直接将所有格子变为同色。思路：首先处理 < k 的部分，我们可以通过二进制的思想来构造整数，例如。
算法训练营第十一天 | LeetCode 20 有效的括号、LeetCode 1047 删除字符串中的所有相邻重复项
qq_63149342的博客
04-27 113
注意用的是字符串数组作为输入，而我们要用int型进行计算，这时候就要用到一个string转int类型的库函数stoi函数，aoti是字符数组转int类型。一个是最后循环结束后要判断栈内存是否为空，一个是出栈时要判断栈是否为空，总的来说是考验对于栈内存空间的掌控吧。这一题考栈的性质，相邻字符用未进栈的元素和进栈的元素进行模拟即可，相同且栈不为空即出栈，否则进栈，之后将栈内元素全部导入一个字符串，还要注意要写一个反转函数翻转下即可。LeetCode 1047 删除字符串中的所有相邻重复项。
Golang | Leetcode Golang题解之第56题合并区间
weixin_66442839的博客
04-28 444
Golang | Leetcode Golang题解之第56题合并区间
4/26发布发布：缺了好几次的作业，矩形法+二分法求下面方程根+顺序查找n+程序填空，补一下还有八九没做，炸8412 字不是干的，哈哈哈
2201_75637762的博客
04-26 1235
eps：用于定义逼近的精度，即当x1和x2的差小于eps时，认为找到了根。x1和x2：用于二分法的初始区间，这里选择的是[-10, 10]。y1和y2：分别是x1和x2处函数的值。这个程序通过二分法在一个给定的区间内寻找三次方程的根。它首先检查函数在区间端点的值的符号，然后使用二分法逐步缩小区间，直到找到满足精度要求的根或确定区间内没有根为止。okll测试数据：3 4 7 12 24 78 9 15 80 45第一次运行程序输入测试数据 12。
算法~本质
最新发布
sweet_Mary的博客
04-30 248
数据结构分为数组和链表，数据结构的目的是提升增删改查的效率。算法的本质是基于这两种数据结构进行高效穷举。2.如何聪明地穷举？--并查集/贪心/KMP）数组--二分搜索/双指针/滑动窗口/前缀+差分。二叉树系列（回溯算法+动态规划）eg.求二叉树最大深度。2. 分解问题计算答案。2.分解问题计算答案。eg.二叉树前缀遍历。
代码随想录算法训练营Day25 | 216.组合总和III、17.电话号码的字母组合 | Python | 个人记录向
Python基本算法
04-27 636
回溯算法：216.组合总和III、17.电话号码的字母组合。
c入门基础题（3）
梦昼初
04-26 886
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)
【C++中的模板】
Z15255808023的博客
04-27 727
本片内容主要是C++中模板的有关知识，主要讲述了模板及其实用和注意事项，请耐心观看。相必我们大家都听说过泛型编程这个概念：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。简单的说就是编写一种可以在多种数据类型上都能用的代码。比如说，你写一次代码，就可以在很多不同的数据类型上使用，而不需要为每种数据类型都重新写一遍相同逻辑的代码。它能让编程变得更简单、更灵活。
使用rust学习基本算法（四）
weixin_40539956的博客
04-27 974
对于一个包含n个顶点的图，其邻接矩阵是一个n×n的矩阵，记为A。如果顶点i和顶点j之间存在一条边，则矩阵中的元素A[i][j]表示这条边的权重；如果不存在边，则A[i][j]的值通常设为0（对于无权图）或某个特定的非负值，如无穷大（对于有权图），表示两个顶点之间没有直接的连接。
【算法】五子连线
qq_59306099的博客
04-25 389
棋盘一般为15X15的，横向为A～O，纵向为1～15，从棋盘的左下角开始标记，如下图所示。例如，图示中上面的5个棋子可标记为G13、H13、I13、J13、K13，正好形成横向五子连线的情况；图示中左下方的5个棋子可标记为H7、F5、E4、D3、C2，未能形成五子连线的情况。五子棋是世界智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏，通常双方分别使用黑白两色的棋子，下在棋盘直线与横线的交叉点上，先形成连续的五子连线（横、竖、斜）者获胜。接下来有n行数据，每行一组数据，每组数据包括5个棋子的位置。
【力扣】16. 最接近的三数之和
嵌入式小菜鸟一枚~
04-25 387
【力扣】16. 最接近的三数之和
【算法】【贪心算法】【leetcode】870. 优势洗牌
zhaoliubao1的博客
04-30 786
给定两个长度相等的数组 nums1 和 nums2，nums1 相对于 nums2 的优势可以用满足 nums1[i] > nums2[i]孙膑就教他用自己的下等马对齐王的上等马，再用自己的上等马对齐王的中等马，最后用自己的中等马对齐王的下等马，结果三局两胜，田忌赢了。把nums1当成是田忌的马，nums2当成是齐威王的马。输入：nums1 = [12,24,8,32], nums2 = [13,25,32,11]输入：nums1 = [2,7,11,15], nums2 = [1,10,4,11]
【算法系列】模拟
m0_74126249的博客
04-28 838
给定一个数组，数组每个元素表示发起攻击(被攻击后会中毒)的时间，给定一个整数，表示中毒的时长，如果中毒还没有结束，就发起下次攻击，那么中毒时间被重置！2.遇到c字符，找最后一个字符(本题是k字符)在哈希表是否存在，存在则最后一个字符个数--，当前字符++， 不存在则当前字符++1.遇到r/o/a/k字符，在哈希表中找一下前驱字符，如果存在，前驱个数--， 当前字符++， 不存在，则返回-1。最后还要检查记录字符出现个数的哈希表情况，如果前n-1个字符中有个数不为0的字符，也要返回-1。
算法6-1~6-4：二叉链表存储的二叉树
06-28
### 回答1： 算法6-1：二叉链表存储的二叉树的结构定义 二叉链表存储的二叉树是一种常见的二叉树存储方式，其结构定义如下： typedef struct BiTNode{ TElemType data; // 数据域 struct BiTNode *lchild, *rchild; // 左右孩子指针 }BiTNode, *BiTree; 其中，TElemType为二叉树节点的数据类型，可以根据实际情况进行定义。 算法6-2：二叉链表存储的二叉树的创建 二叉链表存储的二叉树的创建可以通过递归方式实现，具体算法如下： void CreateBiTree(BiTree *T){ TElemType ch; scanf("%c", &ch); // 输入节点的值 if(ch == '#'){ // 如果输入的是#，表示该节点为空 *T = NULL; }else{ *T = (BiTree)malloc(sizeof(BiTNode)); // 创建新节点 (*T)->data = ch; // 节点赋值 CreateBiTree(&((*T)->lchild)); // 递归创建左子树 CreateBiTree(&((*T)->rchild)); // 递归创建右子树 } } 其中，#表示空节点，输入#时，该节点为空。 算法6-3：二叉链表存储的二叉树的遍历 二叉链表存储的二叉树的遍历可以通过递归方式实现，具体算法如下： void PreOrderTraverse(BiTree T){ // 先序遍历 if(T != NULL){ printf("%c ", T->data); // 访问根节点 PreOrderTraverse(T->lchild); // 遍历左子树 PreOrderTraverse(T->rchild); // 遍历右子树 } } void InOrderTraverse(BiTree T){ // 中序遍历 if(T != NULL){ InOrderTraverse(T->lchild); // 遍历左子树 printf("%c ", T->data); // 访问根节点 InOrderTraverse(T->rchild); // 遍历右子树 } } void PostOrderTraverse(BiTree T){ // 后序遍历 if(T != NULL){ PostOrderTraverse(T->lchild); // 遍历左子树 PostOrderTraverse(T->rchild); // 遍历右子树 printf("%c ", T->data); // 访问根节点 } } 其中，先序遍历是先访问根节点，再遍历左子树和右子树；中序遍历是先遍历左子树，再访问根节点和右子树；后序遍历是先遍历左子树和右子树，再访问根节点。 算法6-4：二叉链表存储的二叉树的销毁 二叉链表存储的二叉树的销毁可以通过递归方式实现，具体算法如下： void DestroyBiTree(BiTree *T){ if(*T != NULL){ DestroyBiTree(&((*T)->lchild)); // 销毁左子树 DestroyBiTree(&((*T)->rchild)); // 销毁右子树 free(*T); // 释放节点空间 *T = NULL; // 节点指针置空 } } 其中，递归销毁左子树和右子树，最后释放节点空间并将节点指针置空。 ### 回答2： 二叉链表存储的二叉树是一种常见的二叉树存储结构，它是由一个节点数组和一个指向根节点的指针组成的。每个节点都包含一个值、一个左孩子指针和一个右孩子指针。这种存储结构可以非常方便地进行二叉树的遍历和修改操作，是二叉树基本操作的重要实现方式。 算法6-1是建立二叉链表存储结构的算法，它通过前序遍历和中序遍历来构造一棵二叉树。具体而言，算法6-1会先遍历前序序列找到根节点，并在中序序列中找到根节点的位置，然后递归地建立左子树和右子树。该算法时间复杂度为O(n^2)，其中n为二叉树的节点数。算法6-1的缺点是在处理大规模的二叉树时效率较低。 算法6-2是先序遍历的递归算法，它通过递归实现先序遍历。具体而言，先访问根节点，然后递归访问左子树和右子树。该算法时间复杂度为O(n)，其中n为二叉树的节点数。 算法6-3是中序遍历的递归算法，它通过递归实现中序遍历。具体而言，先递归访问左子树，然后访问根节点，最后递归访问右子树。该算法的时间复杂度为O(n)，其中n为二叉树的节点数。 算法6-4是后序遍历的递归算法，它通过递归实现后序遍历。具体而言，先递归访问左子树和右子树，最后访问根节点。该算法的时间复杂度为O(n)，其中n为二叉树的节点数。 总之，二叉链表存储的二叉树是一种非常方便实用的数据结构，可以方便地进行各种遍历和修改操作。同时，基于递归实现的三种遍历算法也非常简洁高效，应用广泛。 ### 回答3： 算法6-1至6-4描述了二叉链表存储的二叉树。二叉链表存储的二叉树是一种基于线性链式结构存储的二叉树，它通过指针关系将每个结点的左右子树联系起来。下面我们将分别对每个算法进行详细解释。 算法6-1：二叉链表存储结构定义。该算法定义了二叉树的结构，主要是通过指针关系分别指向左右子树和父节点。这样的结构便于对二叉树的操作和遍历。 算法6-2：二叉链表存储的建立。该算法通过输入有序序列，依次插入二叉树结点，先从根结点开始比较大小，插入到左右子树中。当插入到空节点时，创建新的结点，通过指针关系连接起来。递归地进行插入操作，直到序列中的所有元素插入完毕。 算法6-3：二叉链表存储的遍历。该算法通过对二叉树的先序、中序和后序遍历进行递归实现。先序遍历需要先访问根节点，然后再对左右子树进行遍历；中序遍历需要先访问左子树，再访问根节点，最后再访问右子树；后序遍历需要先访问左右子树，最后访问根节点。 算法6-4：二叉链表的基本操作。该算法主要包括插入、删除、查找和修改等操作。其中，插入和删除操作需要先定位到相应的结点，然后通过指针关系进行连接或删除。查找操作需要按照二叉树的规律进行查找，找到目标结点后返回其对应的指针。修改操作类似于删除操作，先找到需要修改的结点，然后进行相应的修改操作。 综上所述，二叉链表存储的二叉树是一种便于操作和遍历的数据结构，它通过指针关系将每个结点的左右子树联系起来。该结构的建立、遍历和操作都可以通过递归实现，不仅提高了程序的可读性，还方便了程序员的开发。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值