数据结构-9：遍历二叉树（全站最细

最新推荐文章于 2025-03-26 06:00:00 发布
最新推荐文章于 2025-03-26 06:00:00 发布
阅读量772 收藏 22
点赞数 22
分类专栏： DS 文章标签： 数据结构 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_69378371/article/details/145173319
版权

九、二叉树的遍历

二叉树的遍历是指按照某种特定的顺序访问二叉树中的所有节点。遍历二叉树在各种算法和应用中起着至关重要的作用，如表达式求值、树的复制、查找特定节点等。二叉树的遍历方法主要分为深度优先遍历（Depth-First Traversal）和广度优先遍历（Breadth-First Traversal）。本文将详细介绍这些遍历方法，包括递归和非递归的实现方式，并通过C++示例代码进行说明。

1. 遍历的基本概念

  • 遍历（Traversal）：访问二叉树中所有节点的一种系统方法，确保每个节点被访问一次且仅被访问一次。
  • 深度优先遍历（DFS）：尽可能深入树的分支进行遍历，直到无法继续，然后回溯。
  • 广度优先遍历（BFS）：按层级顺序从上到下、从左到右逐层遍历树。

2. 二叉树的遍历类型

2.1 深度优先遍历（Depth-First Traversal）

深度优先遍历主要包括以下三种方式：

  1. 前序遍历（Preorder Traversal）：访问根节点 → 遍历左子树 → 遍历右子树。
  2. 中序遍历（Inorder Traversal）：遍历左子树 → 访问根节点 → 遍历右子树。
  3. 后序遍历（Postorder Traversal）：遍历左子树 → 遍历右子树 → 访问根节点。
2.2 广度优先遍历（Breadth-First Traversal）
  1. 层序遍历（Level-order Traversal）：按层级顺序从上到下、从左到右逐层访问节点。

3. 遍历的实现方法

遍历二叉树可以通过递归和**非递归（迭代）**两种方法实现。递归方法简洁直观，但在处理深度较大的树时可能导致栈溢出。非递归方法通常使用显式的数据结构（如栈或队列）来模拟递归过程，适用于深度较大的树。

3.1 递归实现
3.1.1 前序遍历（Preorder Traversal）

算法步骤：

  1. 访问当前节点。
  2. 递归遍历左子树。
  3. 递归遍历右子树。

示例代码（C++）：

#include <iostream>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 前序遍历（递归）
void preorderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    std::cout << root->data << " ";
    preorderTraversal(root->left);
    preorderTraversal(root->right);
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    std::cout << "前序遍历（递归）: ";
    preorderTraversal(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

前序遍历（递归）: 1 2 4 5 3 6 7
3.1.2 中序遍历（Inorder Traversal）

算法步骤：

  1. 递归遍历左子树。
  2. 访问当前节点。
  3. 递归遍历右子树。

示例代码（C++）：

#include <iostream>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 中序遍历（递归）
void inorderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    inorderTraversal(root->left);
    std::cout << root->data << " ";
    inorderTraversal(root->right);
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    std::cout << "中序遍历（递归）: ";
    inorderTraversal(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

中序遍历（递归）: 4 2 5 1 6 3 7
3.1.3 后序遍历（Postorder Traversal）

算法步骤：

  1. 递归遍历左子树。
  2. 递归遍历右子树。
  3. 访问当前节点。

示例代码（C++）：

#include <iostream>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 后序遍历（递归）
void postorderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    postorderTraversal(root->left);
    postorderTraversal(root->right);
    std::cout << root->data << " ";
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    std::cout << "后序遍历（递归）: ";
    postorderTraversal(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

后序遍历（递归）: 4 5 2 6 7 3 1
3.1.4 层序遍历（Level-order Traversal）

算法步骤：

  1. 使用队列存储节点。
  2. 将根节点入队。
  3. 当队列不为空时：
    • 取出队首节点，访问它。
    • 将其左子节点和右子节点依次入队。

示例代码（C++）：

#include <iostream>
#include <queue>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 层序遍历（递归）
void levelOrderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    std::queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        TreeNode* current = q.front(); q.pop();
        std::cout << current->data << " ";
        if (current->left != nullptr) q.push(current->left);
        if (current->right != nullptr) q.push(current->right);
    }
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    std::cout << "层序遍历（递归）: ";
    levelOrderTraversal(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

层序遍历（递归）: 1 2 3 4 5 6 7
3.2 非递归实现

非递归遍历通常使用栈或队列来模拟递归的过程。以下将介绍如何使用这些数据结构实现不同的遍历方法。

3.2.1 前序遍历（Preorder Traversal）— 非递归

算法步骤：

  1. 初始化一个空栈，并将根节点入栈。
  2. 当栈不为空时：
    • 取出栈顶节点，访问它。
    • 如果该节点有右子节点，则将右子节点入栈。
    • 如果该节点有左子节点，则将左子节点入栈。
    这样确保左子节点先被处理。

示例代码（C++）：

#include <iostream>
#include <stack>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 前序遍历（非递归）
void preorderTraversalIterative(TreeNode* root) {
    if (root == nullptr) return;
    std::stack<TreeNode*> s;
    s.push(root);
    while (!s.empty()) {
        TreeNode* current = s.top(); s.pop();
        std::cout << current->data << " ";
        // 先右后左，保证左子节点先被访问
        if (current->right) s.push(current->right);
        if (current->left) s.push(current->left);
    }
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    std::cout << "前序遍历（非递归）: ";
    preorderTraversalIterative(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

前序遍历（非递归）: 1 2 4 5 3 6 7
3.2.2 中序遍历（Inorder Traversal）— 非递归

算法步骤：

  1. 初始化一个空栈，设置当前节点为根节点。
  2. 当当前节点不为空或栈不为空时：
    • 将当前节点不断压入栈，移动到左子节点。
    • 当当前节点为空时，弹出栈顶节点，访问它，移动到右子节点。

示例代码（C++）：

#include <iostream>
#include <stack>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 中序遍历（非递归）
void inorderTraversalIterative(TreeNode* root) {
    std::stack<TreeNode*> s;
    TreeNode* current = root;

    while (current != nullptr || !s.empty()) {
        // 到达最左下节点
        while (current != nullptr) {
            s.push(current);
            current = current->left;
        }

        // 当前节点为空，弹出栈顶节点
        current = s.top(); s.pop();
        std::cout << current->data << " ";

        // 访问右子节点
        current = current->right;
    }
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    std::cout << "中序遍历（非递归）: ";
    inorderTraversalIterative(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

中序遍历（非递归）: 4 2 5 1 6 3 7
3.2.3 后序遍历（Postorder Traversal）— 非递归

算法步骤：

后序遍历的非递归实现较为复杂，通常需要使用两个栈，或使用一个栈并记录上一次访问的节点。

方法一：使用两个栈

  1. 初始化两个空栈：s1 和 s2。
  2. 将根节点入栈 s1。
  3. 当 s1 不为空时：
    • 弹出 s1 的栈顶节点，将其压入 s2。
    • 如果该节点有左子节点，将左子节点入栈 s1。
    • 如果该节点有右子节点，将右子节点入栈 s1。
  4. 当 s1 为空时，弹出 s2 的栈顶节点并访问它。

示例代码（C++）：

#include <iostream>
#include <stack>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 后序遍历（非递归，使用两个栈）
void postorderTraversalIterative(TreeNode* root) {
    if (root == nullptr) return;
    std::stack<TreeNode*> s1, s2;
    s1.push(root);
    while (!s1.empty()) {
        TreeNode* current = s1.top(); s1.pop();
        s2.push(current);
        if (current->left) s1.push(current->left);
        if (current->right) s1.push(current->right);
    }
    while (!s2.empty()) {
        TreeNode* current = s2.top(); s2.pop();
        std::cout << current->data << " ";
    }
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    std::cout << "后序遍历（非递归）: ";
    postorderTraversalIterative(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

后序遍历（非递归）: 4 5 2 6 7 3 1

方法二：使用单个栈和记录上次访问的节点

示例代码（C++）：

#include <iostream>
#include <stack>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 后序遍历（非递归，使用单个栈）
void postorderTraversalSingleStack(TreeNode* root) {
    if (root == nullptr) return;
    std::stack<TreeNode*> s;
    TreeNode* current = root;
    TreeNode* lastVisited = nullptr;

    while (!s.empty() || current != nullptr) {
        if (current != nullptr) {
            s.push(current);
            current = current->left;
        }
        else {
            TreeNode* peekNode = s.top();
            if (peekNode->right != nullptr && lastVisited != peekNode->right) {
                current = peekNode->right;
            }
            else {
                std::cout << peekNode->data << " ";
                lastVisited = peekNode;
                s.pop();
            }
        }
    }
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    std::cout << "后序遍历（非递归，单栈）: ";
    postorderTraversalSingleStack(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

后序遍历（非递归，单栈）: 4 5 2 6 7 3 1
3.2.4 层序遍历（Level-order Traversal）— 非递归

层序遍历通常使用队列实现，其递归实现在实践中不常用，因为它需要额外的数据结构来存储每一层的节点。

示例代码（C++）：

#include <iostream>
#include <queue>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 层序遍历（非递归）
void levelOrderTraversalIterative(TreeNode* root) {
    if (root == nullptr) return;
    std::queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        TreeNode* current = q.front(); q.pop();
        std::cout << current->data << " ";
        if (current->left != nullptr) q.push(current->left);
        if (current->right != nullptr) q.push(current->right);
    }
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    std::cout << "层序遍历（非递归）: ";
    levelOrderTraversalIterative(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

层序遍历（非递归）: 1 2 3 4 5 6 7

4. 遍历方法的比较与选择

遍历类型递归实现非递归实现应用场景
前序遍历简单使用栈树的复制、表达式求值、生成前缀表达式
中序遍历简单使用栈二叉搜索树的有序输出、验证BST性质
后序遍历简单使用两个栈或单个栈删除树、表达式求值、生成后缀表达式
层序遍历较复杂（需队列）使用队列广度优先搜索、层级显示、查找节点的深度

选择建议：

  • 递归实现适用于树的深度较小、代码简洁性优先的场景。
  • 非递归实现适用于树的深度较大、避免栈溢出风险的场景。
  • 层序遍历适用于需要按层级处理节点的应用，如广度优先搜索。

5. 遍历的应用实例

5.1 表达式求值

通过表达式树的遍历，可以计算数学表达式的值。

示例：

对于表达式 (3 + 5) * (2 - 4)，对应的表达式树如下：

       *
      / \
     +   -
    / \ / \
   3  5 2  4

中序遍历打印表达式为：3 + 5 * 2 - 4

前序遍历生成前缀表达式为：* + 3 5 - 2 4

后序遍历生成后缀表达式为：3 5 + 2 4 - *

通过后序遍历的结果，可以利用栈进行表达式求值。

5.2 二叉搜索树的有序输出

中序遍历二叉搜索树可以得到一个有序的节点序列，常用于排序数据或验证树的正确性。

示例：

#include <iostream>
#include <stack>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 中序遍历（非递归）
void inorderTraversalIterative(TreeNode* root) {
    std::stack<TreeNode*> s;
    TreeNode* current = root;

    while (current != nullptr || !s.empty()) {
        while (current != nullptr) {
            s.push(current);
            current = current->left;
        }

        current = s.top(); s.pop();
        std::cout << current->data << " ";
        current = current->right;
    }
}

int main() {
    // 构建二叉搜索树
    TreeNode* root = new TreeNode(50);
    root->left = new TreeNode(30);
    root->right = new TreeNode(70);
    root->left->left = new TreeNode(20);
    root->left->right = new TreeNode(40);
    root->right->left = new TreeNode(60);
    root->right->right = new TreeNode(80);

    std::cout << "中序遍历（非递归）: ";
    inorderTraversalIterative(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

中序遍历（非递归）: 20 30 40 50 60 70 80
5.3 判断二叉树是否为二叉搜索树

通过中序遍历验证遍历结果是否为升序，可以判断一棵二叉树是否为二叉搜索树。

示例代码（C++）：

#include <iostream>
#include <stack>
#include <climits>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 中序遍历验证BST
bool isBST(TreeNode* root) {
    std::stack<TreeNode*> s;
    TreeNode* current = root;
    int prev = INT_MIN;

    while (current != nullptr || !s.empty()) {
        while (current != nullptr) {
            s.push(current);
            current = current->left;
        }

        current = s.top(); s.pop();

        // 检查是否为升序
        if (current->data < prev) return false;
        prev = current->data;

        current = current->right;
    }
    return true;
}

int main() {
    // 构建二叉搜索树
    TreeNode* root = new TreeNode(50);
    root->left = new TreeNode(30);
    root->right = new TreeNode(70);
    root->left->left = new TreeNode(20);
    root->left->right = new TreeNode(40);
    root->right->left = new TreeNode(60);
    root->right->right = new TreeNode(80);

    std::cout << "二叉树是否为BST: " << (isBST(root) ? "是" : "否") << std::endl;

    // 构建非BST二叉树
    TreeNode* root2 = new TreeNode(50);
    root2->left = new TreeNode(70); // 错误位置
    root2->right = new TreeNode(30); // 错误位置

    std::cout << "二叉树是否为BST: " << (isBST(root2) ? "是" : "否") << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    delete root2->right;
    delete root2->left;
    delete root2;

    return 0;
}

输出：

二叉树是否为BST: 是
二叉树是否为BST: 否

6. 遍历的应用场景

  • 表达式求值：通过后序遍历计算表达式树的值。
  • 树的复制：前序或后序遍历用于复制树结构。
  • 查找特定节点：利用遍历方法搜索节点或验证节点存在性。
  • 打印树的结构：层序遍历适用于按层级打印树的结构。
  • 数据库索引：中序遍历二叉搜索树生成有序数据序列。

7. 遍历的性能分析

遍历二叉树的时间复杂度为 O(n)，其中 n 是树的节点数，因为每个节点都需要被访问一次。空间复杂度取决于实现方式：

  • 递归实现：空间复杂度为 O(h)，其中 h 是树的高度，主要用于递归调用栈。
  • 非递归实现：空间复杂度为 O(n)，最坏情况下需要存储所有节点。

8. 遍历的优化技巧

  • 避免重复访问：在后序遍历的单栈实现中，记录上一次访问的节点以避免重复处理。
  • 使用尾递归优化：对于支持尾递归优化的语言，可以优化递归调用以减少栈空间。
  • 并行遍历：在多核处理器上，可以并行执行遍历的不同子树，提高遍历速度。

9. 遍历的最佳实践

  • 选择合适的遍历方法：根据具体的应用需求选择适当的遍历类型。
  • 处理深度较大的树时，优先考虑非递归实现，避免栈溢出。
  • 封装遍历逻辑：将遍历方法封装在类或模块中，提升代码的可维护性和复用性。
  • 结合遍历和操作：在遍历过程中执行特定的操作，如节点计数、求和、查找等，以提高效率。

10. 完整示例：综合遍历实现

以下是一个包含所有遍历方法的完整C++示例，展示如何构建二叉树并执行各种遍历操作。

#include <iostream>
#include <stack>
#include <queue>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 前序遍历（递归）
void preorderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    std::cout << root->data << " ";
    preorderTraversal(root->left);
    preorderTraversal(root->right);
}

// 中序遍历（递归）
void inorderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    inorderTraversal(root->left);
    std::cout << root->data << " ";
    inorderTraversal(root->right);
}

// 后序遍历（递归）
void postorderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    postorderTraversal(root->left);
    postorderTraversal(root->right);
    std::cout << root->data << " ";
}

// 前序遍历（非递归）
void preorderTraversalIterative(TreeNode* root) {
    if (root == nullptr) return;
    std::stack<TreeNode*> s;
    s.push(root);
    while (!s.empty()) {
        TreeNode* current = s.top(); s.pop();
        std::cout << current->data << " ";
        if (current->right) s.push(current->right);
        if (current->left) s.push(current->left);
    }
}

// 中序遍历（非递归）
void inorderTraversalIterative(TreeNode* root) {
    std::stack<TreeNode*> s;
    TreeNode* current = root;

    while (current != nullptr || !s.empty()) {
        while (current != nullptr) {
            s.push(current);
            current = current->left;
        }

        current = s.top(); s.pop();
        std::cout << current->data << " ";
        current = current->right;
    }
}

// 后序遍历（非递归，使用两个栈）
void postorderTraversalIterative(TreeNode* root) {
    if (root == nullptr) return;
    std::stack<TreeNode*> s1, s2;
    s1.push(root);
    while (!s1.empty()) {
        TreeNode* current = s1.top(); s1.pop();
        s2.push(current);
        if (current->left) s1.push(current->left);
        if (current->right) s1.push(current->right);
    }
    while (!s2.empty()) {
        TreeNode* current = s2.top(); s2.pop();
        std::cout << current->data << " ";
    }
}

// 后序遍历（非递归，单栈）
void postorderTraversalSingleStack(TreeNode* root) {
    if (root == nullptr) return;
    std::stack<TreeNode*> s;
    TreeNode* current = root;
    TreeNode* lastVisited = nullptr;

    while (!s.empty() || current != nullptr) {
        if (current != nullptr) {
            s.push(current);
            current = current->left;
        }
        else {
            TreeNode* peekNode = s.top();
            if (peekNode->right != nullptr && lastVisited != peekNode->right) {
                current = peekNode->right;
            }
            else {
                std::cout << peekNode->data << " ";
                lastVisited = peekNode;
                s.pop();
            }
        }
    }
}

// 层序遍历（非递归）
void levelOrderTraversalIterative(TreeNode* root) {
    if (root == nullptr) return;
    std::queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        TreeNode* current = q.front(); q.pop();
        std::cout << current->data << " ";
        if (current->left != nullptr) q.push(current->left);
        if (current->right != nullptr) q.push(current->right);
    }
}

int main() {
    // 构建二叉树
    /*
            1
           / \
          2   3
         / \ / \
        4  5 6  7
    */
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    // 递归遍历
    std::cout << "前序遍历（递归）: ";
    preorderTraversal(root);
    std::cout << std::endl;

    std::cout << "中序遍历（递归）: ";
    inorderTraversal(root);
    std::cout << std::endl;

    std::cout << "后序遍历（递归）: ";
    postorderTraversal(root);
    std::cout << std::endl;

    // 非递归遍历
    std::cout << "前序遍历（非递归）: ";
    preorderTraversalIterative(root);
    std::cout << std::endl;

    std::cout << "中序遍历（非递归）: ";
    inorderTraversalIterative(root);
    std::cout << std::endl;

    std::cout << "后序遍历（非递归，双栈）: ";
    postorderTraversalIterative(root);
    std::cout << std::endl;

    std::cout << "后序遍历（非递归，单栈）: ";
    postorderTraversalSingleStack(root);
    std::cout << std::endl;

    std::cout << "层序遍历（非递归）: ";
    levelOrderTraversalIterative(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

前序遍历（递归）: 1 2 4 5 3 6 7 
中序遍历（递归）: 4 2 5 1 6 3 7 
后序遍历（递归）: 4 5 2 6 7 3 1 
前序遍历（非递归）: 1 2 4 5 3 6 7 
中序遍历（非递归）: 4 2 5 1 6 3 7 
后序遍历（非递归，双栈）: 4 5 2 6 7 3 1 
后序遍历（非递归，单栈）: 4 5 2 6 7 3 1 
层序遍历（非递归）: 1 2 3 4 5 6 7

11. 遍历的总结与关键点

  • 遍历类型多样：前序、中序、后序适用于深度优先搜索，层序适用于广度优先搜索。
  • 递归与非递归的权衡：
    • 递归实现代码简洁，但受限于栈空间，适用于树的深度较小的情况。
    • 非递归实现较为复杂，但适用于深度较大的树，避免栈溢出。
  • 选择合适的遍历方法：根据具体应用需求选择适当的遍历类型和实现方式。
  • 遍历的应用广泛：涵盖表达式求值、树的复制、查找操作、验证树性质等多个方面。

12. 遍历的常见问题与解决方法

12.1 树的高度过大导致递归遍历栈溢出

问题描述：对于高度较大的树，递归遍历可能导致调用栈溢出。

解决方法：

  • 使用非递归遍历：通过显式栈或队列实现遍历，避免依赖系统调用栈。
  • 优化树的结构：尽量保持树的平衡，减少树的高度。
  • 增加系统栈空间（不推荐）：通过调整编译器或系统设置增加可用栈空间。

示例：使用非递归中序遍历避免栈溢出。

12.2 如何在遍历过程中执行特定操作

问题描述：在遍历二叉树时，需要对每个节点执行特定的操作，如计算节点值、查找节点等。

解决方法：

  • 在遍历函数中嵌入操作：将操作逻辑集成到遍历过程中，如在访问节点时进行计算。
  • 使用回调函数：将操作作为回调函数传递给遍历函数，实现更高的灵活性。

示例：在中序遍历中计算所有节点的和。

#include <iostream>
#include <stack>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 中序遍历（非递归），计算节点和
int inorderSum(TreeNode* root) {
    std::stack<TreeNode*> s;
    TreeNode* current = root;
    int sum = 0;

    while (current != nullptr || !s.empty()) {
        while (current != nullptr) {
            s.push(current);
            current = current->left;
        }

        current = s.top(); s.pop();
        sum += current->data;
        current = current->right;
    }
    return sum;
}

int main() {
    // 构建二叉搜索树
    TreeNode* root = new TreeNode(50);
    root->left = new TreeNode(30);
    root->right = new TreeNode(70);
    root->left->left = new TreeNode(20);
    root->left->right = new TreeNode(40);
    root->right->left = new TreeNode(60);
    root->right->right = new TreeNode(80);

    int totalSum = inorderSum(root);
    std::cout << "二叉树所有节点的和: " << totalSum << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

二叉树所有节点的和: 300
12.3 如何实现层序遍历的递归版本

问题描述：层序遍历通常使用迭代方法实现，递归实现相对复杂，因为需要知道当前的层级。

解决方法：

  1. 计算树的高度。
  2. 针对每一层执行遍历，递归访问当前层的节点。

示例代码（C++）：

#include <iostream>
#include <vector>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 计算树的高度
int treeHeight(TreeNode* root) {
    if (root == nullptr) return 0;
    int leftHeight = treeHeight(root->left);
    int rightHeight = treeHeight(root->right);
    return std::max(leftHeight, rightHeight) + 1;
}

// 打印指定层的节点
void printGivenLevel(TreeNode* root, int level) {
    if (root == nullptr) return;
    if (level == 1) {
        std::cout << root->data << " ";
    }
    else if (level > 1) {
        printGivenLevel(root->left, level - 1);
        printGivenLevel(root->right, level - 1);
    }
}

// 层序遍历（递归）
void levelOrderTraversalRecursive(TreeNode* root) {
    int h = treeHeight(root);
    for (int i = 1; i <= h; ++i) {
        printGivenLevel(root, i);
    }
}

int main() {
    // 构建二叉树
    /*
            1
           / \
          2   3
         / \ / \
        4  5 6  7
    */
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    std::cout << "层序遍历（递归）: ";
    levelOrderTraversalRecursive(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

层序遍历（递归）: 1 2 3 4 5 6 7

13. 遍历的关键点总结

  • 遍历类型：

    • 前序：根 → 左 → 右，适用于复制树、生成前缀表达式。
    • 中序：左 → 根 → 右，适用于二叉搜索树的有序输出、验证BST。
    • 后序：左 →右 →根，适用于删除树、生成后缀表达式。
    • 层序：按层级顺序访问，适用于广度优先搜索、层级显示。

  • 实现方法：

    • 递归实现代码简洁，但受限于栈空间。
    • 非递归实现使用栈或队列，适用于深度较大的树，避免栈溢出。

  • 应用场景：

    • 表达式求值：通过后序遍历计算表达式值。
    • 树的复制：通过前序或后序遍历复制树结构。
    • 查找操作：通过遍历查找特定节点或验证树的性质。
    • 层级显示：通过层序遍历打印树的结构。

  • 优化技巧：

    • 避免重复访问：如后序遍历的单栈实现中，记录上次访问的节点。
    • 结合遍历与操作：在遍历过程中执行所需操作，提高效率。

14. 遍历的最佳实践

  • 选择合适的遍历类型：根据具体需求选择前序、中序、后序或层序遍历。
  • 使用非递归实现处理深度较大的树：避免递归导致的栈溢出。
  • 封装遍历逻辑：将遍历方法封装在类或模块中，提升代码的可维护性和复用性。
  • 结合遍历与操作：在遍历过程中执行所需的操作，如计算节点和、查找节点等。
  • 优化内存使用：在非递归遍历中，合理使用栈或队列，避免不必要的内存开销。
  • 测试遍历实现：通过构建不同结构的树，测试遍历方法的正确性和效率。

15. 遍历的常见问题与解决方法

15.1 如何避免递归遍历时的栈溢出

问题描述：对于高度较大的二叉树，递归遍历可能导致调用栈溢出。

解决方法：

  • 使用非递归遍历：通过显式的栈或队列实现遍历，避免依赖系统调用栈。
  • 优化树的结构：保持树的平衡，减少树的高度。
  • 使用尾递归优化：部分编译器支持尾递归优化，可以减少栈空间使用（但在C++中不常见）。

示例：使用非递归中序遍历代替递归遍历。

15.2 如何在遍历过程中执行特定操作

问题描述：在遍历二叉树时，需要对每个节点执行特定的操作，如打印、计算和、查找等。

解决方法：

  • 在遍历函数中嵌入操作：将操作逻辑集成到遍历过程中，如在访问节点时执行打印或计算。
  • 使用回调函数：将操作作为函数指针或可调用对象传递给遍历函数，实现更高的灵活性和复用性。

示例：在中序遍历中计算所有节点的和。

#include <iostream>
#include <stack>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 中序遍历（非递归），计算节点和
int inorderSum(TreeNode* root) {
    std::stack<TreeNode*> s;
    TreeNode* current = root;
    int sum = 0;

    while (current != nullptr || !s.empty()) {
        while (current != nullptr) {
            s.push(current);
            current = current->left;
        }

        current = s.top(); s.pop();
        sum += current->data;
        current = current->right;
    }
    return sum;
}

int main() {
    // 构建二叉搜索树
    TreeNode* root = new TreeNode(50);
    root->left = new TreeNode(30);
    root->right = new TreeNode(70);
    root->left->left = new TreeNode(20);
    root->left->right = new TreeNode(40);
    root->right->left = new TreeNode(60);
    root->right->right = new TreeNode(80);

    int totalSum = inorderSum(root);
    std::cout << "二叉树所有节点的和: " << totalSum << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

二叉树所有节点的和: 300
15.3 如何实现层序遍历的递归版本

问题描述：层序遍历通常使用迭代方法实现，递归实现相对复杂，因为需要知道当前的层级。

解决方法：

  1. 计算树的高度。
  2. 针对每一层执行遍历，递归访问当前层的节点。

示例代码（C++）：

#include <iostream>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 计算树的高度
int treeHeight(TreeNode* root) {
    if (root == nullptr) return 0;
    int leftHeight = treeHeight(root->left);
    int rightHeight = treeHeight(root->right);
    return std::max(leftHeight, rightHeight) + 1;
}

// 打印指定层的节点
void printGivenLevel(TreeNode* root, int level) {
    if (root == nullptr) return;
    if (level == 1) {
        std::cout << root->data << " ";
    }
    else if (level > 1) {
        printGivenLevel(root->left, level - 1);
        printGivenLevel(root->right, level - 1);
    }
}

// 层序遍历（递归）
void levelOrderTraversalRecursive(TreeNode* root) {
    int h = treeHeight(root);
    for (int i = 1; i <= h; ++i) {
        printGivenLevel(root, i);
    }
}

int main() {
    // 构建二叉树
    /*
            1
           / \
          2   3
         / \ / \
        4  5 6  7
    */
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    std::cout << "层序遍历（递归）: ";
    levelOrderTraversalRecursive(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

层序遍历（递归）: 1 2 3 4 5 6 7

16. 遍历的关键点总结

  • 遍历类型多样：前序、中序、后序适用于深度优先搜索，层序适用于广度优先搜索。
  • 递归与非递归的权衡：
    • 递归实现代码简洁，但受限于栈空间，适用于树的深度较小的情况。
    • 非递归实现较为复杂，但适用于深度较大的树，避免栈溢出。
  • 选择合适的遍历方法：根据具体应用需求选择适当的遍历类型和实现方式。
  • 遍历的应用广泛：涵盖表达式求值、树的复制、查找操作、验证树性质等多个方面。
  • 优化技巧：
    • 避免重复访问：如后序遍历的单栈实现中，记录上次访问的节点。
    • 结合遍历与操作：在遍历过程中执行所需操作，提高效率。

17. 遍历的最佳实践

  • 选择合适的遍历类型：根据具体需求选择前序、中序、后序或层序遍历。
  • 使用非递归实现处理深度较大的树：避免递归导致的栈溢出。
  • 封装遍历逻辑：将遍历方法封装在类或模块中，提升代码的可维护性和复用性。
  • 结合遍历与操作：在遍历过程中执行所需的操作，如计算节点和、查找节点等。
  • 优化内存使用：在非递归遍历中，合理使用栈或队列，避免不必要的内存开销。
  • 测试遍历实现：通过构建不同结构的树，测试遍历方法的正确性和效率。

18. 遍历的扩展应用

18.1 表达式树（Expression Tree）

定义：表达式树用于表示和计算数学或逻辑表达式的二叉树结构，支持运算符优先级和括号。

应用场景：

  • 编译器设计：用于中间代码生成和表达式优化。
  • 计算器实现：解析和计算复杂表达式。
  • 数学软件：支持符号计算和表达式求值。

示例：

对于表达式 (3 + 5) * (2 - 4)，对应的表达式树如下：

       *
      / \
     +   -
    / \ / \
   3  5 2  4

通过后序遍历生成后缀表达式 3 5 + 2 4 - *，并使用栈进行表达式求值。

18.2 二叉搜索树的有序输出

中序遍历二叉搜索树可以得到一个有序的节点序列，常用于排序数据或验证树的正确性。

示例：

#include <iostream>
#include <stack>

// 定义树节点结构
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// 中序遍历（非递归）
void inorderTraversalIterative(TreeNode* root) {
    std::stack<TreeNode*> s;
    TreeNode* current = root;

    while (current != nullptr || !s.empty()) {
        while (current != nullptr) {
            s.push(current);
            current = current->left;
        }

        current = s.top(); s.pop();
        std::cout << current->data << " ";
        current = current->right;
    }
}

int main() {
    // 构建二叉搜索树
    TreeNode* root = new TreeNode(50);
    root->left = new TreeNode(30);
    root->right = new TreeNode(70);
    root->left->left = new TreeNode(20);
    root->left->right = new TreeNode(40);
    root->right->left = new TreeNode(60);
    root->right->right = new TreeNode(80);

    std::cout << "中序遍历（非递归）: ";
    inorderTraversalIterative(root);
    std::cout << std::endl;

    // 释放内存（简化，不进行完整释放）
    delete root->right->right;
    delete root->right->left;
    delete root->right;
    delete root->left->right;
    delete root->left->left;
    delete root->left;
    delete root;

    return 0;
}

输出：

中序遍历（非递归）: 20 30 40 50 60 70 80
18.3 二叉树的广泛应用

二叉树因其结构简单且性能优良，在计算机科学的多个领域中得到广泛应用，包括但不限于：

  • 数据库索引：如B树、B+树等变种用于高效的数据检索。
  • 文件系统管理：目录和子目录以树形结构组织，便于层次化管理。
  • 编译器设计：抽象语法树（AST）用于表示程序的语法结构。
  • 机器学习：决策树用于分类和回归任务。
  • 网络路由：路由树用于管理和优化路由信息。

19. 遍历的优缺点

遍历类型优点缺点
前序遍历易于复制树、生成前缀表达式无法直接生成有序序列
中序遍历生成有序序列（适用于BST）、验证BST性质仅适用于需要有序输出的场景
后序遍历适用于删除树、生成后缀表达式实现较为复杂，尤其是非递归方法
层序遍历适用于广度优先搜索、层级显示、查找节点的深度需要额外的队列存储空间
递归实现代码简洁、易于理解栈空间受限，处理深度较大的树时可能导致栈溢出
非递归实现适用于深度较大的树、避免栈溢出风险实现复杂，需要显式的数据结构（栈或队列）

20. 总结

二叉树的遍历是理解和应用二叉树的基础，掌握不同的遍历方法及其实现方式对于高效地处理树结构至关重要。通过递归和非递归方法，可以灵活地实现各种遍历需求，适应不同的应用场景。

关键点总结：

  • 遍历类型：前序、中序、后序适用于深度优先搜索，层序适用于广度优先搜索。
  • 实现方法：
    • 递归实现简洁直观，适用于树的深度较小的情况。
    • 非递归实现使用显式栈或队列，适用于深度较大的树，避免栈溢出。
  • 应用场景：
    • 表达式求值：通过后序遍历计算表达式值。
    • 树的复制：通过前序或后序遍历复制树结构。
    • 查找操作：通过遍历查找特定节点或验证树的性质。
    • 层级显示：通过层序遍历打印树的结构。
  • 优化技巧：
    • 避免重复访问：如后序遍历的单栈实现中，记录上次访问的节点。
    • 结合遍历与操作：在遍历过程中执行所需操作，提高效率。

通过深入理解和掌握二叉树的遍历方法，可以显著提升编程能力和解决问题的效率，为学习和实现更复杂的数据结构和算法打下坚实的基础。

如果你对二叉树的遍历方法、实现细节或其他相关内容有更多疑问，欢迎随时提问！

深入理解常见数据结构：数组、链表、栈、队列、树、图、哈希表和堆
weixin_42559561的博客
12-01 2073
在计算机科学中，数据结构是一种组织和存储数据的方式，对于解决各种问题和优化算法至关重要。本文将深入探讨几种常见的数据结构，包括数组、链表、栈、队列、树、图、哈希表和堆。我们将详细解释每种数据结构的定义、特点以及常见的应用场景，同时提供代码示例以帮助读者更好地理解这些概念。
二叉树的深度遍历
DAN_L的博客
02-29 1828
一、深度优先遍历 对于一棵二叉树，深度优先搜索（Depth First Search）是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。 二、二叉树的深度遍历的三种方法 这三种方法常被用于访问树的节点，它们之间的不同在于访问每个节点的次序不同 （一）先序遍历：先访问根节点，然后递归使用先序遍历访问左子树，再递归使用先序遍历右子树 根节点->左子树->右子树 （二）中序遍历：递归使用中...
看懂二叉树的三种遍历
soundwave_的博客
11-10 16万+
二叉树的遍历分为以下三种： 先序遍历：遍历顺序规则为【根左右】 中序遍历：遍历顺序规则为【左根右】 后序遍历：遍历顺序规则为【左右根】 什么是【根左右】？就是先遍历根，再遍历左孩子，最后遍历右孩子； 举个例子，看下图（图从网上找的）： 先序遍历：ABCDEFGHK 中序遍历：BDCAEHGKF 后序遍历：DCBHKGFEA 以中序遍历为例： 中序遍历的规则是【左根右】，
练20：二叉树的遍历
最新发布
2302_80253507的博客
03-26 675
二叉树遍历的练习。
二叉树的遍历及其用途
起风了
03-05 3105
先序遍历：在第一次遍历到节点时就执行操作，一般只是想遍历执行操作（或输出结果）可选用先序遍历； 中序遍历：对于二分搜索树，中序遍历的操作顺序（或输出结果顺序）是符合从小到大（或从大到小）顺序的，故要遍历输出排序好的结果需要使用中序遍历; 后序遍历：后续遍历的特点是执行操作时，肯定已经遍历过该节点的左右子节点，故适用于要进行破坏性操作的情况，比如删除所有节点. 作者：Entronad 链接：...
二叉树的遍历
虫师
04-18 295
二叉树的遍历有三种方式，如下： （1）前序遍历（DLR），首先访问根结点，然后遍历左子树，最后遍历右子树。简记根-左-右。 （2）中序遍历（LDR），首先遍历左子树，然后访问根结点，最后遍历右子树。简记左-根-右。 （3）后序遍历（LRD），首先遍历左子树，然后遍历右子树，最后访问根结点。简记左-右-根。 例1：如上图所示的二叉树，若按前序遍历，则其输出...
1018-深度遍历二叉树
weixin_30701575的博客
11-21 153
描述 二叉树(binary tree)是非常重要的树形数据结构，它是结点的有限集合，该集合或者为空集，或者是由一个根和两个互不相交的、称为该根的左子树和右子树的二叉树组成。 一般意义上，遍历（traverse）一棵二叉树意味着对该二叉树中的每个结点访问且仅访问一次。 （1）若二叉树不为空，先序遍历是指先访问该树根结点，再访问先序遍历左子树，最后先序遍历右子树。 （2）若二叉树不为空，...
二叉树遍历
weixin_45903533的博客
11-09 452
二叉树遍历（前、中、后序遍历） 1.声明二叉树的二叉链表结点类Node如下，T指定结点的元素类型。 class Node<T>{ public Node<T> lChild;//地址域，指向左孩子结点 public T date;//数据域，存储数据元素 public Node<T> rChild;//地址域，指向右孩子结点 public Node(T date, Node<T> lChild, Node<T> rChild){ thi
数据结构实验
04-13
2．掌握对二叉树每种操作的具体实现，学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。 二 、实验要求 1．认真阅读和掌握和本实验相关的教材内容。 2．编写完整程序完成下面的实验内容并上机运行。 3...
王道考研数据结构笔记
weixin_45016439的博客
04-15 2万+
2022年4月16日 整理了这篇博客的pdf版本，但是缺的部分可能没法补上啦，把毕业的事忙完了可能！可以！对着书把笔记再整理一遍！所以所以，如果有需要pdf版本的可以私信我(有偿，奶茶钱这样)。 大家加油！一定会成功的！ 王道考研数据结构笔记 第二章 线性表 2.1 线性表的定义和基本操作 要点： 线性表的基本操作——创销、增删、改查 传入参数时，何时要用引用 & 2.2 线性表的顺序表示 2.2.1 顺序表的定义 顺序表的实现———静态分配 #include <stdio.h>
数据结构与算法365天刷题特训营
02-25
数据结构与算法是计算机科学的基础，对于任何想要在IT领域深入发展的人来说，它们的重要性不言而喻。...结合B站视频资源，学生可以享受到全方位的学习体验，逐步成长为一名精通数据结构和算法的优秀计算机专业人士。
尚硅谷Java数据结构与java算法 全194章笔记整理
Foools的博客
08-11 2416
前言 视频地址：https://www.bilibili.com/video/BV1E4411H73v?from=search&seid=13120683720695451628 评价：整个教程的数据结构部分讲的挺好的，知识点全都覆盖了，而且每个数据结构都有代码解释，但是最后20节算法部分讲的有点乱，算法部分我决定直接刷leetcode了 数组 稀疏数组： 二维数组的省内存的保存方法，一般是n行3列，三列分别为行，列，值。 二维数组转稀疏数组： 遍历整个二维数组，查看有多少个有效数字 根据有效数字
循环遍历二叉树
weixin_30258027的博客
02-13 89
前序遍历 struct Node { Node*left; Node*right; int data; Node(){ func; } }; Node* create(Node*p, int depth) { if (p && depth) { p->left = new Node; p->right ...
二叉树的遍历（深度详解）
sinat_30545761的博客
08-27 637
二叉树是一种数据结构，它是一棵树，每个节点最多有两个子节点，分别称为左子节点和右子节点。每个节点最多有两个子节点，分别称为左子节点和右子节点。根节点是二叉树的开始节点，没有父节点。如果一个节点只有左子节点，那么它的右子节点为空。如果一个节点只有右子节点，那么它的左子节点为空。左子节点和右子节点不能同时为空。int data;这个定义中，binary_tree 是一个结构体，它包含三个成员变量：data：存储节点的数据。
遍历二叉树
weixin_52555350的博客
03-25 5354
二叉树遍历
二叉树遍历（前序、中序、后序、层次遍历、深度优先、广度优先）
热门推荐
My_Jobs的专栏
02-03 42万+
二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即我们平常所说的层次遍历。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁，而对于广度遍历来说，需要其他数据结构的支撑，比如堆了。所以，对于一段代码来说，可读性有时候要比代码本身的效率要重要的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值