把二元查找树转变成排序的双向链表

把二元查找树转变成排序的双向链表

 题目：

输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。

  10
  / /
 6 14
 / / / /
4 8 12 16
   
  转换成双向链表
4=6=8=10=12=14=16 。
   
  首先我们定义的二元查找树 节点的数据结构如下：
 struct BSTreeNode
{
  int m_nValue; // value of node
  BSTreeNode *m_pLeft; // left child of node
  BSTreeNode *m_pRight; // right child of node

};

主函数如下：

#include <iostream>
#include "BST.h"

using namespace std;
//将二元查找树转变成双向链表


int main()
{
	int data[]={10,6,14,4,8,12,16};
	int num=7;

	struct BSTreeNode *Root=NULL;
	BSTree tp1;

	struct ListNode *lroot;

	//二元查找树的建立
	Root=tp1.buildBSTree(Root,data,num);
    //显示
	std::cout<<"前序遍历:"<<std::endl;
	tp1.BSTreeNodePrint_midfirst(Root);

	std::cout<<"中序遍历:"<<std::endl;
	tp1.BSTreeNodePrint_leftfirst(Root);

	std::cout<<"后序遍历:"<<std::endl;
	tp1.BSTreeNodePrint_rightfirst(Root);

	//按中序遍历的顺序将二元查找树转换成双向链表
	lroot=BSTreeToList(Root);
	//显示链表中的内容
	std::cout<<"链表显示："<<std::endl;
	ListNodePrint(lroot);
	return 1;
}

BST.h

#ifndef _BST_H_
#define _BST_H_

#include <iostream>

struct BSTreeNode
{
	int m_nValue; // value of node
	BSTreeNode *m_pLeft; // left child of node
	BSTreeNode *m_pRight; // right child of node
};

struct ListNode
{
	int data;
	ListNode *m_left;
	ListNode *m_right;
};

class BSTree{
public:
	BSTreeNode *buildBSTree(BSTreeNode *root,int *data,int num);
	BSTreeNode *BSTreeDelete(BSTreeNode *root,int *data,int num);
	void BSTreeNodePrint_leftfirst(BSTreeNode *root);
	void BSTreeNodePrint_midfirst(BSTreeNode *root);
	void BSTreeNodePrint_rightfirst(BSTreeNode *root);
};

struct ListNode *BSTreeToList(BSTreeNode *root);
void BSTreeListSearch(BSTreeNode *root,ListNode **lroot,ListNode **currentListNode,int &m);
void ListNodePrint(ListNode *head);

#endif

BST.cpp

#include "BST.h"

BSTreeNode *BSTree::buildBSTree(BSTreeNode *root,int *data,int num)
{
	for(int i=0;i<num;i++)
	{
		BSTreeNode *z=(struct BSTreeNode*)malloc(sizeof(struct BSTreeNode));//结构体指针需要初始化

		z->m_nValue=*(data+i);//initialize new node
		z->m_pLeft=NULL;
		z->m_pRight=NULL;

		BSTreeNode *y=NULL;
		BSTreeNode *x=root;
		while(x!=NULL)
		{
			y=x;
			if (z->m_nValue<x->m_nValue)
			{
				x=x->m_pLeft;
			}
			else
			{
				x=x->m_pRight;
			}
		}
		if (y==NULL)
		{
			root=z;
		}
		else if (z->m_nValue<y->m_nValue)
		{
			y->m_pLeft=z;
		}
		else
		{
			y->m_pRight=z;
		}
	}
	return root;
}


void BSTreeListSearch(BSTreeNode *root,ListNode **lroot,ListNode **currentListNode,int &m)//
{	
	BSTreeNode *currentNode=root;
	if(root!=NULL)
	{
		ListNode *zp=(struct ListNode*)malloc(sizeof(struct ListNode));

		if (currentNode->m_pLeft!=NULL)
		{
			BSTreeListSearch(currentNode->m_pLeft,lroot,currentListNode,m);
		}

		m++;//通过m判断是否为双向链表的第一个元素
		//将该节点加入到链表中
		zp->data=currentNode->m_nValue;
		zp->m_left=*currentListNode;		
		zp->m_right=NULL;
		if (m!=1)
		{
			(*currentListNode)->m_right=zp;
		}

		//更新链表中当前节点
		*currentListNode=zp;

		if(m==1)
		{
			*lroot=*currentListNode;
		}

		if (currentNode->m_pRight!=NULL)
		{
			BSTreeListSearch(currentNode->m_pRight,lroot,currentListNode,m);
		}
		
	}
}

struct ListNode *BSTreeToList(BSTreeNode *root)
{
	ListNode *P=NULL;
	ListNode *Q=NULL;//保证链表头结点的左向指针为空
	ListNode **currentListNode=&Q;
	ListNode **lroot=&P;
	int m=0;
	BSTreeListSearch(root,lroot,currentListNode,m);
	return *lroot;
}

void ListNodePrint(ListNode *head)
{
	while(head !=NULL)
	{
		std::cout<<head->data<<std::endl;
		head=head->m_right;
	}
}

void BSTree::BSTreeNodePrint_leftfirst(BSTreeNode *root)//左根右，中序遍历
{
	BSTreeNode *currentNode=root;
	if(root!=NULL)
	{
		if (currentNode->m_pLeft!=NULL)
		{
			BSTreeNodePrint_leftfirst(currentNode->m_pLeft);
		}
		std::cout<<currentNode->m_nValue<<std::endl;
		if (currentNode->m_pRight!=NULL)
		{
			BSTreeNodePrint_leftfirst(currentNode->m_pRight);
		}
	}
}

void BSTree::BSTreeNodePrint_midfirst(BSTreeNode *root)//根左右，前序遍历
{
	BSTreeNode *currentNode=root;
	if(currentNode!=NULL)
	{
		std::cout<<currentNode->m_nValue<<std::endl;
	}
	if (currentNode->m_pLeft!=NULL)
	{
		BSTreeNodePrint_midfirst(currentNode->m_pLeft);
	}
	if (currentNode->m_pRight!=NULL)
	{
		BSTreeNodePrint_midfirst(currentNode->m_pRight);
	}
}


void BSTree::BSTreeNodePrint_rightfirst(BSTreeNode *root)//左右根，后序遍历
{
	BSTreeNode *currentNode=root;
	if (root!=NULL)
	{
		if (currentNode->m_pLeft!=NULL)
		{
			BSTreeNodePrint_rightfirst(currentNode->m_pLeft);
		}
		if (currentNode->m_pRight!=NULL)
		{
			BSTreeNodePrint_rightfirst(currentNode->m_pRight);
		}
		std::cout<<currentNode->m_nValue<<std::endl;
	}
}

运行结果：