六、二叉树

一、二叉查找树
1.最好的查找情况是，在完全二叉树中查找，查找的复杂度为Olg（（n））
2.最坏的查找情况是树呈链状结构，查找的复杂度为log(n).
3.一般情况(介于n和lg（n））：假设树中包括从1到n，如果节点i是根节点，它的左子树就有i-1个节点，右子树有n-i个节点，假设path1与path2分别是这些子树的平均路径长度，则该树的平均路径长度就是：
path(i)=((i-1)(path_(i-1)+1)+(n-i)(path_(n-i)+1))/n
二、二叉查找树的查找函数

template<class T>
T* BST<T>::search(BSTNode<T>*p,const T&el)const{
	while(p!=0)
		if(el==p->el)
			return &p->el;
		else if(el<p->el)
			p = p->left;
			else p = p->right;
		return 0;
}

三、树的遍历
1.广度优先遍历

//从上到下从左到右的广度优先遍历
template<class T>
void BST<T>::breadthFirst(){
	Queue<BSTNode<T>*> queue;
	BSTNode<T>*p = root;
	if(p!=0){
		queue.enqueue(p);
		while(!queue.empty()){
			p=queue.dequeue();
			vist(p);
			if(p->left != 0)
				queue.enqueue(p->left);
			if(p->right != 0)
				queue.enqueue(p->right);
		}
	}
}

2.深度优先遍历
1.VLR—前序树遍历

//递归实现
template<class T>
void BST<T>::preorder(BSTNode<T>*p){
	if(p!=0){
		vist(p);
		perorder(p->left);
		perorder(p->right);
	}
}
//非递归(栈)实现
template <class T>
void BST<T>::iterativePreOrder(){
	Stack<BSTNode<T>*> travStack;
	BSTNode<T>*p = root;
	if(p!=0){   //如果树不为空则开始遍历
		travStack.push(p);   //把根节点压栈
		while(!travStack.empty){  //当栈不为空
		p=travStack.pop();	//将弹出的赋给p
		visit(p);             
		if(p->right != 0){   //先把右节点压栈
			travStack.push(p->right);
		}
		if(p->left != 0){  
			travStack.push(p->left);
		}
		}
	}
}

2.LVR— 中序树遍历

//前序遍历（递归实现）
template<class T>
void BST<T>::inorder(BSTNode<T>*p){
	if(p!=0)
	{
		inorder(p->left);
		vist(p);
		inorder(p->right);
	}
}

//非递归实现(少用)
template<class T>
void BST<T>::interativeInorder(){
	Stack<BSTNode<T>*> travStack;
	BSTNode *p=root;
	while(p!=0){
		while(p!=0){
			if()p->right)
				travStack.push(right);
			travStack.push(p);
			p = p->left;
		}
		p=travStack.pop();
		while(!travStack.empty()&&p->right == 0){
			visit(p);
			p=travStack.pop();
		}
		visit(p);
		if(!travStack.empty()){
			p = travSatck.pop();
		}
		else p=0;
	}
}

3.LRV— 后序树遍历

//递归实现
template<class T>
void BST<T>::postorder(BSTNode<T>*p){
	if(p!=0){
		postorder(p->left);
		postorder(p->right);
		vist(p);
	}
}

//非递归实现
template<class T>
void BST<T>::iterativePostorder(){
		Stack<BST<T>*> travStack;
		BSTNode<T>*p = root, *q = root;
		while(p != 0){
			for(;p->left != 0; p->left)
				travStack.push(p);
			while(p->right == 0 || p->right == q){
				vist(p);
				q = p;
				if(travStack.empty())
					return;
				p=travStack.pop();
			
			}
			travStack.push(p);
			p = p->right;
		}

}

四、AVL树

AVL树的旋转平衡

五、堆
堆是一种特殊的二叉树，具有以下两个性质（最大堆）：
（1）每个节点的值大于等于其每个子节点的值
（2）该树完全平衡，最后一层的叶子都处于最左侧的位置
最小堆：将性质（1）的大于改为小于即为最小堆

1.将堆作为优先队列

2.用数组实现堆
图解最小堆形成-以数组方式表示

• Robert Floyd 算法建堆操作（由一个数组建堆）
  堆自底向上构造，首先构造较小的堆，在将它们复合成大堆