剑指Offer----面试题18：树的子结构

最新推荐文章于 2023-12-31 17:32:35 发布
最新推荐文章于 2023-12-31 17:32:35 发布
阅读量442 收藏
点赞数
分类专栏： 剑指Offer 文章标签： C++ 剑指offer 面试题 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qianqin_2014/article/details/51585161
版权

题目：


输入两颗二叉树A和B，判断B是不是A的子结构。如下图：树B是树A的子结构。


方法一：


分析：要判断树B是否为树A的子结构，可以分为两步，第一步在树A中找到和树B的根节点的值一样的结点R，第二步再判断树A中以R为根节点的子树是不是包含和树B一样的结构。


源代码如下： 

#include"BinaryTree.h"
#include<iostream>

using std::cout;
using std::endl;

using namespace OrdinaryBinaryTreeSpace2;

bool Total(BinaryTreeNode *root1, BinaryTreeNode *root2);
bool HasSubTree(BinaryTreeNode *root1, BinaryTreeNode *root2);
bool DoesTreeOneHaveTreeTwo(BinaryTreeNode *root1, BinaryTreeNode *root2);

bool Total(BinaryTreeNode *root1, BinaryTreeNode *root2)
{
	if (root1 == NULL && root2 != NULL)
		return false;
	else if (root1 == NULL && root2 == NULL)
		return false;
	else if (root1 != NULL && root2 == NULL)
		return true;

	return HasSubTree(root1, root2);
}

bool HasSubTree(BinaryTreeNode *root1, BinaryTreeNode *root2)
{
	bool result = false;

	if (root1 != NULL && root2 != NULL)
	{
		if (root1->element == root2->element)
			result = DoesTreeOneHaveTreeTwo(root1, root2);
		if (!result)
			result = HasSubTree(root1->left, root2);
		if (!result)
			result = HasSubTree(root1->right, root2);
	}

	return result;
}

bool DoesTreeOneHaveTreeTwo(BinaryTreeNode *root1, BinaryTreeNode *root2)
{
	if (root2 == NULL)
		return true;

	if (root1 == NULL)
		return false;

	if (root1->element != root2->element)
		return false;

	return DoesTreeOneHaveTreeTwo(root1->left, root2->left) && DoesTreeOneHaveTreeTwo(root1->right, root2->right);
}

void test11()
{
	cout << "\t===========树A含有树B============" << endl;
	BinaryTreeNode *node1 = CreateBinaryTreeNode(8);
	BinaryTreeNode *node2 = CreateBinaryTreeNode(8);
	BinaryTreeNode *node3 = CreateBinaryTreeNode(7);
	BinaryTreeNode *node4 = CreateBinaryTreeNode(9);
	BinaryTreeNode *node5 = CreateBinaryTreeNode(2);
	BinaryTreeNode *node6 = CreateBinaryTreeNode(4);
	BinaryTreeNode *node7 = CreateBinaryTreeNode(7);
	ConnectBinaryTreeNodes(node1, node2, node3);
	ConnectBinaryTreeNodes(node2, node4, node5);
	ConnectBinaryTreeNodes(node3, NULL, NULL);
	ConnectBinaryTreeNodes(node4, NULL, NULL);
	ConnectBinaryTreeNodes(node5, node6, node7);
	ConnectBinaryTreeNodes(node6, NULL, NULL);
	ConnectBinaryTreeNodes(node7, NULL, NULL);

	BinaryTreeNode *node21 = CreateBinaryTreeNode(8);
	BinaryTreeNode *node22 = CreateBinaryTreeNode(9);
	BinaryTreeNode *node23 = CreateBinaryTreeNode(2);
	ConnectBinaryTreeNodes(node21, node22, node23);
	ConnectBinaryTreeNodes(node22, NULL, NULL);
	ConnectBinaryTreeNodes(node23, NULL, NULL);

	bool result = Total(node1, node21);

	if (result)
		cout << "Tree A contains tree B" << endl;
	else
		cout << "Tree A not contains tree B" << endl;
}

void test12()
{
	cout << "\t===========树A不含有树B============" << endl;
	BinaryTreeNode *node1 = CreateBinaryTreeNode(8);
	BinaryTreeNode *node2 = CreateBinaryTreeNode(8);
	BinaryTreeNode *node3 = CreateBinaryTreeNode(7);
	BinaryTreeNode *node4 = CreateBinaryTreeNode(9);
	BinaryTreeNode *node5 = CreateBinaryTreeNode(2);
	BinaryTreeNode *node6 = CreateBinaryTreeNode(4);
	BinaryTreeNode *node7 = CreateBinaryTreeNode(7);
	ConnectBinaryTreeNodes(node1, node2, node3);
	ConnectBinaryTreeNodes(node2, node4, node5);
	ConnectBinaryTreeNodes(node3, NULL, NULL);
	ConnectBinaryTreeNodes(node4, NULL, NULL);
	ConnectBinaryTreeNodes(node5, node6, node7);
	ConnectBinaryTreeNodes(node6, NULL, NULL);
	ConnectBinaryTreeNodes(node7, NULL, NULL);

	BinaryTreeNode *node21 = CreateBinaryTreeNode(8);
	BinaryTreeNode *node22 = CreateBinaryTreeNode(9);
	BinaryTreeNode *node23 = CreateBinaryTreeNode(3);
	ConnectBinaryTreeNodes(node21, node22, node23);
	ConnectBinaryTreeNodes(node22, NULL, NULL);
	ConnectBinaryTreeNodes(node23, NULL, NULL);

	bool result = Total(node1, node21);

	if (result)
		cout << "Tree A contains tree B" << endl;
	else
		cout << "Tree A not contains tree B" << endl;
}

void test13()
{
	cout << "\t===========树A非空，树B为空============" << endl;
	BinaryTreeNode *node1 = CreateBinaryTreeNode(8);
	BinaryTreeNode *node2 = CreateBinaryTreeNode(8);
	BinaryTreeNode *node3 = CreateBinaryTreeNode(7);
	BinaryTreeNode *node4 = CreateBinaryTreeNode(9);
	BinaryTreeNode *node5 = CreateBinaryTreeNode(2);
	BinaryTreeNode *node6 = CreateBinaryTreeNode(4);
	BinaryTreeNode *node7 = CreateBinaryTreeNode(7);
	ConnectBinaryTreeNodes(node1, node2, node3);
	ConnectBinaryTreeNodes(node2, node4, node5);
	ConnectBinaryTreeNodes(node3, NULL, NULL);
	ConnectBinaryTreeNodes(node4, NULL, NULL);
	ConnectBinaryTreeNodes(node5, node6, node7);
	ConnectBinaryTreeNodes(node6, NULL, NULL);
	ConnectBinaryTreeNodes(node7, NULL, NULL);

	bool result = Total(node1, NULL);

	if (result)
		cout << "Tree A contains tree B" << endl;
	else
		cout << "Tree A not contains tree B" << endl;
}

void test14()
{
	cout << "\t===========树A为空，树B非空============" << endl;
	BinaryTreeNode *node21 = CreateBinaryTreeNode(8);
	BinaryTreeNode *node22 = CreateBinaryTreeNode(9);
	BinaryTreeNode *node23 = CreateBinaryTreeNode(3);
	ConnectBinaryTreeNodes(node21, node22, node23);
	ConnectBinaryTreeNodes(node22, NULL, NULL);
	ConnectBinaryTreeNodes(node23, NULL, NULL);

	bool result = Total(NULL, node21);

	if (result)
		cout << "Tree A contains tree B" << endl;
	else
		cout << "Tree A not contains tree B" << endl;
}

void test15()
{
	cout << "\t===========树A树B都为空============" << endl;
	bool result = Total(NULL, NULL);

	if (result)
		cout << "Tree A contains tree B" << endl;
	else
		cout << "Tree A not contains tree B" << endl;
}

int main()
{
	test11();
	test12();
	test13();
	test14();
	test15();

	system("pause");
	return 0;
}

运行结果： 
        ===========树A含有树B============
Tree A contains tree B
        ===========树A不含有树B============
Tree A not contains tree B
        ===========树A非空，树B为空============
Tree A contains tree B
        ===========树A为空，树B非空============
Tree A not contains tree B
        ===========树A树B都为空============
Tree A not contains tree B
请按任意键继续. . .


官方源代码：

#include"BinaryTree.h"
#include<cstdio>
#include<cstdlib>

using namespace OrdinaryBinaryTreeSpace2;

bool HasSubtreeCore(BinaryTreeNode* pRoot1, BinaryTreeNode* pRoot2);
bool DoesTree1HaveTree2(BinaryTreeNode* pRoot1, BinaryTreeNode* pRoot2);

bool HasSubtree(BinaryTreeNode* pRoot1, BinaryTreeNode* pRoot2)
{
	bool result = false;

	if (pRoot1 != NULL && pRoot2 != NULL)
	{
		if (pRoot1->element == pRoot2->element)
			result = DoesTree1HaveTree2(pRoot1, pRoot2);
		if (!result)
			result = HasSubtree(pRoot1->left, pRoot2);
		if (!result)
			result = HasSubtree(pRoot1->right, pRoot2);
	}

	return result;
}

bool DoesTree1HaveTree2(BinaryTreeNode* pRoot1, BinaryTreeNode* pRoot2)
{
	if (pRoot2 == NULL)
		return true;

	if (pRoot1 == NULL)
		return false;

	if (pRoot1->element != pRoot2->element)
		return false;

	return DoesTree1HaveTree2(pRoot1->left, pRoot2->left) &&
		DoesTree1HaveTree2(pRoot1->right, pRoot2->right);
}

// ====================测试代码====================
void Test(char* testName, BinaryTreeNode* pRoot1, BinaryTreeNode* pRoot2, bool expected)
{
	if (HasSubtree(pRoot1, pRoot2) == expected)
		printf("%s passed.\n", testName);
	else
		printf("%s failed.\n", testName);
}

// 树中结点含有分叉，树B是树A的子结构
//                  8                8
//              /       \           / \
//             8         7         9   2
//           /   \
//          9     2
//               / \
//              4   7
void Test1()
{
	BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(7);
	BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode(2);
	BinaryTreeNode* pNodeA6 = CreateBinaryTreeNode(4);
	BinaryTreeNode* pNodeA7 = CreateBinaryTreeNode(7);

	ConnectBinaryTreeNodes(pNodeA1, pNodeA2, pNodeA3);
	ConnectBinaryTreeNodes(pNodeA2, pNodeA4, pNodeA5);
	ConnectBinaryTreeNodes(pNodeA5, pNodeA6, pNodeA7);

	BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(2);

	ConnectBinaryTreeNodes(pNodeB1, pNodeB2, pNodeB3);

	Test("Test1", pNodeA1, pNodeB1, true);

	DestoryTree(pNodeA1);
	DestoryTree(pNodeB1);
}

// 树中结点含有分叉，树B不是树A的子结构
//                  8                8
//              /       \           / \
//             8         7         9   2
//           /   \
//          9     3
//               / \
//              4   7
void Test2()
{
	BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(7);
	BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode(3);
	BinaryTreeNode* pNodeA6 = CreateBinaryTreeNode(4);
	BinaryTreeNode* pNodeA7 = CreateBinaryTreeNode(7);

	ConnectBinaryTreeNodes(pNodeA1, pNodeA2, pNodeA3);
	ConnectBinaryTreeNodes(pNodeA2, pNodeA4, pNodeA5);
	ConnectBinaryTreeNodes(pNodeA5, pNodeA6, pNodeA7);

	BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(2);

	ConnectBinaryTreeNodes(pNodeB1, pNodeB2, pNodeB3);

	Test("Test2", pNodeA1, pNodeB1, false);

	DestoryTree(pNodeA1);
	DestoryTree(pNodeB1);
}

// 树中结点只有左子结点，树B是树A的子结构
//                8                  8
//              /                   / 
//             8                   9   
//           /                    /
//          9                    2
//         /      
//        2        
//       /
//      5
void Test3()
{
	BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(2);
	BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode(5);

	ConnectBinaryTreeNodes(pNodeA1, pNodeA2, NULL);
	ConnectBinaryTreeNodes(pNodeA2, pNodeA3, NULL);
	ConnectBinaryTreeNodes(pNodeA3, pNodeA4, NULL);
	ConnectBinaryTreeNodes(pNodeA4, pNodeA5, NULL);

	BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(2);

	ConnectBinaryTreeNodes(pNodeB1, pNodeB2, NULL);
	ConnectBinaryTreeNodes(pNodeB2, pNodeB3, NULL);

	Test("Test3", pNodeA1, pNodeB1, true);

	DestoryTree(pNodeA1);
	DestoryTree(pNodeB1);
}

// 树中结点只有左子结点，树B不是树A的子结构
//                8                  8
//              /                   / 
//             8                   9   
//           /                    /
//          9                    3
//         /      
//        2        
//       /
//      5
void Test4()
{
	BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(2);
	BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode(5);

	ConnectBinaryTreeNodes(pNodeA1, pNodeA2, NULL);
	ConnectBinaryTreeNodes(pNodeA2, pNodeA3, NULL);
	ConnectBinaryTreeNodes(pNodeA3, pNodeA4, NULL);
	ConnectBinaryTreeNodes(pNodeA4, pNodeA5, NULL);

	BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(3);

	ConnectBinaryTreeNodes(pNodeB1, pNodeB2, NULL);
	ConnectBinaryTreeNodes(pNodeB2, pNodeB3, NULL);

	Test("Test4", pNodeA1, pNodeB1, false);

	DestoryTree(pNodeA1);
	DestoryTree(pNodeB1);
}

// 树中结点只有右子结点，树B是树A的子结构
//       8                   8
//        \                   \ 
//         8                   9   
//          \                   \
//           9                   2
//            \      
//             2        
//              \
//               5
void Test5()
{
	BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(2);
	BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode(5);

	ConnectBinaryTreeNodes(pNodeA1, NULL, pNodeA2);
	ConnectBinaryTreeNodes(pNodeA2, NULL, pNodeA3);
	ConnectBinaryTreeNodes(pNodeA3, NULL, pNodeA4);
	ConnectBinaryTreeNodes(pNodeA4, NULL, pNodeA5);

	BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(2);

	ConnectBinaryTreeNodes(pNodeB1, NULL, pNodeB2);
	ConnectBinaryTreeNodes(pNodeB2, NULL, pNodeB3);

	Test("Test5", pNodeA1, pNodeB1, true);

	DestoryTree(pNodeA1);
	DestoryTree(pNodeB1);
}

// 树A中结点只有右子结点，树B不是树A的子结构
//       8                   8
//        \                   \ 
//         8                   9   
//          \                 / \
//           9               3   2
//            \      
//             2        
//              \
//               5
void Test6()
{
	BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(2);
	BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode(5);

	ConnectBinaryTreeNodes(pNodeA1, NULL, pNodeA2);
	ConnectBinaryTreeNodes(pNodeA2, NULL, pNodeA3);
	ConnectBinaryTreeNodes(pNodeA3, NULL, pNodeA4);
	ConnectBinaryTreeNodes(pNodeA4, NULL, pNodeA5);

	BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(3);
	BinaryTreeNode* pNodeB4 = CreateBinaryTreeNode(2);

	ConnectBinaryTreeNodes(pNodeB1, NULL, pNodeB2);
	ConnectBinaryTreeNodes(pNodeB2, pNodeB3, pNodeB4);

	Test("Test6", pNodeA1, pNodeB1, false);

	DestoryTree(pNodeA1);
	DestoryTree(pNodeB1);
}

// 树A为空树
void Test7()
{
	BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(3);
	BinaryTreeNode* pNodeB4 = CreateBinaryTreeNode(2);

	ConnectBinaryTreeNodes(pNodeB1, NULL, pNodeB2);
	ConnectBinaryTreeNodes(pNodeB2, pNodeB3, pNodeB4);

	Test("Test7", NULL, pNodeB1, false);

	DestoryTree(pNodeB1);
}

// 树B为空树
void Test8()
{
	BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(3);
	BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(2);

	ConnectBinaryTreeNodes(pNodeA1, NULL, pNodeA2);
	ConnectBinaryTreeNodes(pNodeA2, pNodeA3, pNodeA4);

	Test("Test8", pNodeA1, NULL, false);

	DestoryTree(pNodeA1);
}

// 树A和树B都为空
void Test9()
{
	Test("Test9", NULL, NULL, false);
}

int main()
{
	Test1();
	Test2();
	Test3();
	Test4();
	Test5();
	Test6();
	Test7();
	Test8();
	Test9();

	system("pause");
	return 0;
}

运行结果： 
Test1 passed.
Test2 passed.
Test3 passed.
Test4 passed.
Test5 passed.
Test6 passed.
Test7 passed.
Test8 passed.
Test9 passed.
请按任意键继续. . .



烽火前秦路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer--面试题18：树的子结构
qingyujean的博客
09-26 234
 题目描述 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构） python实现： # -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # se
剑指Offer---面试题18:树的子结构
范二er
12-21 516
一.题目输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）;树的结点结构如下:public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val =
《剑指 Offer》专项突破版 - 面试题 1 : 整数除法
最新发布
melonyzzZ的博客
12-31 937
详解面试题 1 : 整数除法
剑指 Offer（第2版）面试题 26：树的子结构
ProgramNovice的博客
12-13 669
剑指 Offer（第2版）面试题 26：树的子结构
[剑指-Offer] 0. 《剑指-Offer》面试题题解汇总
Y-puyu 的博客
02-14 703
剑指-Offer 该专栏收录了学习《剑指-Offer》第二版书中的面试题，书中编程题是新大多以 LeetCode 对应系列的线上 OJ 给解答，下面会以章节的形式给出博主总结的本书中各个面试题的链接，方便对应查阅、学习。 第2章： 2.2 编程语言 [剑指-Offer] 1. 赋值运算符函数 ...
剑指offer--面试题65：滑动窗口的最大值
qingyujean的博客
10-08 716
题目描述 给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],
剑指offer-面试题18.树的子结构
vpoet
04-07 808
题目:输入两棵二叉树A和B,判断B是不是A的子结构。 二叉树节点定义如下: 1 struct BinaryTreeNode 2 { 3 int m_nValue; 4 BinaryTreeNode* m_pLeft; 5 BinaryTreeNode* m_pRight; 6 };   求子树的思路大概是这样的:
剑指offer面试题汇总-Java实现
LYZ
05-24 1633
剑指offer面试题汇总-Java实现 说明：参考DERRANTCM的剑指offer学习专栏的排版。 DERRANTCM是我的学习榜样，他的博客给予我极大的帮助。感谢你！让我们一起分享知识，创造快乐！ 目录第01-10题面试题2 实现单例模式面试题3 二维数组中的查找面试题4 替换空格面试题5 从尾到头打印链表面试题6 重建二叉树面试题6 重建二叉树2面试题7 用两个栈实现队列面试题8 旋
剑指Offer之面试题18:树的子结构
Pillary的专栏
12-25 480
所有代码均通过G++编译器测试，仅为练手纪录。 //面试题18:树的子结构 //题目：输入两棵二叉树A和B，判断B是不是A的子结构。 //面试题18:树的子结构 //题目：输入两棵二叉树A和B，判断B是不是A的子结构。 bool TreeCompre(BinTreeNode *pRootTree,BinTreeNode *pSubTree) { if(NULL
剑指Offer-面试题27：二叉搜索树与双向链表
MSP_甄心cherish的专栏
07-06 427
题面：《剑指Offer》P151 / 牛客网 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。 如 如果不考虑箭头，可以看到4 6 8 10 12 14 16是树的中序遍历 因此可以借用中序遍历的方法进行修改 /* struct TreeNode { int val; struct TreeNode *le
剑指offer面试题1-10
01-20
题目中提到的面试题是关于如何为自定义的类`CMyString`添加赋值运算符（copy assignment operator）。在C++中，赋值运算符需要处理深拷贝和浅拷贝的问题，以防止内存泄漏和悬挂指针。下面我们将详细讨论这个问题以及...
剑指offer面试题5-替换空格C语言.cpp
06-17
请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。输入：每个输入件仅包含一组测试样例。对于每组测试案例，输入一行代表要处理的字符...
（剑指offer）面试题14- I. 剪绳子
12-21
该问题源自《剑指Offer》中的面试题14-I，它挑战了我们对动态规划和数学原理的理解，旨在考察程序员在解决实际问题时的思维灵活性。 题目描述是这样的：假设有一根长度为n的绳子，我们需要将其剪切成m段整数长度的...
Leetcode刷题：剑指offer【面试题07】
01-20
【面试题07】重建二叉树 难度： 中等 限制： 0 <= 节点个数 <= 5000 输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 Leetcode题目对应...
华为研发工程师编程题(2)----明明的随机数
热门推荐
烽火前秦路
04-28 2万+
试题： 明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤100），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。 Input Param n 输入随机数的个数 inputArra
华为研发工程师编程题(1)----汽水瓶
烽火前秦路
04-28 6859
试题： 有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶. 方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
华为2016年校园招聘上机笔试题(3)----扑克牌大小
烽火前秦路
05-03 3836
扑克牌游戏大家应该都比较熟悉了，一副牌由54张组成，含3~A，2各4张，小王1张，大王1张。牌面从小到大用如下字符和字符串表示（其中，小写joker表示小王，大写JOKER表示大王）:) 3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER 输入两手牌，两手牌之间用“-”连接，每手牌的每张牌以空格分隔，“-”两边没有空格，如：4 4 4 4-joker JOKER 请
结构体内存对齐问题
烽火前秦路
04-06 1978
转自 我们先看一道IBM和微软的笔试题： IBM笔试题： struct{ short a1; short a2; short a3; }A; struct{ long a1; short a2; }B; sizeof( A)=6, sizeof(B)=8,为什么？ 注：sizeof(short)=2,sizeof(lo
华为2016研发工程师编程题(1)----删数
烽火前秦路
05-03 1653
问题： 有一个数组a[N]顺序存放0-N，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。 以8个数(N=7)为例:｛0，1，2，3，4，5，6，7｝，0->1->2(删除)->3->4->5(删除)->6->7->0(删除),如此循环直到最后一个数被删除。 输入描述: 每组数据为一行一个整数n(小于等于1000)，为数组成员数,如100，则对
Java版《剑指offer》面试题：单例模式与二维数组查找
"剑指offer（java版）.pdf，涵盖了Java编程语言中的面试题，包括设计模式和数组操作等主题。" 在Java编程中，单例模式是一种常用的创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。该模式在很多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值