二叉搜索树（搜索二叉树）转换成一个双向链表

标签：

1.题目描述：

将一个二叉搜索树转换成一个双向链表；

2.二叉搜索树，直接看图：

如图就是一个二叉搜索树的模型，也就是转换函数的入口数据，也是下边函数中即将用到的例子，既然有输入，肯定有输出，先面在看一张图（第三条）：

3.输入输出模型：

右边就是最终的输出结果，5后边是空，下边来分析一下：

1.在二叉搜索树中，每个节点都有两个孩子，即左和右，而在双向链表中，每个节点也有两个指针，前驱和后继指针，二叉树和双向链表很有相似性；

2.改变二叉搜索树的左右孩子指针指向，就可完成二叉搜索树到双向链表的转换；

3.由于最终双向链表的遍历结果就是二叉搜索树中序的遍历结果；

4.开始中序线索化二叉树（即改变二叉树指针指向）

如果对中序线索化二叉树还有疑问，请看下图：

如图叶子节点的左右孩子指针指向都按中序线索的方式改变了；

4.看代码说话：

第一部分：

首先需要保存最后双向链表的头，即二叉树的最左节点：

Node* _BinaryToDoubleList(Node* root)
	{
		//1.找到双向链表的头；
		Node* head = root;
		while(head->_left != nullptr)
		{
			head = head->_left;
		}

		Node* prev = nullptr;
		_Change(root,prev);    //转换函数

		return head;
	}

转换函数：一个递归过程，按照中序线索化走的

	void _Change(Node* cur,Node*& prev)
	{
		if (cur == nullptr)
			return;
		//1.找到最左边
		_Change(cur->_left,prev);
		cur->_left = prev;  //此时prev为空

		if (prev != nullptr)
			prev->_right = cur;

		prev = cur;

		_Change(cur->_right, prev);
	}

#pragma once

template<class K, class V>
struct SBTNode
{
	K key;
	V value;

	SBTNode<K, V> *_left;
	SBTNode<K, V> *_right;

	SBTNode(const K& key, const V& value)
		:key(key)
		, value(value)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

template<class K, class V>
class SBTree
{
	typedef SBTNode<K, V> Node;
public:
	SBTree()
		:_root(nullptr)
	{}

	~SBTree()
	{}

public:
	//非递归插入
	bool Insert(const K& key, const V& value)
	{
		return _Insert(key, value);
	}

	//递归插入
	bool Insert_R(const K& key, const V& value);

	//非递归查找节点
	SBTNode<K, V>* Find(const K& key)
	{
		if (_root == nullptr)
		{
			return nullptr;
		}

		SBTNode<K, V> *cur = _root;
		while (cur->_left || cur->_right)
		{
			if (cur->key == key)
			{
				return cur;
			}
			else if (cur->key > key)
			{
				cur = cur->_left;
			}
			else if (cur->key < key)
			{
				cur = cur->_right;
			}
			else
			{
				return nullptr;
			}
		}
	}

	bool _Insert(const K& key, const V& value)
	{
		if (_root == nullptr)
		{
			_root = new SBTNode<K, V>(key, value);
			return true;
		}

		SBTNode<K, V> *parent = nullptr; //指向cur 的前驱
		SBTNode<K, V> *cur = _root;
		while (cur)
		{
			if (cur->key > key)  //插左边
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}

		if (parent->key < key)
		{
			SBTNode<K, V> *node = new SBTNode<K, V>(key, value);
			parent->_right = node;
			return true;
		}

		else if (parent->key > key)
		{
			SBTNode<K, V> *node = new SBTNode<K, V>(key, value);
			parent->_left = node;
			return true;
		}
		else
		{
			return false;
		}
	}

	Node* BinaryToDoubleList()
	{
		return _BinaryToDoubleList(_root);
	}

	Node* _BinaryToDoubleList(Node* root)
	{
		//1.找到双向链表的头；
		Node* head = root;
		while(head->_left != nullptr)
		{
			head = head->_left;
		}

		Node* prev = nullptr;
		_Change(root,prev);    //转换函数

		return head;
	}

	void _Change(Node* cur,Node*& prev)
	{
		if (cur == nullptr)
			return;
		//1.找到最左边
		_Change(cur->_left,prev);
		cur->_left = prev;  //此时prev为空

		if (prev != nullptr)
			prev->_right = cur;

		prev = cur;

		_Change(cur->_right, prev);
	}

	//中序遍历
	void InOrder(SBTNode<K, V>* root)
	{
		if (root == nullptr)
		{
			return; //递归结束出口
		}

		SBTNode<K, V> *cur = root;
		InOrder(cur->_left);
		cout << cur->key << " ";
		InOrder(cur->_right);
	}

	//顺序遍历双向链表
	void TreaveList()
	{
		Node* cur = BinaryToDoubleList();
		while (cur)
		{
			cout << cur->key<< " ";
			cur = cur->_right;
		}
		cout << endl;
	}

public:
	SBTNode<K, V> *_root;
};

二叉搜索树（搜索二叉树）转换成一个双向链表

标签：

原文地址：http://blog.csdn.net/li_ning_/article/details/51330259