数据结构 第五章 树-类图及代码实现

类图:

 

代码实现:

KNode.h

#ifndef DATA_STRUCT_KTREE_K_NODE_H
#define DATA_STRUCT_KTREE_K_NODE_H

//   //////////////// 模板类声明与实现都存放在同一个 .h文件中,否则调用会有问题。

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <assert.h>
#include <stack>
using namespace std;

template<typename N>
class KPNode;

template<typename N>
/**
 * 树节点
 */
class KNode
{
public:
	/**
	 * 结点的临时高度 avl树判断时使用
	 */
	int m_nHtemp;

	/**
	 * 指向其左孩子结点,非二叉树时,值为nullptr
	 */
	KPNode<N> m_pLeft;

	/**
	 * 前缀编码
	 */
	string m_strCode;

	/**
	 * 叶结点标志 0-分支结点 1-叶子结点
	 */
	int m_nLeafFlag;

	/**
	 * 结点的路径长度
	 */
	int m_nLength;

	/**
	 * 结点的权重
	 */
	int m_nWeight;

	/**
	 * 结点的位置
	 * 0-左孩子结点 1-右孩子结点 2-root结点
	 */
	int m_nPosFlag;

	vector<KPNode<N>> m_arrayNode;

	/**
	 * 指向其父结点
	 */
	KPNode<N> m_pFatherNode;

	/**
	 * 树的高度
	 */
	int m_nHeight;

	/**
	 * 二叉树线索化时使用,
	 * 0-left结点指针指向左孩子结点
	 * 1-left结点指针指向其前驱结点
	 * 
	 */
	int m_nLTag;

	/**
	 * 二叉树线索化时使用,
	 * 0-right结点指针指向右孩子结点
	 * 1-right结点指针指向其后继结点
	 */
	int m_nRTag;

	/**
	 * 指向其右孩子结点,非二叉树时,值为nullptr
	 */
	KPNode<N> m_pRight;

	/**
	 * 结点被访问的次数,先序 中序 后序遍历时,出栈判断用
	 */
	int m_nVisit;

	/**
	 * 结点的值
	 */
	N m_nData;

	/**
	* 共享次数,析构时,判断用
	*/
	int m_nShareNum;

public:
	/**
	 * 构造函数
	 */
	KNode(N v);

	/**
	 * 析构函数
	 */
	virtual ~KNode();

	/**
	 * 拷贝构造 注意 &rhs == this 的判断
	 */
	KNode(const KNode<N>& rhs);

	/**
	 * 拷贝赋值函数
	 */
	KNode<N>& operator=(const KNode<N>& rhs);

	/**
	 * 移动拷贝构造函数
	 */
	KNode(const KNode<N>&& rhs);

	/**
	 * 移动赋值函数
	 */
	KNode<N>& operator=(const KNode<N>&& rhs);

};


#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <assert.h>

template<typename N>
KNode<N>::KNode(N v)
{
	// 结点的临时高度 avl树判断时使用
	m_nHtemp = 1;

	// 指向其左孩子结点,非二叉树时,值为nullptr
	//m_pLeft = nullptr;

	// 叶结点标志 0-分支结点 1-叶子结点
	m_nLeafFlag = 0;

	// 结点的路径长度
	m_nLength = 0;

	// 结点的权重
	m_nWeight = 0;

	// 结点的位置
	// 0-左孩子结点 1-右孩子结点 2-root结点
	m_nPosFlag = 2;

	// 指向其父结点
	//m_pFatherNode = nullptr;

	// 树的高度
	m_nHeight = 1;

	/**
	* 二叉树线索化时使用,
	* 0-left结点指针指向左孩子结点
	* 1-left结点指针指向其前驱结点
	*/
	m_nLTag = 0;

	/**
	* 二叉树线索化时使用,
	* 0-right结点指针指向右孩子结点
	* 1-right结点指针指向其后继结点
	*/
	m_nRTag = 0;

	/**
	* 指向其右孩子结点,非二叉树时,值为nullptr
	*/
	//m_pRight = nullptr;

	// 结点被访问的次数,先序 中序 后序遍历时,出栈判断用
	m_nVisit = 0;

	// 结点的值
	m_nData = v;

	/**
	* 共享次数,析构时,判断用
	*/
	m_nShareNum = 1;
}

template<typename N>
KNode<N>::~KNode()
{
	// 关联结点自己释放
	cout << m_nData << " ";
}

template<typename N>
KNode<N>::KNode(const KNode<N>& rhs)
{
	if (&rhs == this)
	{
		return;
	}

	m_nHtemp = rhs.m_nHtemp;
	m_pLeft = rhs.m_pLeft;
	m_nLeafFlag = rhs.m_nLeafFlag;
	m_nLength = rhs.m_nLength;
	m_nWeight = rhs.m_nWeight;
	m_nPosFlag = rhs.m_nPosFlag;
	m_pFatherNode = rhs.m_pFatherNode;
	m_nHeight = rhs.m_nHeight;
	m_nLTag = rhs.m_nLTag;
	m_nRTag = rhs.m_nRTag;
	m_pRight = rhs.m_pRight;
	m_nVisit = rhs.m_nVisit;
	m_nData = rhs.m_nData;
	m_nShareNum = ++rhs.m_nShareNum;

}

template<typename N>
KNode<N>& KNode<N>::operator=(const KNode<N>& rhs)
{
	if (&rhs != this)
	{
		m_nHtemp = rhs.m_nHtemp;
		m_pLeft = rhs.m_pLeft;
		m_nLeafFlag = rhs.m_nLeafFlag;
		m_nLength = rhs.m_nLength;
		m_nWeight = rhs.m_nWeight;
		m_nPosFlag = rhs.m_nPosFlag;
		m_pFatherNode = rhs.m_pFatherNode;
		m_nHeight = rhs.m_nHeight;
		m_nLTag = rhs.m_nLTag;
		m_nRTag = rhs.m_nRTag;
		m_pRight = rhs.m_pRight;
		m_nVisit = rhs.m_nVisit;
		m_nData = rhs.m_nData;
		m_nShareNum = ++rhs.m_nShareNum;
	}

	return *this;
}

template<typename N>
KNode<N>::KNode(const KNode<N>&& rhs)
{
	if (&rhs != this)
	{
		m_nHtemp = rhs.m_nHtemp;
		m_pLeft = rhs.m_pLeft;
		m_nLeafFlag = rhs.m_nLeafFlag;
		m_nLength = rhs.m_nLength;
		m_nWeight = rhs.m_nWeight;
		m_nPosFlag = rhs.m_nPosFlag;
		m_pFatherNode = rhs.m_pFatherNode;
		m_nHeight = rhs.m_nHeight;
		m_nLTag = rhs.m_nLTag;
		m_nRTag = rhs.m_nRTag;
		m_pRight = rhs.m_pRight;
		m_nVisit = rhs.m_nVisit;
		m_nData = rhs.m_nData;
		m_nShareNum = ++rhs.m_nShareNum;
	}
}

template<typename N>
KNode<N>& KNode<N>::operator=(const KNode<N>&& rhs)
{
	if (&rhs != this)
	{
		m_nHtemp = rhs.m_nHtemp;
		m_pLeft = rhs.m_pLeft;
		m_nLeafFlag = rhs.m_nLeafFlag;
		m_nLength = rhs.m_nLength;
		m_nWeight = rhs.m_nWeight;
		m_nPosFlag = rhs.m_nPosFlag;
		m_pFatherNode = rhs.m_pFatherNode;
		m_nHeight = rhs.m_nHeight;
		m_nLTag = rhs.m_nLTag;
		m_nRTag = rhs.m_nRTag;
		m_pRight = rhs.m_pRight;
		m_nVisit = rhs.m_nVisit;
		m_nData = rhs.m_nData;
		m_nShareNum = ++rhs.m_nShareNum;
	}

	return *this;
}

#endif

  

KPNode.h

#ifndef DATA_STRUCT_KTREE_K_P_NODE_H
#define DATA_STRUCT_KTREE_K_P_NODE_H

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <assert.h>


#include "../KTree/KNode.h"

template<typename N>

struct compare {
	bool operator() (const  KPNode<N> &lhs, const  KPNode<N> &rhs) const{
		return (lhs.m_pNode->m_nWeight > rhs.m_pNode->m_nWeight);
	}
};


template<typename N>
/**
 * 包含树节点指针的类,构造哈夫曼树是,放到set 结点中,只复制指针,提高效率
 */
class KPNode
{
public:
	KNode<N>* m_pNode;

public:
	KPNode();
	KPNode(N v);

	KPNode(KNode<N>* v);

	/**
	 * 析构时,不释放m_pNode指针,由外层的调用 DeletePoint()函数来释放
	 */
	virtual ~KPNode();

	KPNode(const KPNode<N>& rhs);

	KPNode<N>& operator=(const KPNode<N>& rhs);

	/**
	 * 释放 m_pNode 结点
	 */
	void DeletePoint();

	bool operator<(const KPNode<N>& tmp) const{
		if (this->m_pNode->m_nWeight < tmp.m_pNode->m_nWeight)
			return true;   //自定义排序规则
		return false;
	}




};

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <assert.h>


template<typename N>
KPNode<N>::KPNode()
{
	m_pNode = nullptr;
}


template<typename N>
KPNode<N>::KPNode(N v)
{
	//m_pNode = nullptr;
	m_pNode = new (std::nothrow)  KNode<N>(v);
}

template<typename N>
KPNode<N>::KPNode(KNode<N>* v)
{
	//if (m_pNode != v && nullptr != m_pNode)
	//{
	//	DeletePoint();
	//}
//	v->m_nShareNum++;
	m_pNode = v;

}

template<typename N>
KPNode<N>::~KPNode()
{
	// DeletePoint();
	// m_pNode = nullptr;
}

template<typename N>
KPNode<N>::KPNode(const KPNode<N>& rhs)
{
	if (&rhs != this)
	{
		m_pNode = rhs.m_pNode;
//		m_pNode->m_nShareNum++;
	}
}

template<typename N>
KPNode<N>& KPNode<N>::operator=(const KPNode<N>& rhs)
{
	if (&rhs != this)
	{
		m_pNode = rhs.m_pNode;
//		m_pNode->m_nShareNum++;
	}

	return *this;
}


template<typename N>
void KPNode<N>::DeletePoint()
{
//if (nullptr == m_pNode)
//{
//	return;
//}

//	int k = m_pNode->m_arrayNode.size();
//	if (nullptr != m_pNode->m_pLeft.m_pNode)
//	{
//		k++;
//	}
//	if (nullptr != m_pNode->m_pRight.m_pNode)
//	{
//		k++;
//	}
//
//	// 引用计数减一
////	m_pNode->m_nShareNum--;
//	if (m_pNode->m_nShareNum == k)
//	{
//		delete m_pNode;
//		m_pNode = nullptr;
//	}


	delete m_pNode;
	m_pNode = nullptr;
}






#endif

  

KTree.h

#ifndef DATA_STRUCT_KTREE_K_TREE_H
#define DATA_STRUCT_KTREE_K_TREE_H

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <assert.h>


#include "../KTree/KPNode.h"
//#include "../KTree/KBinaryTree.h"

template<typename N>
class KBinaryTree;

template<typename N>
/**
 * 普通树
 */
class KTree
{
protected:
	/**
	 * 0 普通树 1-二叉树
	 */
	int m_nBinaryFlag;

	/**
	 * 根结点
	 */
	KPNode<N> m_stRoot;

	/**
	 * 保存遍历后的结果结点
	 */
	vector<KPNode<N>> m_hNodeArray;

/*
	/ **
	* 共享次数,析构时,判断用
	* /
	int m_nShareNum;*/

protected:
	/**
	 * 二叉树的先序遍历
	 */
	void PerOrderBST();

	/**
	 * 二叉树的后序遍历
	 */
	void PostOrderBST();

	/**
	 * 非二叉树的先序遍历
	 */
	void PerOrderOther();

	/**
	 * 非二叉树的后序遍历
	 */
	void PostOrderOther();

	// 二叉树的层次遍历
	void LevelTraversalBST();

	// 普通树的层次遍历
	void LevelTraversalOther();

	// 构造树
	void CreateKTree(vector<N> v, vector<int> level_num)
	{
		if (v.size() > 0)
		{
			m_stRoot = KPNode<N>(v[0]);
			m_stRoot.m_pNode->m_nPosFlag = 2;
		}

		// 开始构建树
		// 使用队列,对结点进行赋值操作
		queue<KPNode<N>> temp_queue;
		temp_queue.push(m_stRoot);

		int i = 1;
		// 结点数量
		for (auto num : level_num)
		{
			if (temp_queue.empty())
			{
				break;
			}

			KPNode<N> node = temp_queue.front();
			temp_queue.pop();

			for (int j = 0; j < num && i < (int)v.size(); i++, j++)
			{
				KPNode<N> new_node = KPNode<N>(v[i]);
				node.m_pNode->m_arrayNode.push_back(new_node.m_pNode);
				new_node.m_pNode->m_pFatherNode = node.m_pNode;
				temp_queue.push(new_node);
			}
		}
	}

	// 删除原树结点
	void delete_point()
	{
		if (nullptr == m_stRoot.m_pNode)
		{
			return;
		}

		m_stRoot.m_pNode->m_nShareNum--;
		if (0 == m_stRoot.m_pNode->m_nShareNum)
		{
			cout << "delete tree:";
			// 树进行层次遍历
			LevelTraversal();
			// 释放节点
			for (auto v : m_hNodeArray)
			{
				//v.m_pNode->m_nShareNum = 2;
				v.DeletePoint();
			}
			cout << endl;
		}
	}



public:
	/**
	 * 默认构造函数
	 */
	KTree();
	//{
	//	m_nBinaryFlag = 0;
	//	m_stRoot = nullptr;
	//}

	KTree(KPNode<N>& n){
		m_stRoot = n; 
		m_stRoot.m_pNode->m_nShareNum++; 
	}


	/**
	 * 构造函数
	 * vector<int> level_num 按层次,从左到右后,续结点的个数
	 */
	KTree(vector<N> v, vector<int> level_num);

	/**
	 * 析构函数
	 */
	virtual ~KTree();

	/**
	 * 拷贝构造
	 */
	KTree(const KTree<N>& rhs);

	/**
	 * 拷贝赋值函数
	 */
	KTree operator=(const KTree<N>& rhs);

	/**
	 * 树的层次遍历
	 */
	void LevelTraversal();

	/**
	 * 先根/先序遍历
	 */
	void PerOrder();

	/**
	 * 后序遍历
	 */
	void PostOrder();

	/**
	 * 打印 保存遍历结果的结点数组
	 */
	void PrintNodeArray();

	/**
	 * 取得打印结果数组 
	 */
	void GetNodeArray(vector<N>& dest);

	/**
	 * 树的并查集之并操作
	 */
	void Union(KTree<N>& rhs);

	/**
	 * 树的并查集之查操作
	 */
	KPNode<N> Select();

	/**
	 * 转换为二叉树 true 成功  false 失败
	 */
	KBinaryTree<N> ConvertKBinaryTree();

};

//#include "../KTree/KTree.cpp"


#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <queue>
#include <assert.h>

//#include "KTree.h"
//#include "KBinaryTree.h"

//template<typename N>
//class KBinaryTree;

template<typename N>
KTree<N>::KTree()
{
	m_nBinaryFlag = 0;
	//m_stRoot = nullptr;
	//m_nShareNum = 1;
}

template<typename N>
KTree<N>::KTree(vector<N> v, vector<int> level_num)
{
	m_nBinaryFlag = 0;
	
	// 创建树
	CreateKTree(v, level_num);
}

template<typename N>
KTree<N>::~KTree()
{
	//int k = m_stRoot.m_pNode->m_arrayNode.size();
	//if (nullptr != m_stRoot.m_pNode->m_pLeft.m_pNode)
	//{
	//	k++;
	//}
	//if (nullptr != m_stRoot.m_pNode->m_pRight.m_pNode)
	//{
	//	k++;
	//}
	//m_hNodeArray.clear();
	if (nullptr == m_stRoot.m_pNode)
	{
		return;
	}

	m_stRoot.m_pNode->m_nShareNum--;
	if (0 == m_stRoot.m_pNode->m_nShareNum)
	{
		cout << "delete tree:";
		// 树进行层次遍历
		LevelTraversal();
		// 释放节点
		for (auto v : m_hNodeArray)
		{
			//v.m_pNode->m_nShareNum = 2;
			v.DeletePoint();
		}
		cout << endl;
	}

}

template<typename N>
KTree<N>::KTree(const KTree<N>& rhs)
{
//	m_nBinaryFlag = 0;
	if (&rhs != this)
	{
		delete_point();
		m_stRoot = rhs.m_stRoot;
		m_stRoot.m_pNode->m_nShareNum++;
	}
}

template<typename N>
KTree<N> KTree<N>::operator=(const KTree<N>& rhs)
{
//	m_nBinaryFlag = 0;
	if (&rhs != this)
	{
		delete_point();
		m_stRoot = rhs.m_stRoot;
		m_stRoot.m_pNode->m_nShareNum++;
	}

	return *this;
}


template<typename N>
void KTree<N>::LevelTraversal()
{
	m_hNodeArray.clear();
	if (0 == m_nBinaryFlag)
	{
		LevelTraversalOther();
	}
	else
	{
		LevelTraversalBST();
	}
}

template<typename N>
void KTree<N>::PerOrder()
{
	m_hNodeArray.clear();
	if (0 == m_nBinaryFlag)
	{
		PerOrderOther();
	}
	else
	{
		PerOrderBST();
	}
}

template<typename N>
void KTree<N>::PostOrder()
{
	m_hNodeArray.clear();
	if (0 == m_nBinaryFlag)
	{
		PostOrderOther();
	}
	else
	{
		PostOrderBST();
	}
}


template<typename N>
void KTree<N>::PrintNodeArray()
{
	cout << "m_nData:" << endl;
	for (auto v : m_hNodeArray)
	{
		cout << v.m_pNode->m_nData << '\t';
	}
	cout << endl;


	cout << "m_strCode:" << endl;
	for (auto v : m_hNodeArray)
	{
		cout << v.m_pNode->m_strCode << '\t';
	}
	cout << endl;

	cout << "m_nLength:" << endl;
	for (auto v : m_hNodeArray)
	{
		cout << v.m_pNode->m_nLength << '\t';
	}
	cout << endl;

	cout << "m_nWeight:" << endl;
	for (auto v : m_hNodeArray)
	{
		cout << v.m_pNode->m_nWeight << '\t';
	}
	cout << endl;
}

template<typename N>
void KTree<N>::GetNodeArray(vector<N>& dest)
{
	dest.clear();

	for (auto v : m_hNodeArray)
	{
		dest.push_back(v.m_pNode->m_nData);
	}
}


template<typename N>
void KTree<N>::Union(KTree<N>& rhs)
{
	rhs.m_stRoot.m_pNode->m_pFatherNode = m_stRoot.m_pNode;
	rhs.m_stRoot.m_pNode->m_nPosFlag = 0;
	m_stRoot.m_pNode->m_arrayNode.push_back(rhs.m_stRoot.m_pNode);
	//delete rhs.m_stRoot;
	m_stRoot.m_pNode->m_nShareNum += rhs.m_stRoot.m_pNode->m_nShareNum;
	rhs.m_stRoot = m_stRoot;
}


template<typename N>
KPNode<N> KTree<N>::Select()
{
	return m_stRoot;
}


// 树 转 二叉树
template<typename N>
KBinaryTree<N> KTree<N>::ConvertKBinaryTree()
{
	//if (1 == m_nBinaryFlag)
	//{
	//	return *this;
	//}
	m_nBinaryFlag = 1;
	KBinaryTree<N> bintree;
	auto T = m_stRoot.m_pNode;
	if (T == nullptr)
	{
		return bintree;
	}

	//m_stRoot.m_pNode->m_nShareNum++;
	queue<KPNode<N>> node_queue;
	node_queue.push(m_stRoot);

	while (!node_queue.empty())
	{
		auto K = node_queue.front();
		node_queue.pop();
		if (K.m_pNode->m_arrayNode.size() == 0)
		{
			continue;
		}

		// 左结点
		K.m_pNode->m_pLeft = K.m_pNode->m_arrayNode[0];
		K.m_pNode->m_arrayNode[0].m_pNode->m_pFatherNode = K.m_pNode;
		K.m_pNode->m_arrayNode[0].m_pNode->m_nPosFlag = 0;
		node_queue.push(K.m_pNode->m_arrayNode[0]);
		
		size_t i = 1;

		// 右结点
		for (; i< K.m_pNode->m_arrayNode.size(); i++)
		{
			K.m_pNode->m_arrayNode[i - 1].m_pNode->m_pRight = K.m_pNode->m_arrayNode[i];
			K.m_pNode->m_arrayNode[i].m_pNode->m_pFatherNode = K.m_pNode->m_arrayNode[i - 1];
			K.m_pNode->m_arrayNode[i].m_pNode->m_nPosFlag = 1;
			node_queue.push(K.m_pNode->m_arrayNode[i]);
		}

		K.m_pNode->m_arrayNode.clear();
	}

	return KBinaryTree<N>(m_stRoot);
}


template<typename N>
void KTree<N>::PerOrderBST()
{
	if (m_stRoot.m_pNode == nullptr)
	{
		return ;
	}

	stack<KPNode<N>> node_stack;
	node_stack.push(m_stRoot);

	while (!node_stack.empty())
	{
		auto K = node_stack.top();
		node_stack.pop();

		m_hNodeArray.push_back(K);

		// 右子树入栈
		if (nullptr != K.m_pNode->m_pRight.m_pNode)
		{
			node_stack.push(K.m_pNode->m_pRight);
		}

		// 左子树入栈
		if (nullptr != K.m_pNode->m_pLeft.m_pNode)
		{
			node_stack.push(K.m_pNode->m_pLeft);
		}
	}
}


template<typename N>
void KTree<N>::PostOrderBST()
{
	if (m_stRoot.m_pNode == nullptr)
	{
		return;
	}

	stack<KPNode<N>> node_stack;
	node_stack.push(m_stRoot);

	while (!node_stack.empty())
	{
		auto K = node_stack.top();
		node_stack.pop();

		if (K.m_pNode->m_nVisit == 2)
		{
			if (nullptr != K.m_pNode->m_pFatherNode.m_pNode)
			{
				K.m_pNode->m_pFatherNode.m_pNode->m_nVisit++;
			}

			m_hNodeArray.push_back(K);
			K.m_pNode->m_nVisit = 0;

			continue;
		}

		node_stack.push(K);

		// 右结点入栈
		if (nullptr != K.m_pNode->m_pRight.m_pNode)
		{
			node_stack.push(K.m_pNode->m_pRight.m_pNode);
		}
		else
		{
			K.m_pNode->m_nVisit++;
		}

		// 左结点入栈
		if (nullptr != K.m_pNode->m_pLeft.m_pNode)
		{
			node_stack.push(K.m_pNode->m_pLeft.m_pNode);
		}
		else
		{
			K.m_pNode->m_nVisit++;
		}
	}
}



template<typename N>
void KTree<N>::PerOrderOther()
{
	if (m_stRoot.m_pNode == nullptr)
	{
		return;
	}

	stack<KPNode<N>> node_stack;
	node_stack.push(m_stRoot);

	while (!node_stack.empty())
	{
		auto K = node_stack.top();
		node_stack.pop();
		m_hNodeArray.push_back(K);

		// 子树逆序入栈
		for (int i = K.m_pNode->m_arrayNode.size() - 1; i >= 0; i--)
		{
			node_stack.push(K.m_pNode->m_arrayNode[i]);
		}
	}
}


template<typename N>
void KTree<N>::PostOrderOther()
{
	if (m_stRoot.m_pNode == nullptr)
	{
		return;
	}

	stack<KPNode<N>> node_stack;
	node_stack.push(m_stRoot);

	while (!node_stack.empty())
	{
		auto K = node_stack.top();
		node_stack.pop();

		if (K.m_pNode->m_arrayNode.size() == 0 || K.m_pNode->m_nVisit > 0)
		{
			m_hNodeArray.push_back(K);
			continue;
		}

		K.m_pNode->m_nVisit++;
		node_stack.push(K);

		// 子树逆序入栈
		for (int i = K.m_pNode->m_arrayNode.size() - 1; i >= 0; i--)
		{
			node_stack.push(K.m_pNode->m_arrayNode[i]);
		}
	}
}


template<typename N>
void KTree<N>::LevelTraversalBST()
{
	if (nullptr == m_stRoot.m_pNode)
	{
		return;
	}

	queue<KPNode<N>> node_queue;
	node_queue.push(m_stRoot);

	while (!node_queue.empty())
	{
		KPNode<N> K = node_queue.front();
		node_queue.pop();
		m_hNodeArray.push_back(K);
		if (K.m_pNode->m_pLeft.m_pNode != nullptr && K.m_pNode->m_nLTag == 0)
		{
			node_queue.push(K.m_pNode->m_pLeft.m_pNode);
		}

		if (K.m_pNode->m_pRight.m_pNode != nullptr && K.m_pNode->m_nRTag == 0)
		{
			node_queue.push(K.m_pNode->m_pRight.m_pNode);
		}
	}

}


template<typename N>
void KTree<N>::LevelTraversalOther()
{
	if (nullptr == m_stRoot.m_pNode)
	{
		return;
	}

	queue<KPNode<N>> node_queue;
	node_queue.push(m_stRoot);

	while (!node_queue.empty())
	{
		KPNode<N> K = node_queue.front();
		node_queue.pop();

		m_hNodeArray.push_back(K);	// 保存扫描队列

		if (K.m_pNode->m_arrayNode.size() == 0)
		{
			continue;
		}

		for (auto v : K.m_pNode->m_arrayNode)
		{
			node_queue.push(v);
		}	
	}
}



#endif

  

KBinaryTree.h

#ifndef DATA_STRUCT_KTREE_K_BINARY_TREE_H
#define DATA_STRUCT_KTREE_K_BINARY_TREE_H

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <assert.h>

#include "../KTree/KTree.h"

template<typename N>
class KForest;


template<typename N>
/**
 * 二叉树
 */
class KBinaryTree : public KTree<N>
{
public:
	// 默认构造函数
	KBinaryTree(){ m_nBinaryFlag = 1; }
	

	// 默认构造函数
	KBinaryTree(KPNode<N>& t) :KTree(t){ m_nBinaryFlag = 1; }

	/**
	 * 构造函数
	 * pos_flag 0-左孩子结点 1-右孩子结点 2-root结点
	 */
	KBinaryTree(vector<N> v, vector<int> level_num, vector<int> pos_flag)
	{
		m_nBinaryFlag = 1;


		// 判断分支
		for (auto& v : level_num)
		{
			if (v > 2)
			{
				return;
			}
		}

		// 根结点创建
		if (v.size() == 0)
		{
			return;
		}
		m_stRoot = KPNode<N>(v[0]); 
		m_stRoot.m_pNode->m_nPosFlag = 2;

		// 其他结点创建
		// 使用队列,对结点进行赋值操作
		queue<KPNode<N>> temp_queue;
		temp_queue.push(m_stRoot);

		int i = 1;
		// 结点数量
		for (auto num : level_num)
		{
			if (temp_queue.empty())
			{
				break;
			}

			KPNode<N> node = temp_queue.front();
			temp_queue.pop();

			for (int j = 0; j < num && i < (int)v.size(); i++, j++)
			{
				KPNode<N> new_node = KPNode<N>(v[i]);

				if (0 == pos_flag[i])
				{
					node.m_pNode->m_pLeft = new_node;
				}
				else
				{
					node.m_pNode->m_pRight = new_node;
				}

				new_node.m_pNode->m_pFatherNode = node.m_pNode;
				temp_queue.push(new_node);
			}
		}
	}

	/**
	 * 析构函数
	 */
	virtual ~KBinaryTree()
	{
	}

	/**
	 * 拷贝构造函数
	 */
	KBinaryTree(KBinaryTree<N>& rhs)
		:KTree(rhs)
	{
//		m_nBinaryFlag = 1;
	}

	/**
	 * 赋值函数
	 */
	KBinaryTree operator=(KBinaryTree<N>& rhs)
	{

		if (this == &rhs) return *this;
		// 调用基类的 赋值构造函数
		KTree::operator=(rhs);
//		m_nBinaryFlag = 1;
		return *this;
	}


	// 左结点追加子树
	void AddChildTreeForRight(KBinaryTree<N>& rhs)
	{
		rhs.m_stRoot.m_pNode->m_nPosFlag = 1;;
		rhs.m_stRoot.m_pNode->m_nShareNum++;
		rhs.m_stRoot.m_pNode->m_pFatherNode = m_stRoot;
		m_stRoot.m_pNode->m_pRight = rhs.m_stRoot;

	}


	/**
	 * 中序遍历
	 */
	void MidOrder()
	{
		m_hNodeArray.clear();
		if (m_stRoot.m_pNode == nullptr)
		{
			return;
		}

		stack<KPNode<N>> node_stack;
		node_stack.push(m_stRoot);

		while (!node_stack.empty())
		{
			auto K = node_stack.top();
			node_stack.pop();

			if (K.m_pNode->m_nVisit == 1)
			{
				if (nullptr != K.m_pNode->m_pFatherNode.m_pNode)
				{
					K.m_pNode->m_pFatherNode.m_pNode->m_nVisit++;
				}

				m_hNodeArray.push_back(K);
				K.m_pNode->m_nVisit = 0;

				continue;
			}


			// 右结点入栈
			if (nullptr != K.m_pNode->m_pRight.m_pNode)
			{
				node_stack.push(K.m_pNode->m_pRight.m_pNode);
			}

			// 父结点入栈
			node_stack.push(K);

			// 左结点入栈
			if (nullptr != K.m_pNode->m_pLeft.m_pNode)
			{
				node_stack.push(K.m_pNode->m_pLeft.m_pNode);
			}
			else
			{
				K.m_pNode->m_nVisit++;
			}
		}
	}

	/**
	 * 先序线索化,按照先序遍历,把树结点链式化,中序、后序
	 */
	void PreCueing()
	{
		// 先序遍历
		PerOrder();

		// 清理线索化
		ClearCueing();

		// 先序线索化
		for (size_t i = 1; i < m_hNodeArray.size()-1; i++)
		{
			// 前驱节点
			if (nullptr == m_hNodeArray[i].m_pNode->m_pLeft.m_pNode)
			{
				m_hNodeArray[i].m_pNode->m_nLTag = 1;

				m_hNodeArray[i].m_pNode->m_pLeft.m_pNode = m_hNodeArray[i - 1].m_pNode;
			}

			// 后继节点
			if (nullptr == m_hNodeArray[i].m_pNode->m_pRight.m_pNode)
			{
				m_hNodeArray[i].m_pNode->m_nRTag = 1;

				m_hNodeArray[i].m_pNode->m_pRight.m_pNode = m_hNodeArray[i+1].m_pNode;
			}
		}


		// 先序线索化 打印结果
		cout << "先序线索化的结果: " << endl;
		for (size_t i = 1; i < m_hNodeArray.size() - 1; i++)
		{
			// 前驱节点
			if (1 == m_hNodeArray[i].m_pNode->m_nLTag)
			{
				cout << m_hNodeArray[i].m_pNode->m_nData << " 的前驱结点为:\t" << m_hNodeArray[i].m_pNode->m_pLeft.m_pNode->m_nData << endl;
			}

			// 后继节点
			if (1 == m_hNodeArray[i].m_pNode->m_nRTag)
			{
				cout << m_hNodeArray[i].m_pNode->m_nData << " 的后继结点为:\t" << m_hNodeArray[i].m_pNode->m_pRight.m_pNode->m_nData << endl;
			}
		}
	}

	/**
	 * 清理线索化
	 */
	void ClearCueing()
	{
		for (auto v : m_hNodeArray)
		{
			if (1 == v.m_pNode->m_nLTag)
			{
				v.m_pNode->m_pLeft.m_pNode = nullptr;
				v.m_pNode->m_nLTag = 0;
			}

			if (1 == v.m_pNode->m_nRTag)
			{
				v.m_pNode->m_pRight.m_pNode = nullptr;
				v.m_pNode->m_nLTag = 0;
			}	
		}
	}

	/**
	 * 二叉树转森林 true  成功  false 失败
	 */
	bool ConvertKForest(KForest<N>& hKForest)
	{
		if (nullptr == m_stRoot.m_pNode)
		{
			return false;
		}

		vector<KTree<N>> KTreeArray;

		auto K = m_stRoot;
		auto temp_right = K.m_pNode->m_pRight;
		K.m_pNode->m_pRight.m_pNode = nullptr;
		//KTreeArray.push_back(K);
		auto temp = KBinaryTree<N>(K);
		KTreeArray.push_back(temp);

		while (nullptr != temp_right.m_pNode)
		{
			K = temp_right;
			temp_right = K.m_pNode->m_pRight;
			K.m_pNode->m_pRight.m_pNode = nullptr;

			temp = KBinaryTree<N>(K);
			KTreeArray.push_back(temp);
		}

		//for (auto& v : KTreeArray)
		//{
		//	v.m_nBinaryFlag = 1;
		//}

		hKForest = KForest<N>(KTreeArray);

		return true;
	}

	/**
	 * 二叉树转普通树 true  成功  false 失败
	 */
	bool ConvertKTree(KTree<N>& Tree)
	{
		if (0 == m_nBinaryFlag)
		{
			return true;
		}

		if (nullptr == m_stRoot.m_pNode)
		{
			m_nBinaryFlag = 0;
			Tree = *this;
			return true;
		}

		// 该树只能转换为森林
		if (nullptr != m_stRoot.m_pNode->m_pRight.m_pNode)
		{
			return false;
		}


		if (nullptr == m_stRoot.m_pNode->m_pLeft.m_pNode)
		{
			m_nBinaryFlag = 0;
			Tree = *this;
			return true;
		}

		queue<KPNode<N>> node_queue;
		node_queue.push(m_stRoot.m_pNode->m_pLeft);

		while (!node_queue.empty())
		{
			auto K = node_queue.front();
			node_queue.pop();
			auto F = K.m_pNode->m_pFatherNode;

			auto temp = K;
			auto R = temp.m_pNode->m_pRight;
			temp.m_pNode->m_pRight = nullptr;

			auto& node_array = F.m_pNode->m_arrayNode;
			node_array.clear();
			node_array.push_back(K);
			F.m_pNode->m_pLeft = nullptr;

			while (true)
			{
				if (nullptr != temp.m_pNode->m_pLeft.m_pNode)
				{
					node_queue.push(temp.m_pNode->m_pLeft);
				}

				if (nullptr == R.m_pNode)
				{
					break;
				}

				node_array.push_back(R);

				R.m_pNode->m_pFatherNode = F;

				temp = R;
				R = R.m_pNode->m_pRight;
				temp.m_pNode->m_pRight = nullptr;
			}
		}

		m_nBinaryFlag = 0;
		Tree = *this;
		return true;
	}

};

#endif

  

KForest.h

#ifndef DATA_STRUCT_KTREE_K_FOREST_H
#define DATA_STRUCT_KTREE_K_FOREST_H

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <assert.h>


#include "../KTree/KTree.h"
#include "../KTree/KBinaryTree.h"

template<typename N>
/**
 * 森林
 */
class KForest
{
protected:
	/**
	 * 森林遍历结果的保存值
	 */
	vector<KTree<N>> m_hTreeArray;

public:
	/**
	 * 构造函数
	 */
	KForest()
	{
	}


	KForest(vector<KTree<N>> v)
	{
		m_hTreeArray = v;
	}

	/**
	 * 析构函数
	 */
	~KForest()
	{

	}

	/**
	 * 拷贝构造函数
	 */
	KForest(const KForest<N>& rhs)
	{
		this->m_hTreeArray = rhs.m_hTreeArray;
	}

	/**
	 * 赋值函数
	 */
	KForest operator=(const KForest<N>& rhs)
	{
		if (this != &rhs)
		{
			this->m_hTreeArray = rhs.m_hTreeArray;
		}

		return *this;
	}

	/**
	 * 先序遍历
	 */
	void PerOrder()
	{
		for (auto& v : m_hTreeArray)
		{
			v.PerOrder();
		}
	}

	/**
	 * 后序遍历
	 */
	void PostOrder()
	{

		for (auto& v : m_hTreeArray)
		{
			v.PostOrder();
		}
	}

	/**
	 * 层次遍历
	 */
	void LevelTraversal()
	{
		for (auto& v : m_hTreeArray)
		{
			v.LevelTraversal();
		}
	}

	/**
	 * 打印遍历结果
	 */
	void PrintNodeArray()
	{
		for (auto& v : m_hTreeArray)
		{
			v.PrintNodeArray();
		}
	}

	/**
	 * 转换为二叉树 true 成功  false 失败
	 */
	KBinaryTree<N> ConvertKBinaryTree()
	{
		//KPNode root;
		vector<KBinaryTree<N>> KBinaryTreeArray;

		for (auto& v : m_hTreeArray)
		{
			KBinaryTreeArray.push_back(v.ConvertKBinaryTree());
		}

		// 二叉树组合
		for (size_t i = 1; i < KBinaryTreeArray.size(); i++)
		{
			KBinaryTreeArray[i - 1].AddChildTreeForRight(KBinaryTreeArray[i]);
		}

		if (KBinaryTreeArray.size() > 0)
		{
			return 	KBinaryTreeArray[0];
		}

		return KBinaryTree<N>();

	}

};

#endif

  

KBSTree.h

#ifndef DATA_STRUCT_KTREE_K_B_S_TREE_H
#define DATA_STRUCT_KTREE_K_B_S_TREE_H

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <assert.h>


#include "../KTree/KBinaryTree.h"
#include "../KTree/KPNode.h"

template<typename N>

/**
 * 二叉排序树/二叉查找树
 */
class KBSTree : public KBinaryTree<N>
{
protected:
	KPNode<N> m_stpNotAVLNode; // 非AVL树的起始节点
public:
	/**
	* 构造函数
	*/
	KBSTree()
	{
	}

	/**
	 * 构造函数
	 */
	KBSTree(vector<N> v)
	{
		for (auto n:v)
		{
			Insert(n);
		}
	}

	/**
	 * 析构函数
	 */
	~KBSTree()
	{

	}

	/**
	 * 拷贝构造函数
	 */
	KBSTree(KBSTree<N>& rhs)
		:KBinaryTree(rhs)
	{
	}

	/**
	 * 赋值函数
	 */
	KBSTree operator=(KBSTree<N>& rhs)
	{
		KBinaryTree::operator=(rhs);
	}

	/**
	 * 查找结点
	 */
	KPNode<N> Find(N v)
	{
		KPNode<N> ret;
		auto T = m_stRoot;
		while (true)
		{
			if (nullptr == T.m_pNode)
			{
				break;
			}

			if (v < T.m_pNode->m_nData)
			{
				T = T.m_pNode->m_pLeft;
				continue;
			}
			if (v > T.m_pNode->m_nData)
			{
				T = T.m_pNode->m_pRight;
				continue;
			}

			ret = T;
			break;
		}

		return ret;
	}


	// 插入结点
	virtual bool Insert(N v)
	{
		KPNode<N> NewNode(v);
		if (nullptr == m_stRoot.m_pNode)
		{
			m_stRoot = NewNode;
			m_stRoot.m_pNode->m_nPosFlag = 2;
			return true;
		}

		auto T = m_stRoot;
		while (true)
		{
			if (v < T.m_pNode->m_nData)
			{
				if (nullptr == T.m_pNode->m_pLeft.m_pNode)
				{
					NewNode.m_pNode->m_nPosFlag = 0;
					NewNode.m_pNode->m_pFatherNode = T;
					T.m_pNode->m_pLeft = NewNode;
					break;
				}
				T = T.m_pNode->m_pLeft;
				continue;
			}
			if (v > T.m_pNode->m_nData)
			{

				if (nullptr == T.m_pNode->m_pRight.m_pNode)
				{
					NewNode.m_pNode->m_nPosFlag = 1;
					NewNode.m_pNode->m_pFatherNode = T;
					T.m_pNode->m_pRight = NewNode;
					break;
				}
				T = T.m_pNode->m_pRight;
				continue;
			}
			break;
		}

		return true;
	}


	/**
	 * 删除结点【比较复杂】
	 */
	virtual bool Delete(N v)
	{
		// 查找结点
		auto T = Find(v);
		if (nullptr == T.m_pNode)
		{
			return false;
		}

		// 叶子结点
		if (nullptr == T.m_pNode->m_pLeft.m_pNode && nullptr == T.m_pNode->m_pRight.m_pNode)
		{
			//T.DeletePoint();
			if (0 == T.m_pNode->m_nPosFlag)
			{
				T.m_pNode->m_pFatherNode.m_pNode->m_pLeft.DeletePoint();
			}
			else if (1 == T.m_pNode->m_nPosFlag)
			{
				T.m_pNode->m_pFatherNode.m_pNode->m_pRight.DeletePoint();
			}
			else
			{
				T.DeletePoint();
			}


		}
		// 只有右孩子结点
		else if (nullptr == T.m_pNode->m_pLeft.m_pNode)
		{
			auto temp = T.m_pNode->m_pRight;
			T.m_pNode->m_nData = temp.m_pNode->m_nData;
			T.m_pNode->m_pLeft = temp.m_pNode->m_pLeft;
			T.m_pNode->m_pRight = temp.m_pNode->m_pRight;
			if (0 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pLeft.DeletePoint();
			}
			else if (1 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pRight.DeletePoint();
			}
			else
			{
				temp.DeletePoint();
			}
		}
		// 只有左孩子结点
		else if (nullptr == T.m_pNode->m_pRight.m_pNode)
		{
			auto temp = T.m_pNode->m_pLeft;
			T.m_pNode->m_nData = temp.m_pNode->m_nData;
			T.m_pNode->m_pLeft = temp.m_pNode->m_pLeft;
			T.m_pNode->m_pRight = temp.m_pNode->m_pRight;
			if (0 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pLeft.DeletePoint();
			}
			else if (1 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pRight.DeletePoint();
			}
			else
			{
				temp.DeletePoint();
			}
		}
		// 有双子结点
		else
		{
			auto temp = T.m_pNode->m_pLeft;
			// 寻找左孩子最右侧的结点
			while (nullptr != temp.m_pNode->m_pRight.m_pNode)
			{
				temp = temp.m_pNode->m_pRight;
			}
			T.m_pNode->m_nData = temp.m_pNode->m_nData;

			if (0 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pLeft.DeletePoint();
			}
			else if (1 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pRight.DeletePoint();
			}
			else
			{
				temp.DeletePoint();
			}
		}

		return true;
	}



	/**
	 * 判断当前 BST 是否为 AVL 树
	 * true  AVL 树, false 非AVL 树
	 * 空树不为AVL 树
	 * 使用了树的后序遍历
	 * 
	 */
	bool IsAVLTree(KPNode<N>& T)
	{
		int hl = 0, hr = 0;

		if (nullptr != T.m_pNode->m_pLeft.m_pNode)
		{
			hl = T.m_pNode->m_pLeft.m_pNode->m_nHeight;

		}
		if (nullptr != T.m_pNode->m_pRight.m_pNode)
		{
			hr = T.m_pNode->m_pRight.m_pNode->m_nHeight;
		}

		//判断当前结点为根结点的树是否为AVL 树
		if (abs(hl - hr) > 1)
		{
			return false;
		}

		T.m_pNode->m_nHeight = max(hl, hr) + 1;
		if (nullptr != T.m_pNode->m_pFatherNode.m_pNode)
		{
			T.m_pNode->m_pFatherNode.m_pNode->m_nHeight++;
			T.m_pNode->m_pFatherNode.m_pNode->m_nHeight = max(T.m_pNode->m_pFatherNode.m_pNode->m_nHeight, (T.m_pNode->m_nHeight + 1));
		}

		return true;
	}


	virtual bool IsAVLTree()
	{
		auto T = m_stRoot;
		if (nullptr == T.m_pNode)
		{
			return false;
		}

		// 保存结点的栈
		bool ret = true;
		stack<KPNode<N>> node_stack;
		node_stack.push(T);

		while (!node_stack.empty())
		{
			auto K = node_stack.top();
			node_stack.pop();

			if (K.m_pNode->m_nVisit == 2)
			{
				K.m_pNode->m_nVisit = 0;
				ret = IsAVLTree(K);
				// 子树不是AVL树的情况
				if (!ret)
				{
					// 记录非AVL树的根结点
					m_stpNotAVLNode = T;
					return ret;
				}
				continue;
			}

			// 当前结点入栈
			node_stack.push(K);

			// 左结点入栈
			if (nullptr != K.m_pNode->m_pRight.m_pNode && 0 == K.m_pNode->m_nVisit)
			{
				node_stack.push(K.m_pNode->m_pRight);
			}
			K.m_pNode->m_nVisit++;

			// 右结点入栈
			if (nullptr != K.m_pNode->m_pLeft.m_pNode && 1 == K.m_pNode->m_nVisit)
			{
				node_stack.push(K.m_pNode->m_pLeft);
			}
			K.m_pNode->m_nVisit++;
		}


		return ret;
	}

};

#endif

  

KAVLTree.h

#ifndef DATA_STRUCT_KTREE_K_A_V_L_TREE_H
#define DATA_STRUCT_KTREE_K_A_V_L_TREE_H

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <assert.h>


#include "../KTree/KBSTree.h"

template<typename N>
/**
 * AVL树/平衡二叉排序树
 */
class KAVLTree : public KBSTree<N>
{
protected:
	/**
	* m_nType:
	* L为0 R 为1
	* 00 LL 右单旋转
	* 11 RR 左单旋转
	* 01 LR 先左后右旋转
	* 10 RL 先右后左旋转
	*/
	int m_nType;

	//计算 m_nType 所经过的结点路径 -- 包括子树开始的根结点
	//vector<KPNode<N>> m_stTypeNodeArray; 

	int m_nIndex; // 从m_stPassNodeArray数组中,那个下标开始,树开始不平衡了

	// 插入/删除 经过的结点数组
	vector<KPNode<N>> m_stPassNodeArray;
private:

	// 旋转功能里面不做高度的处理
	/**
	 * LL 右单旋转
	 */
	void LLSpin(KPNode<N> A, KPNode<N> B, KPNode<N> F)
	{
		// B获得A 的posflag
		swap(B.m_pNode->m_nPosFlag, A.m_pNode->m_nPosFlag);
		// B 父结点的变化
		B.m_pNode->m_pFatherNode = F;

		// 左孩子
		if (B.m_pNode->m_nPosFlag == 0)
		{
			F.m_pNode->m_pLeft = B;
		}
		// 右孩子
		else if (B.m_pNode->m_nPosFlag == 1)
		{
			F.m_pNode->m_pRight = B;
		}
		// 根结点
		else
		{
			// do nothing;
		}


		// 根结点的转移
		if (2 == B.m_pNode->m_nPosFlag)
		{
			m_stRoot = B;
		}

		// B的右子树变为A的左子树
		A.m_pNode->m_pLeft = B.m_pNode->m_pRight;
		if (nullptr != B.m_pNode->m_pRight.m_pNode)
		{
			B.m_pNode->m_pRight.m_pNode->m_nPosFlag = 0;
			B.m_pNode->m_pRight.m_pNode->m_pFatherNode = A;
		}
		

		// A作为B的右结点
		B.m_pNode->m_pRight = A;
		A.m_pNode->m_nPosFlag = 1;
		A.m_pNode->m_pFatherNode = B;



	
	}

	/**
	 * RR 左单旋转
	 */
	void RRSpin(KPNode<N> A, KPNode<N> B, KPNode<N> F)
	{
		// B获得A 的posflag
		//B.m_pNode->m_nPosFlag = A.m_pNode->m_nPosFlag;
		swap(B.m_pNode->m_nPosFlag, A.m_pNode->m_nPosFlag);
		// B 父结点的变化
		B.m_pNode->m_pFatherNode = F;

		// 左孩子
		if (B.m_pNode->m_nPosFlag == 0)
		{
			F.m_pNode->m_pLeft = B;
		}
		// 右孩子
		else if (B.m_pNode->m_nPosFlag == 1)
		{
			F.m_pNode->m_pRight = B;
		}
		// 根结点
		else
		{
			// do nothing;
		}


		// 根结点的转移
		if (2 == B.m_pNode->m_nPosFlag)
		{
			m_stRoot = B;
		}

		// B的左子树变为A的右子树
		A.m_pNode->m_pRight = B.m_pNode->m_pLeft;
		if (nullptr != B.m_pNode->m_pLeft.m_pNode)
		{
			B.m_pNode->m_pLeft.m_pNode->m_nPosFlag = 1;
			B.m_pNode->m_pLeft.m_pNode->m_pFatherNode = A;
		}

		// A作为B的左结点
		B.m_pNode->m_pLeft = A;
		A.m_pNode->m_nPosFlag = 0;
		A.m_pNode->m_pFatherNode = B;




	}

	/**
	 * LR 先左后右旋转
	 */
	void LRSpin(KPNode<N>& A, KPNode<N>& B)
	{
		RRSpin(B, B.m_pNode->m_pRight, B.m_pNode->m_pFatherNode);
		LLSpin(A, A.m_pNode->m_pLeft, A.m_pNode->m_pFatherNode);
	}

	/**
	 * RL 先右后左旋转
	 */
	void RLSpin(KPNode<N>& A, KPNode<N>& B)
	{
		LLSpin(B, B.m_pNode->m_pLeft, B.m_pNode->m_pFatherNode);
		RRSpin(A, A.m_pNode->m_pRight, A.m_pNode->m_pFatherNode);
	}

//public:
	/**
	* 是否为 AVL树
	*/
	bool IsAVLTree(KPNode<N>& T)
	{
		int hl = 0, hr = 0;
		if (nullptr != T.m_pNode->m_pLeft.m_pNode)
		{
			hl = T.m_pNode->m_pLeft.m_pNode->m_nHtemp;

		}
		if (nullptr != T.m_pNode->m_pRight.m_pNode)
		{
			hr = T.m_pNode->m_pRight.m_pNode->m_nHtemp;
		}

		//判断当前结点为根结点的树是否为AVL 树
		if (abs(hl - hr) > 1)
		{
			return false;
		}

		return true;
	}


public:
	KAVLTree(){}

	/**
	 * 构造函数
	 */


	KAVLTree(vector<N> v)
	{
		// 一次插入结点
		for (auto n:v)
		{
			Insert(n);
		}
	}

	/**
	 * 析构函数
	 */
	~KAVLTree()
	{

	}

	/**
	 * 拷贝构造函数
	 */
	KAVLTree(KAVLTree<N>& rhs) :KBinaryTree(rhs)
	{
	}

	/**
	 * 赋值函数
	 */
	KAVLTree<N> operator=(KAVLTree<N>& rhs)
	{
		KBinaryTree::operator=(rhs);
	}

	/**
	 * m_nType:
	 * L为0 R 为1
	 * 00 LL 右单旋转 
	 * 11 RR 左单旋转
	 * 01 LR 先左后右旋转
	 * 10 RL 先右后左旋转
	 */
	void AVLSpin()
	{
		switch (m_nType)
		{
		case 0: //00 LL 右单旋转 
			{
				m_stPassNodeArray[m_nIndex].m_pNode->m_nHeight -= 1;
				for (size_t i = m_nIndex + 1; i < m_stPassNodeArray.size(); i++)
				{
					m_stPassNodeArray[i].m_pNode->m_nHeight += 1;
				}
				LLSpin(m_stPassNodeArray[m_nIndex], m_stPassNodeArray[m_nIndex + 1], m_stPassNodeArray[m_nIndex].m_pNode->m_pFatherNode);
			}
			break;

		case 1:// 01 LR 先左后右旋转
			{
				m_stPassNodeArray[m_nIndex].m_pNode->m_nHeight -= 1;
				m_stPassNodeArray[m_nIndex+2].m_pNode->m_nHeight += 2;
				for (size_t i = m_nIndex + 3; i < m_stPassNodeArray.size(); i++)
				{
					m_stPassNodeArray[i].m_pNode->m_nHeight += 1;
				}
				LRSpin(m_stPassNodeArray[m_nIndex], m_stPassNodeArray[m_nIndex + 1]);
			}
			break;

		case 2:// 10 RL 先右后左旋转
			{
				m_stPassNodeArray[m_nIndex].m_pNode->m_nHeight -= 1;
				m_stPassNodeArray[m_nIndex + 2].m_pNode->m_nHeight += 2;
				for (size_t i = m_nIndex + 3; i < m_stPassNodeArray.size(); i++)
				{
					m_stPassNodeArray[i].m_pNode->m_nHeight += 1;
				}
				RLSpin(m_stPassNodeArray[m_nIndex], m_stPassNodeArray[m_nIndex + 1]);
			}
			break;

		case 3://11 RR 左单旋转
			{
				m_stPassNodeArray[m_nIndex].m_pNode->m_nHeight -= 1;
				for (size_t i = m_nIndex + 1; i < m_stPassNodeArray.size(); i++)
				{
					m_stPassNodeArray[i].m_pNode->m_nHeight += 1;
				}
				RRSpin(m_stPassNodeArray[m_nIndex], m_stPassNodeArray[m_nIndex + 1], m_stPassNodeArray[m_nIndex].m_pNode->m_pFatherNode);
			}

			break;

		default:
			break;
		}
	}


	// 设定旋转类型
	// 从上向下计算 -- 应对删除操作
	void SetAVLSpinType()
	{
		//m_nType = m_stPassNodeArray[m_nIndex+1].m_pNode->m_nPosFlag << 1;
		//m_nType += m_stPassNodeArray[m_nIndex+2].m_pNode->m_nPosFlag
		int first = 0; // m_nType的二进制第1位
		int second = 0; // m_nType的二进制第0位

		auto T = m_stPassNodeArray[m_nIndex];



		int hl = 0, hr = 0;

		if (nullptr != T.m_pNode->m_pLeft.m_pNode)
		{
			hl = T.m_pNode->m_pLeft.m_pNode->m_nHtemp;
		}

		if (nullptr != T.m_pNode->m_pRight.m_pNode)
		{
			hr = T.m_pNode->m_pRight.m_pNode->m_nHtemp;
		}


		// m_nType的二进制第1位 求值
		if (hl  > hr)
		{
			first = 0;
			T = T.m_pNode->m_pLeft;
		}
		else
		{
			first = 1;
			T = T.m_pNode->m_pRight;
		}

		if ((int)m_stPassNodeArray.size() > m_nIndex + 1)
		{
			m_stPassNodeArray[m_nIndex + 1] = T;
		}
		else
		{
			m_stPassNodeArray.push_back(T);
		}



		hl = 0, hr = 0;
		if (nullptr != T.m_pNode->m_pLeft.m_pNode)
		{
			hl = T.m_pNode->m_pLeft.m_pNode->m_nHtemp;
		}

		if (nullptr != T.m_pNode->m_pRight.m_pNode)
		{
			hr = T.m_pNode->m_pRight.m_pNode->m_nHtemp;
		}



		// m_nType的二进制第0位求值
		if (hl == hr)
		{
			second = first;
		}
		else if (hl > hr)
		{
			second = 0;
		} 
		else
		{
			second = 1;
		}


		///////
		if (0 == second)
		{
			T = T.m_pNode->m_pLeft;
		}
		else
		{
			T = T.m_pNode->m_pRight;
		}

		if ((int)m_stPassNodeArray.size() > m_nIndex + 2)
		{
			m_stPassNodeArray[m_nIndex + 2] = T;
		}
		else
		{
			m_stPassNodeArray.push_back(T);
		}

		//////


		// 计算 m_nType 值
		m_nType = first << 1;
		m_nType += second;
	}


	/**
	 * 插入结点
	 */
	virtual bool Insert(N v)
	{
		m_stPassNodeArray.clear();
		KPNode<N> NewNode(v);
		if (nullptr == m_stRoot.m_pNode)
		{
			m_stRoot = NewNode;
			m_stRoot.m_pNode->m_nPosFlag = 2;
			return true;
		}

		auto IsExsitNode = true;
		auto T = m_stRoot;
		while (true)
		{
			m_stPassNodeArray.push_back(T);
			if (v < T.m_pNode->m_nData)
			{
				if (nullptr == T.m_pNode->m_pLeft.m_pNode)
				{
					NewNode.m_pNode->m_nPosFlag = 0;
					NewNode.m_pNode->m_pFatherNode = T;
					T.m_pNode->m_pLeft = NewNode;

					if (nullptr == T.m_pNode->m_pRight.m_pNode)
					{
						IsExsitNode = false;
					}


					break;
				}
				T = T.m_pNode->m_pLeft;
				continue;
			}
			if (v > T.m_pNode->m_nData)
			{

				if (nullptr == T.m_pNode->m_pRight.m_pNode)
				{
					NewNode.m_pNode->m_nPosFlag = 1;
					NewNode.m_pNode->m_pFatherNode = T;
					T.m_pNode->m_pRight = NewNode;

					if (nullptr == T.m_pNode->m_pLeft.m_pNode)
					{
						IsExsitNode = false;
					}

					break;
				}
				T = T.m_pNode->m_pRight;
				continue;
			}
			break;
		}

		if (IsExsitNode)
		{
			return true;
		}

		m_stPassNodeArray.push_back(NewNode);

		// 计算 temp 高度
		m_stPassNodeArray[m_stPassNodeArray.size() - 1].m_pNode->m_nHtemp = m_stPassNodeArray[m_stPassNodeArray.size() - 1].m_pNode->m_nHeight;
		for (int i = (int)m_stPassNodeArray.size()-1; i > 0; i--)
		{
			m_stPassNodeArray[i - 1].m_pNode->m_nHtemp = max(m_stPassNodeArray[i - 1].m_pNode->m_nHeight, m_stPassNodeArray[i].m_pNode->m_nHtemp + 1);
		}

		// AVL树的判断及其旋转
		for (int i = (int)m_stPassNodeArray.size()-1; i >= 0; i--)
		{
			bool ret = IsAVLTree(m_stPassNodeArray[i]);
			if (!ret)
			{
				m_nIndex = (int)i;
				SetAVLSpinType();
				AVLSpin();
				break;
			}
			else
			{
				m_stPassNodeArray[i].m_pNode->m_nHeight = m_stPassNodeArray[i].m_pNode->m_nHtemp;
			}
		}

		return true;
	}


	/**
	 * 删除结点
	 * 先找到旋转因子,再判断使用什么旋转--找到 导致旋转的差值在哪里
	 */
	virtual bool Delete(N v)
	{
		m_stPassNodeArray.clear();
		bool ret = true;
		auto T = m_stRoot;
		auto F = m_stRoot;
		while (true)
		{
			m_stPassNodeArray.push_back(T);
			if (nullptr == T.m_pNode)
			{
				ret = false;
				break;
			}

			if (v < T.m_pNode->m_nData)
			{
				T = T.m_pNode->m_pLeft;
				//m_stPassNodeArray.push_back(T);
				continue;
			}
			if (v > T.m_pNode->m_nData)
			{
				T = T.m_pNode->m_pRight;
				//m_stPassNodeArray.push_back(T);
				continue;
			}

			// 记录被删除结点的父结点
			F = T.m_pNode->m_pFatherNode;
			break;
		}

		// 查找值失败
		if (!ret)
		{
			return false;
		}

		// int nPosFlag = 0; // 结点位置
		KPNode<N> stPosNode;
		// 叶子结点
		if (nullptr == T.m_pNode->m_pLeft.m_pNode && nullptr == T.m_pNode->m_pRight.m_pNode)
		{
			m_stPassNodeArray.erase(m_stPassNodeArray.begin() + m_stPassNodeArray.size()-1);
			//T.DeletePoint();
			if (0 == T.m_pNode->m_nPosFlag)
			{
				stPosNode = T.m_pNode->m_pFatherNode.m_pNode->m_pRight;
				T.m_pNode->m_pFatherNode.m_pNode->m_pLeft.DeletePoint();
	
			}
			else if (1 == T.m_pNode->m_nPosFlag)
			{
				stPosNode = T.m_pNode->m_pFatherNode.m_pNode->m_pLeft;
				T.m_pNode->m_pFatherNode.m_pNode->m_pRight.DeletePoint();
			}
			else
			{
				T.DeletePoint();
				m_stRoot.m_pNode = nullptr; // 树变为空树
				return true;
			}

			// 父结点还有子树,高度未变化,仍然是一颗AVL树
			if (nullptr != stPosNode.m_pNode && stPosNode.m_pNode->m_nHeight <= 1)
			{
				return true;
			}
		}

		// 只有右孩子结点
		else if (nullptr == T.m_pNode->m_pLeft.m_pNode)
		{
			auto temp = T.m_pNode->m_pRight;
			T.m_pNode->m_nData = temp.m_pNode->m_nData;
			T.m_pNode->m_pLeft = temp.m_pNode->m_pLeft;
			T.m_pNode->m_pRight = temp.m_pNode->m_pRight;
			if (0 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pLeft.DeletePoint();
			}
			else if (1 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pRight.DeletePoint();
			}
			else
			{
				temp.DeletePoint();
			}
		}

		// 只有左孩子结点
		else if (nullptr == T.m_pNode->m_pRight.m_pNode)
		{
			auto temp = T.m_pNode->m_pLeft;
			T.m_pNode->m_nData = temp.m_pNode->m_nData;
			T.m_pNode->m_pLeft = temp.m_pNode->m_pLeft;
			T.m_pNode->m_pRight = temp.m_pNode->m_pRight;
			if (0 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pLeft.DeletePoint();
			}
			else if (1 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pRight.DeletePoint();
			}
			else
			{
				temp.DeletePoint();
			}
		}
		// 有双子结点
		else
		{
			auto temp = T.m_pNode->m_pLeft;

			// 寻找左孩子最右侧的结点
			while (nullptr != temp.m_pNode->m_pRight.m_pNode)
			{
				temp = temp.m_pNode->m_pRight;
			}

			F = temp.m_pNode->m_pFatherNode;
			stPosNode = F.m_pNode->m_pLeft; // 被替换结点的兄弟(左)结点

			int data_temp = T.m_pNode->m_nData;
			T.m_pNode->m_nData = temp.m_pNode->m_nData;
			temp.m_pNode->m_nData = data_temp;

			if (0 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pLeft.DeletePoint();
			}
			else if (1 == temp.m_pNode->m_nPosFlag)
			{
				temp.m_pNode->m_pFatherNode.m_pNode->m_pRight.DeletePoint();
			}
			else
			{
				temp.DeletePoint();
			}

			// 父结点还有子树,高度未变化,仍然是一颗AVL树
			if (nullptr != stPosNode.m_pNode && stPosNode.m_pNode->m_nHeight <= 1)
			{
				return true;
			}
		}

		// 计算 temp 高度
		// 删除跟插入正好相反,要去考虑其兄弟结点对高度的影响
		auto brothers = m_stRoot;
		if (nullptr != m_stPassNodeArray[m_stPassNodeArray.size() - 1].m_pNode->m_pLeft.m_pNode)
		{
			brothers = m_stPassNodeArray[m_stPassNodeArray.size() - 1].m_pNode->m_pLeft.m_pNode;
		}
		else
		{
			brothers = m_stPassNodeArray[m_stPassNodeArray.size() - 1].m_pNode->m_pRight.m_pNode;
		}

		if (nullptr != brothers.m_pNode)
		{
			brothers.m_pNode->m_nHtemp = brothers.m_pNode->m_nHeight;

			if (nullptr != brothers.m_pNode->m_pLeft.m_pNode)
			{
				brothers.m_pNode->m_pLeft.m_pNode->m_nHtemp = brothers.m_pNode->m_pLeft.m_pNode->m_nHeight;
			}
			else
			{
				brothers.m_pNode->m_pRight.m_pNode->m_nHtemp = brothers.m_pNode->m_pRight.m_pNode->m_nHeight;
			}
		}

		// 删除后,原父结点不再发生变化
		for (int i = (int)m_stPassNodeArray.size() - 1; i > 0; i--)
		{
			m_stPassNodeArray[i].m_pNode->m_nHtemp = m_stPassNodeArray[i].m_pNode->m_nHeight;
		}

		// AVL树的判断及其旋转
		for (int i = (int)m_stPassNodeArray.size() - 1; i >= 0; i--)
		{
			bool ret = IsAVLTree(m_stPassNodeArray[i]);
			if (!ret)
			{
				m_nIndex = (int)i;
				SetAVLSpinType();
				AVLSpin();
				break;
			}
			else
			{
				m_stPassNodeArray[i].m_pNode->m_nHeight = m_stPassNodeArray[i].m_pNode->m_nHtemp;
			}
		}

		return true;
	}

};


#endif

  



KCBTree.h

#ifndef DATA_STRUCT_KTREE_K_C_B_TREE_H
#define DATA_STRUCT_KTREE_K_C_B_TREE_H

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <assert.h>


#include "../KTree/KBinaryTree.h"

template<typename N>
/**
 * complete binary tree 完全二叉树
 */
class KCBTree : public KBinaryTree<N>
{
public:
	KCBTree(){}
	/**
	 * 构造函数
	 */
	KCBTree(vector<N> v)
	{
		if (v.size() == 0)
		{
			return;
		}

		m_stRoot = KPNode<N>(v[0]);
		for (size_t i = 1; i < v.size(); i++)
		{
			LevelTraversal();
			for (auto& node : m_hNodeArray)
			{
				if (nullptr == node.m_pNode->m_pLeft.m_pNode)
				{
					node.m_pNode->m_pLeft = KPNode<N>(v[i]);
					break;
				}
				if (nullptr == node.m_pNode->m_pRight.m_pNode)
				{
					node.m_pNode->m_pRight = KPNode<N>(v[i]);
					break;
				}
			}
		}
	}

	/**
	 * 析构函数
	 */
	~KCBTree()
	{
	}

	/**
	 * 拷贝构造函数
	 */
	KCBTree(KCBTree<N>& rhs):KBinaryTree(rhs)
	{
	}

	/**
	 * 赋值函数
	 */
	KCBTree operator=(KCBTree<N>& rhs)
	{
		if (this == &rhs) return *this;
		// 调用基类的 赋值构造函数
		KBinaryTree::operator=(rhs);
		return *this;
	}

};

#endif

  

KFBTree.h

#ifndef DATA_STRUCT_KTREE_K_F_B_TREE_H
#define DATA_STRUCT_KTREE_K_F_B_TREE_H

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <assert.h>


#include "../KTree/KCBTree.h"

template<typename N>
/**
 * full binary tree 满二叉树
 * 判断方法 !(i&(i+1)) i是否为 2^n - 1
 */
class KFBTree : public KCBTree<N>
{
protected:
	/**
	 * true 满二叉树构造成功
	 * false 满二叉树构造失败
	 */
	bool m_bIsKFBTree;

public:
	KFBTree(){}
	/**
	 * 构造函数
	 */
	KFBTree(vector<N> v) :KCBTree(v)
	{
		int i = v.size();
		m_bIsKFBTree = !(i&(i + 1)) ? true: false;
	}

	/**
	 * 析构函数
	 */
	~KFBTree()
	{
	}

	/**
	 * 拷贝构造函数
	 */
	KFBTree(KFBTree<N>& rhs) :KCBTree(rhs)

	/**
	 * 赋值函数
	 */
	 KFBTree operator=(KFBTree<N>& rhs)
	{
		if (this == &rhs) return *this;
		// 调用基类的 赋值构造函数
		KCBTree::operator=(rhs);
		return *this;
	}

	/**
	 * 返回  m_bIsKFBTree成员变量
	 */
	bool IsSuccess()
	{
		return m_bIsKFBTree;
	}

};

#endif

  


KHuffmanTree.h

#ifndef DATA_STRUCT_KTREE_K_HUFFMAN_TREE_H
#define DATA_STRUCT_KTREE_K_HUFFMAN_TREE_H

#include <string>
#include <vector>
#include <list>
#include <set>
//#include <multiset>
#include <iostream>
#include <assert.h>

#include "../KTree/KBinaryTree.h"

template<typename N, typename T>
/**
 * 哈夫曼树
 */
class KHuffmanTree : public KBinaryTree<N>
{
private:
	/**
	 * 哈夫曼树的最短路径长度
	 */
	T m_tWPL;

public:
	/**
	 * 构造函数
	 */
	KHuffmanTree(vector<N> v, vector<T> w)
	{
		if (v.size() != w.size() || w.size() == 0)
		{
			return;
		}

		// 构建结点
		//set<KPNode<N>, compare<N>> nodeSet;
		multiset<KPNode<N>> nodeSet;
		for (size_t i = 0; i < w.size(); i++)
		{
			KPNode<N> node(v[i]);
			node.m_pNode->m_nLeafFlag = 1; // 叶子结点
			node.m_pNode->m_nWeight = w[i]; // 叶子结点的权重
			m_hNodeArray.push_back(node);
			nodeSet.insert(node);
		}

		// 对结点进行 边排序边构建哈夫曼树
		while (nodeSet.size()!= 1)
		{
			auto first = nodeSet.begin();
			(*first).m_pNode->m_nPosFlag = 0;

			auto second = first++;
			(*second).m_pNode->m_nPosFlag = 1;
	
			KPNode<N> newNode((*first).m_pNode->m_nData + (*second).m_pNode->m_nData);
			newNode.m_pNode->m_nWeight = (*first).m_pNode->m_nWeight + (*second).m_pNode->m_nWeight;
			newNode.m_pNode->m_pLeft = *first;
			newNode.m_pNode->m_pRight = *second;




			nodeSet.erase(nodeSet.begin());
			nodeSet.erase(nodeSet.begin());

			nodeSet.insert(newNode);




		}

		m_stRoot = *nodeSet.begin();

		// 设定路径长度
		queue<KPNode<N>> Q;
		auto T = m_stRoot;
		Q.push(T);

		while (!Q.empty())
		{
			auto K = Q.front();
			Q.pop();

			if (nullptr != K.m_pNode->m_pRight.m_pNode)
			{
				K.m_pNode->m_pRight.m_pNode->m_nLength = K.m_pNode->m_nLength + 1;
				K.m_pNode->m_pRight.m_pNode->m_strCode = K.m_pNode->m_strCode + "1";
				Q.push(K.m_pNode->m_pRight);
			}

			if (nullptr != K.m_pNode->m_pLeft.m_pNode)
			{
				K.m_pNode->m_pLeft.m_pNode->m_nLength = K.m_pNode->m_nLength + 1;
				K.m_pNode->m_pLeft.m_pNode->m_strCode = K.m_pNode->m_strCode + "0";
				Q.push(K.m_pNode->m_pLeft);
			}
		}

		// 计算WPL
		m_tWPL = 0;
		for (size_t i = 0; i < m_hNodeArray.size(); i++)
		{
			m_tWPL += m_hNodeArray[i].m_pNode->m_nLength * m_hNodeArray[i].m_pNode->m_nWeight;
		}
	}

	/**
	 * 析构函数
	 */
	~KHuffmanTree()
	{
	}

	/**
	 * 拷贝构造函数
	 */
	KHuffmanTree(KHuffmanTree<N, T>& rhs) :KBinaryTree(rhs)
	{
	}

	/**
	 * 赋值函数
	 */
	KHuffmanTree operator=(KHuffmanTree<N, T>& rhs)
	{
		if (this == &rhs) return *this;
		// 调用基类的 赋值构造函数
		KBinaryTree::operator=(rhs);
		return *this;
	}

	/**
	 * 取得哈夫曼树的最短路径长度
	 */
	T GetWPL()
	{
		return m_tWPL;
	}

};

#endif

 

KTreeTest.h

#pragma once
//#include "../KTree/KAVLTree.h"
#include "../KTree/KAVLTree.h"
#include "../KTree/KForest.h"
#include "../KTree/KFBTree.h"
#include "../KTree/KHuffmanTree.h"
void KTreeTest202103151640();

  

 


KTreeTest.cpp

#include "KTreeTest.h"


void KTreeTest202103151640()
{
//	KTree<int> tree001;
//	vector<int> lll;

	// 树函数测试
	vector<int> data{1,2,3,4,5,6,7,8,9,10};
	vector<int> level_num{3,2,1,1,2};
	KTree<int> otherTree(data, level_num);
	otherTree.PerOrder();
	otherTree.PrintNodeArray();

	otherTree.PostOrder();
	otherTree.PrintNodeArray();

	otherTree.LevelTraversal();
	otherTree.PrintNodeArray();

	vector<int> data1{11, 12, 13, 14, 15, 16, 17, 18, 19, 110};
	vector<int> level_num1{3, 2, 1, 1, 2};
	KTree<int> otherTree1(data1, level_num1);

	otherTree.Union(otherTree1);
	otherTree.LevelTraversal();
	otherTree.PrintNodeArray();

	KPNode<int>  node = otherTree1.Select();
	cout << "tree select result is	" << node.m_pNode->m_nData << endl;

	// 树 转 二叉树
	// 树函数测试
	vector<int> data_03181625{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	vector<int> level_num_03181625{3, 2, 1, 1, 2};
	KTree<int> otherTree_03181625(data_03181625,level_num_03181625);
	KBinaryTree<int> hKBinaryTree_03181642 = otherTree_03181625.ConvertKBinaryTree();
	hKBinaryTree_03181642.LevelTraversal();
	hKBinaryTree_03181642.PrintNodeArray();




	// 二叉树方法测试
	vector<int> data_Binary{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	vector<int> level_num_Binary{2, 1, 1, 2, 2, 0, 1, 0, 0,0};
	vector<int> pos_Binary{2,0,1,0,1,0,1,0,1,1};
	KBinaryTree<int> hKBinaryTree(data_Binary, level_num_Binary, pos_Binary);
	hKBinaryTree.PerOrder();
	hKBinaryTree.PrintNodeArray();

	hKBinaryTree.PostOrder();
	hKBinaryTree.PrintNodeArray();

	hKBinaryTree.LevelTraversal();
	hKBinaryTree.PrintNodeArray();
	
	
	KBinaryTree<int> hKBinaryTree_000;
	hKBinaryTree_000 = hKBinaryTree;
	hKBinaryTree_000.LevelTraversal();
	hKBinaryTree_000.PrintNodeArray();

	hKBinaryTree_000.MidOrder();
	hKBinaryTree_000.PrintNodeArray();

	hKBinaryTree.PerOrder();
	hKBinaryTree.PrintNodeArray();
	hKBinaryTree_000.PreCueing();
	//hKBinaryTree_000.ClearCueing();


	vector<int> data_Binary_111{1, 2, 3, 4, 5, 6};
	vector<int> level_num_Binary_111{1,2,0,2};
	vector<int> pos_Binary_111{2,0,0,1,0,1};
	KBinaryTree<int> hKBinaryTree_111(data_Binary_111, level_num_Binary_111, pos_Binary_111);
	KTree<int> hKBinaryTree_111_tree;

	hKBinaryTree_111.LevelTraversal();
	hKBinaryTree_111.PrintNodeArray();

	bool B61RET = hKBinaryTree_111.ConvertKTree(hKBinaryTree_111_tree);
	hKBinaryTree_111_tree.LevelTraversal();
	hKBinaryTree_111_tree.PrintNodeArray();

	// 二叉树 转 森林
	vector<int> data_Binary_03190928{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	vector<int> level_num_Binary_03190928{2, 1, 1, 2, 2, 0, 1, 0, 0, 0};
	vector<int> pos_Binary_03190928{2, 0, 1, 0, 1, 0, 1, 0, 1, 1};
	KBinaryTree<int> hBinary_03190928(data_Binary_03190928, level_num_Binary_03190928, pos_Binary_03190928);

	KForest<int> KForest_03190928;
	hBinary_03190928.ConvertKForest(KForest_03190928);
	KForest_03190928.LevelTraversal();
	KForest_03190928.PrintNodeArray();


	// 森林方法测试
	cout << "森林测试:" << endl;
	vector<int> data_03181850{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	vector<int> level_num_03181850{3, 2, 1, 1, 2};
	KTree<int> KForest_tree_03181850(data_03181850, level_num_03181850);
	KForest_tree_03181850.LevelTraversal();
	KForest_tree_03181850.PrintNodeArray();

	vector<int> data_03181851{11, 12, 13, 14, 15, 16, 17, 18, 19, 110};
	vector<int> level_num_03181851{3, 2, 1, 1, 2};
	KTree<int> KForest_tree_03181851(data_03181851, level_num_03181851);
	KForest_tree_03181851.LevelTraversal();
	KForest_tree_03181851.PrintNodeArray();


	vector<KTree<int>>   KForest_tree_array_03181852;
	KForest_tree_array_03181852.push_back(KForest_tree_03181850);
	KForest_tree_array_03181852.push_back(KForest_tree_03181851);

	KForest<int> KForest_03181854(KForest_tree_array_03181852);
	KForest_03181854.LevelTraversal();
	KForest_03181854.PrintNodeArray();

	KBinaryTree<int> hKBinaryTree03181911(KForest_03181854.ConvertKBinaryTree());
	hKBinaryTree03181911.LevelTraversal();
	hKBinaryTree03181911.PrintNodeArray();

	// BST 方法测试
	vector<int> data_03191720{32,16,64,8,24,48,80};
	KBSTree<int> hKBSTree03191720(data_03191720);
	hKBSTree03191720.PerOrder();
	hKBSTree03191720.PrintNodeArray();
	hKBSTree03191720.LevelTraversal();
	hKBSTree03191720.PrintNodeArray();

	hKBSTree03191720.Insert(60);
	hKBSTree03191720.PerOrder();
	hKBSTree03191720.PrintNodeArray();


	hKBSTree03191720.Delete(64);
	hKBSTree03191720.PerOrder();
	hKBSTree03191720.PrintNodeArray();

	auto v = hKBSTree03191720.Find(48);
	cout << v.m_pNode->m_nPosFlag << endl;


	KPNode<int> *p_03191905 = new KPNode<int>(5);
	KPNode<int> *p_03191906 = nullptr;
	KPNode<int>*& pvp_03191905 = p_03191906;
	pvp_03191905 = p_03191905;
	delete p_03191905;
	p_03191905 = nullptr;

	cout << "hKBSTree03191720.IsAVLTree:" << endl;
	cout << hKBSTree03191720.IsAVLTree() << endl;

	cout << "hKBSTree03191720.Delete(48)" << endl;
	hKBSTree03191720.Delete(48);
	cout << hKBSTree03191720.IsAVLTree() << endl;
	cout << endl;

	cout << "hKBSTree03191720.Delete(80)" << endl;
	hKBSTree03191720.Delete(80);
	cout << endl;
	cout << hKBSTree03191720.IsAVLTree() << endl;

	cout << "hKBSTree03191720.Delete(60)" << endl;
	hKBSTree03191720.Delete(60);
	cout << endl;
	cout << hKBSTree03191720.IsAVLTree() << endl;
	cout << "hKBSTree03191720.IsAVLTree:  end" << endl;


	// AVL 方法测试
	cout << "AVL 方法测试:" << endl;
	vector<int> data_03221410{32, 16, 64, 8, 24, 48, 80};
	KAVLTree<int> hKAVLTree03191720(data_03221410);
	hKAVLTree03191720.PerOrder();
	hKAVLTree03191720.PrintNodeArray();
	hKAVLTree03191720.LevelTraversal();
	hKAVLTree03191720.PrintNodeArray();


	KBSTree<int>* PKAVLTree03191720 = &hKAVLTree03191720;
	cout << "hKAVLTree03191720 IS AVL TREE:";
	cout << PKAVLTree03191720->IsAVLTree() << endl;

	// RR 平衡旋转
 	PKAVLTree03191720->Insert(128);
	PKAVLTree03191720->Insert(256);

	hKAVLTree03191720.LevelTraversal();
	hKAVLTree03191720.PrintNodeArray();

	// LL 平衡旋转
	PKAVLTree03191720->Insert(4);
	PKAVLTree03191720->Insert(2);

	hKAVLTree03191720.LevelTraversal();
	hKAVLTree03191720.PrintNodeArray();

	// LR 平衡旋转
	cout << "LR 平衡旋转:" << endl;
	PKAVLTree03191720->Insert(6);
	hKAVLTree03191720.LevelTraversal();
	hKAVLTree03191720.PrintNodeArray();
	cout << "hKAVLTree03191720 IS AVL TREE:";
	cout << PKAVLTree03191720->IsAVLTree() << endl;

	// RL 平衡旋转 	
	cout << "RL 平衡旋转:" << endl;
	PKAVLTree03191720->Insert(50);

	hKAVLTree03191720.LevelTraversal();
	hKAVLTree03191720.PrintNodeArray();

	PKAVLTree03191720->Insert(49);
	hKAVLTree03191720.LevelTraversal();
	hKAVLTree03191720.PrintNodeArray();
	cout << "hKAVLTree03191720 IS AVL TREE:";
	cout << PKAVLTree03191720->IsAVLTree() << endl;

	// 删除操作
	cout << "RR 平衡旋转:" << endl;
	PKAVLTree03191720->Delete(49);
	PKAVLTree03191720->Delete(50);
	PKAVLTree03191720->Delete(48);
	hKAVLTree03191720.LevelTraversal();
	hKAVLTree03191720.PrintNodeArray();
	cout << "hKAVLTree03191720 IS AVL TREE:";
	cout << PKAVLTree03191720->IsAVLTree() << endl;



	// 完全二叉树方法测试
	cout << "完全二叉树方法测试:" << endl;
	vector<int> data_03231040{32, 16, 64, 8, 24, 48, 80};
	KCBTree<int> hKCBTree_03231040(data_03231040);
	hKCBTree_03231040.LevelTraversal();
	hKCBTree_03231040.PrintNodeArray();


	// 满二叉树方法测试
	cout << "满二叉树方法测试:" << endl;
	vector<int> data_03231042{32, 16, 64, 8, 24, 48, 80};
	KFBTree<int> hKFBTree_03231042(data_03231042);
	hKFBTree_03231042.LevelTraversal();
	hKFBTree_03231042.PrintNodeArray();
	cout << "是否为满二叉树:" << hKFBTree_03231042.IsSuccess() << endl;

	vector<int> data_03231043{1,2,3,4,5,6,7,8,9,10,11,12,13,14};
	KFBTree<int> hKFBTree_03231043(data_03231043);
	hKFBTree_03231043.LevelTraversal();
	hKFBTree_03231043.PrintNodeArray();
	cout << "是否为满二叉树:" << hKFBTree_03231043.IsSuccess() << endl;


	// 哈夫曼树方法测试
	cout << "哈夫曼树方法测试:" << endl;
	vector<int> data_03231522  {1,2,3,4,5,6};
	vector<int> weight_03231522{3,2,1,2,2,1};
	KHuffmanTree<int,int> hKHuffmanTree_03231522(data_03231522, weight_03231522);
	hKHuffmanTree_03231522.LevelTraversal();
	hKHuffmanTree_03231522.PrintNodeArray();

	cout << "哈夫曼树 WPL:" << hKHuffmanTree_03231522.GetWPL() << endl;



	int i = 0;
	i++;



}

  结束

 

posted @ 2021-03-23 16:52  雪域蓝心  阅读(61)  评论(0编辑  收藏  举报