前序中序、后序中序遍历创建二叉树，并检验是否是二叉搜索树，若是则转换为双向链表

本文链接：https://blog.youkuaiyun.com/GLaaDOS/article/details/122651458

本文介绍了一种根据前序、中序或后序序列构建二叉树的方法，并提供了将二叉搜索树转换为双向链表的功能。文章详细阐述了二叉树节点结构及构建流程，同时展示了如何通过递归方式构建二叉树并验证其是否符合二叉搜索树的条件。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

finalbst.h

//该程序的作用是根据所给的前序序列以及中序序列或者中序序列以及后序序列创建二叉树 
#include <iostream>
#include <vector>
using namespace std;
typedef int datatype;

struct node{
	datatype data;
	node *Lchild;
	node *Rchild;
	node *Rpar;		//右孩子的双亲节点 
	node *Lpar;		//左孩子的双亲节点 
	node *nxt;
	node *lst;
};

class BST{
	public:
		BST();
		void createpre(vector<datatype>&pre, vector<datatype>&mid); 		//1、该函数将元素按前序、中序储存在两个vector容器中 
		node* buildpre(vector<datatype>pre,vector<datatype>mid);			//2、调用1创建好的参数，创建二叉树 
		void createpos(vector<datatype>&pos,vector<datatype>&mid);			//3、该函数将元素按后序、中序序列存在两个vector容器中 
		node*buildpos(vector<datatype>pos, vector<datatype>mid);			//4、调用 3创建好的参数，创建二叉树 
		int printBST(node*curr);											//5、显示二叉树 
		bool ifBST();														//6、通过key的值判断二叉树是否是搜索树 
		node*returnroot();													//7、返回根节点 
		int JudgeBST(node*curr);											//8、判断是否是二叉搜索树，并给出key值 
		/*函数2配合函数1使用
		函数5配合函数7使用
		函数6配合函数8使用
		函数8配合函数7使用
		以上函数用来创建二叉树以及判断是否为二叉搜索树*/
		int convert(node*curr);											//7、将二叉搜索树转换为双向链表
		void printChain();										//8、显示双向链表 
	private:
		node*root;
		node*head;
		datatype rootdata;		//储存根节点的值 
		int size;		//树的节点数 
		int key;		//判断是否是BST 
};

finalbst.cpp

#include<iostream>
#include"finalbst.h"
using namespace std;

BST::BST(){
	root=new node();
	key = 1;		//初始化key值为1 
	head=new node();
	cout<<"初始化完成";
}

void BST::createpre(vector<datatype>&pre, vector<datatype>&mid){
	cout<<"输入前序序列,输入-1停止" <<endl; 
	datatype a;
	while(cin>>a&&a!=-1){
		pre.push_back(a); 
	}
	rootdata=pre[0]; 
	cout<<"输入中序序列，输入-1停止"<<endl;
	datatype b;
	while(cin>>b&&b!=-1){
		mid.push_back(b);
	}
}

node*BST::buildpre(vector<datatype>pre, vector<datatype>mid){
	size = pre.size();		//调用头文件vector.h中的函数返回当前容器的大小 
	if(size==0)	return NULL;
	node*curr;
	curr=new node();
	curr->data=pre[0];		//当前节点对应当前根节点 
	vector<datatype>Lpre, Rpre, Lmid, Rmid;
	if(curr->data==rootdata) root=curr;		//确定根节点 
	int currpos;		//记录当前节点在mid中的位置 
	for(int i=0;i<size;i++)
		if(mid[i]==pre[0]){
			currpos=i;
			break;
		}
	for(int i=0;i<size;i++){		//对左右子树的前中序列容器进行装填 
		if(i<currpos){
			Lpre.push_back(pre[i+1]);
			Lmid.push_back(mid[i]);
		}
		if(i>currpos){
			Rpre.push_back(pre[i]);
			Rmid.push_back(mid[i]);
		}
	}
	curr->Lchild=buildpre(Lpre, Lmid);		//布置当前节点的左右子树 
	curr->Rchild=buildpre(Rpre, Rmid);
	return curr;		//该函数返回的值是当前函数参数对应的根节点 
}

void BST::createpos(vector<datatype>&pos, vector<datatype>&mid){
	datatype a,b;
	cout<<"输入中序序列：(按-1停止)"<<endl;
	while(cin>>a&&a!=-1){
		mid.push_back(a);
	}
	cout<<"输入后序序列：（按-1停止）"<<endl;
	while(cin>>b&&b!=-1){
		pos.push_back(b);
	}
	size=pos.size();
	rootdata=pos[size-1];
	//cout<<rootdata;
}

node*BST::buildpos(vector<datatype>pos, vector<datatype>mid){
	size=pos.size();
	if(size==0) return NULL;
	node *curr;
	curr=new node();
	curr->data=pos[size-1];
	if(curr->data==rootdata) root=curr;
	int currpos=0;
	while(mid[currpos]!=curr->data){
		currpos++;
	}
	vector<datatype>Lpos, Lmid, Rpos, Rmid;
	for(int i=0;i<size;i++){
		if(i<currpos){
			Lpos.push_back(pos[i]);
			Lmid.push_back(mid[i]);
		}
		if(i>currpos){
			Rpos.push_back(pos[i-1]);
			Rmid.push_back(mid[i]);
		}
	}
	curr->Lchild=buildpos(Lpos, Lmid);
	curr->Rchild=buildpos(Rpos, Rmid);
	return curr;
}

int BST::printBST(node*curr){		//在该函数中布置双亲指针 
	if(curr==NULL) return 0;
	if(curr->Lchild!=NULL||curr->Rchild!=NULL)cout<<"根节点"<<curr->data<<endl;
	if(curr->Lchild!=NULL) {
		cout<<"左孩子"<<curr->Lchild->data<<endl;
		curr->Lchild->Lpar=curr;
	}
	if(curr->Rchild!=NULL){
		cout<<"右孩子"<<curr->Rchild->data<<endl<<endl; 
		curr->Rchild->Rpar=curr;
	} 
	printBST(curr->Lchild);
	printBST(curr->Rchild);
}

int BST::JudgeBST(node*curr){
	if(curr==NULL) return 0;
	if(curr->Lchild!=NULL&&curr->Rchild!=NULL)
			if(curr->Lchild->data>=curr->data||curr->Rchild->data<=curr->data){
				key=0;
				return 0;
			}
	else if(curr->Lchild!=NULL&&curr->Rchild==NULL)
		if(curr->Lchild->data>=curr->data){
			key = 0;
			return 0;
		}
	else if(curr->Rchild!=NULL&&curr->Lchild==NULL)
		if(curr->Rchild->data<=curr->data){
			key = 0;
			return 0;
		}
	
	JudgeBST(curr->Lchild);
	JudgeBST(curr->Rchild);
}

bool BST::ifBST(){
	if(key==1) return true;
	else return false;
}

node*BST::returnroot(){
	return root;
}

int BST::convert(node*curr){
	if(curr==NULL) return 0;
	//cout<<curr->data<<"  ";//测试 
	if(curr->Rchild==NULL&&curr->Lchild==NULL) return 0;
	if(curr==root){
		if(curr->Rchild!=NULL&&curr->Lchild!=NULL){
			curr->Lchild->nxt=curr;
			curr->lst=curr->Lchild;
			curr->nxt=curr->Rchild;
			curr->Rchild->lst=curr;
		}
		else if(curr->Rchild!=NULL&&curr->Lchild==NULL){
			curr->nxt=curr->Rchild;
			curr->Rchild->lst=curr;
		}
		else if(curr->Lchild!=NULL&&curr->Rchild==NULL){
			curr->Lchild->nxt=curr;
			curr->lst=curr->Lchild;
		}
	}
	else if(curr->Lpar!=NULL){
		if(curr->Rchild!=NULL&&curr->Lchild!=NULL){
			if(curr->lst!=NULL&&curr->lst->data<=curr->Lchild->data){
				curr->lst->nxt=curr->Lchild;
				curr->Lchild->lst=curr->lst;
			} 
			curr->nxt=curr->Rchild;
			curr->Rchild->lst=curr;
			curr->Rchild->nxt=curr->Lpar;
			curr->Lpar->lst=curr->Rchild;
			curr->Lchild->nxt=curr;
			curr->lst=curr->Lchild;
		}
		else if(curr->Rchild!=NULL&&curr->Lchild==NULL){
			curr->nxt=curr->Rchild;
			curr->Rchild->lst=curr;
			curr->Rchild->nxt=curr->Lpar;
			curr->Lpar->lst=curr->Rchild;
		}
		else if(curr->Rchild==NULL&&curr->Lchild!=NULL){
			if(curr->lst!=NULL&&curr->lst->data<=curr->Lchild->data){
				curr->lst->nxt=curr->Lchild;
				curr->Lchild->lst=curr->lst;
			} 
			curr->Lchild->nxt=curr;
			curr->lst=curr->Lchild;
		}
	}
	else if(curr->Rpar!=NULL){
		if(curr->Rchild!=NULL&&curr->Lchild!=NULL){
			if(curr->nxt!=NULL&&curr->nxt->data>=curr->Rchild->data){
				curr->Rchild->nxt=curr->nxt;
				curr->nxt->lst=curr->Rchild;
			}
			curr->nxt=curr->Rchild;
			curr->Rchild->lst=curr; 
			curr->Lchild->nxt=curr;
			curr->lst=curr->Lchild;
			curr->Rpar->nxt=curr->Lchild;
			curr->Lchild->lst=curr->Rpar;
			
		}
		else if(curr->Rchild==NULL&&curr->Lchild!=NULL){
			curr->Lchild->nxt=curr;
			curr->lst=curr->Lchild;
			curr->Rpar->nxt=curr->Lchild;
			curr->Lchild->lst=curr->Rpar;
		}
		else if(curr->Rchild!=NULL&&curr->Lchild==NULL){
			if(curr->nxt!=NULL&&curr->nxt->data>=curr->Rchild->data){
				curr->Rchild->nxt=curr->nxt;
				curr->nxt->lst=curr->Rchild;
			}
			curr->nxt=curr->Rchild;
			curr->Rchild->lst=curr;
		}
	}
	convert(curr->Lchild);
	convert(curr->Rchild);
}

void BST::printChain(){
	node *curr;
	curr=root;
	while(curr->lst!=NULL){
		//system("PAUSE");//测试 
		curr=curr->lst;
		//cout<<curr->data<<endl;//测试 
	}
	//cout<<root->lst<<endl;//测试 
	//cout<<root->data<<endl;//测试 
	while(curr!=NULL){
		//system("PAUSE");//测试 
		//cout<<curr<<":"<<curr->data<<"  ";//测试
		cout<<curr->data<<"  "; 
		curr=curr->nxt;
	} 
}

int main(){
	//前序：9 4 2 1 3 6 5 7 13 11 10 12 15 14 16
	//中序：1 2 3 4 5 6 7 9 10 11 12 13 14 15 16
	//前序：5 3 2 4 7 6 8 9
	//中序：2 3 4 5 6 7 8 9 
	BST use;
	cout<<"1、前序+中序	  2、后序+中序"<<endl;
	int a;
	cin>>a;
	if(a==1){
		vector<datatype>pre;
		vector<datatype>mid;
		use.createpre(pre, mid);
		use.buildpre(pre, mid);
	}
	else{
		vector<datatype>pos;
		vector<datatype>mid;
		use.createpos(pos, mid);
		use.buildpos(pos, mid);
	}
	use.printBST(use.returnroot());		//函数返回值作参数 
	use.JudgeBST(use.returnroot());		//判断是否是二叉搜索树，并为key赋值
	if(use.ifBST()==true){
		cout<<"是BST"<<endl<<"开始转换BST为双向链表"<<endl;
		use.convert(use.returnroot());
		cout<<"转换完成"<<endl<<"开始显示双链表"<<endl;
		use.printChain();
	}
	else cout<<"不是BST"<<endl;
	
	return 0;
}