顺序二叉树

最新推荐文章于 2024-05-23 14:39:06 发布

Don‘t NULL

最新推荐文章于 2024-05-23 14:39:06 发布

阅读量214

点赞数 5

文章标签：数据结构

本文链接：https://blog.csdn.net/xiawubushangban/article/details/138764196

版权

二叉树一般在学校中要求重点掌握链式二叉树，殊不知数组有其区别于链表的优势，并且利用二叉树双亲节点和孩子节点的数量关系可以实现二叉树的基本功能。

说明：本程序利用C++面向对象编程，树类中包含二叉树的各种方法

template<typename T>
class BinaryTree
{
private:
	T* treeArray;
	int size;
public:
	BinaryTree(int maxsize);
	void insert(int n);
	void preTraversal(int index);//前序遍历
	void midTraversal(int index);//中序遍历
	void posTraversal(int index);//后序遍历
	int getDepth();//获取树的深度
	int getLeafCount();//获取叶子节点数
	T getMAxValue();//获取节点最大值
	void print_same_level(int level);//打印同层节点
	T getParent(int index);//获得节点双亲
	//堆排序
	//未完成
	void BuildMaxHeap(int size, int index);
	void heapSort(int size);
	//将二叉树输出
	void printUtil(int index, int space);
	void printtree();
};

二叉树的方法实现

template<typename T>
inline BinaryTree<T>::BinaryTree(int maxsize)
{
	size = pow(2, maxsize)-1;//根据层数分配空间
	treeArray = new T[size];
	for (int i = 0; i < size; i++)
	{
		treeArray[i] = -1;
	}
}

template<typename T>
inline void BinaryTree<T>::insert(int n)
{
	for (int index = 0; index < n; index++)
	{
		int data=0;
		cin >> data;
		treeArray[index] = data;
	}
}

template<typename T>
inline void BinaryTree<T>::preTraversal(int index)
{
	if (index >= 0 && index < size && treeArray[index] != -1)
	{
		cout << treeArray[index] << " ";
		preTraversal(2 * index + 1);//左子树
		preTraversal(2 * index + 2);//右子树
	}
}

template<typename T>
inline void BinaryTree<T>::midTraversal(int index)
{
	if (index >= 0 && index < size && treeArray[index] != -1)
	{
		midTraversal(2 * index + 1);
		cout << treeArray[index] << " ";
		midTraversal(2 * index + 2);
	}
}

template<typename T>
inline void BinaryTree<T>::posTraversal(int index)
{
	if (index >= 0 && index < size && treeArray[index] != -1)
	{
		posTraversal(2 * index + 1);
		posTraversal(2 * index + 2);
		cout << treeArray[index] << " ";
	}
}

template<typename T>
inline int BinaryTree<T>::getDepth()
{
	return log(size + 1);
}

template<typename T>
inline int BinaryTree<T>::getLeafCount()
{
	int count = 0;
	for (int i = 0; i < size; i++) 
	{
		if (treeArray[i] != -1 && treeArray[2 * i + 1] == -1 && treeArray[2 * i + 2] == -1) 
		{
			count++; // 叶子节点的判断条件：左右子节点都为空
		}
	}
	return count;
}

template<typename T>
inline T BinaryTree<T>::getMAxValue()
{
	T max = treeArray[0];
	for (int i = 0; i < size; i++)
	{
		if (treeArray[i] > max)
		{
			max = treeArray[i];
		}
	}
	return max;
}

template<typename T>
inline void BinaryTree<T>::print_same_level(int level)
{
	int start = pow(2, level - 1) - 1;
	int end = pow(2, level) - 2;
	for (int i = start; i <= end; i++)
	{
		if (treeArray[i] != -1)
		{
			cout << treeArray[i] << " ";
		}
	}
}

template<typename T>
inline T BinaryTree<T>::getParent(int index)
{
	if (index >= 0&& index < size)
	{
		 return treeArray[(index - 1) / 2];
	}
	return -1;
}

template<typename T>
inline void BinaryTree<T>::BuildMaxHeap(int size, int index)
{
	int largest = index;
	int left = 2 * index + 1;
	int right = 2 * index + 2;
	if (left<size && treeArray[left]>treeArray[largest])
	{
		largest = left;
	}
	if (right<size && treeArray[right]>treeArray[largest])
	{
		largest = right;
	}
	if (largest != index)
	{
		swap(treeArray[index], treeArray[largest]);
		BuildMaxHeap(size, largest);

	}
}

template<typename T>
inline void BinaryTree<T>::heapSort(int size)
{
	for (int i = size / 2 - 1; i >= 0; i--)
	{
		BuildMaxHeap(size, i);
	}
	for (int i = size; i > 0; i--)
	{
		swap(treeArray[0], treeArray[i]);
		BuildMaxHeap(i, 0);
	}
}

template<typename T>
inline void BinaryTree<T>::printUtil(int index, int space)
{
	if (index >=size  || treeArray[index] == NULL) 
	{
		return;
	}

	space += 5;

	printUtil(2 * index + 1, space);

	cout << setw(space) << treeArray[index] << endl;

	printUtil(2 * index + 2, space);
}

template<typename T>
inline void BinaryTree<T>::printtree()
{
	printUtil(0, 0);
}

主函数

#include"BinaryTree.h"
void menu()
{
	cout << "\t\t\t\t\t" << "[...*************************************************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*******************数组二叉树********************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*************************************************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*****************1.插入数据**********************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*****************2.先序遍历**********************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*****************3.中序遍历**********************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*****************4.后序遍历**********************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*****************5.获取深度**********************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*****************6.获取叶子节点数****************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*****************7.获取同层节点******************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*****************8.获取节点最大值****************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*****************9.获取孩子双亲******************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*****************10.完全二叉树堆排序*************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*****************11.打印二叉树*******************...]" << endl;
	cout << "\t\t\t\t\t" << "[...*************************************************...]" << endl;
}

int main()
{
	int size;
	cout << "您想开个深度多少的二叉树?" << endl;
	cin >> size;
	BinaryTree<int> tree(size);
	
	while (1)
	{
		menu();
		int x;
		cout << "请输入你的选择：" << endl;
		cin >> x;
		int n;
		switch (x)
		{
		case 1:
		{
			cout << "请输入你要插入几个元素" << endl;
			
			cin >> n;
			tree.insert(n);
		}break;
		case 2:
		{
			tree.preTraversal(0);
		}break;
		case 3:
		{
			tree.midTraversal(0);
		}break;
		case 4:
		{
			tree.posTraversal(0);
		}break;
		case 5:
		{
			cout << "深度为：" << tree.getDepth() << endl;
		}break;
		case 6:
		{
			cout << "叶子节点数为：" << tree.getLeafCount() << endl;
		}break;
		case 7:
		{
			int level;
			cout << "你要查询哪一层级:" << endl;
			cin >> level;
			tree.print_same_level(level);
		}break;
		case 8:
		{
			cout << "最大值：" << tree.getMAxValue() << endl;
		}break;
		case 9:
		{
			cout << "请输入孩子节点的下表" << endl;
			int index;
			cin >> index;
			cout << "孩子的双亲为：" << tree.getParent(index) << endl;
		}break;
		case 10:
		{
			tree.heapSort(n);
		}break;
		case 11:
		{
			tree.printtree();
		}break;
		}
		system("pause");
		system("cls");
	}
}