【数据结构】树

1.DS二叉树—二叉树构建与遍历（不含框架）

#include <iostream>
using namespace std;

struct Tree{
	char data;
	Tree *left,*right;
};

class BTree{
	Tree* root;
	void Build_Tree(Tree* &p){
		p=new Tree;
		char t;
		cin>>t;
		if(t=='#'){
			p=NULL;
			return;
		}
		p->data=t;
		Build_Tree(p->left);
		Build_Tree(p->right); 
	}
	void Pre_order(Tree* p){
		if(p==NULL)	return;
		cout<<p->data;
		Pre_order(p->left);
		Pre_order(p->right);
	}
	void In_order(Tree* p){
		if(p==NULL)	return;
		In_order(p->left);
		cout<<p->data;
		In_order(p->right);
	}
	void Post_order(Tree* p){
		if(p==NULL)	return;
		Post_order(p->left);
		Post_order(p->right);
		cout<<p->data;
	}
public:
	BTree(){
		root=NULL;
	}
	void Build_Tree(){
		Build_Tree(root);
	}
	void Pre_order(){
		Pre_order(root);
		cout<<endl;
	}
	void In_order(){
		In_order(root);
		cout<<endl;
	}
	void Post_order(){
		Post_order(root);
		cout<<endl;
	}
};

int main(){
	//freopen("d:\\in.txt","r",stdin);
	int T;
	cin>>T;
	while(T--){
		BTree t;
		t.Build_Tree();
		t.Pre_order();
		t.In_order();
		t.Post_order();
	}
	return 0;
}

2.DS二叉树——二叉树之数组存储

#include <iostream>
using namespace std;

class BTree{
	int* Tree;
	int n;
public:
	BTree(){
		cin>>n;
		Tree=new int[n+1];
		for(int i=1;i<=n;i++)
			cin>>Tree[i];
	}
	void Pre_order(int i){
		if(i>n||Tree[i]==0)	return;
		cout<<Tree[i]<<" ";
		Pre_order(i*2);
		Pre_order(i*2+1);
	}
	void In_order(int i){
		if(i>n||Tree[i]==0)	return;	
		Pre_order(i*2);
		cout<<Tree[i]<<" ";
		Pre_order(i*2+1);
	}
	void Post_order(int i){
		if(i>n||Tree[i]==0)	return;	
		Pre_order(i*2);
		Pre_order(i*2+1);
		cout<<Tree[i]<<" ";
	}
};

int main(){
//	freopen("d:\\in.txt","r",stdin);
	int T;
	cin>>T;
	while(T--){
		BTree t;
		t.Pre_order(1);
		cout<<endl;
	}
	return 0;
}

3.DS二叉树–叶子数量

#include <iostream>
using namespace std;

struct Tree{
	char data;
	Tree *left,*right;
};

class BTree{
	Tree* root;
	void Build_Tree(Tree* &p){
		p=new Tree;
		char t;
		cin>>t;
		if(t=='0'){
			p=NULL;
			return;
		}
		p->data=t;
		Build_Tree(p->left);
		Build_Tree(p->right); 
	}
	int Pre_order(Tree* p){
		int ans=0;
		if(p==NULL)	return 0;
	//	cout<<p->data;
		if(p->left==NULL&&p->right==NULL){
			return 1;
		}
		ans+=Pre_order(p->left);
		ans+=Pre_order(p->right);
		return ans;
	}
	void In_order(Tree* p){
		if(p==NULL)	return;
		In_order(p->left);
		cout<<p->data;
		In_order(p->right);
	}
	void Post_order(Tree* p){
		if(p==NULL)	return;
		Post_order(p->left);
		Post_order(p->right);
		cout<<p->data;
	}
public:
	BTree(){
		root=NULL;
	}
	void Build_Tree(){
		Build_Tree(root);
	}
	int Pre_order(){
		cout<<Pre_order(root);
		cout<<endl;
	}
	void In_order(){
		In_order(root);
		cout<<endl;
	}
	void Post_order(){
		Post_order(root);
		cout<<endl;
	}
};

int main(){
//	freopen("d:\\in.txt","r",stdin);
	int T;
	cin>>T;
	while(T--){
		BTree t;
		t.Build_Tree();
		t.Pre_order();
	}
	return 0;
}

4. DS二叉树–左叶子数量

#include <iostream>
using namespace std;

struct Tree{
	char data;
	Tree *left,*right;
};

class BTree{
	Tree* root;
	void Build_Tree(Tree* &p){
		p=new Tree;
		char t;
		cin>>t;
		if(t=='0'){
			p=NULL;
			return;
		}
		p->data=t;
		Build_Tree(p->left);
		Build_Tree(p->right); 
	}
	int Pre_order(Tree* p){
		int ans=0;
		if(p==NULL)	return 0;
	//	cout<<p->data;
		if(p->left!=NULL)
			if((p->left->left==NULL&&p->left->right==NULL)){
				ans++;
				ans+=Pre_order(p->right);
				return ans;
			}
		ans+=Pre_order(p->left);
		ans+=Pre_order(p->right);
		return ans;
	}
	void In_order(Tree* p){
		if(p==NULL)	return;
		In_order(p->left);
		cout<<p->data;
		In_order(p->right);
	}
	void Post_order(Tree* p){
		if(p==NULL)	return;
		Post_order(p->left);
		Post_order(p->right);
		cout<<p->data;
	}
public:
	BTree(){
		root=NULL;
	}
	void Build_Tree(){
		Build_Tree(root);
	}
	int Pre_order(){
		cout<<Pre_order(root);
		cout<<endl;
	}
	void In_order(){
		In_order(root);
		cout<<endl;
	}
	void Post_order(){
		Post_order(root);
		cout<<endl;
	}
};

int main(){
	//freopen("d:\\in.txt","r",stdin);
	int T;
	cin>>T;
	while(T--){
		BTree t;
		t.Build_Tree();
		t.Pre_order();
	}
	return 0;
}

5.DS二叉树–层次遍历

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

struct Tree{
	char data;
	Tree *left,*right;
};

class BTree{
	Tree* root;
	void Build_Tree(Tree* &p){
		p=new Tree;
		char t;
		cin>>t;
		if(t=='0'){
			p=NULL;
			return;
		}
		p->data=t;
		Build_Tree(p->left);
		Build_Tree(p->right); 
	}
	void Pre_order(Tree* p){
		if(p==NULL)	return;
		queue<Tree*>q;
		q.push(p);
		while(q.size()){
			auto t=q.front();
			q.pop();
			cout<<t->data;
			if(t->left!=NULL)	q.push(t->left);
			if(t->right!=NULL)	q.push(t->right);
		}
	}
	void In_order(Tree* p){
		if(p==NULL)	return;
		In_order(p->left);
		cout<<p->data;
		In_order(p->right);
	}
	void Post_order(Tree* p){
		if(p==NULL)	return;
		Post_order(p->left);
		Post_order(p->right);
		cout<<p->data;
	}
public:
	BTree(){
		root=NULL;
	}
	void Build_Tree(){
		Build_Tree(root);
	}
	void Pre_order(){
		Pre_order(root);
		cout<<endl;
	}
	void In_order(){
		In_order(root);
		cout<<endl;
	}
	void Post_order(){
		Post_order(root);
		cout<<endl;
	}
};

int main(){
	//freopen("d:\\in.txt","r",stdin);
	int T;
	cin>>T;
	while(T--){
		BTree t;
		t.Build_Tree();
		t.Pre_order();
	}
	return 0;
}

6.DS二叉树–后序遍历非递归算法

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

struct Tree{
	char data;
	int flag;
	Tree *left,*right;
};

class BTree{
	Tree* root;
	void Build_Tree(Tree* &p){
		p=new Tree;
		char t;
		cin>>t;
		if(t=='0'){
			p=NULL;
			return;
		}
		p->data=t;
		Build_Tree(p->left);
		Build_Tree(p->right); 
	}
	int Pre_order(Tree* p){
		int ans=0;
		if(p==NULL)	return 0;
	//	cout<<p->data;
		if(p->left!=NULL)
			if((p->left->left==NULL&&p->left->right==NULL)){
				ans++;
				ans+=Pre_order(p->right);
				return ans;
			}
		ans+=Pre_order(p->left);
		ans+=Pre_order(p->right);
		return ans;
	}
	void In_order(Tree* p){
		if(p==NULL)	return;
		In_order(p->left);
		cout<<p->data;
		In_order(p->right);
	}
	void Post_order(Tree* p){
		stack<Tree*>stk;
		Tree* t=p;
		while(t!=NULL||stk.size()){
			if(t!=NULL){
				t->flag=1;
				stk.push(t);
				t=t->left;
			}
			else{
				t=stk.top();
				stk.pop();
				if(t->flag==1){
					t->flag=2;
					stk.push(t);
					t=t->right;
				}
				else{
					cout<<t->data;
					t=NULL;
				}
			}
		}
	}
public:
	BTree(){
		root=NULL;
	}
	void Build_Tree(){
		Build_Tree(root);
	}
	int Pre_order(){
		cout<<Pre_order(root);
		cout<<endl;
	}
	void In_order(){
		In_order(root);
		cout<<endl;
	}
	void Post_order(){
		Post_order(root);
		cout<<endl;
	}
};

int main(){
	freopen("d:\\in.txt","r",stdin);
	int T;
	cin>>T;
	while(T--){
		BTree t;
		t.Build_Tree();
		t.Post_order();
	}
	return 0;
}

7。DS二叉树——二叉树之父子结点

#include <iostream>
using namespace std;

struct Tree{
	char data;
	Tr
	ee *left,*right,*fa;
};

class BTree{
	Tree* root;
	void Build_Tree(Tree* &p,Tree* Parent){
		p=new Tree;
		char t;
		cin>>t;
		if(t=='0'){
			p=NULL;
			return;
		}
		p->data=t;
		p->fa=Parent;
		Build_Tree(p->left,p);
		Build_Tree(p->right,p); 
	}
	void Pre_order_son(Tree* p){
		if(p==NULL)	return ;
		if(p->left==NULL&&p->right==NULL){
			cout<<p->data<<" ";
			return;
		}
		Pre_order_son(p->left);
		Pre_order_son(p->right);
	}
	void Pre_order_fa(Tree* p){
		if(p==NULL)	return ;
		if(p->left==NULL&&p->right==NULL){
			cout<<p->fa->data<<" ";
			return;
		}
		Pre_order_fa(p->left);
		Pre_order_fa(p->right);
	}
	void In_order(Tree* p){
		if(p==NULL)	return;
		In_order(p->left);
		cout<<p->data;
		In_order(p->right);
	}
	void Post_order(Tree* p){
		if(p==NULL)	return;
		Post_order(p->left);
		Post_order(p->right);
		cout<<p->data;
	}

public:
	BTree(){
		root=NULL;
	}
	void Build_Tree(){
		Build_Tree(root,NULL);
	}
	void Pre_order_son(){
		Pre_order_son(root);
		cout<<endl;
	}
	void Pre_order_fa(){
		Pre_order_fa(root);
		cout<<endl;
	}
	void In_order(){
		In_order(root);
		cout<<endl;
	}

};

int main(){
//	freopen("d:\\in.txt","r",stdin);
	int T;
	cin>>T;
	while(T--){
		BTree t;
		t.Build_Tree();
		t.Pre_order_son();
		t.Pre_order_fa();
	}
	return 0;
}