模板在二叉树和队列中的应用（借助队列广度遍历二叉树）

　　接着这两三天的时间把模板、队列、链表、二叉树等知识又过了一遍。也亲自动手写了以上数据结构，算是把当年学数据结构时没做完的实验重新做了一遍，有点小小的成就感。因此写此博文以记之，以备以后用的时候查阅。

　　模板和头文件的知识前面两篇博文已经大概交代了一下，以前没学模板的时候看到这东西头就大，现在学习了一下感觉模板对于代码的重用对提高开发效率还是很有帮助的。

　　一、链表的实现：

  1 //Node.h
  2 #ifndef NODE_H_H
  3 #define NODE_H_H
  4 template<class T>class LinkList;
  5 template<class T>
  6 class Node
  7 {
  8     friend LinkList<T>;
  9 private:
 10     T Data;
 11     Node *Next;
 12 };
 13 #endif
 14 ///////////////////////////////////////////////////////
 15 //LinkList.h
 16 #include "Node.h"
 17 #ifndef LINKLIST_H_H
 18 #define LINKLIST_H_H
 19 template<class T>
 20 class LinkList
 21 {
 22 private:
 23     Node<T> *head;
 24 public:
 25     LinkList();
 26     ~LinkList();
 27     void Insert(T data);
 28     void printLinkList();
 29     Node<T> *Create(int len);
 30 };
 31 #endif
 32 
 33 template<class T>
 34 LinkList<T>::LinkList()
 35 {
 36     head=NULL;
 37 }
 38 
 39 template<class T>
 40 LinkList<T>::~LinkList()
 41 {
 42     Node<T> *p;
 43     while(head)
 44     {
 45         p=head->Next;
 46         delete head;
 47         head=p;
 48         cout<<"析构！"<<endl;
 49     }    
 50 }
 51 template <class T>
 52 Node<T> *LinkList<T>::Create(int len)
 53 {
 54     Node<T> *p;
 55     Node<T> *temp;
 56     T s;
 57     while(len--)
 58     {
 59         cout<<"输入数据："<<endl;
 60         cin>>s;
 61         temp=new Node<T>;
 62         temp->Data=s;
 63         temp->Next=NULL;
 64         if (!head)
 65         {
 66             head=temp;
 67             p=head;
 68         }
 69         else
 70         {
 71             p->Next=temp;
 72             p=temp;
 73         }
 74     }
 75     return head;
 76 }
 77 template<class T>
 78 void LinkList<T>::Insert(T data)
 79 {
 80     Node<T> *p=head;
 81     Node<T> *s=new Node<T>;
 82     s->Data=data;
 83     s->Next=NULL;
 84     if (head==NULL)
 85     {
 86         head=s;
 87         
 88     }
 89     else
 90     {
 91         while(p->Next)
 92         {
 93             p=p->Next;
 94         }
 95         p->Next=s;
 96     }
 97 }
 98 
 99 template<class T>
100 void LinkList<T>::printLinkList()
101 {
102     Node<T> *p=head;
103     while(p)
104     {
105         cout<<p->Data<<endl;
106         p=p->Next;
107 
108     }
109 }
110 ///////////////////////////////////////////////////////////////////
111 //TemplateLinkList.cpp
112 #include <iostream>
113 #include<string>
114 #include "Node.h"
115 #include "LinkList.h"
116 using namespace std;
117 
118 int main()
119 {
120     LinkList<char> L;
121     L.Insert('a');
122     L.Insert('b');
123     L.Insert('c');
124     L.printLinkList();
125 
126     LinkList<string> s;
127     s.Insert("abcd");
128     s.Insert("efgh");
129     s.Insert("ijkl");
130     s.printLinkList();
131 
132     LinkList<int> t;
133     t.Insert(1);
134     t.Insert(2);
135     t.Insert(3);
136     t.printLinkList();
137 
138     LinkList<double> d;
139     Node<double> *b;
140     b=d.Create(4);
141     d.printLinkList();
142 
143     //Node<int> n;
144     return 0;
145 }
View Code

有以下几点需要注意的地方：

　　1、在封闭链表时没有用模板时是通过检测指定的特殊字符，比如'*'来封闭链表。但是用了模板之后对不同的数据类型，前者这种方法只对char类型是有效。所以最后改成Node<T> *Create(int len);通过长度来封闭链表。再写链表的时候用到两个类Node和LinkList注意Node成员如果是private的话要在Node中声明为友元。还有就是在链表中因为要插入节点或者对节点操作，往往要先用一个或者是两个指针指到你要操作的节点或是该节点的前继。一般使用while(p){p=p->Next;}或是while(p->Next){p=p->Next;}具体用的时候还需要仔细考虑一下，比如要指到最后一个节点应该采用while(p->Next){p=p->Next;}。

　　2、写析构函数的时候一开始写的比较麻烦，最后参考别人写了一种比较简洁的。代码如下：

　　

 1 template<class T>
 2 LinkList<T>::~LinkList()
 3 {
 4     Node<T> *p;
 5     while(head)
 6     {
 7         p=head->Next;
 8         delete head;
 9         head=p;
10         cout<<"析构！"<<endl;
11     }    
12 }
View Code

　　3、写链表主要还是指针的操作，有的时候指来指去容易搞错需要注意，实现的过程中注意有头结点和没有头结点的区别。

 

　　二、队列的实现

 1 //Queue.h
 2 #ifndef QUQUE_H_H
 3 #define QUQUE_H_H
 4 template<class T>
 5 class Node
 6 {
 7     public:
 8         T Data;            //节点数据
 9         Node<T> *Next;    //指向下一个节点
10 };
11 
12 template<class T>
13 class Queue
14 {
15     private:
16         Node<T> *Front;    //队头，出队
17         Node<T> *Rear;    //队尾，入队
18     public:
19         Queue();
20         ~Queue();
21         void EnQueue(T data);
22         T DeQueue();
23         bool QueueEmpty() const;
24 
25 };
26 #endif
27 
28 template<class T>
29 Queue<T>::Queue()
30 {
31     Front=Rear=NULL;
32 }
33 
34 template<class T>
35 Queue<T>::~Queue()
36 {
37     Node<T>*p=Front;
38     while(Front)
39     {
40         p=p->Next;
41         delete Front;
42         Front=p;
43     }
44     Front=Rear=NULL;
45     cout<<"XiGou!"<<endl;
46 }
47 
48 template<class T>
49 void Queue<T>::EnQueue(T data)
50 {
51     Node<T> *p;
52     Node<T> *s=new Node<T>;
53     s->Data=data;
54     s->Next=NULL;
55     //队列为空
56     if (Front==NULL&&Rear==NULL)
57     {
58         Front=s;
59         Rear=s;
60     }
61     else
62     {
63         p=Front;
64         //指到队尾
65         while (p->Next)
66         {
67             p=p->Next;
68         }
69         //入队一个节点
70         p->Next=s;
71         Rear=s;    //Rear始终指向队尾
72     }
73 }
74 
75 template<class T>
76 T Queue<T>::DeQueue()
77 {
78     Node<T> *p=Front;
79     T data=Front->Data;
80     Front=Front->Next;
81     //队列中只有一个节点，删除后队列置空
82     if(NULL==Front) Rear=NULL;
83     delete p;
84     return data;
85 }
86 
87 template<class T>
88 bool Queue<T>::QueueEmpty() const
89 {
90     if (Front==NULL&&Rear==NULL)
91     {
92         return true;
93     }
94     return false;
95 }
View Code

　　需要注意的地方：

　　1、知道队列的基本原理"先进先出"，从队头（Front）出队尾（Rear）进.

　　2、Front指针永远指向队头，Rear永远指向队尾。当进行了出队和入队后记得更新Front和Rear指针。

　　3、如果本身队列只有一个节点，出队后队列为空注意此时Front=Rear=NULL,避免成为悬浮指针。

　　4、注意类模板的语法。

 

　　三、二叉树的实现

　　

  1 #include "Queue.h"
  2 #ifndef BINARYTREE_H_H
  3 #define BINARYTREE_H_H
  4 template<class T>
  5 class BinaryTree
  6 {
  7 private:
  8     BinaryTree<T> *left;
  9     BinaryTree<T> *right;
 10     T data;
 11 public:
 12     void Create(BinaryTree<T> * &root);
 13     void PreOrder(BinaryTree<T> *p);
 14     void InOrder(BinaryTree<T> *p);
 15     void PostOrder(BinaryTree<T> *p);
 16     void CountLeaf(BinaryTree<T> *p,int &count);
 17     void BinatyTreeDepth(BinaryTree<T> *p,int level,int &count);
 18     void LayerOrder(BinaryTree<T> *t);
 19 };
 20 #endif
 21 
 22 template<class T>
 23 void BinaryTree<T>::Create(BinaryTree<T> * &root)
 24 {
 25     T a;
 26     cin>>a;
 27     if (a!='*')
 28     {
 29         root=new BinaryTree;
 30         root->data=a;
 31         Create(root->left);
 32         Create(root->right);
 33     }
 34         else root=NULL;
 35 }
 36 
 37 template<class T>
 38 void BinaryTree<T>::PreOrder(BinaryTree<T> *p)
 39 {
 40     if (p!=NULL)
 41     {
 42         cout<<p->data<<endl;
 43         PreOrder(p->left);
 44         PreOrder(p->right);
 45     }
 46 }
 47 
 48 template<class T>
 49 void BinaryTree<T>::InOrder(BinaryTree<T> *p)
 50 {
 51     if (p!=NULL)
 52     {
 53         InOrder(p->left);
 54         cout<<p->data<<endl;
 55         InOrder(p->right);
 56     }
 57 }
 58 
 59 template<class T>
 60 void BinaryTree<T>::PostOrder(BinaryTree<T> *p)
 61 {
 62     if (p!=NULL)
 63     {
 64         PostOrder(p->left);
 65         PostOrder(p->right);
 66         cout<<p->data<<endl;
 67     }
 68 }
 69 
 70 template<class T>
 71 void BinaryTree<T>::CountLeaf(BinaryTree<T> *p,int &count)
 72 {
 73     if (p)
 74     {
 75         if (!(p->left)&&!(p->right))
 76         {
 77             count++;
 78         }
 79         //注意这两句话外层这个if语句大括号里
 80         CountLeaf(p->left,count);
 81         CountLeaf(p->right,count);
 82     }
 83 }
 84 
 85 template<class T>
 86 void BinaryTree<T>::BinatyTreeDepth(BinaryTree<T> *p,int level,int &count)
 87 {
 88     if (p)
 89     {
 90         if (level>count)count=level;
 91         BinatyTreeDepth(p->left,level+1,count);
 92         BinatyTreeDepth(p->right,level+1,count);
 93     }
 94 }
 95 
 96 
 97 template<class T>
 98 void BinaryTree<T>::LayerOrder(BinaryTree<T> *t)
 99 {
100     Queue<BinaryTree<T>*> q;
101     BinaryTree<T> *p;
102     T da;
103     q.EnQueue(t);
104     while(!q.QueueEmpty())
105     {
106         p=q.DeQueue();
107         da=p->data;
108         cout<<da<<endl;
109         if(p->left) 
110             q.EnQueue(p->left);
111         if(p->right) 
112             q.EnQueue(p->right);
113     }
114 }
View Code

　　需要注意的几点地方：

　　1、void Create(BinaryTree<T> * &root);中&不能少。如果不要&递归每次生成左子树和右子树每次不会生成新的节点。

　　2、统计叶节点的思路“当一个节点的左子树和右子树为空时，该节点就是叶节点”if (!(p->left)&&!(p->right)){count++; }。

　　3、计算树的深度“每递归往下走一层，对比当前子树深度是否大于当前记录的值，大于就替换”

　　4、广度遍历二叉树时需要用到队列，队列的元素师指向树的指针，从根节点的指针开始入队，每个while()循环把当前队头节点的两个节点入队。所以循环一共循环非叶节点个数减一次，减一主要是根节点一开始就入队了。最后队列中就按层次的顺序排列了树的部分节点。注意不是全部节点都在队列中，入队和出队是动态的过程，不是一口气全部节点全部入队再出队。

　　

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/maxiaofang/p/3355747.html