题目

【问题描述】

    假设二叉树中的每个结点值为单个整数，采用二叉链结构存储，设计算法判断给定的二叉树是否是完全二叉树。假定每棵二叉树节点不超过2000个。

【输入形式】

    每个测试是一颗二叉树的括号表示法字符串

【输出形式】

     如果是完全二叉树，输出“1”；如果不是完全二叉树，输出“0”

【样例输入】

    1(2(4,5),3)

【样例输出】

     1

【样例说明】

   测试数据的文件名为in.txt                                                      
 
【评分标准】

   该题目有10个测试用例，每通过一个测试用例，得10分。

思路

  1. 把数据读入，构建成树
  2. 层序遍历二叉树。根据完全二叉树的性质，一旦出现空结点，此后就不能再有空结点了。

设计

括号表示法建树（non-recursive）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//str为括号表示串，例如str = "A(B(D(,G)),C(E,F))"
void CreateBTree(string str){
	BTNode *r = nullptr;
	stack<BTNode*> st;
	BTNode *p;
	bool flag;
	int i = 0;
	while(i < str.length()){
		switch(str[i]){
		case '('://说明该结点p有孩子
			st.push(p);
			flag = true;
			break;
		case ')'://说明p的孩子已经处理完了
			st.pop();
			break;
		case ','://说明栈顶结点有右孩子
			flag = false;//表示开始处理栈顶结点的右孩子
			break;
		default://即遇到的是字符
			p = new BTNode(str[i]);
			if(r == nullptr){//如果
				r = p;
			}else{
				if(flag && !st.empty()){
					//该结点作为栈顶结点的左孩子结点
					st.top()->lchild = p;
				}else if(!st.empty()){
					//该结点作为栈顶结点的右孩子结点
					st.top()->rchild = p;
				}
			}
			break;
		}
		i++;
	}
}
  1. 声明一个根节点r、一个栈st、一个用来标记左右孩子的bool类型变量flag（有孩子时才会用到flag，为真是左孩子，为假是右孩子）
  2. 如果遇到数字字符，则以该字符创建新结点（如果此时r为空，则把该新结点赋值给r）
    1. 如果此时flag为真并且栈非空，则该新结点作为栈顶结点的左孩子
    2. 如果此时栈非空且flag不为真，则该新结点作为栈顶结点的右孩子
  3. 如果遇到’(‘，则证明上个字符所创建的结点是有孩子的，则把上个字符所创建的结点（被p保存了）入栈，并将flag改为ture
  4. 如果遇到’)’，则说明栈顶结点的孩子已经被处理完了，将栈顶出栈
  5. 如果遇到’,’，则说明要么左孩子已经被处理完了，要么没有左孩子。此时改变flag为false；

插曲

本身以为单个整数值的是只有一位的整数，后面提交后发现有误QAQ
其实还是存在多位数的

层序遍历（non-recursive）

没啥好说的，基本的层序遍历

  1. 设计一个bool类型变量用于标记
  2. 层序遍历过程中，如果遇到空结点，则改变标记状态
  3. 如果标记状态改变后又遇到空节点，则证明此树不是完全二叉树，返回false
  4. 如果顺利走完循环，则返回true

代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
#include<iostream>

#include<fstream>

#include<vector>

#include<stack>

#include<queue>

using namespace std;

  

struct BTNode

{

    int val;

    BTNode* left;

    BTNode* right;

    BTNode() {}

    BTNode(int i) : val(i), left(nullptr), right(nullptr) {}  

};

  

BTNode* CreateTree(string str){

    stack<BTNode*> st;

    int i = 0;

    BTNode* r = nullptr;

    BTNode* p;

    bool flag = false;

    while(i < str.length()){

        char ch = str[i];

        switch(ch){

        case '(':

            st.push(p);

            flag = true;

            break;

        case ')':

            st.pop();

            break;

        case ',':

            flag = false;

            break;

        default:

            string d = "";

            int val_;

            while(ch >= '0' && ch <= '9'){

                d += ch;

                i++;

                if(i < str.length()){

                    ch = str[i];

                }else{

                    break;

                }

            }

            i--;

            val_ = stoi(d);

            p = new BTNode(val_);

            if(r == nullptr){

                r = p;

            }else{

                if(flag && !st.empty()){

                    st.top()->left = p;

                }else if(!st.empty()){

                    st.top()->right = p;

                }

            }

            break;

        }

        i++;

    }

    return r;

}

  

void Display(BTNode* b){

    if(b != nullptr){

        cout << b->val << ' ';

        Display(b->left);

        Display(b->right);

    }

}

  

bool Check(BTNode* b){

    queue<BTNode*> qu;

    qu.push(b);

    BTNode* cur;

    bool isappear = false;

    while(!qu.empty()){

        cur = qu.front();

        if(cur != nullptr){

            if(isappear){

                return false;

            }

            qu.push(cur->left);

            qu.push(cur->right);

        }else{

            isappear = true;

        }

        qu.pop();

    }

    return true;

}

  

int main(){

    ifstream file("in.txt");

    string str;

    file >> str;

    BTNode* root = CreateTree(str);

    if(Check(root)){

        cout << '1';

    }else{

        cout << '0';

    }

    return 0;

}