c++实现二叉树的层次遍历以及二叉树存放方式即常用操作

#pragma once
#include<iostream>
using namespace std;

//层次遍历以及二叉树存放方式即常用操作
//二叉树的顺序存放---一维数组

#define Maxsize 100

enum NODE
{
	E_Root,
	E_Lchild,
	E_Rchild,
};

template<class T>
struct TreeNode
{
	T data;
	bool isVaild;//标记该节点是否存放数据
};

template<class T>
class Tree
{
public:
	Tree()
	{
		for (int i = 0; i <= Maxsize; i++)
		{
			Tree_data[i].isVaild = false;// 该节点是否存放数据
		}
	}
	~Tree() {}
public:
	//参数父亲节点的数组 下标，标记的是根还是左孩子还是右孩子，插入元素
	int createNode(int parindex, NODE pointSign, const T& e);//创建一个树的节点

	int getParentindex(int sonindex)//获取父亲节点下标
	{
		if (ifVaildIndex(sonindex) == false)//下标位置不合法
			return -1;
		if (Tree_data[sonindex].isVaild == false)//该节点未存放数据
			return -1;
		return int(sonindex / 2);
	}

	int getPointLevel(int index)//获取某个节点的高度
	{
		if (ifVaildIndex(index) == false)//下标位置不合法
			return -1;
		if (Tree_data[index].isVaild == false)//该节点未存放数据
			return -1;
		int level = int(log(index) / log(2)) + 1;//c++以2为底的log： log(index) / log(2)
		return level;
	}

	int getLevel()//获取树的深度
	{
		if (Tree_data[1].isVaild == false)//无根
			return 0;

		int i=-5;
		for (int i = Maxsize; i >= 1; i--)
		{
			if (Tree_data[i].isVaild == true)//找到了一个有效的节点
				break;
		}
		return getPointLevel(i);//返回树的深度
	}

	bool ifCompeleteTree()//判断是否未完全二叉树
	{
		if (Tree_data[1].isVaild == false)//无根
			return false;

		int i=-5;
		for (int i = Maxsize; i >= 1; i--)
		{
			if (Tree_data[i].isVaild == true)//找到了一个有效的节点
				break;
		}
		for (int k = 1; k <= i; k++)
		{
			if (Tree_data[k].isVaild == false)//所有节点都要有效
				return false;
		}
		return true;
	}

	void preOrder()//前序遍历
	{
		if (Tree_data[1].isVaild == false)//该节点未存放数据
			return;
		preOrder(1);//根的节点下标为1，传递下面的遍历
	}

	void preOrder(int index)//前序遍历
	{
		if (ifVaildIndex(index) == false)//下标位置不合法
			return;
		if (Tree_data[index].isVaild == false)//该节点未存放数据
			return;

		cout << (char)Tree_data[index].data << " ";
		preOrder(2 * index);
		preOrder(2 * index+1);
	}


private:
	bool ifVaildIndex(int index)//判断位置是否合法
	{
		if (index<1 || index>Maxsize)
			return false;
		return true;
	}

private:
	TreeNode<T> Tree_data[Maxsize+1];//0的位置不存放数据
};


template<class T>
int Tree<T>::createNode(int parindex, NODE pointSign, const T& e)//创建一个树的节点
{
	if (pointSign != E_Root)
	{
		if (ifVaildIndex(parindex) == false)
			return -1;
		if (Tree_data[parindex].isVaild == false)
			return -1;
	}
	int index = -1;
	if (pointSign == E_Root)//根存放在下标为一的位置
	{
		index = 1;
	}
	else if(pointSign== E_Lchild)
	{
		index = 2 * parindex;
		if (ifVaildIndex(index) == false)
			return -1;
	}
	else if (pointSign == E_Rchild)
	{
		index = 2 * parindex+1;
		if (ifVaildIndex(index) == false)
			return -1;
	}

	Tree_data[index].data = e;
	Tree_data[index].isVaild = true;
	return index;
}

#include"Tree.hpp"

void test1()
{
	Tree<int>t;
	int indexroot = t.createNode(-1, E_Root, 'A');
	int indexNodeB = t.createNode(indexroot, E_Lchild, 'B');
	int indexNodeC = t.createNode(indexroot, E_Rchild, 'C');

	int indexNodeD = t.createNode(indexNodeB, E_Lchild, 'D');
	int indexNodeE = t.createNode(indexNodeC, E_Rchild, 'E');

	int parIndexE = t.getParentindex(indexNodeE);
	cout << "E的父节点下标：" << parIndexE << endl;

	int level = t.getPointLevel(indexNodeD);
	cout << "D的高度: " << level << endl;
	level = t.getPointLevel(indexNodeE);
	cout << "E的高度: " << level << endl;

	cout << "树的高度: " << t.getLevel()<< endl;

	cout << "是否为完全二叉树：" << (t.ifCompeleteTree() == true ? "是" : "否") << endl;

	t.preOrder();
}

int main()
{
	test1();
	system("pause");
	return 0;
}