二叉树

最新推荐文章于 2022-09-05 11:51:04 发布
最新推荐文章于 2022-09-05 11:51:04 发布
阅读量133 收藏
点赞数
分类专栏： UPC_DataStructure
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42718542/article/details/90678042
版权

文章目录

0 二叉树与表达式

在这里插入图片描述

代码

#include <iostream>
#include <stdio.h>
#include "cstdio"
#include <cmath>

using namespace std;

class Tree;
class TreeNode
{
    friend class Tree;

private:
    char data;
    TreeNode *left;
    TreeNode *right;

public:
    TreeNode() : left(NULL), right(NULL){};
    TreeNode(char data1) : data(data1), left(NULL), right(NULL) {}
};

class Tree
{
private:
    TreeNode *root;
    char endtag;
    void Create(TreeNode *&subtree);  //指针的引用
    void destroy(TreeNode *&subtree); // 指针的引用
    void inorder(TreeNode *subtree);
    int operator1(TreeNode *subtree);
    TreeNode *parent(TreeNode *subtree, TreeNode *cur);
    void in_test(TreeNode *subtree);

public:
    Tree() { root = NULL; }
    Tree(char end1, TreeNode *p = NULL) : root(p), endtag(end1) {}
    ~Tree() { destroy(root); }
    bool isEmpty() { return root == NULL ? true : false; }
    void Create() { Create(root); }
    void inorder() { inorder(root); }
    int operator1() { return operator1(root); }
    bool see(char op1, char oop2);
    TreeNode *parent(TreeNode *cur)
    {
        return (root == NULL || root == cur) ? NULL : parent(root, cur);
    }
    void in_test() { in_test(root); }
};

void Tree::in_test(TreeNode *subtree)
{
    if (!subtree)
    {
        in_test(subtree->left);
        if (subtree->data == 'D')
        {
            cout << parent(subtree)->data << endl;
        }
        in_test(subtree->right);
    }
}

TreeNode *Tree::parent(TreeNode *subtree, TreeNode *cur)
{
    if (subtree == NULL)
    {
        return NULL;
    }
    if (subtree->left == cur || subtree->right == cur)
    {
        return subtree;
    }
    return parent(subtree->left, cur) == NULL ? parent(subtree->right, cur) : parent(subtree->left, cur);
}

void Tree::Create(TreeNode *&subtree)
{
    char item;
    cin >> item;
    if (item != endtag)
    {
        subtree = new TreeNode(item);
        Create(subtree->left);
        Create(subtree->right);
    }
}

void Tree::destroy(TreeNode *&subtree)
{
    if (subtree != NULL)
    {
        destroy(subtree->left);
        destroy(subtree->right);
        delete subtree;
    }
}

void Tree::inorder(TreeNode *subtree)
{
    if (subtree != NULL)
    {
        if (subtree->right != NULL && see(subtree->data, subtree->right->data))
        {
            inorder(subtree->left);
            cout << subtree->data;
            cout << "(";
            inorder(subtree->right);
            cout << ')';
        }
        else
        {
            inorder(subtree->left);
            cout << subtree->data;
            inorder(subtree->right);
        }
    }
}

int Tree::operator1(TreeNode *subtree)
{
    if (subtree != NULL)
    {
        switch (subtree->data)
        {
        case '+':
            return operator1(subtree->left) + operator1(subtree->right);
            break;
        case '-':
            return operator1(subtree->left) - operator1(subtree->right);
            break;
        case '*':
            return operator1(subtree->left) * operator1(subtree->right);
            break;
        case '/':
            return operator1(subtree->left) / operator1(subtree->right);
            break;
        default:
            return int(subtree->data - '0');
            break;
        }
    }
    else
        return 0;
}

bool Tree::see(char op1, char op2)
{
    if ((op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-'))
        return true;
    else
        return false;
}

int main()
{
//    Tree tree('#');
//    tree.Create();
//    tree.in_test();

    Tree tree1('@');
    tree1.Create();
    tree1.inorder();
    cout << "=" << tree1.operator1() << endl;
//    Tree tree2('@');
//    tree2.Create();
//    tree2.inorder();
//    cout << "=" << tree2.operator1() << endl; 
    return 0;
}

1. 二叉树的基本操作:题目描述

在这里插入图片描述
在这里插入图片描述

代码1(面向过程)

#include "iostream"
#include "cstdio"
#include "cstdlib"
#include "string"
#include "cstring"
#include "cmath"

using namespace std;

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef char Elemtype;
typedef int Status;

typedef struct BiTNode
{
    Elemtype data;
    int depth; /* 每个node的depth */
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

string tree_str;
int index_ = 0;
int Tree_depth = 0;
int num_nodes = 0;
int num_leaves = 0;
int find_A_cnt = 0;

Status InitBiTree(BiTree *T);
//void CreateBiTree(BiTree *T);
int TreeDeep(BiTree T);
int GetHeight(BiTree root);

void PreOrderTraverse(BiTree T);
void InOrderTraverse(BiTree root);
void PostOrderTraverse(BiTree T);

int CntFind(BiTree T, int find_e, int ini_);
void DestoryBiTree(BiTree *T);

BiTNode *BTreeFind(BiTNode *root, char x);
struct BiTNode *build();
void getDepth(BiTree p, int depth_);
void Print_Tab_BiTree(BiTree T);
void num_nodes_fun(BiTree T);
void num_leaves_fun(BiTree T);

void find_cnt(BiTree T, Elemtype e);

int main()
{
    //freopen("in.txt","r",stdin);

    char c;
    cin>>c;
    cout<<"Created success!"<<endl;


    BiTree head;
    InitBiTree(&head);

    cin>>tree_str;
    head = build();
    getDepth(head, 0); /* 深度从0开始数 */

    while(cin>>c)
    {
        if(c =='H')
            cout<<"Height="<<Tree_depth+1<<"."<<endl;
        else if(c == 'L')
        {
            num_leaves_fun(head);
            cout<<"Leaf="<<num_leaves<<"."<<endl;
        }
        else if(c == 'N')
        {
            num_nodes_fun(head);
            cout<<"Nodes="<<num_nodes<<"."<<endl;
        }
        else if(c == '1')
        {
            cout<<"Preorder is:";
            PreOrderTraverse(head);
            cout<<"."<<endl;
        }
        else if(c == '2')
        {
            cout<<"Inorder is:";
            InOrderTraverse(head);
            cout<<"."<<endl;
        }
        else if(c == '3')
        {
            cout<<"Postorder is:";
            PostOrderTraverse(head);
            cout<<"."<<endl;
        }
        else if(c == 'F')
        {
            cout<<"The count of A is ";
            find_cnt(head, c);
            cout<<find_A_cnt<<"."<<endl;
        }
        else if(c == 'P')
        {
            cout<<"The tree is:"<<endl;
            Print_Tab_BiTree(head);
        }
    }

    DestoryBiTree(&head);
    return 0;
}

Status InitBiTree(BiTree *T)
{
    *T = NULL;
    return OK;
}

//void CreateBiTree(BiTree *T)
//{
//    Elemtype ch;
//    //scanf("%c", &ch);
//
//    ch = tree_str[index_++];
//    if (ch == '#')
//        *T = NULL;
//    else
//    {
//        *T = (BiTree)malloc(sizeof(BiTNode));
//        if (!*T)
//        {
//            exit(_OVERFLOW);
//        }
//        (*T)->data = ch; /* 生成根节点 */
//        CreateBiTree(&(*T)->lchild);
//        CreateBiTree(&(*T)->rchild);
//    }
//}

int TreeDeep(BiTree T)
{
    int deep = 0;
    if (T != NULL)
    {
        int LeftDeep = TreeDeep(T->lchild);
        int RightDeep = TreeDeep(T->rchild);
        deep = LeftDeep >= RightDeep ? LeftDeep + 1 : RightDeep + 1;
    }
    return deep;
}

/* invalid function */
int GetHeight(BiTree root)
{
    if (root == NULL)
    {
        return 0;
    }

    int CntLeft = GetHeight(root->lchild);
    int CntRight = GetHeight(root->rchild);

    return CntLeft > CntRight ? CntLeft : CntRight;
}

void PreOrderTraverse(BiTree T)
{
    if (T == NULL)
    {
        return;
    }
    printf("%c ", T->data);
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
}

void InOrderTraverse(BiTree root)
{
    if (root == NULL)
    {
        return;
    }
    InOrderTraverse(root->lchild);
    printf("%c ", root->data);
    InOrderTraverse(root->rchild);
}

void PostOrderTraverse(BiTree T)
{
    if (T == NULL)
    {
        return;
    }
    PostOrderTraverse(T->lchild);
    PostOrderTraverse(T->rchild);
    printf("%c ", T->data);
}

void DestoryBiTree(BiTree *T)
{
    if (*T)
    {
        if ((*T)->lchild) /* 有左孩子 */
        {
            DestoryBiTree(&(*T)->lchild);
        }
        if ((*T)->rchild)
        {
            DestoryBiTree(&(*T)->rchild);
        }
        free(*T); /* 释放根结点 */
        *T = NULL; /* 空指针赋值0 */
    }

}

BiTNode *BTreeFind(BiTNode *root, char x)
{
    BiTNode *ret = NULL;
    if (root == NULL)
    {
        return root;
    }
    if (root->data == x)
    {
        return root;
    }
    else
    {
        ret = BTreeFind(root->lchild, x);
        if(ret != NULL)
        {
            if (ret->data == x)
            {
                return ret;
            }
        }
        ret = BTreeFind(root->rchild, x);
    }
    return ret;
}

struct BiTNode *build()
{
    char ch;
    ch = tree_str[index_++];
    if(ch == '#')
        return NULL;
    BiTree p = (BiTree)malloc(sizeof(struct BiTNode));
    p->data = ch;
    p->lchild = build();
    p->rchild = build();
    return p;
};

void getDepth(BiTree p, int depth_)
{
    if(!p)
        return;
    p->depth = depth_;
    if(p->lchild == NULL && p->rchild == NULL)
        Tree_depth = max(Tree_depth, p->depth);

    getDepth(p->lchild, depth_+1);
    getDepth(p->rchild, depth_+1);
}

void Print_Tab_BiTree(BiTree T)
{
    if(T == NULL)
        return;
    while(T->depth--)
        cout<<"  ";

    cout<<T->data<<endl;
    Print_Tab_BiTree(T->lchild);
    Print_Tab_BiTree(T->rchild);
}

void num_nodes_fun(BiTree T)
{
    if(T == NULL)
        return;
    num_nodes++;

    num_nodes_fun(T->lchild);
    num_nodes_fun(T->rchild);
}

void num_leaves_fun(BiTree T)
{
    if(T == NULL)
        return;

    if(T->lchild == NULL && T->rchild == NULL)
        num_leaves++;

    num_leaves_fun(T->lchild);
    num_leaves_fun(T->rchild);
}

void find_cnt(BiTree T, Elemtype e)
{
    if(T == NULL)
        return;
    if(T->data == e)
        find_A_cnt++;

    find_cnt(T->lchild, e);
    find_cnt(T->rchild, e);
}

代码2 (OO)

#include <iostream>

using namespace std;

class BinaryTree;
class BinTreeNode {
	friend BinaryTree;
private:
	BinTreeNode * leftChild, *rightChild;
	char data;
public:
	BinTreeNode() {
		leftChild = NULL;
		rightChild = NULL;
	}
	BinTreeNode(char x,BinTreeNode *left=NULL,BinTreeNode *right=NULL) {
		data = x;
		leftChild = left;
		rightChild = right;
	}
	~BinTreeNode() {}
};
class BinaryTree {
private:
	BinTreeNode * root;
	char endtag;
	int cnt = 0;
	void createBinTree(BinTreeNode* &subTree);
	BinTreeNode *parent(BinTreeNode *subTree, BinTreeNode *current);
	int height(BinTreeNode *subTree);
	int size(BinTreeNode *subTree);
	int leaf(BinTreeNode *subTree);
	void destroy(BinTreeNode *&subTree);
	void preOrder(BinTreeNode *subTree);
	void inOrder(BinTreeNode *subTree);
	void postOrder(BinTreeNode *subTree);
	void find(BinTreeNode *subTree, char x);
	void show(BinTreeNode *subTree,int cnt);
	void tes(BinTreeNode *t, int cnt); //For testing
public:
	int cn = 0;
	BinaryTree(char value) {
		endtag = value;
		root = NULL;
	}
	~BinaryTree() {
		destroy(root);            //why must destroy;
	}
	void createBinTree() {
		createBinTree(root);
	}
	bool IsEmpty(){
		return(root == NULL) ? true : false;
	}
	BinTreeNode *parent(BinTreeNode *current) {
		return(root == NULL || root == current) ? NULL : parent(root, current);    //parent wahts the
	}
	BinTreeNode *leftChild(BinTreeNode *current) {
		return(current != NULL) ? current->leftChild : NULL;
	}
	BinTreeNode *rightChild(BinTreeNode *current) {
		return(current != NULL) ? current->rightChild : NULL;
	}
	int height() {
		return height(root);
	}
	int size() {
		return size(root);
	}
	int leaf() {
		return leaf(root);
	}
	void preOrder() {
		preOrder(root);
	}
	void inOrder() {
		inOrder(root);
	}
	void postOrder() {
		postOrder(root);
	}
	void find(char x) {
		find(root, x);
	}
	void show(int &cnt) {
		show(root,cnt);
	}
	void tes(int &cnt)
	{
	    tes(root, cnt);
	}
};


void BinaryTree::createBinTree(BinTreeNode *& subTree)
{
	char item;
	cin >> item;
	if (item != endtag) {
		subTree = new BinTreeNode(item);
		createBinTree(subTree->leftChild);
		createBinTree(subTree->rightChild);
	}
	else subTree = NULL;   //this line can be remove;
}
BinTreeNode * BinaryTree::parent(BinTreeNode * subTree, BinTreeNode * current)
{
	if (subTree == NULL)
		return NULL;
	if (subTree->leftChild == current || subTree->rightChild == current)
		return subTree;    // what the reason
	BinTreeNode *p = parent(subTree->leftChild, current);
	if (p != NULL)
		return p;
	else
		return (parent(subTree->rightChild, current));

}

int BinaryTree::height(BinTreeNode * subTree)
{
	if (subTree == NULL)
		return 0;
	else if (height(subTree->leftChild) > height(subTree->rightChild))
		return 1 + height(subTree->leftChild);
	else
		return 1 + height(subTree->rightChild);
}

int BinaryTree::size(BinTreeNode * subTree)
{
	if (subTree == NULL) {
		return 0;
	}
	else {
		return 1 + size(subTree->leftChild) + size(subTree->rightChild);
	}
}

int BinaryTree::leaf(BinTreeNode * subTree)//need to be rewrite
{
	if (subTree != NULL) {
		if (subTree->leftChild == NULL && subTree->rightChild == NULL)
		{
			cnt++;
		}
		leaf(subTree->leftChild);
		leaf(subTree->rightChild);
	}
	return cnt;
}

void BinaryTree::destroy(BinTreeNode *& subTree)
{
	if (subTree != NULL) {
		destroy(subTree->leftChild);
		destroy(subTree->rightChild);
		delete subTree;
	}
}

void BinaryTree::preOrder(BinTreeNode * subTree)
{
	if (subTree != NULL) {
		cout << subTree->data<<" ";
		preOrder(subTree->leftChild);
		preOrder(subTree->rightChild);
	}
}

void BinaryTree::inOrder(BinTreeNode * subTree)
{
	if (subTree != NULL) {
		inOrder(subTree->leftChild);
		cout << subTree->data << " ";
		inOrder(subTree->rightChild);
	}
}

void BinaryTree::postOrder(BinTreeNode * subTree)
{
	if (subTree != NULL) {
		postOrder(subTree->leftChild);
		postOrder(subTree->rightChild);
		cout << subTree->data << " ";
	}
}

void BinaryTree::find(BinTreeNode * subTree, char x)
{
	if (subTree != NULL) {
		find(subTree->leftChild,x);
		find(subTree->rightChild,x);
		if (subTree->data == x) {
			cn++;
		}
	}
}

void BinaryTree::show(BinTreeNode * subTree,int cnt)
{

	if (subTree != NULL) {
		for (int i = 0; i < cnt; i++) {
		cout << "  ";
	    }
		cout << subTree->data<<endl;
	    show(subTree->leftChild, cnt+1);
	    show(subTree->rightChild, cnt+1);
	}
}

void BinaryTree::tes(BinTreeNode *t, int cnt)
{
    if(t)
    {
        for(int i=0;i<cnt;i++)
        {
            cout<<'\t';
        }
        cout<<cnt<<t->data<<endl;
        tes(t->leftChild, cnt+1);
        tes(t->rightChild, cnt+1);
    }
}

int main()
{
	BinaryTree b('#');
//	char c;
//	while (cin >> c) {
//		if (c == 'C') {
//			b.createBinTree();
//			if (b.IsEmpty() != true) {
//				cout << "Created success!" << endl;
//			}
//		}
//		else if (c == 'H') {
//			cout << "Height=" << b.height() << "." << endl;
//		}
//		else if (c == 'L') {
//			cout << "Leaf=" << b.leaf() << "." << endl;
//		}
//
//		else if (c == '1') {
//			cout << "Preorder is:";
//			b.preOrder();
//			cout << "." << endl;
//		}
//		else if (c == 'N') {
//			cout << "Nodes=" << b.size() << "." << endl;
//		}
//
//		else if (c == '2') {
//			cout << "Inorder is:";
//			b.inOrder();
//			cout << "." << endl;
//		}
//
//		else if (c == '3') {
//			cout << "Postorder is:";
//			b.postOrder();
//			cout << "." << endl;
//		}
//		else if (c == 'F') {
//			char x;
//			cin >> x;
//			b.find(x);
//			cout << "The count of " << x << " is " << b.cn << "." << endl;
//		}
//		else if (c == 'P') {
//			cout << "The tree is:" << endl;
//			int cnt = 0;
//			b.show(cnt);
//		}
//	}
//
    b.createBinTree();
	int cnt=1;
	b.tes(cnt);
    return 0;
}

2. 前缀编码

例子

在这里插入图片描述
在这里插入图片描述

Coop_Multi-Agent_DRL
关注
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
吕鑫：【C++语法与数据结构第24天】【第2堂课】二叉树映射类（CMap）加强版
12-04
1、进一步演示通过1、进一步演示通过循环算法开发二叉树映射类（CMap）的过程；循环算法开发二叉树映射类（CMap）的过程；
二叉树之二叉树的镜像
守得云开见月明
07-01 214
1.本题知识点    二叉树，递归 2. 题目描述    操作给定的二叉树，将其变换为源二叉树的镜像。 3. 思路    思路比较简单，首先先弄明白什么是镜像？    然后，每次输入根节点，交换其左右子节点即可。过程如下：    Java递归版本： /** public class TreeNode { int val = 0; TreeNode left = null;...
将二叉树的子树映射成一个数，用于判断子树相同
qq_41358366的博客
09-05 297
子树映射
C# 实现 LeetCode 677. 键值映射
什么风把您给吹来了
05-09 311
废了好大劲 用的二叉树结构 不会使用迭代器，就用Dictionary模拟了一下迭代器 public interface Map<K, V> { void add(K key, V value); V remove(K key); bool contains(K key); V get(K key); void set(K key, V value); int getSize(); bool isEmpty(); } ...
数据映射--平衡二叉有序树
chivalry
10-12 1399
http://blog.sina.com.cn/s/blog_693f08470101mnna.html 上次我们提到了使用有序的数组来进行二分查找，从而提高映射查询的效率，使时间复杂度从O(n)降低到O(log2N).   本周让我来介绍一下二叉树。   一谈到二叉树，相信很多人一定会有一个疑问： 这玩意儿有什么用？ （当然这么多人里面肯定包括大学时候的我-
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
易语言二叉树遍历
07-21
在易语言中，处理数据结构如二叉树是一项常见的任务，特别是在处理递归和树形结构的数据时。二叉树遍历是理解数据结构和算法的基础，它包括前序遍历、中序遍历和后序遍历三种主要方法。 1. **二叉树的基本概念**： ...
二叉树的遍历实验报告.pdf
最新发布
11-11
二叉树是一种重要的数据结构，它由有限个节点组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于搜索、排序、表达式求解等多种场景。本实验报告将探讨二叉树的遍历...
映射表map(平衡二叉树实现)_集合与映射
weixin_39528029的博客
11-21 335
今天我们来聊聊集合(Set)和映射(Map)，由于这两种数据结构相对比较简单，我们用一章的篇幅已经可以说明白了。相信很多人都对集合和映射比较熟悉了，这篇文章我们不准备花太多篇幅来讲概念性的东西，我们主要分析一下集合与映射的时间复杂度，使用不同数据结构实现之间的差别。这篇文章主要是为了整个系列内容的完整性。所以，如果你觉得自己对集合与映射已经非常熟悉了，那你可以出门左拐，不用浪费时间了。...
C++实现哈希映射(与map二叉树映射，线性映射比较)
weixin_34004750的博客
02-22 541
practice1.h(包含线性映射) #ifndef PRACTICE1_H_INCLUDED #define PRACTICE1_H_INCLUDED #include<vector> template<class Key,class Value> class LinerMap //线性映射 { public: LinerMa...
映射表map(平衡二叉树实现)_九、集合Set和映射Map
weixin_39905624的博客
11-21 166
熬夜写代码关注公众号：EZ大数据。每天学习一点点，不亏！"世界上最重要的事情是理解现实如何运行，一级如何应对现实。面对这一过程的心态至关重要！——达利欧《原则》"昨天说完二叉搜索树，今天来个简单点的：集合Set和映射Map。然后我们再使用链表和二叉树来初步实现Set和Map的功能，并研究下相关操作的时间复杂度。OK，正餐开始(我是来对比树和链表的，别搞错)！说起集合Set，其里面的元素不会重复，所...
【算法练习】数据结构/二叉树 前序重建 以及 树与二叉树转换4082:树的镜面映射
一蓑烟雨任平生
09-01 515
题目：http://bailian.openjudge.cn/practice/4082 4082:树的镜面映射 总时间限制: 1000ms 内存限制: 65536kB 描述 一棵树的镜面映射指的是对于树中的每个结点，都将其子结点反序。例如，对左边的树，镜面映射后变成右边这棵树。 a a / | \...
集合与映射——基于线性表和二叉树实现：
zhangpupu320的博客
04-30 197
1.集合Set接口定义： public interface Set { public void add(E e); public void remove(E e); public boolean contains(E e); public int getSize(); public boolean isEmpty(); } （1）基于链表ArrayList实现的集合：linkedSet impor...
数据结构-哈希与映射
weixin_38383877的博客
06-14 736
二叉树映射map #include<iostream> #include<map> //映射（也叫字典），二叉树映射，不是哈希映射 using namespace std; int main() { cout << "二叉树（红黑树）" << endl; map<string, int> m; m["bi...
编程构造二叉树并实现对应的操作
Stynis 's Blog
06-01 2004
一、编写递归算法，对于二叉树中每一个元素值为x的结点，删去以它为根的子树，并释放相应的空间 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 由算法要求可知，需要进行遍历操作，直至查询到元素值为x的结点，然后用调用递归算法删除此结点以下的所有结点和此结点并释放空间。则可以编写代码如下： int Del_XSub(BiTree &amp;amp;T
树的镜面映射
melanieecd的博客
05-03 1957
poj 4082 http://bailian.openjudge.cn/practice/4082/ 考察： 1） 通过伪满二叉树还原树 2） 层次遍历树的镜面映射总时间限制: 1000ms 内存限制: 65536kB 描述我们在输入输出一棵树的时候，常常会把树转换成对应的二叉树，而且对该二叉树中只有单个子结点的分支结点补充一个虚子结点“$”，形成“伪满二叉树”。例如，对下图左边的树，得
C语言二叉树性质详解
C语言公共基础部分之二叉树性质 根据给定的文件信息，我们可以总结出以下知识点： 1. 二叉树的定义：二叉树是树形结构的一个重要类型，由n个结点的有限集组成，或者是空集，或者由一个根结点及两棵互不相交的、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值