二叉树专题

最新推荐文章于 2024-11-19 23:49:10 发布
原创 最新推荐文章于 2024-11-19 23:49:10 发布 · 118 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#二叉树

反转二叉树

有一个问题，若没有node->lchild = reverse(node->lchild);而是直接reverse(node->lchild)；就会宝座

#include<iostream>
#include<string>
using std::cin;
using std::cout;
using std::endl;
using std::string;
class Node {
public:
    char data;
    Node *lchild, *rchild;
    Node(char _data) {
        data = _data;
        lchild = NULL;
        rchild = NULL;
    }
    ~Node() {
        if (lchild != NULL) {
            delete lchild;
        }
        if (rchild != NULL) {
            delete rchild;
        }
    }
    void postorder() {
        if (lchild != NULL) {
            lchild->postorder();
        }
        if (rchild != NULL) {
            rchild->postorder();
        }
        cout << data;
    }
    // 请在下面实现建立二叉树的方法 build
	Node* build(const string &pre_str, const string &in_str, int len){
        Node *p = new Node(pre_str[0]);
        int pos = in_str.find(pre_str[0]);
        if (pos > 0){
            p->lchild = build(pre_str.substr(1, pos), in_str.substr(0, pos), pos);
        }
        if (len - pos - 1 > 0){
            p->rchild = build(pre_str.substr(pos + 1), in_str.substr(pos + 1), len - pos - 1);
        }
        return p;
    }
    
    Node* reverse(Node *node){
        if (node == NULL){
            return NULL;
        }

        Node *temp = node->lchild;
		node->lchild = node->rchild;
		node->rchild = temp;

		node->lchild = reverse(node->lchild);
		node->rchild = reverse(node->rchild);

        return node;
    }
};
class BinaryTree {
private:
    Node *root;
public:
    BinaryTree() {
        root = NULL;
    }
    ~BinaryTree() {
        delete root;
    }
    // 请在下面实现构造函数
    BinaryTree(const string &pre_str, const string &in_str, int len){
        root = root->build(pre_str, in_str, len);
    }

    void postorder() {
        root->postorder();
    }
    
    void reverse(){
        root->reverse(root);
    }
};
int main() {
    string pre_str = "";
    string in_str = "";
    cin >> pre_str;
    cin >> in_str;
	BinaryTree binarytree(pre_str, in_str, in_str.length());
    binarytree.postorder();
    cout << endl;
    binarytree.reverse();
    binarytree.postorder();
    cout << endl;
    
    return 0;
}

删除二叉树中的节点

这题要求用广义表输入，并在递归删除某个节点后，再使用广义表输出。
这里有几个问题：

  • 删除节点时，我第一遍写的是直接void delete_node(const char &c)，大意是没有再把root赋值一遍，直接使用传入的root值，并在此基础上使用data、lchild…结果是，删除过程没问题，但调用generalized_output函数时不输出，好像走丢了一样（root指针指向错误？？）。后来，把函数类型改为可返回节点，返回一个新的root值，就OK。
  • 在写二叉树生成广义表时，误写为return lchild->generalized_output();，后来对照preorder才写对，大概知道这个逻辑是错的，但不知道具体原因。
  • 在测试组里有一例是空字符串，也就是二叉树为空。但cin和scanf会把空白符跳过！！一开始就输入回车，他仍然会等着你输入。。rlgl，后来还是用char的方法判断回车，但不知道s+=ch的原理。
#include<iostream>
#include<string>
#include<stack>
using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::stack;

class Node {
public:
    char data;
    Node *lchild, *rchild;
    Node(char _data) {
        data = _data;
        lchild = NULL;
        rchild = NULL;
    }
    ~Node() {
        if (lchild != NULL) {
            delete lchild;
        }
        if (rchild != NULL) {
            delete rchild;
        }
    }

	Node* generalized_build(const string &input_str){
		stack<Node *> s;
		Node *root = NULL;
		Node *p, *temp;
		if (input_str == ""){
			return NULL;
		}
		int k = -1;
		for (int i = 0; i < input_str.length(); i++){
			if (input_str[i] == '('){
				k = 0;
				s.push(p);
			}else if(input_str[i] == ','){
				k = 1;
			}else if(input_str[i] == ')'){
				s.pop();
			}else{//字母
				p = new Node(input_str[i]);
				if (k == -1){
					//作为根节点入栈
					root = p;
					s.push(root);
				}else if(k == 0){
					temp = s.top();
					//s.pop();
					temp->lchild = p;
					//s.push(temp);
				}else if(k == 1){
					temp = s.top();
					//s.pop();
					temp->rchild = p;
					//s.push(temp);
				}
			}
		}
		return root;
	}

	void generalized_output(){
		cout << data;
		if (lchild != NULL || rchild != NULL){
			cout << "(";
		}
		if (lchild != NULL){
			lchild->generalized_output();
		}
		if (rchild != NULL){
            cout << ",";
			rchild->generalized_output();
		}
		if (lchild != NULL || rchild != NULL){
			cout << ")";
		}
	}

	Node* delete_node(Node *node, const char &c){
		if (node->data == c){
			if (node->lchild != NULL){
				delete node->lchild;
			}
			if (node->rchild != NULL){
				delete node->rchild;
			}
			return NULL;
		}else{
			if (node->lchild != NULL){
				node->lchild = node->lchild->delete_node(node->lchild, c);
			}
			if (rchild != NULL){
				node->rchild = node->rchild->delete_node(node->rchild, c);
			}
		}
		return node;
	}

};

class BinaryTree {
private:
    Node *root;
public:
    BinaryTree() {
        root = NULL;
    }
    ~BinaryTree() {
        delete root;
    }

    BinaryTree(const string &input_str){
        if (input_str.length() == 0){
            root = NULL;
        }
		root = root->generalized_build(input_str);
	}

    void generalized_output(){
    	if (root == NULL){
    		return;
    	}
    	root->generalized_output();
    }

    void delete_node(const char &c){
        if (root == NULL){
    		return;
    	}
    	root = root->delete_node(root, c);
    }

};

int main() {
    char delete_ch;
    string str = "";
	char ch;
	while ((ch = getchar()) != '\n') str+=ch; //此处可以do stuff
    cin >> delete_ch;
    BinaryTree binarytree(str);
    binarytree.delete_node(delete_ch);
    binarytree.generalized_output();
    cout << endl;

    return 0;
}

由顺序表建立完全二叉树

#include<iostream>
#include<string>
#include<cstring>
#include<stack>
#include<queue>
using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::stack;
using std::queue;

class Node {
public:
    char data;
    Node *lchild, *rchild;
    Node(char _data) {
        data = _data;
        lchild = NULL;
        rchild = NULL;
    }
    ~Node() {
        if (lchild != NULL) {
            delete lchild;
        }
        if (rchild != NULL) {
            delete rchild;
        }
    }

	Node* build_complete(char *p){//p为字符串指针，q为队列指针
		if (p[0] == '$'){
			return NULL;
		}
		Node *node = new Node(p[0]);
		p = std::strtok(NULL," ");

		queue<Node *> q;
		q.push(node);

		int i = 0;
		while(p[0] != '$'){
			if (i % 2 == 0){
				q.front()->lchild = new Node(p[0]);
				q.push(q.front()->lchild);
				p = std::strtok(NULL," ");
				i++;
			}else{
				q.front()->rchild = new Node(p[0]);
				q.push(q.front()->rchild);
				q.pop();
				p = std::strtok(NULL," ");
				i++;
			}
		}
		return node;
	}

	void generalized_output(){
		cout << data;
		if (lchild != NULL || rchild != NULL){
			cout << "(";
		}
		if (lchild != NULL){
			lchild->generalized_output();
		}
		if (rchild != NULL){
            cout << ",";
			rchild->generalized_output();
		}
		if (lchild != NULL || rchild != NULL){
			cout << ")";
		}
	}

};

class BinaryTree {
private:
    Node *root;
public:
    BinaryTree() {
        root = NULL;
    }
    ~BinaryTree() {
        delete root;
    }

    BinaryTree(char *p){
    	root = root->build_complete(p);
    }

    void generalized_output(){
    	if (root == NULL){
    		return;
    	}
    	root->generalized_output();
    }


};

int main() {
	string str;
	char ch;
	while (~scanf("%c", &ch)) str+=ch;
	//while ((ch = getchar()) != '\n') str+=ch;
	char *cstr = new char [str.length()+1];
	strcpy (cstr, str.c_str());
	char *p = std::strtok(cstr," ");
	BinaryTree binarytree(p);
	binarytree.generalized_output();
    cout << endl;

    return 0;
}
二叉树：利用广义表创建二叉树，并实现指定结点的删除
Simpleholly的博客
07-12 1601
题目： 编写递归算法，对于二叉树中每一个元素值data等于x的节点，删去以它为根的子树，并释放相应的空间。 树的结构以广义表的形式给出。如A(B,)表示一颗有2个节点的树。其中根的data值为A，其左孩子为叶子节点，data值为B，右孩子为空。 输入格式 输入有两行，第一行为以广义表的形式给出的树形结构，长度在区间 [0,30)[0,30) 内，均由大写字母和左右括号组成，每个结点
二叉排序树
weixin_47414034的博客
10-02 1616
不断往二叉排序树里面添加新结点，第一个元素是根节点，比根节点小的放在左子树，比根结点大就放在右子树（所以相同一组数，如果给的顺序不一样，构建的二叉排序树结果也不一样，因为根节点不一样）（2）若删除的结点只有左子树或者只有右子树，则让左子树(或者右子树)代替这个被删除的结点即可。先写出这个二叉搜索树的中序遍历结果，这样就可以求出删除的这个节点的后序是哪个结点了。比根节点大，就去根节点的右子树中找，比根节点小，就去根节点的左子树中找...，先删除这个结点，然后将后序结点和这个删除的结点进行交换。
《大话数据结构》二叉排序树代码错误
yingge的专栏
01-24 956
《大话数据结构》二叉排序树，删除某结点的函数 /* 从二叉排序树中删除结点p，并重接它的左或右子树。 */ Status Delete(BiTree *p) { BiTree q,s; if((*p)->rchild==NULL) /* 右子树空则只需重接它的左子树（待删结点是叶子也走此分支) */ { q=*p; *p=(*p)->lchild; free(q); } e
二叉排序树删除结点c语言,关于C语言实现二叉排序树,删除后节点后，原来节点存在且出现垃圾数字的问题...
weixin_34533343的博客
05-21 258
// 二叉搜索树,以特定的规则来进行构建// 1,所有节点中,该节点的左子树中的节点的键值 =< 该节点,右子树中节点的键值 >= 该节点.// 2,当进行一次中序遍历,则会得到升序排列#include #include struct Node{int key;Node *parent, *left, *right;};Node *root, *NIL;void insert_node...
二叉树 专题
shichap的博客
10-05 292
94 二叉树的中序遍历 给定一个二叉树，返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 解题方法 迭代 class Solution { public List<Integer> inorderTraversal(TreeNode root) { List<Integer> res = new ArrayList<>();
二叉树专题刷题
MogulNemenis的博客
07-12 321
使用三个集合，sums集合存储每层的总和，count集合存储每层的节点数，averages存储每层的平均值。set方法：本质上是一种替换操作， 要设置某个位置上的元素，这个位置必须已存在，否则会抛出异常。add方法：用于向集合的末尾插入新的元素，是List接口中最常用的插入方法。使用depue双端队列，两端都可进。使用先进先出队列，每次都重置队列长度，使每次队列里都是每层的节点。我的思路相当暴力，只需要进行层序遍历，然后获取每层最右边的节点。这里要讲一下add方法和set方法的区别。
「代码随想录」二叉树专题精讲（v1.2）.pdf
12-14
"代码随想录二叉树专题精讲" 本资源是关于二叉树的专题讲解，涵盖了二叉树的基本概念、avl树、红黑树、堆、trie树等多种二叉树结构的实现和应用。 知识点一：二叉树的基本概念 二叉树是一种特殊的树状结构，它的每...
二叉树专题精讲（v2.0）.pdf
06-06
二叉树专题精讲（v2.0）.pdf
【二叉树专题】二叉树的经典遍历及其优化方案
最新发布
akiba-miku
11-19 1550
算法角度的看二叉树的遍历方式。 深搜广搜， 递归辅助栈，优化bfs。 最好先把二叉树的数据结构修完然后观看最佳。😌 递归专栏： 经典递归问题 树专栏： 二叉树专题
C语言：源文件 头文件【.c/.cc/.h】的使用
Nemoxy的博客
10-13 3163
一个函数包括定义与声明，定义中包含了函数是如何实现的，声明则阐明函数如何被调用。 工程上为了将个函数模块化，通常将声明与定义分开，一般将主函数定义放在.c中，其他函数定义放在源文件.cc中，函数声明放在.h中。 .c 中包含主函数，并include所有使用到的头文件； .cc中包含其他函数定义，并include需要的.h文件或需要的非本函数的声明；【保证这个源文件可以单独编译成功 如果不将函数的声明与定义分开，将函数声明和定义都放在.c中，那如果现在要增加一个函数的声明文件2.c，这个新函数include其
C语言：Hash表查找字符串内容
Nemoxy的博客
11-08 3082
#include <stdio.h> #include <stdlib.h> #include <string.h> //拉链法 //链表节点，数据域存字符串 typedef struct Node{ char *str; struct Node *next; }Node; //顺序表（表头，大小） typedef struct HashTable{ //链表首地址,是链表头结点的顺序表，由于头结点是Node *,顺序表示Node ** Node **data
2021-08-31 C++： 虚继承下array new / delete 的内存管理
Nemoxy的博客
04-27 2146
以下实验基于VS2015, win32环境 array new出来的对象，能否用父类指针能否调用子类虚函数？ 如果父类大小 * 元素数目 = 子类大小 * 元素数目，就可以，否则不行。 #include "stdafx.h" #include <iostream> using namespace std; class A { public: int x{ 10 }; virtual void PrintVal(int a = 1) { cout << x + a <&l
C++队列*增删查等操作*
Nemoxy的博客
09-11 1238
队列 #include <iostream> using std::cout; using std::endl; template <typename Type> class Queue { private: Type *data; int head, tail, length; public: Queue(int length_input) { data = new Type[length_input]; length = l
C语言基础数据结构：二叉树及与广义表的转换
Nemoxy的博客
11-30 907
二叉树建立与广义表输出 #include <stdio.h> #include <stdlib.h> #include <time.h> typedef struct Node{ int data; struct Node *lchild, *rchild; }Node; typedef struct Tree{ Node *root; int n;//节点个数？ }Tree; Node *init_node(int val){ Node *p = (No
面试笔试算法：深搜
Nemoxy的博客
11-27 807
由数字 0 组成的方阵中，有一任意形状闭合圈，闭合圈由数字 1 构成，围圈时只走上下左右 4 个方向。现要求把闭合圈内的所有空间都填写成 2。例如：6×6 的方阵 （n=6），涂色前和涂色后的方阵如下： #include <iostream> using namespace std; //预留出一圈，并将外圈连通的区域标记为2，那么剩下的为0区域则是要求区域 int n; int mmap[100][100]; int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0
C语言：稳定排序（冒泡，插排，归并）
Nemoxy的博客
11-30 771
什么叫稳定排序呢？比如排序中有两个一摸一样的数字，如果排完序，两个相同的数字顺序没有改变，就是稳定的， 反之，就是非稳定的。 稳定排序包括： 冒泡： 插入：不断地将待排序区数字加入到已排序区，直到待排序区没有元素，【有点像插队；O（n^2） 归并 另外，排序算法还能分为: 内部排序、外部排序（当前数组不可以全部加载到内存中，需要分段加载） ...
Java实现数据结构：二叉树专题代码解析
在众多数据结构中，二叉树是一种基础且广泛使用的结构，它在计算机科学领域具有重要地位。二叉树是一种非线性数据结构，具有以下特点： 1. 每个节点最多有两个子节点，分别为左子节点和右子节点。 2. 左子节点的值...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值