森林与二叉树的转换实现

最新推荐文章于 2023-12-12 11:28:12 发布
最新推荐文章于 2023-12-12 11:28:12 发布
阅读量320 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HANZY72/article/details/105534550
版权

输入格式说明：略

#include<iostream>
#include<queue>
using namespace std;


//类的声明
class Forest;
class BinaryTree;

//森林
struct Node {
	int val;
	Node *next;

	Node() { 
		val = -1;
		next = NULL;
	}
	Node(int v) :val(v) { next = NULL; }
};
struct Root {
	int val;
	int index;
	Root *next;

	Root() { 
		val = -1;
		index = -1;
		next = NULL; 
	}
	Root(int i,int v,Root *n)
		:val(v),index(i),next(n){}
};
//二叉树
struct initNode {
	int A;
	int l;
	int r;
	initNode() {
		A = 0;
		l = 0;
		r = 0;
	}
	initNode(int a, int L, int R)
		:A(a), l(L), r(R)
	{}
};
struct binaryTreeNode {
	int element;
	binaryTreeNode *leftChild, *rightChild;

	binaryTreeNode() {
		element = -1;
		leftChild = NULL;
		rightChild = NULL;
	}
	binaryTreeNode(int ele) {
		element = ele;
		leftChild = NULL;
		rightChild = NULL;
	}
};

class Forest {
private:
	Node **elements;
	int nodeSize; //节点的数目
	int arrayLength; //当前数组已放置多长
	int arraySize; //当前数组大小
	Root *roots; //记录各根节点的位置链表，按值大小有序放置
	int treeSize; //森林共有多少棵树
	int treeLength; //森林已记录多少树根

public:
	Forest(){}
	Forest(const Forest &c) {
		arrayLength = c.arrayLength;
		arraySize = c.arraySize;
		roots = c.roots;
		elements = new Node*[arraySize];
		for (int i = 0; i < arraySize; i++) {
			elements[i] = c.elements[i];
		}
	}
	//私有变量的初始化
	void init_val(int treeNum, int nodeNum) {
		arraySize = 5000;
		elements = new Node *[arraySize];
		for (int i = 0; i < arraySize; i++) {
			elements[i] = new Node;
		}
		arrayLength = 0;
		nodeSize = nodeNum;

		roots = NULL;
		treeSize = treeNum;
		treeLength = 0;
	}
	void display2(); //for test: display the forest structure

	int findInNodes(int val); //查找元素的下标
	int findInRoots(int val); //查找根所在的下标位置
	void insertRoot(int index, int val);
	int insertNode(int val); //返回插入的下标
	void insertChild_Index(int index, int val); //孩子链表中有序插入元素
	int eraseInRoots(int val);
	//对外的操作
	void initializeRoot(int r);
	void initialize(int rootVal, int childNum, int *val);
	void insertChild(int father, int node);
	void eraseNode(int father, int node);
	void insertRootEdge(int father, int node);
	void display();
	binaryTreeNode* toBinaryTree();
};
int Forest::findInNodes(int val) {
	for (int i = 0; i < arrayLength; i++)
		if (elements[i] != NULL && elements[i]->val == val)
			return i;
	return -1;
}
int Forest::findInRoots(int val) {
	Root *temp = roots;
	while (temp != NULL) {
		if (temp->val == val)
			return temp->index;
		temp = temp->next;
	}
	return -1;
}
void Forest::insertRoot(int index, int val) {
	Root *insertElement = new Root(index, val, NULL);
	Root *temp = roots;
	if (temp == NULL || temp->val > val) {
		insertElement->next = temp;
		roots = insertElement;
	}
	else {
		while (temp->next != NULL && temp->next->val < val)
			temp = temp->next;
		if (temp->next == NULL)
			temp->next = insertElement;
		else if (temp->next != NULL && temp->next->val != val) {
			insertElement->next = temp->next;
			temp->next = insertElement;
		}
	}
}
int Forest::insertNode(int val) {
	if (arrayLength == arraySize) {
		arraySize *= 2;
		Node **newElements;
		newElements = new Node*[arraySize];
		for (int i = 0; i < arraySize; i++)
			newElements[i] = new Node;
		for (int i = 0; i < arrayLength; i++)
			newElements[i] = elements[i];
		elements = newElements;
	}
	elements[arrayLength]->val = val;
	elements[arrayLength]->next = NULL;
	return arrayLength++;
}
void Forest::insertChild_Index(int index, int val) {
	Node *insertElement = new Node(val);
	Node *temp = elements[index];
	if (temp->next == NULL || temp->next->val > val) {
		insertElement->next = temp->next;
		temp->next = insertElement;
	}
	else {
		Node *temp2 = temp->next;
		while (temp2->next != NULL && temp2->next->val < val)
			temp2 = temp2->next;
		if (temp2->next == NULL)
			temp2->next = insertElement;
		else if (temp2->next != NULL && temp2->next->val != val)
		{
			insertElement->next = temp2->next;
			temp2->next = insertElement;
		}
	}
}
int Forest::eraseInRoots(int val) {
	Root *temp = roots;
	int index = -1;
	if (temp->val == val) {
		index = temp->index;
		roots = temp->next;
	}
	else {
		while (temp->next != NULL && temp->next->val != val)
			temp = temp->next;
		if (temp->next != NULL) {
			index = temp->next->index;
			temp->next = temp->next->next;
		}
	}
	return index;
}
//对外操作
void Forest::initializeRoot(int r) {
	int index = insertNode(r);
	insertRoot(index, r);
	++treeLength;
}
void Forest::initialize(int root, int childNum, int *val) {
	int index = findInNodes(root);
	if (index == -1)
		index = insertNode(root);

	for (int i = 0; i < childNum; i++)
		insertChild_Index(index, val[i]);
}
void Forest::insertChild(int father, int node) {
	int index = findInNodes(node);
	if (index == -1)
		index = insertNode(node);
	if (father == -1)
		insertRoot(index, node);
	else {
		int rootIndex = findInNodes(father);
		insertChild_Index(rootIndex, node);
	}
}
void Forest::eraseNode(int father, int node) {
	int rootIndex;
	if (father == -1)
		rootIndex = eraseInRoots(node);
	else if (father != -1) {
		int indexTemp = findInNodes(father);

		Node *temp = elements[indexTemp];
		while (temp->next != NULL && temp->next->val != node)
			temp = temp->next;
		if (temp != NULL)
			temp->next = temp->next->next;
		rootIndex = findInNodes(node);
	}

	Node *children = elements[rootIndex]->next;
	elements[rootIndex] = NULL;
	while (children != NULL) {
		int index = findInNodes(children->val);
		insertRoot(index, children->val);
		children = children->next;
	}
}
void Forest::insertRootEdge(int father, int node) {
	eraseInRoots(node);
	int index = findInRoots(father);
	insertChild_Index(index, node);
}
void Forest::display() {
	Root *tempR = roots;
	while (tempR != NULL) {
		queue<Node*> q;
		int index = tempR->index;
		int XOR = elements[index]->val;
		if (elements[index]->next != NULL)
			q.push(elements[index]->next);

		while (!q.empty()) {
			Node *temp = q.front();
			q.pop();
			XOR ^= temp->val;
			int childIndex = findInNodes(temp->val);
			if (temp->next != NULL)
				q.push(temp->next);
			if (elements[childIndex]->next != NULL)
				q.push(elements[childIndex]->next);
		}

		cout << XOR << " ";
		tempR = tempR->next;
	}
	cout << endl;
}
//for test
void Forest::display2() {
	cout << "Roots: index,val " << endl;
	Root *temp1 = roots;
	while (temp1 != NULL) {
		cout << temp1->index << "," << temp1->val << "  ";
		temp1 = temp1->next;
	}
	cout << endl;

	cout << "elements: val +children " << endl;
	for (int i = 0; i < arrayLength; i++) {
		if (elements[i] == NULL)
			continue;
		cout << elements[i]->val << ": ";
		Node *temp2 = elements[i]->next;
		while (temp2 != NULL) {
			cout << temp2->val << "  ";
			temp2 = temp2->next;
		}
		cout << endl;
	}
	cout << "		test over";
}
//构造二叉树搜索
binaryTreeNode* search(binaryTreeNode* root, int val) {
	queue<binaryTreeNode*> q;
	q.push(root);
	while (!q.empty()) {
		binaryTreeNode *temp = q.front();
		q.pop();
		if (temp->element == val)
			return temp;

		if (temp->leftChild != NULL)
			q.push(temp->leftChild);
		if (temp->rightChild != NULL)
			q.push(temp->rightChild);
	}
	return NULL;
}
binaryTreeNode* Forest::toBinaryTree() {
	binaryTreeNode *binaryTreeRoot = new binaryTreeNode(roots->val); //将要返回的二叉树根
	//先处理根节点
	binaryTreeNode *rootTemp = binaryTreeRoot;
	Root *temp = roots->next;
	while (temp != NULL) {
		rootTemp->rightChild = new binaryTreeNode(temp->val);
		rootTemp = rootTemp->rightChild;
		temp = temp->next;
	}

	//处理孩子链表的元素，q是各链的右孩子（兄弟链表）
	queue<binaryTreeNode*> q;
	for (int i = 0; i < arrayLength; i++) {
		if (elements[i] != NULL) {
			//制造一个节点，将在childrenRoot的左孩子链
			binaryTreeNode *childrenRoot = new binaryTreeNode(elements[i]->val);
			//处理孩子们
			Node *childrenTemp = elements[i]->next; //依次处理每一个孩子
			//ttt是要链在左孩子链上的头；childrenRootTemp是顺着这个链向右孩子链兄弟
			binaryTreeNode *childrenRootTemp = NULL, *ttt = NULL;
			while (childrenTemp != NULL) {
				binaryTreeNode *temp2 = new binaryTreeNode(childrenTemp->val);
				if (ttt == NULL) {
					childrenRootTemp = temp2;
					ttt = childrenRootTemp;
				}
				else {
					childrenRootTemp->rightChild = temp2;
					childrenRootTemp = childrenRootTemp->rightChild;
				}
				childrenTemp = childrenTemp->next;
			}
			childrenRoot->leftChild = ttt;
			q.push(childrenRoot);
		}
	}

	while (!q.empty()) {
		binaryTreeNode *temp3 = q.front();
		q.pop();
		binaryTreeNode *insertTemp = search(binaryTreeRoot, temp3->element);
		if (insertTemp != NULL) {
			insertTemp->leftChild = temp3->leftChild;
		}
		else
			q.push(temp3);
	}
	return binaryTreeRoot;
}


//二叉树
class BinaryTree {
private:
	binaryTreeNode *root;
	int size;

public:
	BinaryTree(){
		root = NULL;
		size = 0;
	}
	void init_val(int rootVal, int s) {
		root = new binaryTreeNode(rootVal);
		size = s;
	}
	void init_transFromForest(binaryTreeNode *r) {
		root = r;
	}

	binaryTreeNode* find(int val);

	void preOrder();
	void initialize(queue<initNode> q);
	void insert(int pos, int father, int node);
	Forest toForest();
};
binaryTreeNode* BinaryTree::find(int val) {
	queue<binaryTreeNode*> q;
	q.push(root);
	while (!q.empty()) {
		binaryTreeNode *temp = q.front();
		q.pop();
		if (temp->element == val)
			return temp;
		
		if (temp->leftChild != NULL)
			q.push(temp->leftChild);
		if (temp->rightChild != NULL)
			q.push(temp->rightChild);
	}
	return NULL;
}
void pre(binaryTreeNode *root, int *XOR) {
	if (root != NULL) {
		*XOR ^= root->element;
		pre(root->leftChild, XOR);
		pre(root->rightChild, XOR);
	}
}
void BinaryTree::preOrder() {
	int XOR = 0;
	pre(root,&XOR);
	cout << XOR << endl;
}
void BinaryTree::initialize(queue<initNode> q) {
	while (!q.empty()) {
		initNode node = q.front();
		q.pop();
		binaryTreeNode *temp = find(node.A);
		if (temp != NULL) {
			if (node.l != -1) {
				binaryTreeNode *leftTemp = new binaryTreeNode(node.l);
				temp->leftChild = leftTemp;
			}
			else if (node.l == -1)
				temp->leftChild = NULL;

			if (node.r != -1) {
				binaryTreeNode *rightTemp = new binaryTreeNode(node.r);
				temp->rightChild = rightTemp;
			}
			else if (node.r == -1)
				temp->rightChild = NULL;

			size++;
		}
		else if (temp == NULL)
			q.push(node);
	}
}
void BinaryTree::insert(int pos, int father, int node) {
	binaryTreeNode *temp = find(father);
	binaryTreeNode *child = new binaryTreeNode(node);
	if (pos == 0)
		temp->rightChild = child;
	else if (pos == 1)
		temp->leftChild = child;
	size++;
}

void form(binaryTreeNode *root, Forest &forest) {
	if (root != NULL) {
		//cout << root->element << " ";
		int index = forest.findInNodes(root->element);
		if (index == -1)
			index = forest.insertNode(root->element);
		//cout << index << "; ";
		binaryTreeNode *childTemp = root->leftChild;
		while (childTemp != NULL) {
			forest.insertChild_Index(index, childTemp->element);
			childTemp = childTemp->rightChild;
		}
		form(root->leftChild, forest);
		form(root->rightChild, forest);
	}
}
Forest BinaryTree::toForest() {
	Forest forest;
	forest.init_val(0, 0);

	//初始化森林的树根
	binaryTreeNode *tempOfRoot = root;
	while (tempOfRoot != NULL) {
		forest.initializeRoot(tempOfRoot->element);
		tempOfRoot = tempOfRoot->rightChild;
	}
	//cout << "======" << endl;
	form(root, forest);
	//cout << "======" << endl;
	//cout << ":::::::";
	//forest.display2();
	//cout << "::::::";
	return forest;
}



int main(void){
	Forest forest;
	BinaryTree binaryTree;

	int K, M, N;
	cin >> K >> M >> N;

	if (K == 0)
		forest.init_val(M, N);
	for (int i = 0; i < M; i++) {
		int temp;
		cin >> temp;
		if (K == 0)
			forest.initializeRoot(temp);
		else if (K == 1)
			binaryTree.init_val(temp, N);
	}

	queue<initNode> q;
	for (int i = 0; i < N; i++) {
		//初始化森林
		if (K == 0) {
			int A, B;
			cin >> A >> B;
			int *rootTemp = new int[B];
			for (int j = 0; j < B; j++)
				cin >> rootTemp[j];
			forest.initialize(A, B, rootTemp);
		}
		//初始化二叉树
		else if (K == 1) {
			int A, l, r;
			cin >> A >> l >> r;
			q.push(initNode(A, l, r));
		}
	}
	if (K == 1)
		binaryTree.initialize(q);

	int Q;
	cin >> Q;
	for (int i = 0; i < Q; i++) {
		int op;
		cin >> op;
		//森林插入节点
		if (op == 1) {
			int father, node;
			cin >> father >> node;
			forest.insertChild(father, node);
		}
		//森林删除节点
		else if (op == 2) {
			int father, node;
			cin >> father >> node;
			forest.eraseNode(father, node);
		}
		//在森林根节点插入边
		else if (op == 3) {
			int a, b;
			cin >> a >> b;
			forest.insertRootEdge(a, b);
		}
		//森林二叉树转换
		else if (op == 4) {
			if (K == 0) {
				binaryTreeNode *bn = forest.toBinaryTree();
				binaryTree.init_transFromForest(bn);
			}
			else if (K == 1) {
				forest = binaryTree.toForest();
			}
			K = 1 - K; //类型转换
		}
		//二叉树插入节点
		else if (op == 5) {
			int pos, father, node;
			cin >> pos >> father >> node;
			binaryTree.insert(pos, father, node);
		}
		//显示森林/二叉树
		else if (op == 6) {
			if (K == 0)
				forest.display();
			else if (K == 1)
				binaryTree.preOrder();
		}

	}

	system("pause");
	return 0;
}
Zih_An
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
森林与二叉树的转换
qq_36415932的博客
08-04 2775
什么是森林？ 森林是多棵互不相交的树组成的集合。 森林要转换成二叉树，首先需要学会如何将树转换成二叉树。 树转换成二叉树 1.加线：所有兄弟结点之间加一条线； 2.去线：树中每一个结点，只保留与最左边孩子结点的连线，去掉所有与其他结点的连线； 3.旋转：以根节点为轴心，将树顺时针旋转一定角度，使其结构分明。 森林转换成二叉树 1.先将森林里的每一棵树转换成二叉树； 2.森...
树、森林与二叉树的转换
热门推荐
CSDN
12-30 15万+
树、森林与二叉树的转换 1、树转换为二叉树 由于二叉树是有序的，为了避免混淆，对于无序树，我们约定树中的每个结点的孩子结点按从左到右的顺序进行编号。 将树转换成二叉树的步骤是： （1）加线。就是在所有兄弟结点之间加一条连线； （2）抹线。就是对树中的每个结点，只保留他与第一个孩子结点之间的连线，删除它与其它孩子结点之间的连线； （3）旋转。就是以树的根结点为轴心，将整棵树顺时针旋转一定...
树、森林与二叉树相互转化原理图
ZD的博客
04-07 4万+
1、树转换为二叉树 由于二叉树是有序的，为了避免混淆，对于无序树，我们约定树中的每个结点的孩子结点按从左到右的顺序进行编号。 将树转换成二叉树的步骤是： （1）加线。就是在所有兄弟结点之间加一条连线； （2）抹线。就是对树中的每个结点，只保留他与第一个孩子结点之间的连线，删除它与其它孩子结点之间的连线； （3）旋转。就是以树的根结点为轴心，将整棵树顺时针旋转一定角度，使之结构层次分明。
树、森林和二叉树之间的转换
iw1210的专栏
04-08 1万+
树、森林和二叉树之间的转换   树转换为二叉树 1. 加线      在所有兄弟结点之间加一条连线。 2. 去线      树中的每个结点，只保留它与第一个孩子结点的连线，删除它与其它孩子结点之间的连线。 3. 层次调整     以树的根节点为轴心，将整棵树顺时针旋转一定角度，使之结构层次分明。（注意第一个孩子是结点的左孩子，兄弟转换过来的孩子是结点的右孩子） 森林转换为
（转载）树、森林与二叉树的转换
weixin_30325071的博客
12-07 125
传送门 树、森林与二叉树的转换 1、树转换为二叉树 由于二叉树是有序的，为了避免混淆，对于无序树，我们约定树中的每个结点的孩子结点按从左到右的顺序进行编号。 将树转换成二叉树的步骤是： 加线。就是在所有兄弟结点之间加一条连线； 抹线。就是对树中的每个结点，只保留他与第一个孩子结点之间的连线，删除它与其它孩子结点之间的连线； 旋转。就是以树的根结点为轴心，将整棵树顺时针旋转一定...
树的存储结构、森林及与二叉树的转换
11-26
从二叉树转换回森林的过程是上述过程的逆过程。主要步骤如下： 1. **确定根节点**：找到二叉树的根节点。 2. **分离子树**：从根节点开始，对于每一个节点，将其右子节点看作下一颗树的第一个节点，然后继续遍历。 ...
森林与二叉树的转换.pptx
11-15
森林与二叉树的转换.pptx
森林转换成二叉树
11-03
### 森林转换成二叉树：C语言实现的数据结构算法详解 #### 知识点一：数据结构定义 在本段代码中，我们首先遇到了三种数据结构的定义： 1. **`CTreeNode`**: 表示森林中的树节点。每个节点包含一个字符型数据`...
森林和二叉树的转换
bigbigfans的专栏
08-02 2060
       树是一种数据结构，而二叉树是树的最重要的一种。所有的树都可以找到一棵为一对应的二叉树。而从物理储存结构来说，它们的二叉链表是相同的，只是解释的角度不同。        一、森林转换为树        如果F={T1,T2,...,Tn}是森林，按如下的规则转换为一棵二叉树B={root,LB,RB}。       (1)若F为空，即m=0，则B为空树。       (2)若F非空，即
数据结构——树、森林与二叉树的转换
jiashuai94的博客
06-21 5543
在介绍树的存储结构时，就说到了树的孩子兄弟表示法可以将一棵树用二叉链表进行存储，所以借助二叉链表，树和二叉树可以互相转换。从物理结构上来看，它们的二叉链表也是相同的，只是介绍不太一样而已。因此，只要我们设定一定的规则，用二叉树来表示树，甚至表示森林都是可以的，森林和二叉树也可以互相进行转换。 树转换为二叉树 将树转换为二叉树的步骤如下： 加线：在所有的兄弟结点之间加一条连线； 去线：对树中...
森林和二叉树的转化
qq_25666829的博客
08-10 402
http://www.cnblogs.com/zhuyf87/archive/2012/11/04/2753950.html详解地址 将一个森林转化为二叉树，森林也就是非二叉树，父节点下不止有两个子节点 转化步骤 1.在所有兄弟节点之间加一条线。 2.将除了左孩子之外的线全部去除 3.以根节点为轴心，顺时针旋转（注意第一个孩子是节点的左孩子，兄弟转换过来的
【专题】森林和二叉树的转换
最新发布
qq_42340716的博客
12-12 4031
森林和二叉树的转换
树 —— 森林与二叉树的转换
starter_____的博客
05-29 2172
森林转换为二叉树 （1）转换：把每棵树转换为二叉树。 （2）连接：第一棵二叉树不动，从第二棵二叉树开始，依次把后一棵二叉树的根结点作为前一棵二叉树的根结点的右孩子，用线连接起来。 （3）旋转 二叉树转换为森林 （1）逆旋转 （2）抹线：从根结点开始，依次抹掉结点与右孩子的连线，直到结点没有右孩子为止 （3）转换：将树转换成二叉树（也可以省略该步骤） ...
数据结构之树(五)——森林与二叉树的转换
daocaoren_的博客
08-04 6702
森林转换成二叉树 转换方法： 1.将各棵树分别转换成二叉树。 2.将将每棵树的根结点用线相连。 3.以第一棵树的根结点为二叉树的根，再以根结点为轴心，顺时针旋转，形成二叉树型结构。 即，树变二叉根相连 转换过程： 将下图的森林转换成二叉树 1.将每棵树都变成二叉树。 2.将每棵树的根都连接在一起。 3.只留第一个根(A)，其余根绕A旋转，形成二叉树。 二叉树转换成森...
众树成森——森林与二叉树的转换、树与二叉树的转换、树和森林的遍历
diviner_s的博客
04-25 558
树与二叉树的转换 将树转化为二叉树进行处理，利用二叉树的算法来实现对树的操作。 由于树和二叉树都可以用二叉链表作存储结构，则 以二叉链表作媒介可以导出树与二叉树之间的一个对应关系。 由下图我们可以发现树和二叉树都可以相同的存储结构表示 树????二叉树 ①加线：在兄弟之间加一连线 ②抹线：对每个结点，除了其左孩子外，去除其与其余孩子之间的关系 ③旋转：以树的根结点为轴心，将整树顺时针转45° 树...
数据结构-树-树、森林与二叉树的转换
suxiaorui的博客
08-07 979
树、森林与二叉树的转换 树转换成二叉树 步骤： 加线。在所有兄弟结点之间加一条连线。 去线。对树中每个结点，只保留它与第一个孩子结点的连线，删除它与其它孩子结点之间的连线。 层次调整，以树的根结点为轴心，将整棵树顺时针旋转一定的角度，使之结构层次分明。注意第一个孩子是二叉树结点的左孩子，兄弟转换过来的孩子是结点的右孩子。 森林转换为二叉树 森林是由若干棵树组成的，可以认为，森林中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值