树和森林的概念 二叉树 二叉树遍历 二叉树的计数 线索化二叉树 堆 树与森林 霍夫曼树

1. 第六章 树与森林 • 树和森林的概念 • 二叉树 • 二叉树遍历 • 二叉树的计数 • 线索化二叉树 • 堆 • 树与森林 • 霍夫曼树

2. 树和森林的概念 树的定义 树是由n (n 0) 个结点组成的有限集合。如果 n = 0，称为空树；如果 n > 0，则  有一个特定的称之为根(root)的结点，它只有直接后继，但没有直接前驱； 除根以外的其它结点划分为 m (m 0) 个 互不相交的有限集合T0, T1, …, Tm-1，每个集合又是一棵树，并且称之为根的子树。

3. 树的特点 • 每棵子树的根结点有且仅有一个直接前驱，但可以有0个或多个直接后继。 0层 A 1层 B C D height = 3 2层 E F G H I J 3层 K L M

4. 结点 • 结点的度 • 分支结点 • 叶结点 • 子女 • 双亲 • 兄弟 • 祖先 • 子孙 • 结点层次 • 树的度 • 树高度 • 森林 0层 A 1层 B C D height = 3 2层 E F G H I J 3层 K L M

5. 树的抽象数据类型 template <class Type> class Tree { //对象: 树是由n(≥0)个结点组成的有限集 //合。在类界面中的position是树中结点的 //地址。在顺序存储方式下是下标型, 在链 //表存储方式下是指针型。Type是树结点中存放数据的类型。public: Tree ( ); ~Tree ( );

6. position Root ( ); BuildRoot ( const Type& value ); position FirstChild ( position p ); position NextSibling ( position p, position v ); position Parent ( position p ); Type GetData ( position p ); int InsertChild ( const position p, const Type &value );int DeleteChild ( position p, int i ); }

7. 二叉树(Binary Tree) 二叉树的定义 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根结点加上两棵分别称为左子树和右子树的、互不相交的二叉树组成。 L R L R 二叉树的五种不同形态

8. 二叉树的性质 性质1若二叉树的层次从0开始, 则在二叉树的第 i 层最多有 2i 个结点。(i 0) [证明用数学归纳法] 性质2高度为h的二叉树最多有 2h+1-1个结点。(h-1) [证明用求等比级数前k项和的公式] 20 + 21 + 22 + … + 2h = 2h+1-1

9. 性质3对任何一棵二叉树, 如果其叶结点有n0 个, 度为2的非叶结点有n2 个, 则有 n0＝n2＋1 证明：若设度为1的结点有 n1个，总结点个数为 n，总边数为 e，则根据二叉树的定义， n = n0 + n1 + n2e = 2n2 + n1 = n- 1 因此，有2n2 + n1= n0 + n1 + n2- 1 n2 = n0- 1n0 = n2 + 1

10. 定义1满二叉树 (Full Binary Tree) 定义2完全二叉树 (Complete Binary Tree) 若设二叉树的高度为h，则共有h+1层。除第 h 层外，其它各层 (0  h-1) 的结点数都达到最大个数，第 h 层从右向左连续缺若干结点，这就是完全二叉树。

11. 性质4具有n(n  0) 个结点的完全二叉树的高度为 log2(n+1)-1 证明：设完全二叉树的高度为 h，则有 2h- 1 < n 2h+1- 1 变形 2h < n+1  2h+1 取对数 h < log2(n+1)  h+1 因此有 log2(n+1) = h+1 h = log2(n+1)-1 上面h层结点数 第h层结点数

12. 性质5如将一棵有n个结点的完全二叉树自顶向下，同一层自左向右连续给结点编号0, 1, 2, …, n-1，则有以下关系： • 若i = 0, 则 i 无双亲 若i > 0, 则 i 的双亲为(i -1)/2 • 若2*i+1 < n, 则 i 的左子女为 2*i+1，若2*i+2 < n, 则 i 的右子女为2*i+2 • 若 i 为偶数, 且i != 0, 则其左兄弟为i-1, 若 i 为奇数, 且i != n-1, 则其右兄弟为i+1 0 1 2 3 4 5 6 7 8 9

13. 二叉树的抽象数据类型 template <class Type> class BinaryTree{ public: BinaryTree ( );//构造函数 BinaryTree ( BinTreeNode<Type> * lch, BinTreeNode<Type> * rch, Type item ); //构造以item为根，lch和rch为左、右 //子树的二叉树 int IsEmpty ( );//判二叉树空否？ BinTreeNode<Type> * Parent ( ); //双亲

14. BinTreeNode<Type> * LeftChild ( ); //取左子女结点地址 BinTreeNode<Type> * RightChild ( ); //取右子女结点地址 int Insert ( const Type& item ); //插入 int Find ( const Type &item ) const; //搜索 Type GetData ( ) const; //取得结点数据 BinTreeNode<Type> *GetRoot ( ) const; //取根结点地址 }

15. 0 0 1 2 1 2 3 4 5 6 3 4 5 7 8 9 6 7 8 9 二叉树的顺序表示 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 完全二叉树 一般二叉树 的顺序表示 的顺序表示

16. 二叉树的链表表示 leftChild data rightChild data rightChild leftChild 二叉链表

17. 二叉树的链表表示 leftChild data parent rightChild parent data rightChild leftChild 三叉链表

18. root root root A  A   A B B B  D   D  C D C C         E F E F E F 二叉树 二叉链表 三叉链表 二叉树链表表示的示例

19. root data parent leftChild rightChild A 0 1 2 3 4 5 A-1 1 -1 B 0 2 3 C 1-1 -1 D 1 4 5 E 3 -1 -1 F 3 -1 -1 B C D E F 二叉链表的静态结构

20. 二叉树的类定义 template <class Type> class BinaryTree; template <class Type> Class BinTreeNode { friend class BinaryTree<Type>; private: Type data; BinTreeNode<Type> * leftChild; BinTreeNode<Type> * rightChild; public: BinTreeNode ( ) : leftChild (NULL), rightChild (NULL) { }

21. BinTreeNode ( Type item, BinTreeNode<Type> *left = NULL, BinTreeNode<Type> *right = NULL ) : data (item), leftChild (left), rightChild (right) { } Type GetData( ) const { return data;} BinTreeNode<Type> * GetLeft ( ) const { return leftChild;} BinTreeNode<Type> * GetRight ( ) const { return rightChild;} void SetData ( const Type& item ) { data = item;}

22. void SetLeft ( BinTreeNode <Type> * L ) { leftChild = L;} void SetRight ( BinTreeNode <Type> * R ) { rightChild = R;} }; template <class Type> class BinaryTree { private: BinTreeNode <Type> *root; Type RefValue; void CreateBinTree ( ifstream& in, BinTreeNode<Type> * & current );

23. BinTreeNode<Type> * Parent ( BinTreeNode<Type> * start, BinTreeNode<Type> * current ); int Insert ( BinTreeNode<Type> * & current, const Type&item );//插入 void Traverse ( BinTreeNode<Type> *current, ostream &out ) const//遍历 int Find ( BinTreeNode<Type> *current, const Type &item ) const //搜索 void destroy ( BinTreeNode<Type> * current );//删除

24. public: virtual BinaryTree ( ) : root (NULL) { } virtual BinaryTree ( Type value ) : RefValue (value), root (NULL) { } virtual ~BinaryTree ( ) { destroy ( root ); } virtualint IsEmpty ( ) //判树空否 { return root == NULL ? 1 : 0;} virtual BinTreeNode <Type> * Parent ( BinTreeNode <Type> *current ) { return root == NULL || root == current？ NULL : Parent ( root, current ); } //找current结点的双亲

25. virtual BinTreeNode<Type> * LeftChild ( BinTreeNode<Type> *current) //取current结点的左子女 {return root != NULL ? current->leftChild : NULL;} virtual BinTreeNode<Type> * RightChild ( BinTreeNode<Type> *current ) //取current结点的右子女 { return root != NULL ? current->rightChild : NULL; } virtualint Insert ( const Type& item);

26. virtual BinTreeNode<Type> * Find ( const Type& item ) const; //搜索 BinTreeNode<Type> *GetRoot ( ) const { return root;} //取根 friend istream& operator >> (filename, BinaryTree<Type>& Tree) //重载操作：输入 friend ostream& operator << (ostream&out, BinaryTree<Type>& Tree) //重载操作：输出 }

27. 二叉树部分成员函数的实现 template<class Type> void BinaryTree<Type> :: destroy ( BinTreeNode<Type> *current ) { if ( current != NULL ) { destroy ( current -> leftChild ); destroy ( current -> rightChild ); delete current; } }

28. template<class Type> void BinaryTree <Type> :: CreateBinTree ( ifstream& in, BinTreeNode<Type> * & current ) { //私有函数: 以递归方式建立二叉树。 //输入结点值的顺序必须对应二叉树结点前 //序遍历的顺序。并约定以输入序列中不可 //能出现的值作为空结点的值以结束递归, //此值在RefValue中。例如用“@”或用“-1” //表示字符序列或正整数序列空结点。 Type item; if ( !in.eof ( ) ) {

29. 如图所示的二叉树的前序遍历顺序为 A B C @ @ D E @ G @ @ F @ @ @ A @ B C D @ @ F E @ @ @ G @ @

30. in >> item; //读入根结点的值 if ( item != RefValue ) { current = new BinTreeNode<Type> ( item );//建立根结点 if ( current == NULL ) {cerr << “存储分配错!” << endl; exit (1); } CreateBinTree ( in, current->leftChild ); CreateBinTree ( in, current->rightChild ); } else current = NULL; //封闭叶结点 } }

31. template <class Type> BinTreeNode <Type> * BinaryTree <Type> :: Parent ( BinTreeNode <Type> * start, BinTreeNode <Type> * cuurent ) { if ( start == NULL ) return NULL; if ( start->leftChild == current || start->rightChild == current ) return start; BinTreeNode <Type> *p; if (( p = Parent ( start->leftChild, current )) != NULL ) return p; else return Parent(start->rightChild, current); }

32. template <class Type> void BinaryTree<Type> :: Traverse ( BinTreeNode <Type> *current, ostream &out ) const { //私有函数:搜索并输出根为current的二叉树 if ( current != NULL ) { out << current->data << ‘ ’; Traverse ( current->leftChild, out ); Traverse ( current->rightChild, out ); } }

33. template<class Type> istream& operator >> ( filename, BinaryTree<Type> & Tree ) { //建立一棵二叉树Tree。in是输入流对象 Type item; ifstream fin(filename, //打开文件 ios :: in | ios :: nocreate ); if ( !fin ) { cerr << “文件未发现!” << endl; exit (1); } CreateBinTree ( ifstream& fin, root ); fin.close ( );//关闭文件 }

34. template <class Type> ostream& operator << ( ostream& out, BinaryTree<Type> &Tree ) { out << “二叉树的前序遍历.\n"; Tree.Traverse ( Tree.root, out ); out << endl; return out; }

35. 二叉树遍历 树的遍历就是按某种次序访问树中的结点，要求每个结点访问一次且仅访问一次。 设访问根结点记作 V 遍历根的左子树记作 L 遍历根的右子树记作 R 则可能的遍历次序有 前序 VLR 镜像 VRL 中序 LVR 镜像 RVL 后序 LRV 镜像 RLV

36. 中序遍历 (Inorder Traversal) - 中序遍历二叉树算法的框架是： • 若二叉树为空，则空操作； • 否则 • 中序遍历左子树 (L)； • 访问根结点 (V)； • 中序遍历右子树 (R)。 遍历结果 a + b * c-d-e / f + / * a e f b - c d

37. 二叉树递归的中序遍历算法 template <class Type> void BinaryTree <Type> :: InOrder ( BinTreeNode <Type> *current ) { if ( current != NULL ) { InOrder ( current->leftChild ); cout << current->data; InOrder ( current->rightChild); } }

38. 前序遍历 (Preorder Traversal) - 前序遍历二叉树算法的框架是： • 若二叉树为空，则空操作； • 否则 • 访问根结点 (V)； • 前序遍历左子树 (L)； • 前序遍历右子树 (R)。 遍历结果 - + a * b-c d / e f + / * a e f b - c d

39. 二叉树递归的前序遍历算法 template <class Type> void BinaryTree<Type> :: PreOrder ( BinTreeNode <Type> * current ) { if ( current != NULL ) { cout << current->data; PreOrder ( current->leftChild ); PreOrder ( current->rightChild ); } }

40. 后序遍历 (Postorder Traversal) - 后序遍历二叉树算法的框架是： • 若二叉树为空，则空操作； • 否则 • 后序遍历左子树 (L)； • 后序遍历右子树 (R)； • 访问根结点 (V)。 遍历结果 a b c d- * + e f / - + / * a e f b - c d

41. 二叉树递归的后序遍历算法 template <class Type> void BinaryTree <Type> :: PostOrder ( BinTreeNode <Type> * current ) { if ( current != NULL ) { PostOrder ( current->leftChild ); PostOrder ( current->rightChild ); cout << current->data; } }

42. 应用二叉树遍历的事例 利用二叉树后序遍历计算二叉树结点个数及二叉树的高度 template <class Type> int BinaryTree<Type> :: Count ( const BinTreeNode <Type> * t ) const { if ( t == NULL ) return 0; elsereturn 1 + Count ( t->leftChild ) + Count ( t->rightChild ); }

43. template <class Type> int BinaryTree<Type> :: Height ( const BinTreeNode <Type> * t ) const { if ( t == NULL ) return-1; else return 1 + Max ( Height ( t->leftChild ), Height ( t->rightChild) ); }

44. 利用栈的前序遍历非递归算法 a c b d c c c e d 访问 a 进栈 c 左进 b 访问 b 进栈 d 左进 空 退栈 d 访问 d 左进 空 退栈 c 访问 c 左进 e 访问 e 左进 空 栈空 结束

45. 利用栈的前序遍历非递归算法 template <class Type> void BinaryTree<Type> ::PreOrder( ) { stack <TreeNode<Type>* > S; BinTreeNode<Type> * p = root;//初始化 S.Push ( NULL ); while ( p != NULL ) { cout << p->data << endl; if ( p->rightChild != NULL ) S.Push ( p->rightChild ); //预留右子树指针在栈中

46. if ( p->leftChild != NULL ) p = p->leftChild; //进左子树 else { p = S.getTop( ); S.Pop( );} //左子树为空, 进右子树 } } 利用栈的中序遍历非递归算法 template <class Type> void BinaryTree<Type> ::InOrder ( ) { stack <TreeNode<Type>* > S;

47. 利用栈的中序遍历非递归算法 a d a b a c b a a 退栈 访问 退栈 访问 退栈 访问 左空 左空 e d e c c c 左空 退栈访问 右空 退栈访问 栈空结束

48. BinTreeNode<Type> * p =root;//初始化 do { while ( p != NULL ) { S.Push(p); p = p->leftChild; } if ( !S.IsEmpty( ) ) { //栈非空 p = S.getTop( ); S.Pop( );//退栈 cout << p->data << endl;//访问根 p = p->rightChild; //向右链走 } } while ( p != NULL || !S.IsEmpty( ) ); }

49. 利用栈的后序遍历非递归算法 后序遍历时使用的栈的结点定义 template <class Type> struct stkNode { BinTreeNode<Type> *ptr; enum tag{ L, R }; //该结点退栈标记 stkNode( BinTreeNode<Type>* N = NULL ) : ptr (N), tag ( L ) { }//构造函数 }; 根结点的tag = L，表示从左子树退出, 访问右子树。tag = R, 表示从右子树退出, 访问根。 ptr tag{L,R}

50. a dL bR aL dR bR aL c b bL aL bR aL aL e d eR cL aR eL cL aR bR aL cL aR cR aR aL aR aR