二叉树的一些基本操作 [附代码]

于 2024-05-17 11:25:32 发布
阅读量1.2k 收藏 17
点赞数 51
文章标签： 算法 深度优先 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58739951/article/details/139000442
版权

文章目录

将二叉树bt中每一个结点的左右子树互换的C语言算法

typedef struct node {
    int data;
    struct node *lchild, *rchild;
} btnode;

void ADDQ(queue *Q, btnode *bt); // Assuming these are predefined
btnode* DELQ(queue *Q);           // Assuming these are predefined
int EMPTY(queue *Q);              // Assuming these are predefined

void EXCHANGE(btnode *bt) {
    queue Q;
    initQueue(&Q); // Assuming initQueue initializes the queue

    btnode *p, *q;
    if (bt) {
        ADDQ(&Q, bt); // Add root to the queue
        while (!EMPTY(&Q)) {
            p = DELQ(&Q); // Dequeue a node

            if (p->lchild) {
                ADDQ(&Q, p->lchild); // Enqueue left child
            }

            if (p->rchild) {
                ADDQ(&Q, p->rchild); // Enqueue right child
            }

            // Swap the left and right children
            q = p->lchild;
            p->lchild = p->rchild;
            p->rchild = q;
        }
    }
}

// Note: Ensure to implement or include necessary queue operations (ADDQ, DELQ, EMPTY, initQueue) for the complete functionality.

二叉树中序遍历的非递归算法

Status Inorder(BiTree T) {
    InitStack(s); // 初始化一个栈s
    push(s, T); // 将根结点T进栈

    while (!StackEmpty(s)) { // 当栈不为空时循环
        while (GetTop(s, p) && p) { // 取栈顶元素p，并且p不为空
            push(s, p->lchild); // 将p的左子结点进栈
        }

        pop(s, p); // 栈顶元素出栈
        if (!StackEmpty(s)) { // 如果栈不为空
            pop(s, p); // 再次弹出栈顶元素
            printf("%d ", p->data); // 访问p结点
            push(s, p->rchild); // 将p的右子结点进栈
        }
    }

    return OK;
}

详细讲解

  1. 初始化栈:
InitStack(s); // 初始化一个栈s

首先，我们初始化一个空栈s，用于存储树节点的指针。

  1. 将根结点进栈:
push(s, T); // 将根结点T进栈

将根节点T指针压入栈中，开始遍历。

  1. 外层循环：当栈不为空时循环:
while (!StackEmpty(s)) { // 当栈不为空时循环

只要栈不为空，就继续循环。这个循环确保了所有节点都会被访问。

  1. 内层循环：处理当前节点的左子树:
while (GetTop(s, p) && p) { // 取栈顶元素p，并且p不为空
  push(s, p->lchild); // 将p的左子结点进栈
}

  • GetTop(s, p)：取栈顶元素并将其赋值给p。如果栈顶元素不为空，则继续循环。

  • push(s, p->lchild)：将当前节点p的左子节点压入栈中。

内层循环的目的是不断深入左子树的最左端，将路径上的所有节点压入栈中。

  1. 出栈处理节点:
pop(s, p); // 栈顶元素出栈
if (!StackEmpty(s)) { // 如果栈不为空
  pop(s, p); // 再次弹出栈顶元素
  printf("%d ", p->data); // 访问p结点
  push(s, p->rchild); // 将p的右子结点进栈
}

  • pop(s, p)：弹出栈顶元素，返回给p。

  • if (!StackEmpty(s))：检查栈是否为空，如果不为空则继续处理。

  • pop(s, p)：再次弹出栈顶元素。这是因为在前一个pop操作后，栈顶可能是一个NULL指针，我们需要弹出实际的节点。

  • printf("%d ", p->data)：访问并打印当前节点的数据。

  • push(s, p->rchild)：将当前节点的右子节点压入栈中。

上述步骤处理了一个节点并将其右子树的根节点压入栈中，准备下一次遍历。

通过这个算法，我们实现了非递归的中序遍历。在中序遍历中，访问顺序是左子树 -> 根节点 -> 右子树。栈的使用帮助我们记录路径并回溯到正确的节点，确保遍历顺序正确。

图解

下面是一个示例二叉树以及其非递归中序遍历过程的图解：

示例二叉树

       1
      / \
     2   3
    / \
   4   5

非递归中序遍历过程

我们用栈来帮助进行中序遍历，访问顺序应该是：4, 2, 5, 1, 3。

初始状态：

  • 栈 s 为空

  • 根节点 1

Stack: []
Current node: 1
步骤 1：将根节点及其左子节点压入栈

  • 压入节点 1

  • 当前节点变为 1 的左子节点 2

Stack: [1]
Current node: 2

  • 压入节点 2

  • 当前节点变为 2 的左子节点 4

Stack: [1, 2]
Current node: 4

  • 压入节点 4

  • 当前节点变为 4 的左子节点（NULL）

Stack: [1, 2, 4]
Current node: NULL
步骤 2：处理左子节点为空的情况
  • 弹出节点 4 并访问
Visited: 4
Stack: [1, 2]
  • 将当前节点变为 4 的右子节点（NULL）
Current node: NULL
步骤 3：继续回溯到上一个节点
  • 弹出节点 2 并访问
Visited: 2
Stack: [1]
  • 将当前节点变为 2 的右子节点 5
Current node: 5

  • 压入节点 5

  • 当前节点变为 5 的左子节点（NULL）

Stack: [1, 5]
Current node: NULL
步骤 4：处理右子节点
  • 弹出节点 5 并访问
Visited: 5
Stack: [1]
  • 将当前节点变为 5 的右子节点（NULL）
Current node: NULL
步骤 5：回溯到根节点
  • 弹出节点 1 并访问
Visited: 1
Stack: []
  • 将当前节点变为 1 的右子节点 3
Current node: 3

  • 压入节点 3

  • 当前节点变为 3 的左子节点（NULL）

Stack: [3]
Current node: NULL
步骤 6：处理最后一个节点
  • 弹出节点 3 并访问
Visited: 3
Stack: []
  • 当前节点变为 3 的右子节点（NULL）
Current node: NULL
最终结果

访问顺序为：4, 2, 5, 1, 3

每一步操作通过栈的状态和当前节点的变化，保证了中序遍历的顺序。

非递归方法交换左右孩子

要完成将二叉树中左、右孩子交换的非递归算法，可以参考以下详细实现：

#include <stdio.h>

typedef struct node {
    int data;
    struct node *lchild, *rchild;
} Node, *Tree;

void exchange(Tree t) {
    Tree r, p;
    Tree stack[500];
    int tp = 0;
    
    // (1) 初始化堆栈，将根节点放入堆栈
    stack[tp] = t;
    
    while (tp >= 0) {
        // (2) 取出栈顶元素
        p = stack[tp--];
        
        if (p != NULL) {
            // 交换p的左、右子树
            r = p->lchild;
            p->lchild = p->rchild;
            p->rchild = r;
            
            // 将p的左右子节点分别入栈
            stack[++tp] = p->lchild;
            stack[++tp] = p->rchild;
        }
    }
}

// 辅助函数用于创建新节点
Tree createNode(int data) {
    Tree newNode = (Tree)malloc(sizeof(Node));
    newNode->data = data;
    newNode->lchild = newNode->rchild = NULL;
    return newNode;
}

// 辅助函数用于中序遍历打印树
void inorder(Tree t) {
    if (t != NULL) {
        inorder(t->lchild);
        printf("%d ", t->data);
        inorder(t->rchild);
    }
}

int main() {
    // 创建一个简单的二叉树
    Tree root = createNode(1);
    root->lchild = createNode(2);
    root->rchild = createNode(3);
    root->lchild->lchild = createNode(4);
    root->lchild->rchild = createNode(5);
    
    printf("Original tree (inorder): ");
    inorder(root);
    printf("\n");
    
    exchange(root);
    
    printf("Tree after exchanging children (inorder): ");
    inorder(root);
    printf("\n");
    
    return 0;
}

具体步骤如下：

  1. 初始化堆栈：
stack[tp] = t;

将根节点放入堆栈。

  1. 循环遍历堆栈：
while (tp >= 0) {
  p = stack[tp--];

当堆栈不为空时，取出栈顶元素p。

  1. 交换左右子树：
if (p != NULL) {
  r = p->lchild;
  p->lchild = p->rchild;
  p->rchild = r;

如果当前节点p不为空，交换它的左、右子树。

  1. 将左右子树入栈：
stack[++tp] = p->lchild;
stack[++tp] = p->rchild;

将当前节点p的左、右子树分别入栈。

通过上述步骤实现了对二叉树的左右子树的交换。通过非递归方法和使用堆栈，避免了递归带来的栈溢出风险。

广义表建立二叉树

在这里插入图片描述

广义表建立二叉树的算法

#include <iostream>
#include <stack>
#include <sstream>

using namespace std;

struct BinTreeNode {
    char data;
    BinTreeNode* leftchild;
    BinTreeNode* rightchild;
};

void CreateBinTree(BinTreeNode* &BT, const string& ls) {
    stack<BinTreeNode*> s;
    while (!s.empty()) s.pop(); // MakeEmpty(s):置空栈
    BT = NULL; // 置空二叉树
    BinTreeNode* p = NULL;
    int k = 0; 
    istringstream ins(ls); // 把串ls定义为输入字符串流对象ins
    char ch; 
    ins >> ch; // 从ins顺序读入一个字符
    
    while (ch != '#') { // 逐个字符处理,直到遇到‘#’为止
        switch (ch) {
            case '(': 
                s.push(p); // (1) 当前结点进栈
                k = 1; 
                break;
                
            case ')': 
                s.pop(); // Pop(s):退栈
                break;
                
            case ',': 
                k = 2; // (2) 切换到处理右孩子
                break;
                
            default: 
                p = new BinTreeNode;
                p->data = ch; // 设置结点数据
                p->leftchild = NULL;
                p->rightchild = NULL;
                
                if (BT == NULL) {
                    BT = p; // (4) 置根结点
                } else if (k == 1) {
                    s.top()->leftchild = p; // 处理左孩子
                } else {
                    s.top()->rightchild = p; // 处理右孩子
                }
                break;
        }
        ins >> ch; // (5) 读入下一个字符
    }
}

// 辅助函数用于中序遍历打印树
void inorder(BinTreeNode* t) {
    if (t != NULL) {
        inorder(t->leftchild);
        cout << t->data << " ";
        inorder(t->rightchild);
    }
}

int main() {
    BinTreeNode* BT;
    string ls = "A(B(D,E(H,I)),C(,F(G,)))#";
    CreateBinTree(BT, ls);
    
    cout << "Inorder traversal of the constructed tree: ";
    inorder(BT);
    cout << endl;
    
    return 0;
}

具体填补的地方如下：

  1. 当前结点进栈：
s.push(p);

在遇到左括号 ( 时，将当前节点 p 压入栈中。

  1. 切换到处理右孩子：
k = 2;

在遇到逗号 , 时，切换到处理右孩子。

  1. 弹出栈顶元素：
s.pop();

在遇到右括号 ) 时，弹出栈顶元素。

  1. 设置根结点：
BT = p;

如果树为空，则当前节点 p 为根结点。

  1. 读入下一个字符：
ins >> ch;

在每次处理完一个字符后，读入下一个字符。

通过这些步骤，我们可以从广义表的字符串表示构建二叉树，并通过中序遍历验证树的结构是否正确。

中序线索树遍历

要完成中序线索树的遍历算法，首先需要理解线索树的结构和遍历方法。以下是该算法的完整实现及详细解释：

中序线索树遍历算法

void inorderthread(BinTreeNode* thr) {
    BinTreeNode* p = thr->lchild;

    while (p != thr) { // (1) p不等于头结点时循环
        while (p->ltag == 0) // (2) p的左标志域为0时循环
            p = p->lchild; // (3) p指向其左孩子

        printf("%c ", p->data); // 打印p的数据

        while (p->rtag == 1 && p->rchild != thr) { // (4) p的右标志域为1且p的右孩子不为头结点时循环
            p = p->rchild;
            printf("%c ", p->data); // 打印p的数据
        }

        p = p->rchild; // (5) p指向其右孩子
    }
}

代码说明

  1. 初始化:
BinTreeNode* p = thr->lchild;

从头结点的左孩子开始（即实际的树的根结点）。

  1. 外层循环:
while (p != thr) {

当p不等于头结点时循环。遍历整个树。

  1. 内层循环:
while (p->ltag == 0)
  p = p->lchild;

如果p的左标志域ltag为0，则p指向其左孩子，一直找到最左节点。

  1. 打印数据:
printf("%c ", p->data);

打印当前节点的数据。

  1. 处理线索化右子树:
while (p->rtag == 1 && p->rchild != thr) {
  p = p->rchild;
  printf("%c ", p->data);
}

如果p的右标志域rtag为1，且p的右孩子不为头结点，则通过右线索访问后继节点并打印其数据。

  1. 移动到右孩子:
p = p->rchild;

最后，p指向其右孩子，继续循环。

示例二叉树

假设我们有以下中序线索化的二叉树：

       A
      / \
     B   C
    /   / \
   D   E   F

其线索化过程略。

遍历过程

  1. 从头结点的左孩子（即A）开始。

  2. 沿左子树找到最左节点（即D）。

  3. 打印D。

  4. 处理D的右线索，找到B，打印B。

  5. 处理B的右孩子（即A），打印A。

  6. 沿右子树找到E，打印E。

  7. 处理E的右线索，找到C，打印C。

  8. 沿右子树找到F，打印F。

整个遍历过程依次打印：D, B, A, E, C, F。

ECNU無花果
关注
二叉树的基本操作　C++代码实现
Tanswer_
10-29 1万+
首先定义节点typedef struct BTree { int value; struct BTree *lchild; struct BTree *rchild; }BTree;前序递归建立二叉树/* **num 前序序列 **index 下标 */ BTree *CreateBTree(BTree *node,int *num,int& index) {
数据结构（4）二叉树的基本操作——C语言代码实现
qq_56117689的博客
12-04 1万+
作为一个数据结构学习的新手，这篇文章也算是笔记了，请根据目录食用 目录 单链表的操作（C语言） 一、存储结构 二、前序递归建立二叉树 三、前序递归遍历二叉树 四、前序非递归遍历二叉树 五、中序非递归遍历二叉树 六、后序非递归遍历二叉树 七、层序遍历 八、层序遍历Pro（按层输出）（舍去，采用Pro++） 九、层序遍历Pro++（按层输出） 层序遍历Pro和层序遍历Pro++的对比反思 十、树的深度——递归实现 十一、结点数统计——递归实现 十二、度为0的结点的个数——递归实现
二叉树操作代码
08-24
关于二叉树的各种常规操作
二叉树基本操作代码（数据结构实验）
12-20
1． 熟悉二叉树结点的结构和对二叉树的基本操作。 2． 掌握对二叉树每一种操作的具体实现。 3． 学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。 4． 在二叉树基本操作的基础上掌握对二叉树的一些其它操作的具体实现方法。 5． 掌握构造哈夫曼树以及哈夫曼编码的方法
二叉树基本操作源代码
11-21
二叉树的建立，遍历，非递归遍历，求深度，叶子个数，以及层次遍历 存储结构为二叉链表
二叉树的基本操作（附代码）
H48530的博客
03-26 4530
二叉树 的基本操作二叉树定义结点的定义：构建二叉树前、中、后序遍历遍历求结点的个数汇集思想求结点的个数遍历求叶子结点的个数汇集思想求叶子结点的个数求第k层结点个数求二叉树的高度是否存在结点为e的结点是否存在结点为e的结点，返回其结点位置判断 node 在不在以 root 为根的树中，node 一定不是 null 二叉树定义 详见我的上一篇博客： 初识二叉树 结点的定义： 结点的定义 有数值域，还有左孩子的引用和右孩子的引用，分别表示以左右孩子为根的左子树和右子树 public class TreeNode
C++链式存储实现二叉树（附源代码）
A Lucky Boy的博客
02-02 381
C++链式存储实现二叉树（附源代码）
C语言 数据结构 二叉树的链式存储 基本操作（附输入样例和讲解）
qq_31744851的博客
08-30 3453
代码参照了严蔚敏、吴伟民编写的数据结构（C语言版）。 部分内容参考了这位大佬： https://www.cnblogs.com/cpoint/p/3479788.html 所有代码采用C语言编写。讲解请查看注释。 头文件及宏定义 #include<stdio.h> #include<stdlib.h> #include<math.h> #include<string.h> //#include"链队列.h"//层次遍历时用到 #define OK 1 #
数据结构课与算法课程课程设计_高校社团管理设计,二叉树的应用(附全代码).pdf
07-14
在初始化阶段，我们需要创建一个空的二叉树或者填充一些初始数据。插入操作是二叉树的主要操作之一，对于社团管理，插入操作可能包括插入新的社团或添加成员到已有的社团。插入社团时，可能根据社团名称或其他关键...
二叉树的性质和常用操作代码集合
Steve Wang's blog
04-20 2285
二叉树的性质和常用操作代码集合性质： 二叉树的性质和常用代码操作集合 性质1:在二叉树的第i层上至多有2^i-1个结点 性质2：深度为k的二叉树至多有2^k - 1个结点 性质3：对任意一棵二叉树T，若终端结点数为n0，而其度数为2的结点数为n2，则n0 = n2 + 1 满二叉树：深度为k且有2^-1个结点的树 完全二叉树：深度为k，结点数为n的二叉树，如果其结点1
程序实现二叉树的结构及其操作
yaoxiaokui的专栏
07-01 958
1、完全二叉树的存储可以使用一维数组进行存储。因为每个节点 i 的左儿子为 i*2，右儿子为 i*2 + 1;每个节点 i 的双亲为 i / 2; 2、链式存储结构 （1）：二叉链表结构，结点由 结点元素和两个分别指向左、右子树的指针组成； struct ChainTwo { DATA data; struct ChainTwo *left; struct ChainTwo *rig
二叉树的遍历和一些相关操作
学代码的咸鱼的博客
05-20 560
大家好！这篇就讲一讲二叉树的遍历和一些相关操作，为什么不说二叉树的增删查改，因为二叉树的增删查改没有价值。我们要学会一些二叉树的操作，为以后学习打好基础。 文章目录1. 二叉树的遍历1.1 二叉树遍历的概念1.2 前序/中序/后序的递归结构遍历1.2.1 用代码实现前序遍历1.2.2 用代码实现中序遍历1.2.3 用代码实现后序遍历2. 二叉树的相关操作2.1 求二叉树结点的个数2.1.1 思路1：用局部变量count计数2.1.2 思路2：静态的局部变量2.1.3 思路3：用全局变量count计数2.1
二叉树的使用方法
qq_30534935的博客
02-11 1282
转载： http://blog.jobbole.com/108184/ https://blog.csdn.net/zhanggonglalala/article/details/79738213 https://blog.csdn.net/heyanxi0101/article/details/79593542 一、概述 平衡树：所有结点左右子树深度差≤1 排序树：所有结点“左小右大 字典树：由...
二叉树的基本操作(代码+注释)
Alex_thomas的博客
11-26 3356
前言：掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的层次遍历等。 ps：这里是个人整理的笔记，方便自己后期的复习，若有问题欢迎各位大佬前来指教！ #include<stdio.h> #include<stdlib.h> #define MAXNODE 1000 typedef int ElemType; typedef struct BiNode{ ElemType data; struct BiNode *lchild,*rchild; }BiTNode,
二叉树基本操作函数（先、中、后、层次遍历，含全部代码）
关注网络安全、云原生安全
01-12 1万+
InitTree(BiTree &amp;T) 参数T，二叉树根节点 作用：初始化二叉树，先序递归创建 PreOrder(BiTree T)  参数T，二叉树根节点 作用：先序遍历二叉树，递归方式 InOrder(BiTree T)   参数T，二叉树根节点 作用：中序遍历二叉树，递归方式 PostOrder(BiTree T) 参数T，二叉树根节点 作用：后序遍历二叉树，递归方式 LevelOr...
数据结构——二叉树的基本操作（C语言，完整优美实现）
明宇逸风的博客
10-28 9572
串 文章目录串前言一、树是什么？二、该如何理解树？三、各类树的存在形式四、二叉树的遍历方式深度遍历先序遍历中序遍历后序遍历层次遍历五、二叉树的实现1.二叉树的实现1.1 引入库以及设置结构体1.2初始化二叉树1.3队列的基本操作实现1.4二叉树深度遍历的三种方法1.5层次遍历1.6求子叶个数以及结点个数1.7串的输出功能1.8主函数实现上述全部功能2.运行截图总结 前言 1.本文就介绍了数据结构中二叉树的五条性质以及二叉树的存储结构 2.二叉树的基本操作的编程实现，掌握二叉树的建立、先序，中序，后序遍
二叉树完整操作集（源代码）
weixin_44587168的博客
02-08 948
背景 我在做单片机项目时，遇到了一个很担心的隐患：单片机在用异步串口传输数据的时候，底层直接传输比特流，但是经过多次测试存在一个问题：控制代码、GPIO和数学运算实在是太费时间了，很有可能导致数据传输不稳定，传输过程抖动，频繁建立握手连接，最终导致信息传递不及时，控制动作无法按时到达导致直接挂机。为了解决潜在的隐患，避免实际成品挂掉，必须压缩传输的数据编码。 编码算法？解码算法呢？怎么办？苦思冥想...
C语言二叉树的基本操作（超全）
热门推荐
qq_51553982的博客
05-25 4万+
二叉树作为数据结构其实是一个挺有意思的结构，可以有多种应用 我们直接来看一下二叉树的代码： #include<stdlib.h> #include<stdio.h> #include<malloc.h> #include<string.h> #define maxsize 100 //二叉树的基本操作：建立，前序，中序，后序，层次，求叶子数，求层数,求结点树 //二叉树的数据结构 //创建数据域和左右指针域 typedef struct Tree { c
二叉树的基本操作c代码
最新发布
06-01
下面是二叉树的基本操作的 C 代码： ```c #include #include typedef struct TreeNode { int data; struct TreeNode *left; struct TreeNode *right; } TreeNode; // 创建一个新的二叉树节点 TreeNode* ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值