二叉树的数组表示 C++实现(添加 按层遍历)

<pre name="code" class="cpp">/*
* File name  : BinTree.cpp
* Function   : 二叉树的数组表示 C++实现
* Created on : 2016年4月28日
* Author     : [email protected]
* Copyright  : 欢迎大家和我一起交流学习，转载请保持源文件的完整性。
			   任何单位和个人不经本人允许不得用于商业用途
* Input      :  ABCD##E##F##GHI##J##K##
*
*/
#include <cstdio>
#include <iostream>

using namespace std;

#define SIZE 100
#define MAX 20

typedef char Elem_t;

typedef struct {
	Elem_t data;
	int parent;
	int Lchild;
	int Rchild;
	int level;
}Node;

typedef struct {
	Node depot[MAX];
	int depth;
	int node_count;
}Btree;

/****************************************************************************/
// for void Btree_traverse_by_level(Btree &T, int current_pos);  //按层遍历
template<typename T>
class Pqueue {
private:
	T array[MAX];

	int head;
	int tail;

public:
	int size;
	bool queue_in(T one) {
		if (tail == MAX-1) {
			return false;
		}

		for (int i = 0; i <= tail; i++) {
			if (i == tail) {
				array[i] = one;
				break;
			}
			else
				if (one.level < array[i].level) {
					for (int j = tail + 1; j > i; j--) {
						array[j] = array[j - 1];
					}
					array[i] = one;
					break;
				}
		}
		tail++;
		size++;
		return true;
	}
	bool queue_out(T & A) {
		if (head == tail) {
			return false;
		}
		A = array[head++];
		size--;
		return true;
	}
	Pqueue() {
		for (int i = 0; i < 10; i++) {
			array[i].level = 0;
		}
		head = 0;
		tail = 0;
		size = 0;
	}
	~Pqueue() {
		head = 0;
		tail = 0;
		size = 0;
	}

};

/****************************************************************************/


void Btree_create(Btree & T, int current_pos, int parent_pos, int left, int father_level);
int  Btree_get_depth(Btree &T, int current_pos);

void Btree_dlr(Btree &T, int current_pos);//先序遍历
void Btree_ldr(Btree &T, int current_pos);//中序遍历
void Btree_lrd(Btree &T, int current_pos);//后序遍历
void Btree_traverse_by_level(Btree &T, int current_pos);  //按层遍历
int Btree_get_node_count(Btree &T);
bool Btree_dlr_find_elem(Btree &T, int current_pos, Elem_t elem);


int main(int argc, char** argv)
{
	Btree  BT;
	int k = 0;
	Btree_create(BT,0,-1,2,0);
	k = Btree_get_depth(BT, 0);
	cout <<"The depth of BT is : "<<k  << endl;
	BT.depth = k;
	k = Btree_get_depth(BT, 0);
	cout << "The depth of BT is : " << k << endl;

	Btree_dlr(BT, 0);//先序遍历
	cout << endl;

	Btree_ldr(BT, 0);//中序遍历
	cout << endl;

	Btree_lrd(BT, 0);//后序遍历
	cout << endl;
	cout << "Btree_traverse_by_level : " << endl;
	Btree_traverse_by_level(BT, 0);

	cout << "\nBtree node count is :"<<Btree_get_node_count(BT) << endl;
	cout << "C is in Btree ?" << Btree_dlr_find_elem(BT, 0, 'C')<<endl;
	cout << "M is in Btree ?" << Btree_dlr_find_elem(BT, 0, 'M') << endl;
	return 0; 
}

void Btree_create(Btree & T, int current_pos,int parent_pos,int left,int father_level)
{
	Elem_t tmp;
	static int  next_pos = 0;
	
	cin >> tmp;
	if (left == 2) {//root
		T.depth =0;
	}
	
	if (tmp == '#' ) {// node is null 
		if (left == 1) {
			T.depot[parent_pos].Lchild = -2;
		}
		else {
			T.depot[parent_pos].Rchild = -2;

		}
		return;
	}
	if(T.depth <= father_level)
		T.depth = father_level+1;
	
	T.depot[current_pos].data = tmp;
	T.depot[current_pos].parent = parent_pos;

	T.depot[current_pos].level = father_level +1;
	
	next_pos = current_pos + 1;
	T.depot[current_pos].Lchild = next_pos;
	
	parent_pos = current_pos;
	
	Btree_create(T, T.depot[current_pos].Lchild, parent_pos,1, father_level+1);
	T.depot[current_pos].Rchild = next_pos;
	Btree_create(T, T.depot[current_pos].Rchild, parent_pos,0, father_level+1);
	T.node_count = next_pos;
	
	
}

int Btree_get_depth(Btree &T,int current_pos)
{
	int left_depth;
	int right_depth;
	static int node_count = 0;

	if (T.depth != -1) {
		return T.depth;// in fact, only you,work
	}

	if (T.depot[current_pos].Lchild == -2 && T.depot[current_pos].Rchild == -2) {
		return 1;
	}
	else {
		if (T.depot[current_pos].Lchild != -2)
		{
			left_depth = Btree_get_depth(T,++node_count);
		}
		if (T.depot[current_pos].Rchild != -2) {
			right_depth = Btree_get_depth(T, ++node_count);
		}

		if (left_depth > right_depth) {
			return left_depth+1;
		}
		else {
			return right_depth + 1;
		}

	}
}

int Btree_get_node_count(Btree &T)
{
	return T.node_count;
}
bool Btree_dlr_find_elem(Btree &T, int current_pos, Elem_t elem) { //查找元素

	int left = T.depot[current_pos].Lchild;
	int right = T.depot[current_pos].Rchild;
	bool left_ret = false;
	bool right_ret = false;
	
	//cout << T.depot[current_pos].data << "\t";
	if (T.depot[current_pos].data == elem)
	{
		return true;
	}

	if (T.depot[current_pos].Lchild != -2)
	{
		left_ret= Btree_dlr_find_elem(T, left,elem);
	}
	if (T.depot[current_pos].Rchild != -2) {
		right_ret= Btree_dlr_find_elem(T, right,elem);
	}
	return (left_ret || right_ret);
}



void Btree_dlr(Btree &T, int current_pos) { //先序遍历

	int left = T.depot[current_pos].Lchild;
	int right = T.depot[current_pos].Rchild;

	cout << T.depot[current_pos].data << "\t";
	if (T.depot[current_pos].Lchild != -2)
	{
		Btree_dlr(T, left);
	}
	if (T.depot[current_pos].Rchild != -2) {
		Btree_dlr(T, right);
	}
}



void Btree_ldr(Btree &T, int current_pos) { //中序遍历

	int left = T.depot[current_pos].Lchild;
	int right = T.depot[current_pos].Rchild;

	
	if (T.depot[current_pos].Lchild != -2)
	{
		Btree_ldr(T, left);
	}
	cout << T.depot[current_pos].data << "\t";

	if (T.depot[current_pos].Rchild != -2) {
		Btree_ldr(T, right);
	}
}


void Btree_lrd(Btree &T, int current_pos) { //后序遍历

	int left = T.depot[current_pos].Lchild;
	int right = T.depot[current_pos].Rchild;

	if (T.depot[current_pos].Lchild != -2)
	{
		Btree_lrd(T, left);
	}


	if (T.depot[current_pos].Rchild != -2) {
		Btree_lrd(T, right);
	}

	cout << T.depot[current_pos].data << "\t";
}

Pqueue<Node> Q;
Node tmp;
void Btree_traverse_by_level(Btree &T, int current_pos) { //按层遍历

	int left = T.depot[current_pos].Lchild;
	int right = T.depot[current_pos].Rchild;
	Q.queue_in(T.depot[current_pos]);

	if (T.depot[current_pos].Lchild != -2)
	{
		Btree_traverse_by_level(T, left);
	}

	if (T.depot[current_pos].Rchild != -2) {
		Btree_traverse_by_level(T, right);
	}
	if (Q.size == T.node_count)
	{
		for (int i = 0; i <T.node_count; i++)
		{
			Q.queue_out(tmp);
			cout << tmp.data << "\t";
		}
		cout << endl;
		
	}
}


void Btree_add_node(Btree &T, int father_pos, Elem_t elem, int left) //only left can insert
{
	if (left == 1) { // add left node
		T.depot[father_pos].Lchild = ++T.node_count;
		T.depot[father_pos].Lchild = -2;
		T.depot[T.node_count].data = elem;
		T.depot[T.node_count].level = T.depot[father_pos].level + 1;
		T.depot[T.node_count].parent = father_pos;
		T.depot[T.node_count].Lchild = -2;
		T.depot[T.node_count].Rchild = -2;
		if(T.depth < T.depot[T.node_count].level)
		T.depth = T.depot[T.node_count].level;
	}
	else {
		T.depot[father_pos].Rchild = ++T.node_count;
		T.depot[T.node_count].data = elem;
		T.depot[T.node_count].level = T.depot[father_pos].level + 1;
		T.depot[T.node_count].parent = father_pos;
		T.depot[T.node_count].Lchild = -2;
		T.depot[T.node_count].Rchild = -2;
	}

}