一.树的概念及其相关
1.概念及特点
- 树是一种非线性的数据结构,它是由n(n>=0)个有限结点组成一个具有层次关系的集合。
- 特点:每个结点有零个或多个子结点;
没有父结点的结点称为根结点;
每一个非根结点有且只有一个父结点;
2. 相关定义:
- 节点的度:一个节点含有的子树的个数称为该节点的度;
- 叶子节点:度为0的节点称为叶节点;
- 非叶子节点/分支节点:度不为0的节点;
- 父节点:若一个节点含有子节点,则这个节点称为其子节点的父节点;
- 子节点:一个节点含有的子树的根节点称为该节点的子节点;
- 树的度:一棵树中,最大的节点的度称为树的度;
- 节点的层次:从根开始定义起,根为第1层,根的子节点为第2层,以此类推;
- 树的高度或深度:树中节点的最大层次;
- 森林:由m(m>=0)棵互不相交的树的集合称为森林;
二.二叉树
1.二叉树的特点
- 每个结点最多有两棵子树,即二叉树不存在度大于2的结点。
- 二叉树的子树有左右之分,其子树的次序不能颠倒。
2.特殊二叉树
- 满二叉树:一个二叉树,如果每一个层的结点数都达到最大值,则这个二叉树就是满二叉树。也就是说,如果一个二叉树的层数为K,且结点总数是(2^k) -1 ,则它就是满二叉树。
- 完全二叉树:完全二叉树是由满二叉树而引出来的。对于深度为K的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
3.二叉树的存储
- 二叉树一般可以使用两种结构存储,一种顺序结构,一种链式结构。
1.链式存储及其模拟实现
- 通常的方法是链表中每个结点由三个域组成,数据域和左右指针域,左右指针分别用来给出该结点左孩子和右孩子所在的结点地址 。
#include <vector>
#include <queue>
#include <stack>
template<class T>
struct BinaryTreeNode
{
T _data;
BinaryTreeNode<T>* _left;
BinaryTreeNode<T>* _right;
BinaryTreeNode(const T& x)
: _data(x)
, _left(NULL)
,_right(NULL)
{}
};
template<class T>
class BinaryTree
{
typedef BinaryTreeNode<T> Node;
public:
BinaryTree(T *a, size_t n, const T& invalid)
{
size_t index = 0;
_root = _CreateTree(a, n, invalid, index);
}
Node CopyTree(Node* root)
{
if (root == NULL)
return NULL;
Node* newRoot = new Node(root->_data);
newRoot->_left = CopyTree(root->_left);
newRoot->_right = CopyTree(root->_right);
return newRoot;
}
BinaryTree(const BinaryTree<T>& t)
{
_root = CopyTree(t._root);
}
BinaryTree operator=(BinaryTree<T> t)
{
swap(_root, t._root);
return *this;
}
~BinaryTree()
{
Destory(_root);
_root = NULL;
}
void Destory(Node* root)
{
if (root == NULL)
return;
Destory(root->_left);
Destory(root->_right);
delete root;
}
//前序遍历建树
Node* _CreateTree(T* a, size_t n, const T& invalid, size_t& index)
{
Node* root = NULL;
if (a[index] != invalid)
{
root = new Node(a[index]);
root->_left = _CreateTree(a, n, invalid, ++index);
root->_right = _CreateTree(a, n, invalid, ++index);
}
return root;
}
//前序遍历访问树
void PrevOrder()
{
_PrevOrder(_root);
cout << endl;
}
void _PrevOrder(Node* root)
{
if (root == NULL)
return;
cout << root->_data << " ";
_PrevOrder(root->_left);
_PrevOrder(root->_right);
}
//中序遍历访问树
void InOrder()
{
_InOrder(_root);
cout << endl;
}
void _InOrder(Node* root)
{
if (root == NULL)
return;
_InOrder(root->_left);
cout << root->_data << " ";
_InOrder(root->_right);
}
void PostOrder()
{
_PostOrder(_root);
cout << endl;
}
void _PostOrder(Node* root)
{
if (root == NULL)
return;
_PostOrder(root->_left);
_PostOrder(root->_right);
cout << root->_data << " ";
}
//递归实现求二叉树的大小
int Size()
{
size_t size = 0;
Size(_root, size);
return size;
}
void _Size(Node* root, size_t& size)
{
if (root == NULL)
return;
_Size(root->_left, size);
++size;
_Size(root->_right,size);
}
//求所有叶子节点的数量
size_t LeafSize()
{
return _LeafSize(_root);
}
size_t _LeafSize(Node* root)
{
if (root == NULL)
return 0;
if (root->_left == NULL && root->_right == NULL)
return 1;
return _LeafSize(root->_left) + _LeafSize(root->_right);
}
//求树的高度
size_t Height()
{
return _Height(_root);
}
size_t _Height(Node* root)
{
if (root == NULL)
return 0;
size_t leftHeight = _Height(root->_left);
size_t rightHeight = _Height(root->_right);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
//获取第K层的节点数
size_t GetKLevel(size_t k)
{
size_t Num = _GetKLevel(_root, k);
cout << Num << endl;
return Num;
}
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);
}
//判断是不是完全二叉树
bool IsCompleteTree()
{
queue<Node*> q;
if (_root)
q.push(_root);
bool flag = true;
while (!q.empty())
{
Node* front = q.front();
q.pop();
if (front->_left)
{
if (flag == false)
return flag;
q.push(front->_left);
}
else
{
flag == false;
}
if (front->_right)
{
if (flag == false)
return flag;
q.push(front->_right);
}
else
{
flag = false;
}
}
return true;
}
//查找指定的节点
Node* Find(const T& x)
{
return _Find(_root, x);
}
Node* _Find(Node* root, const T& x)
{
if (root == NULL)
return NULL;
if (root->_data == x)
return root;
Node* cur = _Find(root->_left, x);
if (cur)
return cur;
Node* tem = _Find(root->_right, x);
if (tem)
return tem;
}
private:
Node* _root;
};
void TestTree()
{
int array[] = { 1, 2, 3, '#', '#', 4, 40, '#', '#', '#', 5, 6, '#', '#', '#' };
BinaryTree<int> t(array, sizeof(array) / sizeof(int), '#');
//t.PrevOrder();
//t.PostOrder();
t.GetKLevel(1);
}
2.顺序存储
一般用于完全二叉树的存储实现。下篇博客!
四.常见面试题
填坑中…