【56-60】剑指offer

最新推荐文章于 2023-10-26 21:35:19 发布
最新推荐文章于 2023-10-26 21:35:19 发布
阅读量295 收藏
点赞数
分类专栏： 剑指offer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bijibenzhulin/article/details/52279866
版权

56.题目描述

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

 

#include <iostream>

using namespace std;

 

struct ListNode {

   int val;

   struct ListNode *next;

   ListNode(int x) :

       val(x), next(NULL) {

    }

};

 

class Solution {

public:

       ListNode*deleteDuplication(ListNode* pHead)

    {

              //如果链表为NULL,则返回NULL

              if(pHead== NULL)

                     returnNULL;

              deleteDuplicationCore(&pHead);

              returnpHead;

    }

 

       voiddeleteDuplicationCore(ListNode **pHead)

       {

              if(*pHead== NULL || pHead == NULL)

                     return;

             

              ListNode*pPre = NULL;

              ListNode*pNode = *pHead;

 

              while(pNode!= NULL)

              {

                                  

                     ListNode*pNext = pNode->next;

                     boolbDel = false;

 

                     if(pNext!= NULL && pNext->val == pNode->val)

                            bDel= true;

 

                     if(!bDel)

                     {

                            pPre= pNode;

                            pNode= pNode->next;

                     }

                     else

                     {

                            intval = pNode->val;

                            ListNode*pToBeDel = pNode;

                            while(pToBeDel!= NULL && pToBeDel->val == val)

                            {

                                   pNext= pToBeDel->next;

                                   pToBeDel = pNext;

 

                                   //deletepToBeDel;

                                   //pToBeDel= NULL;

 

                                   //pToBeDel= pNext;

                            }

                           

                            if(pPre== NULL)

                                   *pHead= pNext;

                            else

                                   pPre->next= pNext;

 

                            pNode= pNext;

                     }

              }

       }

 

       voidPrintList(ListNode * pHead)

       {

              if(pHead== NULL)

                     return;

              while(pHead!= NULL)

              {

                     cout<<pHead->val<<"";

                     pHead= pHead->next;

              }

       }

};

 

int main()

{

       ListNodenode1(1);

       ListNodenode2(2);

       ListNodenode3(3);

       ListNodenode4(3);

       ListNodenode5(7);

       ListNodenode6(4);

       ListNodenode7(9);

 

       node1.next= &node2;

       node2.next= &node3;

       node3.next= &node4;

       node4.next= &node5;

       node5.next= &node6;

       node6.next= &node7;

 

       Solutions;

       ListNode*pList = s.deleteDuplication(&node1);

       s.PrintList(pList);

 

       return0;

}

 

57.题目描述

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

 

#include <iostream>

using namespace std;

 

struct TreeLinkNode {

   int val;

   struct TreeLinkNode *left;

   struct TreeLinkNode *right;

   struct TreeLinkNode *next;

   TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(NULL) {

       

    }

};

 

class Solution {

public:

   TreeLinkNode* GetNext(TreeLinkNode* pNode)

    {

              //如果树为NULL

       if(pNode == NULL)

                     returnNULL;

              //如果有右孩子

              TreeLinkNode*pNext = NULL;

              if(pNode->right!= NULL)

              {

                     TreeLinkNode*pRight = pNode->right;

                     while(pRight->left!= NULL)

                     {

                            pRight= pRight->left;

                     }

                     pNext= pRight;

              }

              //如果无右孩子

              elseif(pNode->right == NULL)

              {

                     TreeLinkNode*pCurrent = pNode;

                     TreeLinkNode*pParent = pNode->next;

                     while(pParent!= NULL && pParent->right == pCurrent)

                     {

                            pCurrent= pParent;

                            pParent= pParent->next;

                     }

                     pNext= pParent;

              }

 

              returnpNext;

    }

 

       voidLinkParent(TreeLinkNode *root)

       {

              if(root== NULL)

                     return;

 

              if(root->left!= NULL)

                     root->left->next= root;

              if(root->right!= NULL)

                     root->right->next= root;

              LinkParent(root->left);

              LinkParent(root->right);

       }

 

       TreeLinkNode*CreateTree()

       {

              intval;

              cin>>val;

 

              if(val== -1)

                     returnNULL;

 

              TreeLinkNode*root = new TreeLinkNode(val);

              root->left= CreateTree();

              root->right= CreateTree();

 

              returnroot;

       }

 

       voidPrePrintTree(TreeLinkNode *root)

       {

              if(root== NULL)

                     return;

              cout<<root->val<<"";

              PrePrintTree(root->left);

              PrePrintTree(root->right);

       }

 

       voidMidPrintTree(TreeLinkNode *root)

       {

              if(root== NULL)

                     return;

              MidPrintTree(root->left);

              cout<<root->val<<"";

              MidPrintTree(root->right);

       }

};

 

int main()

{

       freopen("data.txt","r",stdin);

       Solutions;

       TreeLinkNode*root = s.CreateTree();

       s.LinkParent(root);

       if(root!= NULL)

       {

              cout<<"后序:";

              s.PrePrintTree(root);

       }

       else

              cout<<"NULL";

       cout<<endl;

 

       if(root!= NULL)

       {

              cout<<"中序:";

              s.MidPrintTree(root);

       }

       else

              cout<<"NULL";

       cout<<endl;

 

       cout<<root->val<<"的下一个结点为:";

       cout<<(s.GetNext(root))->val<<endl;

      

       return0;

}

 

58.题目描述

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

 

#include <iostream>

using namespace std;

 

struct TreeNode {

   int val;

   struct TreeNode *left;

   struct TreeNode *right;

   TreeNode(int x) :

           val(x), left(NULL), right(NULL) {

    }

};

 

class Solution {

public:

   bool isSymmetrical(TreeNode* pRoot)

    {

              returnisSymmetrical(pRoot, pRoot);

    }

 

       boolisSymmetrical(TreeNode* pRoot1, TreeNode *pRoot2)

       {

              if(pRoot1== NULL && pRoot2 == NULL)

                     returntrue;

              if(pRoot1== NULL || pRoot2 == NULL)

                     returnfalse;

              if(pRoot1->val!= pRoot2->val)

                     returnfalse;

              returnisSymmetrical(pRoot1->left, pRoot2->right) &&isSymmetrical(pRoot1->right, pRoot2->left);

       }

 

       TreeNode*CreateTree()

       {

              intval;

              cin>>val;

 

              if(val== -1)

                     returnNULL;

 

              TreeNode*root = new TreeNode(val);

              root->left= CreateTree();

              root->right= CreateTree();

 

              returnroot;

       }

 

       voidPrePrintTree(TreeNode *root)

       {

              if(root== NULL)

                     return;

              cout<<root->val<<"";

              PrePrintTree(root->left);

              PrePrintTree(root->right);

       }

 

       voidMidPrintTree(TreeNode *root)

       {

              if(root== NULL)

                     return;

              MidPrintTree(root->left);

              cout<<root->val<<"";

              MidPrintTree(root->right);

       }

};

 

int main()

{

       freopen("data.txt","r",stdin);

       Solutions;

       TreeNode*root = s.CreateTree();

       if(root!= NULL)

       {

              cout<<"后序:";

              s.PrePrintTree(root);

       }

       else

              cout<<"NULL";

       cout<<endl;

 

 

       if(root!= NULL)

       {

              cout<<"中序:";

              s.MidPrintTree(root);

       }

       else

              cout<<"NULL";

       cout<<endl;

 

       if(s.isSymmetrical(root))

              cout<<"对称"<<endl;

       else

              cout<<"不对称"<<endl;

      

       return0;

}

 

59.题目描述

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

 

#include <iostream>

#include <vector>

#include <stack>

using namespace std;

 

struct TreeNode {

   int val;

   struct TreeNode *left;

   struct TreeNode *right;

   TreeNode(int x) :

           val(x), left(NULL), right(NULL) {

    }

};

 

class Solution {

public:

   vector<vector<int> > Print(TreeNode* pRoot) {

       if(pRoot == NULL)

                     returnvector<vector<int> >(0);

             

              vector<vector<int>> result;

              stack<TreeNode*> st_TreeNode[2];

              st_TreeNode[0].push(pRoot);

              intnCurrent = 0;

              intnNext = 1;

              vector<int>vTemp;

             

              while(!st_TreeNode[0].empty()|| !st_TreeNode[1].empty())

              {

                     TreeNode*node = st_TreeNode[nCurrent].top();

                     st_TreeNode[nCurrent].pop();

                     vTemp.push_back(node->val);

                    

                     if(nCurrent== 0)

                     {

                            if(node->left!= NULL)

                            {

                                   st_TreeNode[nNext].push(node->left);

                            }

                            if(node->right!= NULL)

                            {

                                   st_TreeNode[nNext].push(node->right);

                            }

                     }

                     else

                     {

                            if(node->right!= NULL)

                            {

                                   st_TreeNode[nNext].push(node->right);

                            }

                            if(node->left!= NULL)

                            {

                                   st_TreeNode[nNext].push(node->left);

                            }

                     }

 

                     if(st_TreeNode[nCurrent].empty())

                     {

                            nCurrent= 1 - nCurrent;

                            nNext= 1 - nNext;

                            result.push_back(vTemp);

                            while(!vTemp.empty())

                                   vTemp.pop_back();

                     }

              }

              returnresult;

    }

 

       TreeNode*CreateTree()

       {

              intval;

              cin>>val;

 

              if(val== -1)

                     returnNULL;

 

              TreeNode*root = new TreeNode(val);

              root->left= CreateTree();

              root->right= CreateTree();

 

              returnroot;

       }

 

       voidPrePrintTree(TreeNode *root)

       {

              if(root== NULL)

                     return;

              cout<<root->val<<"";

              PrePrintTree(root->left);

              PrePrintTree(root->right);

       }

 

       voidMidPrintTree(TreeNode *root)

       {

              if(root== NULL)

                     return;

              MidPrintTree(root->left);

              cout<<root->val<<"";

              MidPrintTree(root->right);

       }

};

 

int main()

{

       freopen("data.txt","r",stdin);

       Solutions;

       TreeNode*root = s.CreateTree();

       if(root!= NULL)

       {

              cout<<"后序:";

              s.PrePrintTree(root);

       }

       else

              cout<<"NULL";

       cout<<endl;

 

       if(root!= NULL)

       {

              cout<<"中序:";

              s.MidPrintTree(root);

       }

       else

              cout<<"NULL";

       cout<<endl;

 

       vector<vector<int>> result = s.Print(root);

       vector<vector<int>>::iterator ite1 = result.begin();

       vector<int>::iteratorite2 = ite1->begin();

       cout<<"Z字型:"<<endl;

       for(;ite1 != result.end(); ite1++)

       {

              cout<<"      ";

              for(ite2= ite1->begin(); ite2 != ite1->end(); ite2++)

              {

                     cout<<*ite2<<"";

              }

              cout<<endl;

       }

       return0;

}

 

60.题目描述

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行

 

#include <iostream>

#include <vector>

#include <queue>

using namespace std;

 

struct TreeNode {

   int val;

   struct TreeNode *left;

   struct TreeNode *right;

   TreeNode(int x) :

           val(x), left(NULL), right(NULL) {

    }

};

 

class Solution {

public:

   vector<vector<int> > Print(TreeNode* pRoot) {

       if(pRoot == NULL)

                     returnvector<vector<int> >(0);

             

              vector<vector<int>> result;

              queue<TreeNode*> qu_TreeNode;

              qu_TreeNode.push(pRoot);

              intnSumCurLevel = 1;

              intnSumNextLevel = 0;

 

              vector<int>vTemp;

             

              while(!qu_TreeNode.empty())

              {

                     TreeNode*node = qu_TreeNode.front();

                     qu_TreeNode.pop();

                     vTemp.push_back(node->val);

                    

                     if(node->left!= NULL)

                     {

                            qu_TreeNode.push(node->left);

                            nSumNextLevel++;

                     }

                     if(node->right!= NULL)

                     {

                            qu_TreeNode.push(node->right);

                            nSumNextLevel++;

                     }

 

                     nSumCurLevel--;

                     if(nSumCurLevel==0)

                     {

                            nSumCurLevel= nSumNextLevel;

                            nSumNextLevel= 0;

                            result.push_back(vTemp);

                            while(!vTemp.empty())

                                   vTemp.pop_back();

                     }

              }

              returnresult;

    }

 

       TreeNode*CreateTree()

       {

              intval;

              cin>>val;

 

              if(val== -1)

                     returnNULL;

 

              TreeNode*root = new TreeNode(val);

              root->left= CreateTree();

              root->right= CreateTree();

 

              returnroot;

       }

 

       voidPrePrintTree(TreeNode *root)

       {

              if(root== NULL)

                     return;

              cout<<root->val<<"";

              PrePrintTree(root->left);

              PrePrintTree(root->right);

       }

 

       voidMidPrintTree(TreeNode *root)

       {

              if(root== NULL)

                     return;

              MidPrintTree(root->left);

              cout<<root->val<<"";

              MidPrintTree(root->right);

       }

};

 

int main()

{

       freopen("data.txt","r",stdin);

       Solutions;

       TreeNode*root = s.CreateTree();

       if(root!= NULL)

       {

              cout<<"后序:";

              s.PrePrintTree(root);

       }

       else

              cout<<"NULL";

       cout<<endl;

 

       if(root!= NULL)

       {

              cout<<"中序:";

              s.MidPrintTree(root);

       }

       else

              cout<<"NULL";

       cout<<endl;

 

       vector<vector<int>> result = s.Print(root);

       vector<vector<int>>::iterator ite1 = result.begin();

       vector<int>::iteratorite2 = ite1->begin();

       cout<<"Z字型:"<<endl;

       for(;ite1 != result.end(); ite1++)

       {

              cout<<"      ";

              for(ite2= ite1->begin(); ite2 != ite1->end(); ite2++)

              {

                     cout<<*ite2<<"";

              }

              cout<<endl;

       }

       return0;

}
Flying_Home
关注
专栏目录
面试必刷--剑指Offer
升级迭代
07-13 378
https://www.nowcoder.com/ 算法的美妙之处在于解法不唯一，遇见好的解法，我再来更新哈！ 稍后，我会把思路也加上，在算法精进的路上，我们一起加油！ 剑指Offer – Java 1.二维数组中的查找 在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 public class Solution { public boolean Find(int target, i
数据结构MOOC|二叉树的表示
笔记本
05-28 618
1.链表表示法struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} };2.数组表示法：将二叉树看作完全二叉树缺点，如果树很稀疏的话，空间浪费比较大。优点，父子结点、兄弟结点之间通过下标...
C++ 输入数组利用递归建立二叉树——层序、前序、中序、后序
xuefeng的博客
08-23 4246
C++ 输入数组利用递归建立二叉树——层序、前序、中序、后序 1、输入数组要求 数组是按照层序输入的，当该结点为空时，用‘#’代替空的位置，如下图。（这里直接截取大话数据结构里面的图片） 2、二叉树结构定义 struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : v...
剑指offer：二叉树的深度
dene_jucember的博客
03-12 122
题目描述 输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。 方法一： 递归查找树的深度。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL...
Leetcode刷题——树篇2
w137093940的博客
05-01 618
文章目录2、树（简单篇2）2.1、965. 单值二叉树2.1、 669. 修剪二叉搜索树2.3 102. 二叉树的层序遍历2.4 107. 二叉树的层次遍历 II2.5、 637. 二叉树的层平均值 2、树（简单篇2） 2.1、965. 单值二叉树 如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。 只有给定的树是单值二叉树时，才返回 true；否则返回 false。 示例 1： ...
C++结构体定义的同时完成初始化：TreeNode(int x) :val(x), left(NULL), right(NULL) {}；
qq_53234413的博客
10-26 182
笔者c++初学选手，在代码随想录二叉树章节学习二叉树定义的方法时遇到了一种结构体初始化的方法：TreeNode(int x) :val(x), left(NULL), right(NULL) {};这一步完成了结构体的初始化，将int型变量赋值给结构体中的int型变量val，两个TreeNode指针型变量left，right（代表二叉树的左右节点）都赋值为NULL。
NullPointerC#Prepared-For-Better-Offer#剑指 Offer 56 - II. 数组中数字出现
07-25
这里的运用位运算的方法我属实是想不太来，这里用了一个32位的数组来计算每一个二进制位出现的次数，如果一个数字出现了3次，那么它的每一位肯定也是出现了3次的，所以
python-剑指offer第56题删除链表中重复的结点
最新发布
08-06
python python_剑指offer第56题删除链表中重复的结点
LeetCode-剑指 Offer 题目集
HeavenDan的博客
12-21 746
题目集汇总 题号 题目链接 知识点 博客题解链接 完成时间 备注 题号 题目 题解链接 标签 备注 遍数 03 数组中重复的数字 【LeetCode-剑指Offer】03. 数组中重复的数字 数组、哈希表 04 二维数组中的查找 数组、双指针 05 替换空格 06 从尾到头打印链表 链表 07 重建二叉树 树、递归 09 用两个栈实现队列 栈、设计 10- I 斐波那契数列 递归 10- II 青蛙跳台阶问题 递归
databinQ#garnetbook#剑指Offer-56-I-数组中数字出现的次数1
07-25
题目描述剑指 Offer 56 - I. 数组中数字出现的次数一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。示例 1：输出：[1,6] 或
编程题分类——树
保持一颗敬畏之心，简单地调用C++，适当地向C++妥协，让以后的自己看懂代码，让别人看懂代码。
10-23 418
目录前言正文按之字形顺序打印二叉树参考 前言 正文 按之字形顺序打印二叉树 code /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } }; */ class Solution { public: vector<vecto
《程序员面试金典》--输出二叉树中某一层的所有元素
zdplife的专栏
10-23 2852
题目描述: struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } }; struct ListNode { int val;
17. 树的子结构
PartyPartyAnimal的博客
03-26 190
/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { public: bool
LeetCode中一些树方面的题
qq_33166535的博客
10-16 321
// #include "stdafx.h" #include #include #include #include using namespace std; struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} };
57.二叉树的下一个结点
Nick
06-01 299
题目描述给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。思路：由于是中序遍历二叉树，因此需要分析当前结点是否含有右子树；若有，则返回右子树的最底层左孩子结点；若没有，则向上找父节点，找到最近的一个满足其父节点的左子树是其本身的节点；若找父节点直到root还没找到，则返回NULL。如图所示：代码：/* struct...
二叉树的下一个节点（详解，折磨我两个小时的题，必须得给它办得明明白白的）（数据结构基础回顾）（剑指offer）
ambiguous__的博客
07-04 4180
题目如下所示： 给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。 它的数据结构如下所示： /* struct TreeLinkNode { int val; struct TreeLinkNode *left; struct TreeLinkNode *right; struct TreeLinkNode *next; TreeLinkNode(int x) :val(x), ...
二叉树的遍历
暴雨是樱桃味der-
12-10 223
1.递归 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */...
求根到叶子节点数字之和（需二）
weixin_44895315的博客
10-29 89
给定一个二叉树，它的每个结点都存放一个0-9的数字，每条从根到叶子节点的路径都代表一个数字。 例如，从根到叶子节点路径 1->2->3 代表数字 123。 计算从根到叶子节点生成的所有数字之和。 说明:叶子节点是指没有子节点的节点。 示例 1: 输入: [1,2,3] 1 / \ 2 3 输出: 25 解释: 从根到叶子节点路径 1->2 代表数字 12. 从根到叶子节点路径 1->3 代表数字 13. 因此，数字总和 = 12 + 13 = 2...
算法期中1002. 合并二叉树
qq_34038762的博客
11-13 277
Description 输入两个二叉树T1和T2，要求对T1和T2进行合并. 合并是指将二叉树同一位置节点上的数求和，作为合并后二叉树相应位置节点的数值. 如果某个位置上只有一个二叉树有节点，则合并后的二叉树对应位置上的节点上的数值就等于这个节点上的数值.例如： T1 T2 1
剑指Offer-Python实现：数组问题精讲
"剑指Offer是一本针对编程面试的经典书籍，涵盖了多种算法和数据结构问题。此摘要主要涉及Python版本的数组题目，包括二维数组中的查找、旋转数组中的最小值等经典问题。" 在编程面试中，数组是基础且重要的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值