树&二叉树

最新推荐文章于 2022-04-11 11:15:50 发布
原创 最新推荐文章于 2022-04-11 11:15:50 发布 · 260 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

奋斗关于树的概念：

a.节点：结点包含数据和指向其它节点的指针。

b.根节点：树第一个结点称为根节点。 

c.结点的度：结点拥有的子节点个数。

d.叶节点：没有子节点的节点(度为0)。 

e.父子节点：一个节点father指向另一个节点child，则child为孩子节点，father为父亲节点 。

f.兄弟节点：具有相同父节点的节点互为兄弟节点。

g.节点的祖先：从根节点开始到该节点所经的所有节点都可以称为该节点的祖先。

h.子孙：以某节点为根的子树中任一节点都称为该节点的子孙。

i.树的高度：树中距离根节点最远节点的路径长度。

奋斗关于二叉树:

     二叉树是一棵特殊的树，二叉树每个节点最多有两个孩子结点，分别称为左孩子和右孩子。 

奋斗满二叉树:高度为N的满二叉树有2^N - 1个节点的二叉树。 

奋斗完全二叉树: 若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左 边，这就是完全二叉树.（三种遍历）

奋斗奋斗奋斗二叉树的简单实现奋斗奋斗奋斗

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

template<class T>
struct BinaryTreeNode
{
	BinaryTreeNode<T>* _left;
	BinaryTreeNode<T>* _right;
	T _date;

	BinaryTreeNode(const T& x)
		:_date(x)
		, _left(NULL)
		, _right(NULL)
	{}
};

template<class T>
class BinaryTree
{
	typedef BinaryTreeNode<T> Node;
public:
	BinaryTree()
		:_root(NULL)
	{
		cout << "BinaryTree()" << endl;
	}
	BinaryTree(const T* a, size_t size, const T& invalid)
	{
		size_t index = 0;
		_root = _BinaryTree(a, size, index, invalid);
		cout << "BinaryTree(const T* a, size_t size, const T& invalid)" << endl;
	}
	BinaryTree(const BinaryTree<T>& t)
	{
		_root = _Copy(t._root);
		cout << "BinaryTree(const BinaryTree<T>& t)" << endl;
	}
	BinaryTree<T>& operator=(const BinaryTree<T>& t)
	{
		if (this != &t)
		{
			Node* tmp = _Copy(t._root);
			_root = _Destory(_root);
			_root = tmp;
		}
		return *this;
	}
	~BinaryTree()
	{
		_root = _Destory(_root);
		cout << "~BinaryTree()" << endl;
	}

	void PrevOrder()//前序遍历
	{
		_PrevOrder(_root);
		cout << endl;
	}
	void InOrder()//中序遍历
	{
		_InOrder(_root);
		cout << endl;
	}
	void PostOrder()//后序遍历
	{
		_PostOrder(_root);
		cout << endl;
	}
	void LevelOrder()//层遍历
	{
		_LevelOrder(_root);
		cout << endl;
	}

	size_t Size()//求节点个数
	{
		return _Size(_root);
	}
	size_t Depth()//求树的深度
	{
		return _Depth(_root);
	}
	size_t LeafSize()//求叶子节点个数
	{
		return _LeafSize(_root);
	}
	size_t GetKLevel(size_t k)//求第K层叶子节点个数
	{
		return _GetKLevel(_root, k);
	}
protected:
	Node* _BinaryTree(const T* a, size_t size, size_t& index, const T& invalid)
	{
		Node* NewNode = NULL;
		if (index < size && a[index] != invalid)
		{
			NewNode = new Node(a[index]);
			NewNode->_left = _BinaryTree(a, size, ++index, invalid);
			NewNode->_right = _BinaryTree(a, size, ++index, invalid);
		}
		return NewNode;
	}

	Node* _Copy(Node* root)
	{
		Node* NewNode = NULL;
		if (root != NULL)
		{
			NewNode = new Node(root->_date);
			NewNode->_left = _Copy(root->_left);
			NewNode->_right = _Copy(root->_right);
		}
		return NewNode;
	}

	Node* _Destory(Node* root)
	{
		if (root != NULL)
		{
			_Destory(root->_left);
			_Destory(root->_right);
			delete root;
			root = NULL;
		}
		return root;
	}

	void _PrevOrder(Node* root)
	{
		if (root != NULL)
		{
			cout << root->_date << " ";
			_PrevOrder(root->_left);
			_PrevOrder(root->_right);
		}
	}
	void _InOrder(Node* root)
	{
		if (root != NULL)
		{
			_InOrder(root->_left);
			cout << root->_date << " ";
			_InOrder(root->_right);
		}
	}
	void _PostOrder(Node* root)
	{
		if (root != NULL)
		{
			_PostOrder(root->_left);
			_PostOrder(root->_right);
			cout << root->_date << " ";
		}
	}
	void _LevelOrder(Node* root)
	{
		queue<Node*> q;
		q.push(root);
		while (!q.empty())
		{
			Node* tmp = q.front();
			cout << tmp->_date << " ";
			q.pop();
			if (tmp->_left != NULL)
			{
				q.push(tmp->_left);
			}
			if (tmp->_right != NULL)
			{
				q.push(tmp->_right);
			}
		}
	}

	size_t _Size(Node* root)
	{
		size_t size = 0;
		if (root != NULL)
		{
			size += 1;
			size += _Size(root->_left);
			size += _Size(root->_right);
		}
		return size;
	}

	size_t _Depth(Node* root)
	{
		if (root == NULL)
			return 0;
		int left = _Depth(root->_left);
		int right = _Depth(root->_right);
		return left > right ? left + 1 : right + 1;
	}

	size_t _LeafSize(Node* root)
	{
		size_t size = 0;
		if (root != NULL)
		{
			if (root->_left == NULL && root->_right == NULL)
			{
				size += 1;
			}
			size += _LeafSize(root->_left);
			size += _LeafSize(root->_right);

		}
		return size;
	}
	size_t _GetKLevel(Node* root, size_t k)
	{
		if (root == NULL)
			return 0;
		if (k == 1)
			return 1;
		return _GetKLevel(root->_left, k - 1) + _GetKLevel(root->_right, k - 1);
	}

protected:
	Node* _root;
};

void TestBinaryTree()
{
	int a[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
	int a2[15] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };
	BinaryTree<int> b(a, 10, '#');
	BinaryTree<int> e(a2, 15, '#');
	b.PostOrder();
	/*b.PrevOrder();
	b.InOrder();
	/*e.PrevOrder();
	e.InOrder();
	/*b.InOrder();
	b.PostOrder();
	b.LevelOrder();
	BinaryTree<int> c(b);
	c.PrevOrder();
	c.InOrder();
	c.PostOrder();
	c.LevelOrder();
	BinaryTree<int> d;
	d = c;
	d.PrevOrder();
	d.InOrder();
	d.PostOrder();
	d.LevelOrder();
	cout<<"size:"<<b.Size()<<endl;*/
	/*BinaryTree<int> e(a2, 15, '#');
	e.PrevOrder();
	cout <<"b.Depth():  "<< b.Depth() << endl;
	cout << "e.Depth():  "<<e.Depth() << endl;

	cout << "b.LeafSize():  "<<b.LeafSize()<<endl;
	cout << "e.LeafSize():  "<<e.LeafSize()<<endl;

	cout <<"b.GetKLevel(2):  "<< b.GetKLevel(2) << endl;
	cout <<"e.GetKLevel(4):  "<< e.GetKLevel(4) << endl;*/
}
int main()
{
	TestBinaryTree();
	return 0;
}

二叉树的递归实现：（先序创建）

#pragma once   
#include<cassert>  
#include<iostream>  
#include<queue>  
using namespace std;  
  
template<typename T>  
struct BinaryTreeNode  
{  
    T _data;  
    BinaryTreeNode *_left;  
    BinaryTreeNode *_right;  
    BinaryTreeNode(const T& data = T())  
        :_data(data)  
        , _left(NULL)  
        , _right(NULL){}  
};  
  
  
template<typename T>  
class BinaryTree  
{  
    typedef BinaryTreeNode<T> Node;  
public:  
    BinaryTree()  
        :_root()  
    {}  
  
    BinaryTree(const T *array,size_t size,const T& invalid)  
    {  
        size_t index = 0;  
        _root=_CreatTree(array,size,index,invalid);  
    }  
  
    BinaryTree(const BinaryTree<T>& t)  
    {  
        _root=_Copy(t._root);  
    }  
  
    BinaryTree& operator=(BinaryTree<T>& t)  
    {  
        if (this != &t)             //防止自赋值  
        {  
            BinaryTree<T> tmp(t);  
            swap(_root,tmp._root);  
        }  
        return *this;  
    }  
  
    ~BinaryTree()  
    {  
        _destory(_root);  
    }  
  
    size_t Leaf()         //求叶子结点的个数  
    {  
        return _leaf(_root);  
    }  
  
    size_t Size()    //求结点个数  
    {  
        return _Size(_root);  
    }  
  
    size_t Depth()          //求深度  
    {  
        return _Depth(_root);  
    }  
  
    void PrevOder()     //前序遍历  
    {  
        _PrevPrint(_root);  
        cout << endl;  
    }  
  
    void InOder()      //中序遍历  
    {  
        _InPrint(_root);  
        cout << endl;  
    }  
  
    void BackOder()      //后序遍历  
    {  
        _BackPrint(_root);  
        cout << endl;  
    }  
  
    void TierOder()       //层序遍历  
    {  
        _TierPrint(_root);  
        cout << endl;  
    }  
  
protected:  
    Node* _CreatTree(const T *array, size_t size, size_t& index, const T& invalid)  
    {  
        assert(array);  
        Node *root=NULL;  
        if (index < size&&array[index] != invalid)  
        {  
            root = new Node(array[index]);                                  //创建根节点  
            root->_left = _CreatTree(array,size,++index,invalid);           //递归创建左子树  
            root->_right= _CreatTree(array,size,++index,invalid);           //递归创建右子树  
        }  
        return root;  
    }  
  
    void _PrevPrint(Node *root)  
    {  
        Node *cur =root;  
        if (cur)  
        {  
            cout << cur->_data << " ";  
            _PrevPrint(cur->_left);  
            _PrevPrint(cur->_right);  
        }  
    }  
  
    void _InPrint(Node *root)  
    {  
        Node *cur = root;  
        if (cur)  
        {  
            _InPrint(cur->_left);  
            cout << cur->_data << " ";  
            _InPrint(cur->_right);  
        }  
    }  
  
    void _BackPrint(Node *root)  
    {  
        Node *cur = root;  
        if (cur)  
        {  
            _BackPrint(cur->_left);  
            _BackPrint(cur->_right);  
            cout << cur->_data << " ";  
        }  
    }  
  
    void _TierPrint(Node *root)  
    {  
        queue<Node*> q;  
        Node* cur=root;  
        q.push(cur);  
        while(!q.empty())  
        {  
            Node* tmp = q.front();  
            cout << tmp->_data <<" ";  
  
            if (tmp->_left)  
                q.push(tmp->_left);  
            if (tmp->_right)  
                q.push(tmp->_right);  
            q.pop();  
        }  
    }  
  
    size_t _Size(Node *root)  
    {  
        if (root == NULL)  
            return 0;  
        return 1 + _Size(root->_left) + _Size(root->_right);  
    }  
  
    size_t _Depth(Node *root)  
    {  
        Node *cur = root;  
        if (NULL == cur)  
            return 0;  
  
        return 1 + (_Depth(cur->_left) > _Depth(cur->_right)   
               ? _Depth(cur->_left) : _Depth(cur->_right));  
    }  
  
    void _destory(Node *root)  
    {  
        Node *cur =root;  
        if (cur)  
        {  
            _destory(cur->_left);  
            _destory(cur->_right);  
            delete cur;  
            cur = NULL;  
        }  
    }  
  
    Node* _Copy(Node* node)  
    {  
        Node* cur= node;  
        Node* root = NULL;  
        if (cur)  
        {  
            root = new Node(cur->_data);  
            root->_left =_Copy(cur->_left);  
            root->_right=_Copy(cur->_right);  
        }  
        return root;  
    }  
  
    size_t _leaf(Node* root)  
    {  
        Node* cur = root;  
        if (NULL==cur)  
            return 0;  
        if (cur->_left == NULL&&cur->_right == NULL)      //如果左右子树都为空，则返回1  
            return 1;  
        return _leaf(cur->_left ) + _leaf(cur->_right);  
    }  
protected:  
    Node *_root;  
};



小记：

//#pragma once
//
//template<class K>
//struct SearchBinaryTreeNode
//{
//	SearchBinaryTreeNode<K>* _left;
//	SearchBinaryTreeNode<K>* _right;
//
//	K _key;
//
//	SearchBinaryTreeNode(const K& key)
//		:_key(key)
//		,_left(NULL)
//		,_right(NULL)
//	{}
//};
//
//template<class K>
//class SearchBinaryTree
//{
//	typedef SearchBinaryTreeNode<K> Node;
//public:
//	SearchBinaryTree()
//		:_root(NULL)
//	{}
//
//	bool Insert(const K& key)
//	{
//		if (_root == NULL)
//		{
//			_root = new Node(key);
//			return true;
//		}
//		
//		Node* parent = NULL;
//		Node* cur = _root;
//		while (cur)
//		{
//			if (cur->_key < key)
//			{
//				parent = cur;
//				cur = cur->_right;
//			}
//			else if (cur->_key > key)
//			{
//				parent = cur;
//				cur = cur->_left;
//			}
//			else
//			{
//				return false;
//			}
//		}
//
//		if (parent->_key < key)
//		{
//			parent->_right = new Node(key);
//			return true;
//		}
//		else
//		{
//			parent->_left = new Node(key);
//			return true;
//		}
//	}
//
//	const Node* Find(const K& key)
//	{
//		Node* cur = _root;
//		while (cur)
//		{
//			if (cur->_key < key)
//			{
//				cur = cur->_right;
//			}
//			else if (cur->_key > key)
//			{
//				cur = cur->_left;
//			}
//			else
//			{
//				return cur;
//			}
//		}
//		
//		return NULL;
//	}
//
//	bool Remove(const K& key)
//	{
//		Node* parent = NULL;
//		Node* cur = _root;
//		while (cur)
//		{
//			if (cur->_key > key)
//			{
//				parent = cur;
//				cur = cur->_left;
//			}
//			else if (cur->_key < key)
//			{
//				parent = cur;
//				cur = cur->_right;
//			}
//			else
//			{
//				Node* del = cur;
//				// 删除
//				if(cur->_left == NULL)
//				{
//					if (parent == NULL) // _root == cur
//					{
//						_root = cur->_right;
//					}
//					else
//					{
//						if (parent->_left == cur)
//						{
//							parent->_left = cur->_right;
//						}
//						else
//						{
//							parent->_right = cur->_right;
//						}
//					}
//				}
//				else if (cur->_right == NULL)
//				{
//					if (parent == NULL)
//					{
//						_root = cur->_left;
//					}
//					else
//					{
//						if (parent->_left = cur)
//						{
//							parent->_left = cur->_left;
//						}
//						else
//						{
//							parent->_right = cur->_left;
//						}
//					}
//				}
//				else
//				{
//					// 替换法
//					Node* parent = cur;
//					Node* subRight = cur->_right;
//					while (subRight->_left)
//					{
//						parent = subRight;
//						subRight = subRight->_left;
//					}
//					
//					cur->_key = subRight->_key;
//					del = subRight;
//
//
//					if (parent->_left == subRight)
//					{
//						parent->_left = subRight->_right;
//					}
//					else
//					{
//						parent->_right = subRight->_right;
//					}
//
//				}
//
//				delete del;
//				return true;
//			}
//		}
//		
//		return false;
//	}
//	
//	void InOrder()
//	{
//		_InOrder(_root);
//		cout<<endl;
//	}
//
//	const Node* FindR(const K& key)
//	{
//		return _FindR(_root, key);
//	}
//
//	bool InsertR(const K& key)
//	{
//		return _Insert(_root, key);
//	}
//
//	bool RemoveR(const K& key)
//	{
//		return _RemoveR(_root, key);
//	}
//
//protected:
//	bool _RemoveR(Node*& root, const K& key)
//	{
//		if (root == NULL)
//			return false;
//
//		if (root->_key < key)
//		{
//			return _RemoveR(root->_right, key);
//		}
//		else if (root->_key > key)
//		{
//			return _RemoveR(root->_left, key);
//		}
//		else
//		{
//			Node* del = root;
//			if (root->_left == NULL)
//			{
//				root = root->_right;
//			}
//			else if (root->_right == NULL)
//			{
//				root = root->_left;
//			}
//			else
//			{
//				// 替换法
//				Node* parent = root;
//				Node* subRight = root->_right;
//				while (subRight->_left)
//				{
//					parent = subRight;
//					subRight = subRight->_left;
//				}
//				
//				swap(subRight->_key, root->_key);
//
//				del = subRight;
//
//				if (parent->_left == subRight)
//				{
//					parent->_left = subRight->_right;
//				}
//				else
//				{
//					parent->_right = subRight->_right;
//				}
//			}
//
//			delete del;
//			return true;
//		}
//	}
//
//	bool _Insert(Node*& root, const K& key)
//	{
//		if (root == NULL)
//		{
//			root = new Node(key);
//			return true;
//		}
//
//		if (root->_key < key)
//		{
//			return _Insert(root->_right, key);
//		}
//		else if (root->_key > key)
//		{
//			return _Insert(root->_left, key);
//		}
//		else
//		{
//			return false;
//		}
//	}
//
//	const Node* _FindR(Node* root, const K& key)
//	{
//		if (root ==  NULL)
//		{
//			return NULL;
//		}
//
//		if (root->_key < key)
//		{
//			return _FindR(root->_right, key);
//		}
//		else if (root->_key > key)
//		{
//			return _FindR(root->_left, key);
//		}
//		else
//		{
//			return root;
//		}
//	}
//
//	void _InOrder(Node* root)
//	{
//		if (root == NULL)
//			return;
//
//		_InOrder(root->_left);
//		cout<<root->_key<<" ";
//		_InOrder(root->_right);
//	}
//
//protected:
//	Node* _root;
//};
//
//
//void TestTree1()
//{
//	SearchBinaryTree<int> t1;
//	int a[] = {5, 3, 4,1,7,8,2,6,0,9};
//	for (size_t i = 0; i < sizeof(a)/sizeof(a[0]); ++i)
//	{
//		t1.Insert(a[i]);
//	}
//
//	t1.InOrder();
//
//	t1.Remove(2);
//	t1.Remove(8);
//	t1.Remove(1);
//	t1.Remove(5);
//
//	t1.Remove(0);
//	t1.Remove(1);
//	t1.Remove(2);
//	t1.Remove(3);
//	t1.Remove(4);
//	t1.Remove(5);
//	t1.Remove(6);
//	t1.Remove(7);
//	t1.Remove(8);
//	t1.Remove(9);
//
//	t1.InOrder();
//
//}
//
//void TestTree2()
//{
//	SearchBinaryTree<int> t1;
//	int a[] = {5, 3, 4,1,7,8,2,6,0,9};
//	for (size_t i = 0; i < sizeof(a)/sizeof(a[0]); ++i)
//	{
//		t1.InsertR(a[i]);
//	}
//
//	t1.InOrder();
//
//
//	t1.RemoveR(2);
//	t1.RemoveR(8);
//	t1.RemoveR(1);
//	t1.RemoveR(5);
//
//	t1.RemoveR(0);
//	t1.RemoveR(1);
//	t1.RemoveR(2);
//	t1.RemoveR(3);
//	t1.RemoveR(4);
//	t1.RemoveR(5);
//	t1.RemoveR(6);
//	t1.RemoveR(7);
//	t1.RemoveR(8);
//	t1.RemoveR(9);
//
//	t1.InOrder();
//}

#pragma once

// K/V

// 1.Key 判断在不在
// 2.Key/Value 找key附带的信息

template<class K, class V>
struct BSTreeNode
{
	K _key;
	V _value;

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

	BSTreeNode(const K& key, const V& value)
		:_key(key)
		,_value(value)
		,_left(NULL)
		,_right(NULL)
	{}
};

template<class K, class V>
class BSTree
{
	typedef BSTreeNode<K, V> Node;
public:
	BSTree()
		:_root(NULL)
	{}

	bool Insert(const K& key, const V& value)
	{
		return _Insert(_root, key, value);
	}

	Node* Find(const K& key)
	{
		return _Find(_root, key);
	}

protected:
	bool _Insert(Node*& root, const K& key, const V& value)
	{
		if (root == NULL)
		{
			root = new Node(key, value);
			return true;
		}

		if (root->_key < key)
		{
			return _Insert(root->_right, key, value);
		}
		else if(root->_key > key)
		{
			return _Insert(root->_left, key, value);
		}
		else
		{
			return false;
		}
	}

	Node* _Find(Node* root, const K& key)
	{
		if (root == NULL)
		{
			return NULL;
		}

		if (root->_key < key)
		{
			return _Find(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _Find(root->_left, key);
		}
		else
		{
			return root;
		}
	}

protected:
	Node* _root;
};

// K 和K/V
void TestTree3()
{
	BSTree<string, string> dict;
	dict.Insert("sort", "排序");
	dict.Insert("tree", "树");
	dict.Insert("string", "xxx");
	dict.Insert("string", "字符串");

	BSTreeNode<string, string>* ret = dict.Find("sort");
	cout<<ret->_value<<endl;

	ret = dict.Find("string");
	ret->_value = "字符串";

	// 1.如何判断一个单词的拼写是否正确？
	// 2.统计一个文件中每个单词出现的次数？
	string file[] = {"string", "sort", "string", "string"};
	BSTree<string, int> countTree;
	for (size_t i = 0; i < sizeof(file)/sizeof(file[0]); ++i)
	{
		BSTreeNode<string, int>* node = countTree.Find(file[i]);
		if (node)
		{
			node->_value++;
		}
		else
		{
			countTree.Insert(file[i], 1);
		}
	}

	// topk 小堆

测试：

#include<iostream>  
#include"BinaryTree.h"  
using namespace std;  
  
void test()  
{  
    int array[] = {1,2,3,'#','#',4,'#','#',5,6,'#','#',7};  
    size_t sz = sizeof(array) / sizeof(array[0]);  
    BinaryTree<int> t(array,sz,'#');  
  
    BinaryTree<int> t2;  
    t2 = t;  
    t2.InOder();  
    cout << t2.Size() << endl;  
    cout << t2.Depth() << endl;  
    cout<<t2.Leaf() << endl;  
}  
  
int main()  
{  
    test();  
    system("pause");  
    return 0;  
}

二叉树非递归遍历：

二叉树是一种非线性结构，遍历二叉树几乎都是通过递归或者用栈辅助实现非递归的遍历。用二叉树作为存储结构时，取到一个节点，只 能获取节点的左孩子和右孩子，不能直接得到节点的任一遍历序列的前驱或者后继。
为了保存这种在遍历中需要的信息，我们利用二叉树中指向左右子树的空指针来存放节点的前驱和后继信息。
enum PointerTag {THREAD, LINK};
template <class T> struct BinaryTreeNode_Thd {     T _data ;                         // 数据     BinaryTreeNode_Thd<T >* _left;   // 左孩子   

BinaryTreeNode_Thd<T >* _right;  // 右孩子 

PointerTag   _leftTag ;          // 左孩子线索标志    

PointerTag   _rightTag ;         // 右孩子线索标志 };

void PrevOrder_NonR()//非递归前序遍历
{
	if (_root == NULL)
		return;
	stack<Node*> s;
	Node* cur = _root;
	while ((cur != NULL) || (!s.empty()))
	{
		while (cur)
		{
			s.push(cur);
			cout << cur->_date << " ";
			cur = cur->_left;
		}
		cur = s.top();
		s.pop();
		cur = cur->_right;
	}
	cout << endl;
}
void InOrder_NonR()//非递归中序遍历
{
	if (_root == NULL)
		return;
	stack<Node*> s;
	Node* cur = _root;
	while ((cur != NULL) || (!s.empty()))
	{
		while (cur)
		{
			s.push(cur);
			cur = cur->_left;
		}
		cur = s.top();
		cout << cur->_date << " ";
		s.pop();
		cur = cur->_right;
	}
	cout << endl;
}
void PostOrder_NonR()//非递归后序遍历
{
	if (_root == NULL)
		return;
	stack<Node*> s;
	Node* cur = _root;
	Node* prev = NULL;//记录上一个访问到的节点
	while ((cur != NULL) || (!s.empty()))
	{
		while (cur)//循环到最左边的节点
		{
			s.push(cur);
			cur = cur->_left;
		}
		Node* top = s.top();
		if (top->_right == NULL || top->_right == prev)//如果top的右节点为空或者访问过，则可以访问此节点
		{
			cout << top->_date << " ";
			s.pop();
			prev = top;
		}
		else
		{
			cur = top->_right;//访问右边
		}
	}
	cout << endl;
}

线索化二叉树：

二叉树的结构：

enum PointerTag
{
    THREAD,  //线索化指针的标记
    LINK     //一般指针的标记
};
template <class T>
struct BinaryTreeNode_Thd
{ 
    //构造函数
    BinaryTreeNode_Thd()
       : _date(0)
       , _left(NULL)
       , _right(NULL)
       , _leftTag(LINK)
       , _rightTag(LINK)
    {}

    BinaryTreeNode_Thd(const T& d)
        : _date(d)
        , _left(NULL)
        , _right(NULL)
        , _leftTag(LINK)
        , _rightTag(LINK)
    {}

    T _date;                      //数据
    BinaryTreeNode_Thd<T>* _left; //左孩子
    BinaryTreeNode_Thd<T>* _right;//右孩子
    PointerTag _leftTag;          //左孩子线索标志
    PointerTag _rightTag;         //右孩子线索标志
};
中序线索化： 

 void _InOrderThreading(Node* cur,Node*& prev)
    {
        if (cur == NULL)
            return;
        _InOrderThreading(cur->_left, prev);    //左子树
        //线索化左
        if (cur->_left == NULL)
        {
            cur->_leftTag = THREAD;
            cur->_left = prev;
        }
        //访问到下一个节点后，线索化上一个节点右
        if (prev && prev->_right == NULL)
        {
            prev->_rightTag = THREAD;
            prev->_right = cur;
        }
        prev = cur;
        _InOrderThreading(cur->_right, prev);   //右子树
    }
//前序线索化
    void PrevOrderThreading()
    {
        Node* prev = NULL;
        _PrevOrderThreading(_root, prev);
    }
    //前序线索化遍历
    void PrevOrderThd()
    {
        Node* cur = _root;
        while (cur)
        {
            while (cur->_leftTag != THREAD)
            {
                cout << cur->_date << " ";
                cur = cur->_left;
            }
            cout << cur->_date << " ";
            cur = cur->_right;
        }
        cout << endl;
    }
void _PrevOrderThreading(Node* cur, Node*& prev)
    {
        if (cur == NULL)
            return;
        if (cur->_left == NULL)
        {
            cur->_leftTag = THREAD;
            cur->_left = prev;
        }
        if (prev && prev->_right == NULL)
        {
            prev->_rightTag = THREAD;
            prev->_right = cur;
        }
        prev = cur;
        if (cur->_leftTag == LINK)
        {
            _PrevOrderThreading(cur->_left, prev);
        }
        if (cur->_rightTag == LINK)
        {
            _PrevOrderThreading(cur->_right, prev);
        }
    }
后序线索化：
  void PostOrderThreading()
    {
        Node* prev = NULL;
        _PostOrderThreading(_root, prev);
    }

//后序线索化
    void _PostOrderThreading(Node* cur, Node*& prev)
    {
        if (cur == NULL)
            return;
        _PostOrderThreading(cur->_left, prev);
        _PostOrderThreading(cur->_right, prev);
        if (cur->_left == NULL)
        {
            cur->_leftTag = THREAD;
            cur->_left = prev;
        }
        if (prev && prev->_right == NULL)
        {
            prev->_rightTag = THREAD;
            prev->_right = cur;
        }
        prev = cur;
    }
小记：
#include <iostream>
#include <cstdlib>
using namespace std;

enum PointerTag
{
    THREAD,  //线索化指针的标记
    LINK     //一般指针的标记
};
template <class T>
struct BinaryTreeNode_Thd
{ 
    //构造函数
    BinaryTreeNode_Thd()
       : _date(0)
       , _left(NULL)
       , _right(NULL)
       , _leftTag(LINK)
       , _rightTag(LINK)
    {}

    BinaryTreeNode_Thd(const T& d)
        : _date(d)
        , _left(NULL)
        , _right(NULL)
        , _leftTag(LINK)
        , _rightTag(LINK)
    {}

    T _date;                      //数据
    BinaryTreeNode_Thd<T>* _left; //左孩子
    BinaryTreeNode_Thd<T>* _right;//右孩子
    PointerTag _leftTag;          //左孩子线索标志
    PointerTag _rightTag;         //右孩子线索标志
};
template <class T>
class BinaryTreeThread
{
    typedef BinaryTreeNode_Thd<T> Node;
public:
    BinaryTreeThread()
        :_root(NULL)
    {}
    BinaryTreeThread(T* a, size_t n, const T& invalid)
    {
        size_t index = 0;
        _root = _CreateTree(a, n, index, invalid);
    }

    //中序线索化
    void InOrderThreading()
    {
        Node* prev = NULL;
        _InOrderThreading(_root, prev);
    }
    //中序线索化遍历
    void InOrderThd()
    {
        Node* cur = _root;
        while (cur)
        {
            while (cur->_leftTag == LINK)
            {
                cur = cur->_left;
            }
            cout << cur->_date << " ";
            while (cur->_leftTag == THREAD)
            {
                cur = cur->_right;
                cout << cur->_date << " ";
            }
            cur = cur->_right;
        }
        cout << endl;
    }

    //前序线索化
    void PrevOrderThreading()
    {
        Node* prev = NULL;
        _PrevOrderThreading(_root, prev);
    }
    //前序线索化遍历
    void PrevOrderThd()
    {
        Node* cur = _root;
        while (cur)
        {
            while (cur->_leftTag != THREAD)
            {
                cout << cur->_date << " ";
                cur = cur->_left;
            }
            cout << cur->_date << " ";
            cur = cur->_right;
        }
        cout << endl;
    }

    //后序线索化
    void PostOrderThreading()
    {
        Node* prev = NULL;
        _PostOrderThreading(_root, prev);
    }

protected:
    //后序线索化
    void _PostOrderThreading(Node* cur, Node*& prev)
    {
        if (cur == NULL)
            return;
        _PostOrderThreading(cur->_left, prev);
        _PostOrderThreading(cur->_right, prev);
        if (cur->_left == NULL)
        {
            cur->_leftTag = THREAD;
            cur->_left = prev;
        }
        if (prev && prev->_right == NULL)
        {
            prev->_rightTag = THREAD;
            prev->_right = cur;
        }
        prev = cur;
    }

    //前序线索化
    void _PrevOrderThreading(Node* cur, Node*& prev)
    {
        if (cur == NULL)
            return;
        if (cur->_left == NULL)
        {
            cur->_leftTag = THREAD;
            cur->_left = prev;
        }
        if (prev && prev->_right == NULL)
        {
            prev->_rightTag = THREAD;
            prev->_right = cur;
        }
        prev = cur;
        if (cur->_leftTag == LINK)
        {
            _PrevOrderThreading(cur->_left, prev);
        }
        if (cur->_rightTag == LINK)
        {
            _PrevOrderThreading(cur->_right, prev);
        }
    }

    //中序线索化
    void _InOrderThreading(Node* cur,Node*& prev)
    {
        if (cur == NULL)
            return;
        _InOrderThreading(cur->_left, prev);    //左子树
        //线索化左
        if (cur->_left == NULL)
        {
            cur->_leftTag = THREAD;
            cur->_left = prev;
        }
        //访问到下一个节点后，线索化上一个节点右
        if (prev && prev->_right == NULL)
        {
            prev->_rightTag = THREAD;
            prev->_right = cur;
        }
        prev = cur;
        _InOrderThreading(cur->_right, prev);   //右子树
    }

    Node* _CreateTree(const T* a, size_t size, size_t& index, const T& invalid)
    {
        Node* NewNode = NULL;
        if (index < size && a[index] != invalid)
        {
            NewNode = new Node(a[index]);
            NewNode->_left = _CreateTree(a, size, ++index, invalid);
            NewNode->_right = _CreateTree(a, size, ++index, invalid);
        }
        return NewNode;
    }

protected:
    Node* _root;
};
void Test()
{
    int a1[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
    int a2[15] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };
    BinaryTreeThread<int> a(a1, 10, '#');
    //a.InOrderThreading();
    //a.InOrderThd();
    //a.PrevOrderThreading();
    //a.PrevOrderThd();
    a.PostOrderThreading();
}
int main()
{
    Test();
    return 0;
}

树、森林与二叉树的转换
优快云
12-30 15万+
树、森林与二叉树的转换 1、树转换为二叉树 由于二叉树是有序的，为了避免混淆，对于无序树，我们约定树中的每个结点的孩子结点按从左到右的顺序进行编号。 将树转换成二叉树的步骤是： （1）加线。就是在所有兄弟结点之间加一条连线； （2）抹线。就是对树中的每个结点，只保留他与第一个孩子结点之间的连线，删除它与其它孩子结点之间的连线； （3）旋转。就是以树的根结点为轴心，将整棵树顺时针旋转一定...
数据结构篇——二叉树
y805805的博客
03-01 421
树的定义 树（Tree）是n（n&amp;gt;=0）个结点的有限集。当n=0时称为空树，在任意一颗非空树中： 有且仅有一个特定的称之为根（root）的结点； 当n&amp;gt;1时，其余结点可分为m(m&amp;gt;0)个互不相交的有限集T1,T2,...,Tm，其中每一 个集合本身又是一棵树，并且称为根的子树（SubTree） n&amp;gt;0时，根节点是唯一的，坚决不可能存在多个根节点...
【数据结构】二叉树
fxkcsdn的博客
08-14 480
定义 二叉树是每个结点最多有两个子树的树结构。它有五种基本形态：二叉树可以是空集；根可以有空的左子树或右子树；或者左、右子树皆为空 二叉树的性质 性质1：二叉树第k层上的结点数目最多为2^(k-1)(k&gt;=1) 性质2：深度为k的二叉树至多有2^k-1个结点（k&gt;=1） 性质3：包含n个结点的二叉树的高度至少为(log2n)+1 性质4：在任意一棵二叉树中，若终...
树及二叉树的概念及知识点
qq_45605759的博客
12-04 322
二叉树 1.树 １.１树型结构 树是一种非线性的数据结构，它是由n（n&gt;=0）个有限结点组成一个具有层次关系的集合。 把它叫做树是因为它看 起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 树的特点： 每个结点有零个或多个子结点； 没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点； 除了根结点外，每个子结点可以分为多个不相 交的子树 。 １.2 树的概念（重要） 节点的度：...
【牛客选择题】树&&二叉树【一】
qq_45605223的博客
04-30 5908
1.下列关于二叉树的叙述中，正确的是（B）。 A.叶子结点总是比度为2的结点少一个 B.叶子结点总是比度为2的结点多一个 C.叶子结点数是度为2的结点数的两倍 D.度为2的结点数是度为1的结点数的两倍 解析： 设结点总数为n，度为0的叶节点为n0，度为1的节点为n1，度为2的结点为n2。 结点总数n=n0+n1+n2 。 ---------（1） 因为，结点，除了根结点之外，其他都是子节点。所以...
＜ 数据结构 ＞ 树与二叉树
bit_zyx的博客
04-11 6176
目录 1、树的概念及结构 树的概念 树的专有名词 树的表示 树在实际中的运用 2、二叉树的概念及结构 概念 现实中的二叉树 特殊的二叉树 二叉树的性质 二叉树的存储结构 1、树的概念及结构 树的概念 现实中的树： 数据结构中的树： 树是一种非线性的数据结构，它是由n（n&gt;=0）个有限结点组成一个具有层次关系的集...
二叉排序树遍历&二叉树打印&简单图书管理系统
大西几胖胖
12-28 4001
实验：二叉排序树的实现
树与二叉树的相互转换
yiranblade的博客
11-11 5728
树-&gt;二叉树 加线 把相应结点的兄弟结点连线 去线 去掉双亲和非最左边孩子的连线 旋转 二叉树-&gt;树 加线-去线 将结点与其左孩子的右孩子及其右子孙连线。然后去掉所有结点与其右孩子的连线。 旋转处理 得到二叉树 #森林-&gt;二叉树 先将每棵树转换为二叉树 连接每棵树的根结点 以第一颗树的根作为二叉树的根顺时针旋转 #二叉树-&gt;森林 将二叉树的根结点与其右孩子及右子孙的连线全部去掉 对剩下的每一棵孤立的二叉树按照二叉树与树的转换规则转换为树 得
树转二叉树
热门推荐
chuyu的博客
01-22 1万+
树转二叉树的转换原则：1.孩子结点-&gt;左子树结点。2.兄弟结点-&gt;右子树结点。 详解：一颗普通的树的根结点的孩子结点转化为这个颗二叉树的左子树，兄弟结点转换为二叉树的右孩子结点。 看描述有点抽象，直接上例题。 1是二叉树的根节点。2，3，4都是1的孩子结点，由于根节点1只有一个左子树，所以只能是2结点是1结点左子树。(下面同理) 3和4都是2的兄弟结点，所以3是2的右子树。 4是3的兄弟结点，所以4是3的右子树。 接下来回到3结点，5是3的左子树。 6，7是5的兄弟结点，所以6是5的右
树和二叉树对比
自己的选择，无论是否正确，请坚持下去，黎明就在下一刻。
09-08 3503
树和二叉树都有一个树字，从结构上来说，都是树状结构，但是它们之间的区别是什么呢？那就拿两者的特点来说一说把。 首先是 树 先看一下树的基本概念和它的一些术语： Root：根节点。 描述：树的顶部节点。 Child：子节点。 描述：离开根节点时直接连接到另一个节点的节点。 Leaf ：叶子节点。 描述：没有子节点的节点 Edge： 边。 描述：一个节点与另一个节点之间的连接。 Path：路径。 描述：连接节点和子节点的节...
【C语言-&gt;数据结构与算法】-&gt;树与二叉树概念&amp;哈夫曼树的构造
01-07
树&amp;二叉树&amp;哈夫曼树Ⅰ 树A. 树的概念B. 树的表达形式（存储结构）C. 树的遍历a. 广度优先遍历（队列）b. 深度优先遍历（堆栈）Ⅱ. 二叉树A. 二叉树的有关概念B. 二叉树中相关公式C. 二叉树的存储结构Ⅲ 哈夫曼树及...
python数据结构树和二叉树简介
01-20
一、树的定义 树形结构是一类重要的非线性结构。树形结构是结点之间有分支，并具有层次关系的结构。它非常类似于自然界中的树。树的递归定义：树(Tree)是n(n&ge;0)个结点的有限集T，T为空...特点：（1）二叉树是有序树，
数据结构第五章-树与二叉树-C语言实现线索二叉树
最新发布
03-16
【数据结构】第五章&mdash;&mdash;树与二叉树&mdash;&mdash;C语言实现线索二叉树 资源内包含7个文件： - 3个头文件 - BiTree.h &mdash;&mdash;二叉树头文件，用于对二叉树的数据结构的定义、实现算法的声明 - ThreadTree.h &mdash;&mdash; 线索二叉树头文件...
二叉树层序遍历&amp;&amp;判断完全二叉树
03-01
二叉树层序遍历是一种遍历树结构的方法，其特点是从树的根节点开始，按层次自上而下，同一层从左到右地访问节点。在二叉树层序遍历中，通常使用队列这一数据结构来实现。具体操作过程如下：首先将根节点入队，然后在...
二叉树面试题 树和二叉树总结.doc
02-24
&quot;二叉树面试题 树和二叉树总结&quot; 本资源摘要信息涵盖了树和二叉树的面试题总结，包括选择题和解释。涵盖的知识点包括树和二叉树的定义、性质、操作和应用等。 一、树和二叉树的定义 树是一种数据结构，由一个根...
/***/二叉树经典面试题之判断一棵二叉树是否是完全二叉树
火锅——博客
05-15 1675
什么是完全二叉树呢 如果一颗二叉树的只有最后两层结点的度能小于2，其余结点的度都等于2。且最后一层的结点从最左边依次排列。 如果一颗二叉树中的每一个结点都与编号从1到n的满二叉树中的结点一一对应，则称这棵二叉树为完全二叉树。 我们可以根据完全二叉树的定义，按照层序遍历一颗树，当遇到空结点时如果这棵树已经遍历完毕，则这棵树就是完全二叉树，如果遇到空结点的后面还有元素则这
栈帧&栈&递归
火锅——博客
05-15 744
一般函数的调用栈帧 递归函数调用栈帧 函数栈帧调用&数据结构栈–栈实现将递归程序转换为非递归程序
堆的基本代码
火锅——博客
09-05 604
#include<iostream> #include<vector> #include<assert.h> using namespace std; template<class T> //利用仿函数，可以完成代码的复用，这里我们假设建立大堆。 struct Greater { bool operator()(const T& x1, const T& x2)
/*****/排序
火锅——博客
08-07 475
直接插入排序 插入排序的基本思想是： 每次将一个待排的记录，按照其关键字的大小，插入到前面已经排好序的有序区中适当的位置，直到全部记录插入完毕为止。 假设待排序的记录存放在数组R[0..n]中，初始时R[0]是一个有序区，R[1..n]是无序区，从i=1开始，依次将R[i]插入到有序区R[0..i-1]中，生成一个包含n个记录的有序区。 Sort.h#pragma o
深入理解红黑树与二叉树的基本原理和应用
二叉树在计算机科学中应用广泛，许多其他的树结构，如二叉搜索树、AVL树、红黑树等，都是二叉树的特例或者基于二叉树的扩展。 #### 二叉树的种类 1. **完全二叉树**：除了最后一层外，每一层都被完全填满，并且...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值