数据结构-复习（二）：树~二叉搜索树_有一棵完全二叉树,包含n个节点。将其叶子节点自左向右从0开始编号-优快云博客

性质1：任何一个二叉树，度数为0的结点比度数为2的结点多一个。（由n=x0+x1+x2; n=0*x0+1*x1+2*x2+1；可得x0 = x2+1;）
性质2：二叉树的第i(i>=0)层上至多有 $2^i$ 个节点。
性质3：高度为h的二叉树至多有 $2^h-1$ 个结点。
性质4：非空满二叉树的叶子节点的数量等于其分支结点的数量加1。
性质5：有n个结点的完全二叉树的高度为 $\left \lceil log_2(n+1) \right \rceil$ .
性质6：如果对一棵有n个结点的完全二叉树的结点按层编号（从跟往下，从左往右），如果从0开始标号，那么i号结点的编号为(i-1)/2,左孩子的编号为2i+1,右孩子的编号为2i+2.

2.4 二叉树的存储结构：

顺序存储结构：一般用来存储完全二叉树。
链式存储结构：二叉链表(data,leftChild,rightChild);三叉链表(data,parent,leftChild,rightChild).

2.5 二叉树的抽象数据结构

template<class T>
class BinaryTreeNode{
    friend class BinaryTreeNode<T>;
private:
    T element;
    BinaryTreeNode<T> *leftChild;
    BinaryTreeNode<T> *rightChild;
public:
    //member function:constructor/get/set/IsLeaf
};
template<class T>
class BinaryTree
{
private:
    BinaryTree<T> * root;
public:
    //member function:constructor/get/set/IsEmpty
    
    void breadthFirstOrder(BinaryTreeNode<T>* root); //广度优先遍历

    void preOrder(BinaryTreeNode<T>* root);//先序遍历
    void inOrder(BinaryTreeNode<T>* root);//中序遍历
    void postOrder(BinaryTreeNode<T>* root);//后序遍历

};

2.6 树的遍历

广度优先遍历(层次遍历)：从第0层开始向下逐层访问结点，每一层从左向右逐个访问结点。

可以用队列来实现。对于非空树，先将根结点加入队列；每次访问队列中的头结点，并把它的左右孩子(如果有的话)加入队列，弹出已访问头结点，直到队列为空为止。

template<class T>
void BinaryTree<T>::breadthFirstOrder(BinaryTreeNode<T>* root)
{
    using std::queue;
    queue<BinaryTreeNode<T>*> NodeQueue;
    BinaryTreeNode<T>* pointer = root;
    if(pointer)
        NodeQueue.push(pointer);
    while(! NodeQueue.empty() )
    {
        pointer = NodeQueue.front();
        visit(pointer);
        if(pointer->leftChild)
            NodeQueue.push(pointer->leftChild);
        if(pointer->rightChild)
            NodeQueue.push(pointer->rightChild);
        NodeQueue.pop();
    }

};

深度优先遍历：
前序：访问根结点，先序遍历左子树，先序遍历右子树。

主要思想：每遇到一个节点，先访问该节点，并把该节点的非空右子树的根结点压入的栈中，然后遍历其左子树，直到左子树为空，然后从栈顶弹出待访问的结点，继续遍历，直至栈为空为止。

中序：中序遍历左子树，访问根结点，中序遍历右子树。

主要思想：从根结点开始向左搜索，每遇到一个节点，就将其压入栈中，然后去遍历其左子树。遍历完左子树后，弹出栈顶结点并访问它，然后遍历其右子树。

后序：后序遍历左子树，后序遍历右子树，访问根结点。

主要思想：从根结点开始向左搜索，每遇到一个节点，就将其压入栈中，直到栈中的结点不在有左子树为止。读取栈顶的结点，如果该节点有右子树且未被访问，则访问其右子树，否则访问该节点并从栈中移除。

//前序遍历的非递归实现
template<class T>
void BinaryTree<T>::preOrder(BinaryTreeNode<T> *root)
{
    using std::stack;
    stack<BinaryTreeNode<T> * > nodeStack;
    BinaryTreeNode<T> * pointer =root;

    while(!nodeStack.empty() || pointer)
    {
        if(pointer)
        {
            visit(pointer);
            if(pointer->rightChild != NULL)
                nodeStack.push(pointer->rightChild);
            pointer = pointer->leftChild;
        }
        else
        {
            pointer = nodeStack.top();
            nodeStack.pop();
        }
    }

}


//中序遍历的非递归实现
template<class T>
void BinaryTree<T>::inOrder(BinaryTreeNode<T> *root)
{
    using std::stack;
    stack<BinaryTreeNode<T> *> nodeStack;
    BinaryTreeNode<T> * pointer = root;

    while(!nodeStack.empty() || pointer)
    {
        if(pointer)
        {              
                nodeStack.push(pointer);
                pointer = pointer->leftChild;           
        }
        else
        {
            pointer = nodeStack.top();

            visit(pointer);
            pointer = pointer->rightChild;
            nodeStack.pop();
        }
    }
}

//后序遍历的非递归实现
template<class T>
void BinaryTree<T>::postOrder(BinaryTreeNode<T> *root)
{
    using std::stack;
    stack<BinaryTreeNode<T> *> nodeStack;
    BinaryTreeNode<T> * pointer = root;
    BinaryTreeNode<T> * preNode= NULL;

    while(pointer || !nodeStack.empty() )
    {
        if(pointer)
        {
            nodeStack.push(pointer);
            pointer = pointer->leftChild;
        }
        else
        {
            pointer = nodeStack.top();
            if(pointer->rightChild != preNode && pointer->rightChild !=nullptr)
            {
                pointer = pointer->rightChild;
            }
            else
            {
                visit(pointer);
                preNode = pointer;
                nodeStack.pop();                
                pointer = NULL;
            }
        }
    }
}

2.7 线索二叉树

n个结点的二叉链表中含有n+1个空指针域，如果利用二叉链表中的空指针域来存放指向结点在某种遍历次序下的前驱和后继结点的指针，则又可以节省空间开销，又能提高时间效率。

为了区分指针所指向的是孩子结点还是前驱、后继结点，对每个结点增加两个标志域。

二叉链表结点的数据结构：（leftChild,leftTag,data,rightTag,rightChild）

leftTag=0,leftChild指向该节点的左孩子。leftTag=1,leftChild指向该节点的前驱结点。

rightTag=0,rightChild指向该节点的右孩子。rightTag=1,rightChild指向该节点的后继结点。

……(To be continued)

2.8 二叉搜索树

二叉搜索树又称为二叉排序树：该树的每个结点都有一个作为搜索依据的关键码，对于任意结点而言，其左子树（如果存在）上的所有结点的关键码均小于该结点的关键码，其右子树（如果存在）的所有结点的关键码均大于该结点的关键码。

二叉搜索树的查找：

由于二叉搜索树的特殊定义，通常用分割式查找法：

1）若根结点的关键码的值等于待查找的键值，则查找成功。

2）否则，若键值小于根结点的关键码的值，则在其左子树中查找；若键值大于根结点的关键码的值，则在其右子树中查找。

//还是利用的前面二叉树的结构，记得在BinaryTree中添加查找函数的声明

//二叉搜索树的查找
template<class T>
BinaryTreeNode<T> * BinaryTree<T>::search(BinaryTreeNode<T> * root,const T & value)
{
	BinaryTreeNode<T> * current = root;
	while(current)
	{
		if(current->element == value)
			return current;
		current = value < current->element ? current->leftChild:current->rightChild;
	}
	return nullptr;
}

二叉搜索树的插入：

插入关键是要找到合适的插入位置。所有，进行插入操作时，首先进行位置的查找。

方法是从根结点开始，将要插入的结点的关键码与根结点比较，如果小于根结点，则和左子树继续比较，如果大于根结点，则和右子树继续比较，直到到达叶子结点。比较要插入结点的关键码和该叶子结点的关键码，如果插入的关键码比较小，则把它置为该叶子结点的左孩子，否则置为右孩子；

//二叉搜索树的插入
template<class T>
void BinaryTree<T>::insert(const T & value)
{
	BinaryTreeNode<T> * current = root,* parent=nullptr;
	while(current !=NULL)
	{
		parent = current;
		if(value<current->element)
			current = current->leftChild;
		else 
			current = current->rightChild;
	}
	if(parent ==NULL)
		root = new BinaryTreeNode<T>(value);
	else if(value < parent->element)
		parent->leftChild = new BinaryTreeNode<T>(value);
	else
		parent->rightChild = new BinaryTreeNode<T>(value);

}

二叉搜索树的删除：

在删除结点操作中，最重要的是如何在删除结点之后，仍然保持二叉搜索树的特征。结点的删除包括以下三种情况：

如果被删除的结点p没有子树，直接删除该结点；
如果被删除的结点p只有一颗子树，那么就用唯一子树的根结点代替要删除的那个结点p。
如果被删除的结点p有两颗子树，那么可以采取两种方法：

1）合并删除：查找到被删除结点p的左子树按中序遍历的最后一个结点r，将结点r的右指针赋值为指向结点p的右子树的根，然后用结点p的左子树的根代替被删除的结点p，最后删除结点p。

2）复制删除：选取一个合适的结点r，并将该节点的关键码复制给被删除结点p，然后将r结点删除。选取结点r的两种方法：结点p的左子树中关键码最大的结点或者结点p的右子树中关键码最小的结点。

//二叉搜索树的删除
template<class T>
void BinaryTree<T>::remove(const T &value)
{
	BinaryTreeNode<T> * current = root,*parent=NULL;
	while(current)
	{
		if(current->element == value)
		{
			if(parent==NULL)
				deleteByCopying(root);//deleteByMerging
			else if(parent->leftChild = current)
				deleteByCopying(parent->leftChild);//deleteByMerging
			else
				deleteByCopying(parent->rightChild);//deleteByMerging
			break;
		}
		parent = current;
		current = value < current->element ? current->leftChild:current->rightChild;
	}
}

template<class T>
void BinaryTree<T>::deleteByMerging(BinaryTreeNode<T> * &node)
{	
	if(node != NULL)
	{
		BinaryTreeNode<T> * tmp = node;
		if(node->rightChild == NULL)
			node=node->leftChild;
		else if(node->leftChild==NULL)
			node=node->rightChild;
		else
		{
			tmp = node->leftChild;
			while(tmp->rightChild != NULL)
				tmp = tmp->rightChild;
			tmp->rightChild = node->rightChild;
			tmp = node;
			node = node->leftChild;
		}
		delete tmp;		
	}
}

template<class T>
void BinaryTree<T>::deleteByCopying(BinaryTreeNode<T> * &node)
{	
	if(node!=NULL)
	{
		BinaryTreeNode<T> * tmp = node;
		if(node->rightChild==NULL)
			node = node->leftChild;
		else if(node->leftChild==NULL)
			node = node->rightChild;
		else
		{			 
			tmp = node->leftChild;
			BinaryTreeNode<T> * preTmp = tmp;
			while(tmp->rightChild)
			{	
				preTmp = tmp;
				tmp = tmp->rightChild;
			}
			node->element = tmp->element;
			if(preTmp != tmp)
				preTmp->rightChild = tmp->leftChild;
		}
		delete tmp;
	}
}