二叉树的遍历

最新推荐文章于 2021-05-24 16:34:12 发布
最新推荐文章于 2021-05-24 16:34:12 发布
阅读量709 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 二叉树 遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XTCGCH/article/details/70257831
版权

摘要：本文讲解了如何使用C++实现了二叉树的创建，添加节点，删除节点，使用递归和非递归方法分别进行前中后遍历，进行层遍历

关键字 ：二叉树遍历

二叉树的结构体

typedef struct node
{
    int key, visited = 0;
    struct node *lChild, *rChild;
}Node, *BST;

这里key是存储节点的值，visited用来辅助判断节点是否被访问，在递归后序遍历时用到。

二叉树的建立

// 建立BST  
void createBST(Node * &T, int a[], int n)
{
    T = NULL;
    int i;
    for(i = 0; i < n; i++)
    {
        BSTInsert(T, a[i]);
    }
}

T是根节点，a[]存储节点的值，n是节点的个数
其中BSTInsert(T, a[i])函数的实现如下：

// 在给定的BST中插入结点，其数据域为element, 使之称为新的BST  
bool BSTInsert(Node * &p, int element)
{
    if(NULL == p) // 空树  
    {
        p = new Node;
        //p = (BST *)malloc(sizeof(BST));
        p->key = element;
        p->lChild = p->rChild = NULL;
        return true;
    }

    if(element == p->key) // BST中不能有相等的值  
        return false;

    if(element < p->key)  // 递归  
        return BSTInsert(p->lChild, element);

    return BSTInsert(p->rChild, element); // 递归  
}

二叉树的递归遍历

前序遍历

// 先序遍历  
void preOrderTraverse(BST T)
{
    BST p = T;
    if(p)
    {
        cout << p->key << " ";
        preOrderTraverse(p->lChild);
        preOrderTraverse(p->rChild);
    }
}

中序遍历

// 中序遍历  
void midOrderTraverse(BST T)
{
    if(T)
    {
        midOrderTraverse(T->lChild);
        cout << T->key << " ";
        midOrderTraverse(T->rChild);
    }
}

后序遍历

// 后序遍历  
void backOrderTraverse(BST T)
{
    if(T)
    {
        backOrderTraverse(T->lChild);
        backOrderTraverse(T->rChild);
        cout << T->key << " ";
    }
}

删除节点

//删除二叉树中与key值相等的节点
bool DeleteBST(BST & T, int key)
{
    /* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素节点 */
    /* 并返回TRUE；否则返回FALSE */
    if(!T)
        return false;   /* 不存在关键字等于key的数据元素 */
    else
    {
        if(key == T->key)
            Delete(T);
        else if(key < T->key)
            return DeleteBST(T->lChild, key);
        else
            return DeleteBST(T->rChild, key);
    }
}

DeleteBST（）的作用是寻找节点值和key值相等的节点，Delete(T)才是真正删除节点的函数。代码如下：

int Delete(BST & p)
{
    /* 从二叉排序树中删除节点p， 并重接它的左或右子树 */
    BST q, s;
    if(!p->lChild && !p->rChild) /* p为叶子节点 */
        p = 0;
    else if(!p->lChild) /* 左子树为空，重接右子树 */
    {
        q = p;
        p = p->rChild;
        free(q);
    }
    else if(!p->rChild) /* 右子树为空，重接左子树 */
    {
        q = p;
        p = p->lChild;
        free(q);
    }
    else                        /* 左右子树均不为空 */
    {
        q = p;
        s = p->lChild;
        while(s->rChild)     /* 转左，然后向右走到尽头*/
        {
            q = s;
            s = s->rChild;
        }
        p->key = s->key;
        if(q != p)               /* 判断是否执行上述while循环 */
            q->rChild = s->lChild;    /* 执行上述while循环，重接右子树 */
        else
            q->lChild = s->lChild;    /* 未执行上述while循环，重接左子树 */
        free(s);
    }
    return true;
}

删除节点要遵循以下规则：
（1）删除节点为叶节点，直接删除；否则，执行步骤（2）
（2）当删除节点的右子树为空时，直接把左子树的根节点作为删除节点的左孩子；否则，执行步骤（3）；
（3）当删除节点的左子树为空时，直接把右子树的根节点作为删除节点的右孩子；否则，执行步骤（4）；
（4）当左子树和右子树都不为空时，设删除节点为p节点，先寻找p节点的左孩子，设为s节点，若s存在右孩子，执行步骤a；否则，执行步骤b；

a.以s节点为起始点，一直寻找s的最右端孩子，设为s节点，s节点的父节点设为q节点。此时把s的左子树作为q节点的右子树，s节点直接替代p节点；

b.p节点的右子树作为s节点的右子树，并且用s节点替换p节点。

步骤图解如下：
1.树的原图
这里写图片描述

2.执行规则（1）
删除叶子节点7，则直接删除
这里写图片描述

3.执行规则（2）
删除值为5的节点，由于该节点右子树为空，只需把节点5的左子树作为父节点6的左子树，然后删除节点5。
这里写图片描述

4.执行规则（3）
删除值为11的节点，由于该节点左子树为空，只需把节点11的右子树作为父节点10的右子树，然后删除节点11。
这里写图片描述

5.执行规则（4）a条例
删除值为10的节点，由于节点10的第一个左孩子6存在右子树，故寻找节点6的最右端孩子节点，为9，把节点9的左子树作为父节点6的右子树，并且以节点9替换要删除节点10，然后删除节点10。
这里写图片描述

6.执行规则（4）b条例
删除值为13的节点，由于节点13的第一个左孩子12不存在右子树，故把13的右子树作为12的右子树，以节点12替代节点13，删除节点13。
这里写图片描述

二叉树的非递归遍历

前序遍历

void preSearch(BST T)
{
    stack<BST> s;
    BST p = T;
    while(p)
    {
        while(p)
        {
            cout << p->key << " ";
            s.push(p);
            p = p->lChild;
        }
        while(!s.empty() && !p)
        {
            p = s.top();
            s.pop();
            p = p->rChild;
        }
    }
}

中序遍历

void midSearch(BST T)
{
    BST p = T;
    stack<BST> s;
    while(p)
    {
        while(p)
        {
            s.push(p);
            p = p->lChild;
        }
        while(!s.empty() && !p)
        {
            p = s.top();
            cout << p->key << " ";
            s.pop();
            p = p->rChild;
        }
        //cout << p->key << " ";
    }
}

后序遍历

void backSearch(BST T)
{
    BST cur;                      
    BST pre = NULL;   
    s.push(T);
    while(!s.empty())
    {
        cur = s.top();
        if((cur->lChild == NULL&&cur->rChild == NULL) ||
            (pre != NULL && (pre == cur->lChild || pre == cur->rChild)))
        {
            cout << cur->key << " ";  //如果当前结点没有孩子结点或者孩子节点都已被访问过 
            s.pop();
            pre = cur;
        }
        else
        {
            if(cur->rChild != NULL)
                s.push(cur->rChild);
            if(cur->lChild != NULL)
                s.push(cur->lChild);
        }
    }
}

层序遍历

void levelOrderTraverse(BST T)
{
    BST p = T;
    if(p)
    {
        de.push_back(p);
    }
    while(!de.empty())
    {
        p = de.front();
        if(p->lChild)
        {
            de.push_back(p->lChild);
        }
        if(p->rChild)
        {
            de.push_back(p->rChild);
        }
        p = de.front();
        cout << p->key << " ";
        de.pop_front();
    }
}

源代码

#include <iostream>  
#include <deque>
#include <stack>
using namespace std;

// BST的结点  
typedef struct node
{
    int key, visited = 0;
    struct node *lChild, *rChild;
}Node, *BST;

deque<BST> de;
stack<BST> s;

// 在给定的BST中插入结点，其数据域为element, 使之称为新的BST  
bool BSTInsert(Node * &p, int element)
{
    if(NULL == p) // 空树  
    {
        p = new Node;
        //p = (BST *)malloc(sizeof(BST));
        p->key = element;
        p->lChild = p->rChild = NULL;
        return true;
    }

    if(element == p->key) // BST中不能有相等的值  
        return false;

    if(element < p->key)  // 递归  
        return BSTInsert(p->lChild, element);

    return BSTInsert(p->rChild, element); // 递归  
}

// 建立BST  
void createBST(Node * &T, int a[], int n)
{
    T = NULL;
    int i;
    for(i = 0; i < n; i++)
    {
        BSTInsert(T, a[i]);
    }
}


#pragma region 递归

// 先序遍历  
void preOrderTraverse(BST T)
{
    BST p = T;
    if(p)
    {
        cout << p->key << " ";
        preOrderTraverse(p->lChild);
        preOrderTraverse(p->rChild);
    }
}

// 中序遍历  
void midOrderTraverse(BST T)
{
    if(T)
    {
        midOrderTraverse(T->lChild);
        cout << T->key << " ";
        midOrderTraverse(T->rChild);
    }
}

// 后序遍历  
void backOrderTraverse(BST T)
{
    if(T)
    {
        backOrderTraverse(T->lChild);
        backOrderTraverse(T->rChild);
        cout << T->key << " ";
    }
}

int Delete(BST & p)
{
    /* 从二叉排序树中删除节点p， 并重接它的左或右子树 */
    BST q, s;
    if(!p->lChild && !p->rChild) /* p为叶子节点 */
        p = 0;
    else if(!p->lChild) /* 左子树为空，重接右子树 */
    {
        q = p;
        p = p->rChild;
        free(q);
    }
    else if(!p->rChild) /* 右子树为空，重接左子树 */
    {
        q = p;
        p = p->lChild;
        free(q);
    }
    else                        /* 左右子树均不为空 */
    {
        q = p;
        s = p->lChild;
        while(s->rChild)     /* 转左，然后向右走到尽头*/
        {
            q = s;
            s = s->rChild;
        }
        p->key = s->key;
        if(q != p)               /* 判断是否执行上述while循环 */
            q->rChild = s->lChild;    /* 执行上述while循环，重接右子树 */
        else
            q->lChild = s->lChild;    /* 未执行上述while循环，重接左子树 */
        free(s);
    }
    return true;
}

bool DeleteBST(BST & T, int key)
{
    /* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素节点 */
    /* 并返回TRUE；否则返回FALSE */
    if(!T)
        return false;   /* 不存在关键字等于key的数据元素 */
    else
    {
        if(key == T->key)
            Delete(T);
        else if(key < T->key)
            return DeleteBST(T->lChild, key);
        else
            return DeleteBST(T->rChild, key);
    }
}


#pragma endregion


#pragma region 非递归

void levelOrderTraverse(BST T)
{
    BST p = T;
    if(p)
    {
        de.push_back(p);
    }
    while(!de.empty())
    {
        p = de.front();
        if(p->lChild)
        {
            de.push_back(p->lChild);
        }
        if(p->rChild)
        {
            de.push_back(p->rChild);
        }
        p = de.front();
        cout << p->key << " ";
        de.pop_front();
    }
}

void preSearch(BST T)
{
    stack<BST> s;
    BST p = T;
    while(p)
    {
        while(p)
        {
            cout << p->key << " ";
            s.push(p);
            p = p->lChild;
        }
        while(!s.empty() && !p)
        {
            p = s.top();
            s.pop();
            p = p->rChild;
        }
    }
}

void midSearch(BST T)
{
    BST p = T;
    stack<BST> s;
    while(p)
    {
        while(p)
        {
            s.push(p);
            p = p->lChild;
        }
        while(!s.empty() && !p)
        {
            p = s.top();
            cout << p->key << " ";
            s.pop();
            p = p->rChild;
        }
        //cout << p->key << " ";
    }
}

void backSearch(BST T)
{
    BST cur;                      
    BST pre = NULL;   
    s.push(T);
    while(!s.empty())
    {
        cur = s.top();
        if((cur->lChild == NULL&&cur->rChild == NULL) ||
            (pre != NULL && (pre == cur->lChild || pre == cur->rChild)))
        {
            cout << cur->key << " ";  //如果当前结点没有孩子结点或者孩子节点都已被访问过 
            s.pop();
            pre = cur;
        }
        else
        {
            if(cur->rChild != NULL)
                s.push(cur->rChild);
            if(cur->lChild != NULL)
                s.push(cur->lChild);
        }
    }
}

#pragma endregion

int main(void)
{
    int a[11] = { 10,6,11,5,9,13,4,8,12,14,7};
    int n = 11;
    BST T;

    // 并非所有的a[]都能构造出BST,所以，最好对createBST的返回值进行判断  
    createBST(T, a, n);
    cout << "前序遍历：" << endl;
    preOrderTraverse(T);
    cout << endl;
    preSearch(T);
    cout << endl;

    cout << "中序遍历：" << endl;
    midOrderTraverse(T);
    cout << endl;
    midSearch(T);
    cout << endl;

    cout << "后序遍历：" << endl;
    backOrderTraverse(T);
    cout << endl;
    backSearch(T);
    cout << endl;

    //cout << DeleteBST(T,2) << endl;
    cout << "层序遍历：" << endl;
    levelOrderTraverse(T);

    cout << "删除2之后" << endl;
    DeleteBST(T, 2);
    levelOrderTraverse(T);

    cout << endl;
    return 0;
}
unistd68
关注
专栏目录
【数据结构】——二叉树的遍历详解
qq_43412060的博客
03-04 288
之前写了一篇关于二叉树的概要介绍，里面包括了二叉树的创建等相关代码，这一篇文章主要来详细的对二叉树的创建讲解一下~ 参考之前的文章二叉树的概要介绍 首先，定义一下关于二叉树的结点信息 typedef struct BtNode { struct BtNode* leftchild; struct BtNode* rightchild; ElemType data; }BtNode, *Bin...
易语言二叉树遍历
07-21
二叉树遍历是理解数据结构和算法的基础，它包括前序遍历、中序遍历和后序遍历三种主要方法。 1. **二叉树的基本概念**： - 二叉树是一种特殊的树结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。 -...
二叉树的遍历总结
量子孤岛
12-09 238
二叉树的遍历总结 前序遍历[leetcode144] 遍历方式：“根结点-左孩子-右孩子” 递归(Recursive) /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeN...
二叉树中序遍历 -- 递归和非递归实现
未来之歌
04-12 734
/* 实现二叉树中序遍历 -- 采用递归和非递归方法 ** 经调试可直接运行源码如下 **/#include <stdio.h> #include <stdlib.h> #include <iostream> #include <stack>using namespace std; /*二叉树结点定义*/ typedef struct BTreeNode { char elem;
二叉树的层序遍历
Keyman_Li的博客
04-28 134
二叉树的层序遍历 运用队列来存取元素 先建立结点的类型 public class BinNode { int val; BinNode left; BinNode right; public BinNode(int val) { this.val = val; } } 然后开始正式的算法部分 pub...
大话数据结构之查找（二）
学习记录
05-24 156
一、二叉排序树 （又称为二叉查找树）它或者是一颗空树，或者是具有下列性质的二叉树 若它的左子树不空，则左子树上所有结点的值均小于它的根结构的值； 若它的右子树不空，则右子树所有的结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树 构造一颗二叉排序树的目的，其实并不是为了排序，而是为了提高查找和插入删除关键字的速度 1、二叉排序树查找操作 /* 二叉树的二叉链表结点结构定义 */ typedef struct BiTNode /* 结点结构 */ { int data; /* 结点数据
【C语言二叉树遍历实例】C语言二叉树遍历实例
最新发布
05-20
二叉树的遍历C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历...
matlab实现二叉树遍历算法（源代码）
04-30
### MATLAB 实现二叉树遍历算法的知识点详解 #### 一、二叉树节点结构体定义 在MATLAB中实现二叉树的第一步是定义一个表示二叉树节点的结构体。在这个例子中，作者定义了一个名为`TreeNode`的类来表示节点，该类...
二叉树遍历流程图（先序、中序、后序、宽度遍历）
05-01
二叉树遍历是计算机科学中处理树结构数据时常用的一种技术，主要分为四种类型：先序遍历、中序遍历、后序遍历和宽度优先遍历。这些遍历方法各有特点，适用于不同的场景。 1. **先序遍历**： - **递归实现**：先...
二叉树遍历问题二叉树遍历问题
10-20
二叉树遍历是计算机科学中处理树结构数据时的一项基本操作，主要应用于数据的检索、存储和操作。在二叉树中，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树遍历有四种常见的方法：先序遍历、中序...
二叉排序树
weixin_33709364的博客
11-09 205
二叉排序树又称“二叉查找树”、“二叉搜索树”。 二叉排序树：或者是一棵空树，或者是具有下列性质的二叉树： 1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 3. 它的左、右子树也分别为二叉排序树。   二叉排序树通常采用二叉链表作为存储结构。中序遍历二叉排序树可得到一个依据关键字的有序序列，一...
二叉树各种遍历算法
silence1772的博客
11-01 2万+
#include &amp;amp;amp;lt;iostream&amp;amp;amp;gt; using namespace std; struct Node { int value; struct Node* left; struct Node* right; Node(int data) : value(data), left(nullptr), right(nullptr) {}; }; // 先序遍历 void Pre...
看懂二叉树的三种遍历
soundwave_的博客
11-10 15万+
二叉树的遍历分为以下三种： 先序遍历：遍历顺序规则为【根左右】 中序遍历：遍历顺序规则为【左根右】 后序遍历：遍历顺序规则为【左右根】 什么是【根左右】？就是先遍历根，再遍历左孩子，最后遍历右孩子； 举个例子，看下图（图从网上找的）： 先序遍历：ABCDEFGHK 中序遍历：BDCAEHGKF 后序遍历：DCBHKGFEA 以中序遍历为例： 中序遍历的规则是【左根右】，
二叉树及其遍历
kevin的博客
04-06 501
1.什么是二叉树 概念 二叉树是节点最多可以包含两个子节点的树，每一个节点都可以区分为左子节点和右子节点，二叉树的一个重要性质就是叶节点的数量<=2，如图所示就是一棵简单的二叉树 2.二叉树的相关概念 路径 指的是从根节点到叶节点的路径。 节点的度 一个节点含有的子树的个数称为该节点的度 节点的权 节点中有意义的值（通常是数值） 层 从根开始定义起，根为第1层，根的子节点为第2层，以...
二叉树遍历（图解）
依步_的专栏
07-11 3万+
二叉树的顺序存储结构就是用一维数组存储二叉树中的节点，并且节点的存储位置，也就是数组的下标要能体现节点之间的逻辑关系。—–>一般只用于完全二叉树 链式存储—–>二叉链表 定义： lchild | data | rchild（两个指针域，一个数据域）typedef struct Node { ElemType data; struct Node *lchild
常用查找算法原理总结
站在人文与技术的交汇点
01-06 581
一、静态查找表 1、顺序查找表：设置界（0~n），然后从头比到尾，有则返回！   顺序查找表plus：把原来的界（0~n）改为设置哨兵R[0]或者R[n]，当比较到R[0]（从后往前比）或者R[n]（从前往后比）还没有相等的时候，就是没有！否则，有则返回！这样省略了每次都要判断是否到了界点的步骤！ 2、有序查找表：“最基本”的是折半查找！首先和R[m]=R[(0+n)/2]比较，如果
关于二叉树的前序、中序、后序三种遍历
热门推荐
迷途中的一片羽毛博客
05-07 47万+
二叉树遍历分为三种：前序、中序、后序，其中序遍历最为重要。为啥叫这个名字？是根据根节点的顺序命名的。比如上图正常的一个满节点，A：根节点、B：左节点、C：右节点，前序顺序是ABC（根节点排最先，然后同级先左后右）；中序顺序是BAC(先左后根最后右）；后序顺序是BCA（先左后右最后根）。    比如上图二叉树遍历结果    前序遍历：ABCDEFGHK    中序遍历：BDCAEHGKF    后序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值