第3章 高质量的代码
从3个方面保证代码的完整性：
| 测试内容 | 要求 |
|---|---|
| 功能测试 | 完成常规的功能要求 |
| 边界测试 | 考虑各种边界值，如循环终止条件，递归终止条件 |
| 负面测试 | 考虑各种可能的错误输入，不合法输入的处理 |
有3中错误处理方法：
| 方法 | 优点 | 缺点 |
|---|---|---|
| 返回值 | 和系统API一致 | 不能方便地使用计算结果 |
| 全局变量 | 能方便地使用计算结果 | 用户可能会忘记检查全局变量 |
| 异常 | 可以为不同错误原因定义不同的异常类型，逻辑清晰 | 有些语言不支持异常，抛出异常时对性能有负面影响 |
面试题16. 数值的整数次方
实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。
示例 1:
输入: 2.00000, 10
输出: 1024.00000
示例 2:
输入: 2.10000, 3
输出: 9.26100
示例 3:
输入: 2.00000, -2
输出: 0.25000
解释: 2-2 = 1/22 = 1/4 = 0.25
说明:
-100.0 < x < 100.0
n 是 32 位有符号整数，其数值范围是 [−231, 231 − 1] 。
这道题是让实现指定的库函数pow。
class Solution {
public:
double myPow(double x, int n) {
if(x == 1 || n == 0) return 1;//1的任意次方，和任何数的0次方，都让返回1
double res = 1;
long num = n;
if(n < 0){//指数为负值时，将指数变为正值，且底数变为底数的倒数
num = -num;
x = 1/x;
}
while(num){//如果指数没有消耗完，两次方两次方的降
if(num & 1) res *= x;//指数的低位存在，res = res * 底数
x *= x;//x = x*x，x扩大为它的平方，因为二进制每位的差距是平方关系
num >>= 1;//指数除以2
}
return res;
}
};
面试题17. 打印从1到最大的n位数
输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
示例 1:
输入: n = 1
输出: [1,2,3,4,5,6,7,8,9]
说明：
用返回一个整数列表来代替打印
n 为正整数
递归解法：
class Solution
{
public:
vector<int> res;
vector<int> printNumbers(int n) {
if (n <= 0) return res;
string number(n, '0');
//从高位到低位进行全排列
for (int i = 0; i <= 9; ++i)
{
number[0] = i + '0';//首字符赋初值
permutationNumbers(number, n, 1);//设置下一位
}
return res;
}
//对数字全排列
void permutationNumbers(string& number, int length, int index) {
if (index == length) {//递归边界
saveNumber(number);//存储结果
return;
}
else
{
for (int i = 0; i <= 9; i++)
{
number[index] = '0' + i;//设置第index位的字符
permutationNumbers(number, length, index + 1);
}
}
}
//存储结果
//只能存储前导非0的排列
void saveNumber(string number) {
bool isBegin0 = true;
string tempStr = "";
string::iterator it = number.begin();
while (it != number.end())//遍历字符串
{
if (isBegin0 && *it != '0') isBegin0 = false;//如果标志位为true，且当前确实不是'0'，将标志位更新为false
if (!isBegin0) {
tempStr += *it;
}
it++;
}
//从高位到低位全排列，要注意首字符为0时，tempStr为空，不能执行stoi
if (tempStr != "") {
int tempNum = stoi(tempStr);
res.push_back(tempNum);
}
}
};
大数string表示：
class Solution {
public:
vector<int> res;
vector<int> printNumbers(int n) {
if (n <= 0) return res;
//创建一个能容纳最大值的字符数组
string number(n, '0');
//初始全部设置为0
while (!Increment(number))
{
saveNumber(number);
}
return res;
}
bool Increment(string& number) {
//注意要使用引用传递，否则无法修改number
bool isOverflow = false;//检测是否越界
int nTakeOver = 0;//存储进位
int nLength = number.size();
for (int i = nLength - 1; i >= 0; i--)
{
int nSum = number[i] - '0' + nTakeOver;
if (i == nLength - 1)
//如果是第一位，进位
{
nSum++;
}
if (nSum >= 10)//有进位
{
if (i == 0)
//如果是最高位有进位，说明超过了给定得到最大值，越界
{
isOverflow = true;
}
else
{
nTakeOver = 1;
number[i] = nSum - 10 + '0';//对第i位进行设置
}
}
else//没有进位
//设置第i位数字
//并直接跳出循环
{
number[i] = nSum + '0';
break;
}
}
return isOverflow;
}
void saveNumber(string number)
//由于此处输出，不需要修改number，因此不需要加引用
{
string s = "";
bool isBegin0 = true;
string::iterator it = number.begin();
while (it != number.end())
{
if (isBegin0 && *it != '0') isBegin0 = false;
if (!isBegin0)
{
s += *it;
}
it++;
}
int num = stoi(s);
res.push_back(num);
}
};
面试题18. 删除链表的节点
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。
注意：此题对比原题有改动
示例 1:
输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
说明：
题目保证链表中节点的值互不相同
若使用 C 或 C++ 语言，你不需要 free 或 delete 被删除的节点
中规中矩：
class Solution {
public:
ListNode* deleteNode(ListNode* head, int val) {
if(head==NULL) return NULL;
if(head->val==val) return head->next;
ListNode* pNode = head;
while(pNode->next){
if(pNode->next->val==val){
pNode->next = pNode->next->next;
break;
}
pNode=pNode->next;
}
return head;
}
};
【原题】
而原题比这道题更有味道，至少让我学会了还能直接根据给定的节点指针，无需遍历，以O(1)的时间复杂度删除这个节点，具体说来就是：
当我们想删除一个节点时，并不一定要删除这个节点本身。可以先把下一个节点的内容复制出来覆盖被删除节点的内容，然后把下一个节点删除。
struct ListNode {
int val;
ListNode* next;
};
void DeletedNode(ListNode** pListHead, ListNode* pToBeDeleted) {
if (!pListHead || !pToBeDeleted) {
return;
}
//要删除的节点不是尾结点
if (pToBeDeleted->next != NULL) {
//绝妙
//找到待删节点，与其下一节点进行数据交换，删除下一节点
ListNode* pNext = pToBeDeleted->next;
pToBeDeleted->val = pNext->val;
pToBeDeleted->next = pNext->next;
//释放内存
delete pNext;
pNext = NULL;
}
//要删除的节点是尾结点，但是链表只有一个节点（此时，要删除的节点也是头节点）
else if (*pListHead == pToBeDeleted) {
delete pToBeDeleted;
pToBeDeleted = NULL;
*pListHead = NULL;
}
//要删除的节点是尾结点，且链表中有多个节点（此时，要删除的节点不是头节点）
else {
ListNode* pNode = *pListHead;
while (pNode->next != pToBeDeleted) {
pNode = pNode->next;
}
pNode->next = NULL;
delete pToBeDeleted;
pToBeDeleted = NULL;
}
}
【原题-引申的题目二】
删除链表中的重复节点们，遇到重复节点，一个不留，斩草除根
struct ListNode {
int val;
ListNode* next;
};
void DeleteDuplication(ListNode** pHead) {//这里不可写成ListNode* pHead?
//如果指向头节点的指针为空
if (pHead == NULL || *pHead == NULL) {
return;
}
ListNode* pPreNode = NULL;
ListNode* pNode = *pHead;
while (pNode != NULL) {
ListNode* pNext = pNode->next;
bool needDelete = false;
if (pNext != NULL && pNext->val == pNode->val) {
needDelete = true;
}
if (!needDelete) {//如果当前pNode节点不需要被删除，那么继续往下个节点遍历
pPreNode = pNode;
pNode = pNode->next;
}
else {//如果当前pNode节点需要被删除
int value = pNode->val;
ListNode* pToBeDel = pNode;
while (pToBeDel != NULL && pToBeDel->val == value) {//一直删除，直到链表为空，或下个节点的值不等于这个数字
pNext = pToBeDel->next;
delete pToBeDel;
pToBeDel = pNext;
}
if (pPreNode == NULL) {//如果下个节点为空，说明删到链表尾了
*pHead = pNext;
}
else {//如果下个节点并不为空，却跳出了循环，说明下个节点值不等于value
pPreNode->next = pNext;
}
pNode = pNext;//从这里开始继续寻找重复的节点
}
}
}
面试题19. 正则表达式匹配（难掉牙了）
请实现一个函数用来匹配包含'. '和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但与"aa.a"和"ab*a"均不匹配。
示例 1:
输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
示例 2:
输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
示例 3:
输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
示例 4:
输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
示例 5:
输入:
s = "mississippi"
p = "mis*is*p*."
输出: false
s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母以及字符 . 和 *，无连续的 '*'。
法一：
class Solution {
public:
bool isMatch(string s, string p) {
if(p.empty()) return s.empty();
if(p[1] == '*'){
return isMatch(s, p.substr(2)) || //目标字符串全都能匹配上模板从位置2往后的内容
(!s.empty() && (s[0] == p[0] || p[0] == '.')) && //目标字符串不能为空 && （两串的首字母相同，或者模板为'.'）
isMatch(s.substr(1), p);//从目标字符串的第2个位置开始的子串，要能和整个模板匹配上
}
else{
return !s.empty() && //目标字符串不能为空，不然不管模板是啥都没办法匹配
(s[0] == p[0] || p[0] == '.') && //如果第二个字符不为*，那么第一个字符务必相同，或者模板为'.'
(isMatch(s.substr(1), p.substr(1)));//且，从位置1开始的字符串（包括位置1字符）比如能满足匹配要求
}
}
};
法二：
class Solution {
public:
bool isMatch(string s, string p) {
s=" "+s;//防止该案例：""
"c*"
p=" "+p;
int m=s.size(),n=p.size();
bool dp[m+1][n+1];
memset(dp,false,(m+1)*(n+1));
dp[0][0]=true;
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++){
if(s[i-1]==p[j-1] || p[j-1]=='.'){
dp[i][j]=dp[i-1][j-1];
}
else if(p[j-1]=='*'){
if(s[i-1]!=p[j-2] && p[j-2]!='.')
dp[i][j]=dp[i][j-2];
else{
dp[i][j]=dp[i][j-1] || dp[i][j-2] || dp[i-1][j];
}
}
}
}
return dp[m][n];
}
};
面试题20. 表示数值的字符串
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100"、“5e2”、"-123"、“3.1416”、“0123"都表示数值，但"12e”、“1a3.14”、“1.2.3”、“±5”、"-1E-16"及"12e+5.4"都不是。
class Solution {
public:
bool isNumber(string s) {
s = trim(s);
const char* str = s.c_str();//将字符串string转变为字符数组
if(str==NULL){
return false;
}
//遍历正负号和纯数字，停留在纯数字的尾后位置
bool numeric = scanInteger(&str);
// 如果当前str是'.'，则接下来应该是数字的小数部分
if(*str=='.'){
++str;
numeric = scanUnsignedInteger(&str) || numeric;//如果有数字，遍历，并移动到纯数字的尾后位置
}
//看是否遇到'e'或'E'
if(*str=='e' || *str=='E'){
++str;
numeric = numeric && scanInteger(&str);
}
return numeric && *str==' ';
}
bool scanUnsignedInteger(const char ** str){
const char* before = *str;
while(**str!=' ' && **str>='0' && **str<='9'){
++(*str);
}
return *str>before;//指针移动了位置，说明存在纯数字
}
bool scanInteger(const char** str){
if(**str=='+' || **str=='-'){
++(*str);
}
return scanUnsignedInteger(str);
}
//去除字符串中的首尾空格
std::string& trim(std::string &s)
{
if (!s.empty())
{
s.erase(0,s.find_first_not_of(" "));
s.erase(s.find_last_not_of(" ") + 1);
}
return s;
}
};
面试题21. 调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。
示例：
输入：nums = [1,2,3,4]
输出：[1,3,2,4]
注：[3,1,2,4] 也是正确的答案之一。
提示：
1 <= nums.length <= 50000
1 <= nums[i] <= 10000
class Solution {
public:
vector<int> exchange(vector<int>& nums) {
int n = nums.size();
if(n<=0) return nums;
int left = 0,right = nums.size()-1;
while(left<right){//很关键，必须有，否则，只处理一对奇数偶数交换
while(left<right && (nums[left]&0x1)!=0){//左边的指针遇到的是奇数就继续往后找
++left;
}
while(left<right && (nums[right]&0x1)==0){//右边的指针遇到的是偶数就继续往前找
--right;
}
if(left<right){
std::swap(nums[left],nums[right]);
}
}
return nums;
}
};
解耦思想：利用解耦思想，拆分函数功能，将判断一个数字该在前面还是后面的函数，与拆分数组的函数解耦，提高代码复用性。涉及函数指针的使用。
class Solution {
public:
vector<int> exchange(vector<int>& nums) {
return ReOrder(nums,iseven);
}
vector<int> ReOrder(vector<int>& nums,bool (*func)(int)) {
int n = nums.size();
if(n<=0) return nums;
int left = 0,right = nums.size()-1;
while(left<right){//很关键，必须有，否则，只处理一对奇数偶数交换
while(left<right && !func(nums[left])){//左边的指针遇到的是奇数就继续往后找
++left;
}
while(left<right && func(nums[right])){//右边的指针遇到的是偶数就继续往前找
--right;
}
if(left<right){
std::swap(nums[left],nums[right]);
}
}
return nums;
}
static bool iseven(int n){
return (n&0x1)==0;
}
};
防御性编程习惯
编写鲁棒性强的代码，在函数开始的时候验证用户输入内容是否符合要求，对于不符合要求的输入也能合理处理，使各种情况都在程序员掌控之中。
多问问：如果不…那么…，此类的问题。
面试题22. 链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* getKthFromEnd(ListNode* head, int k) {
if(head==NULL || k==0){//代码鲁棒性
return NULL;
}
ListNode * pNode1 = head;
//指针1先走k-1步
for(int i=0;i<k-1;++i){
if(pNode1->next != NULL){//代码鲁棒性
pNode1=pNode1->next;
}else{
return NULL;
}
}
//指针2初始化后开始和指针1一起走，直到指针1走到头
ListNode * pNode2 = head;
while(pNode1->next != NULL){
pNode1 = pNode1->next;
pNode2 = pNode2->next;
}
return pNode2;
}
};
快慢指针拓展
快慢指针的思想：当我们用一个指针遍历链表不能解决问题的时候，可以尝试用两个指针遍历链表。可以让一个指针遍历速度快一些（比如一次在链表中走两步），或者让它先在链表上走上若干步。
利用快慢指针的思想，求链表的中间节点也就不是难事：定义两个指针，同时从表头出发，一个指针一次走一步，另一个指针一次走两步。当走的快的指针走到链表尾后时，走得慢的指针恰好在链表中间。
141. 环形链表
给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。
思路：
可以用快慢指针解决问题。定义两个指针，一个指针一次走一步，另一个指针一次走两步。如果走的快的指针追上了走得慢的指针，说明链表包含环。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
bool hasCycle(ListNode *head) {
if(head==NULL){//链表为空，不存在环
return false;
}
ListNode* pSlow = head->next;
if(pSlow==NULL){//链表只有一个节点时，不存在环
return false;
}
ListNode* pFast = pSlow->next;//初始值不能和慢指针一样
while(pFast!=NULL && pSlow!=NULL){
if(pFast==pSlow){//判断快慢指针是否相等，如果相等，说明存在环
return true;
}
pSlow = pSlow->next;//快慢指针一起走路
pFast = pFast->next;//快慢指针一起走路
if(pFast!=NULL){//快指针每次比慢指针多走一步
pFast=pFast->next;
}
}
return false;
}
};
142. 环形链表 II
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：tail connects to node index 1
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：tail connects to node index 0
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：no cycle
解释：链表中没有环。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* meetingNode = MeetingNode(head);
if(meetingNode==NULL){//不存在环
return NULL;
}
//获得环中节点的数目
int count = 1;
ListNode* pNode1 = meetingNode;
while(pNode1->next != meetingNode){
pNode1 = pNode1->next;
++count;
}
//先移动指针1，次数为环中节点数目
pNode1 = head;
for(int i=0;i<count;++i){
pNode1=pNode1->next;
}
//再移动指针1和指针2
ListNode* pNode2 = head;
while(pNode1!=pNode2){
pNode1=pNode1->next;
pNode2=pNode2->next;
}
return pNode1;
}
ListNode* MeetingNode(ListNode* pHead){
if(pHead==NULL){return NULL;}
ListNode* pSlow = pHead->next;
if(pSlow == NULL){
return NULL;
}
ListNode* pFast = pSlow->next;
while(pFast!=NULL && pSlow!=NULL){
if(pSlow==pFast){
return pFast;
}
pSlow = pSlow->next;
pFast = pFast->next;
if(pFast!=NULL){
pFast = pFast->next;
}
}
return NULL;
}
};
面试题24. 反转链表
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
限制：
0 <= 节点个数 <= 5000
处理这个问题的时候，要注意我们需要知道3个关键：
（1）当前节点本身
（2）当前节点的上一个节点（要指向的目标）
（3）当前节点的下一个节点（防止链表断裂）
完成3项检查：
（1）输入链表头指针为空，或整个链表只有一个节点时，程序的鲁棒性
（2）反转后不要出现断裂
（3）返回的反转后的头节点应该是原始链表的尾节点
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* pReversedHead = NULL;//定义反转后的头节点
ListNode* pNode=head,*pPrev=NULL;//定义当前节点指针（并初始化为头指针），和前一个节点的指针
while(pNode!=NULL){//当前节点不为空，才进行下面的步骤，直到它为空
ListNode* pNext = pNode->next;//记录下一个节点指针
if(pNext==NULL){//到了尾节点了
pReversedHead = pNode;
}
pNode->next = pPrev;//反转的关键一步
pPrev = pNode;//往后走一步
pNode = pNext;//往后走一步
}
return pReversedHead;
}
};
面试题25. 合并两个排序的链表
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
示例1：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
限制：
0 <= 链表长度 <= 1000
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
//解决空表的情况，一个表为空，不需要合并，直接返回另一个表即可
if(l1==NULL){
return l2;
}else if(l2==NULL){
return l1;
}
ListNode* pMergeHead=NULL;
if(l1->val < l2->val){
pMergeHead = l1;
pMergeHead->next = mergeTwoLists(l1->next,l2);
}else{
pMergeHead = l2;
pMergeHead->next = mergeTwoLists(l1,l2->next);
}
return pMergeHead;
}
};
面试题26. 树的子结构
输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
B是A的子结构， 即 A中有出现和B相同的结构和节点值。
例如:
给定的树 A:
3
/
4 5
/
1 2
给定的树 B：
4
/
1
返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。
示例 1：
输入：A = [1,2,3], B = [3,1]
输出：false
示例 2：
输入：A = [3,4,5,1,2], B = [4,1]
输出：true
限制：
0 <= 节点个数 <= 10000
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSubStructure(TreeNode* A, TreeNode* B) {
bool result = false;
if(A!=NULL && B!=NULL){
if(A->val==B->val){
result = DoesTree1HaveTree2(A,B);
}
if(!result){
result = isSubStructure(A->left,B);
}
if(!result){
result = isSubStructure(A->right,B);
}
}
return result;
}
bool DoesTree1HaveTree2(TreeNode* A,TreeNode* B){
if(B==NULL){
return true;
}
if(A==NULL){
return false;
}
if(A->val != B->val){
return false;
}
return DoesTree1HaveTree2(A->left,B->left) && DoesTree1HaveTree2(A->right,B->right);
}
};
总结
编程时，注意代码规范性、完整性、鲁棒性：
（1）确保规范性：书写清晰，布局清晰，命名合理
（2）确保完整性：编程前，全面考虑所有可能的输入，确保完成基本功能，考虑边界条件，做好错误处理
（3）增强鲁棒性：采取防御性编程，处理无效输入