数据结构-二叉树线索化迭代器（续上节）

最新推荐文章于 2026-01-06 17:38:45 发布

原创最新推荐文章于 2026-01-06 17:38:45 发布 · 354 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#二叉树线索化 #数据结构 #c++

数据结构专栏收录该内容

8 篇文章

订阅专栏

本文介绍了一种二叉树的线索化方法及其迭代器的实现过程。通过定义二叉树节点结构和使用模板类实现迭代器，使得能够高效地进行中序遍历。同时，还提供了构建二叉树、中序线索化等关键函数。

#pragma once

#include <iostream>

using namespace std;

enum Type
{
	LINK,  //指针指向的是一颗子树
	THREAD //指针指向的是线索化
};

template<typename T>
struct BinaryTreeThdNode    //二叉树的节点结构
{
	T _data;
	BinaryTreeThdNode* _left;
	BinaryTreeThdNode* _right;

	Type _left_type;
	Type _right_type;

	BinaryTreeThdNode(const T& data)
		:_data(data)
		, _left(NULL)
		, _right(NULL)
		, _left_type(LINK)
		, _right_type(LINK)
	{}
};

template <typename T,typename Ref, typename Ptr>  //中序Iterator   Ref和Ptr来实现const和非const迭代器的代码复用
class BinaryTreeThdIterator
{
	typedef BinaryTreeThdNode<T> Node;
	typedef BinaryTreeThdIterator<T, Ref, Ptr> Self;
public:
	BinaryTreeThdIterator(Node* node)
		:_node(node)
	{}
	
	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &(operator*());
	}

	Self operator++()
	{ 
		_node = _Next(_node);
		return *this;
	}

	Self operator++(int)
	{
		Self tmp(*this);
		_node = _Next(_node);
		return tmp;
	}
	Self operator--()
	{
		_node = _Prev(_node);
		return *this;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		_node = _Prev(_node);
		return tmp;
	}

	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}
	
	bool operator==(const Self& s)
	{
		return _node == s._node;
	}
protected:
	Node* _Next(Node* cur)
	{
		if (cur->_right_type == LINK)
		{
			cur = cur->_right;
			while (cur->_left_type == LINK)
			{
				cur = cur->_left;
			}
		}
		else
		{
			cur = cur->_right;
		}
		return cur;
	}

	Node* _Prev(Node* cur)
	{
		if (cur->_left_type == LINK)
		{
			cur = cur->_left;
			while (cur->_right_type == LINK)
			{
				cur = cur->_right;
			}
		}
		else
		{
			cur = cur->_left;
		}
		return cur;
	}
protected:
	Node *_node;
};

template <typename T>
class BinaryTreeThd    //二叉树的线索化
{
	typedef BinaryTreeThdNode<T> Node;
public:
	typedef BinaryTreeThdIterator<T, T&, T*> Iterator;
	typedef BinaryTreeThdIterator<T, const T&, const T*> ConstIterator;
public:
	BinaryTreeThd(T* a, size_t size, const T& invalid = T())
	{
		size_t index = 0;
		_root = _CreatTree(a, size, index, invalid);
	}


	void InOrderThreading() //中序线索化
	{
		Node* prev = NULL;
		_InOrderThreading(_root, prev);
		if (prev && prev->_right == NULL)
			prev->_right_type = THREAD;
	}

	Iterator Begin()  
	{
		Node* cur = _root;
		while (cur->_left_type == LINK)
		{
			cur = cur->_left;
		}

		return cur;
	}

	Iterator End()
	{
		return NULL;
	}	ConstIterator Begin()const
	{
		Node* cur = _root;
		while (cur->_left_type == LINK)
		{
			cur = cur->_left;
		}

		return cur;
	}

	ConstIterator End()const
	{
		return NULL;
	}


protected:
	Node* _CreatTree(T* a, size_t size, size_t& index, const T& invalid = T())
	{
		if (a[index] == invalid || index >= size)
			return NULL;

		Node* root = new Node(a[index]);
		root->_left = _CreatTree(a, size, ++index, invalid);
		root->_right = _CreatTree(a, size, ++index, invalid);

		return root;
	}

	void _InOrderThreading(Node* root, Node*& prev)
	{
		Node* cur = root;
		if (cur == NULL)
			return;

		_InOrderThreading(cur->_left, prev);

		if (cur->_left == NULL)
		{
			cur->_left = prev;
			cur->_left_type = THREAD;
		}

		if (prev && prev->_right == NULL)
		{
			prev->_right = cur;
			prev->_right_type = THREAD;
		}
		prev = cur;

		_InOrderThreading(cur->_right, prev);
	}
protected:
	Node* _root;
};