剑指offer37-两个链表的第一个公共节点

最新推荐文章于 2016-09-26 15:10:44 发布
最新推荐文章于 2016-09-26 15:10:44 发布
阅读量260 收藏
点赞数
分类专栏： 编程练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dalong277/article/details/52223008
版权

//输入两个链表，找出他们的第一个公共节点
//最原始的方法是以其中一个链表最为大循环，对于每一个节点在另一个链表中寻找是否有相同节点
/*方法一****/
//如果同时从尾部开始访问的话，则只要找到第一个不同的节点就可以，因为其前一个节点就是从头访问的第一个共同节点
//但是链表只能从头开始访问，而从头访问的话，两条链表到达公共节点的时间点是不一致的
//而根据两天链表的特点，由于二者在第一个公共节点之后都是相同的
//那么对于其差别，则是在第一个公共节点之前部分，也就是二者如果长度不一样的话，只能在前面部分
//而如果要同时到达公共节点的话，需要从距第一个公共节点相同距离的地方开始共同向后访问
//因而，可以先获取两条链表的长度，然后得到其长度差，让更长的链表先“空转”该长度，
//然后在开始两个链表共同向后访问，并比较其节点是否相同，知道找到第一个共同节点

#include <iostream>
#include "../Utilties/List.h"
#include <stack>
using namespace std;
ListNode* FirstCommonNode_Solution1(ListNode* pHead1, ListNode* pHead2)
{
    if (pHead1==NULL||pHead2==NULL)
    {
        return NULL;
    }
    int Len1 = 0;
    int Len2 = 0;
    int DiffLen = 0;
    ListNode* pNode1 = pHead1;
    ListNode* pNode2 = pHead2;
    while (pNode1!=NULL)
    {
        Len1++;
        pNode1 = pNode1->m_pNext;
    }
    while (pNode2!=NULL)
    {
        Len2++;
        pNode2 = pNode2->m_pNext;
    }
    if (Len1>Len2)        //pNode1始终指向更长的那个
    {
        pNode1 = pHead1;
        pNode2 = pHead2;
        DiffLen = Len1 - Len2;
    }
    else
    {
        pNode2 = pHead1;
        pNode1 = pHead2;
        DiffLen = Len2 - Len1;
    }
    while (DiffLen>0)
    {
        pNode1 = pNode1->m_pNext;
        DiffLen--;
    }
    while (pNode1!=NULL && 
           pNode2!=NULL && 
           pNode1!=pNode2)
    {
        pNode1=pNode1->m_pNext;
        pNode2=pNode2->m_pNext;
    }
    if (pNode1==NULL)
    {
        return NULL;
    }
    else
    {
        return pNode1;
    }

}

//**********方法二****/
根据之前的描述，如果从尾部开始访问的话，由于第一个公共节点后，两条链表是相同的,因而可以很容易得到二者的第一个非公共节点,在得到第一个非公共节点之前则是从后往前的最后一个公共节点，也就是从前往后的第一个公共节点.而从后往前访问，则可以通过栈来实现。定义两个栈，首先分别将两个链表的各个节点分别入栈，然后同时从栈中推出元素，直至栈顶元素不一致为止。

ListNode* FirstCommonNode_Solution2(ListNode* pHead1, ListNode* pHead2)
{
    if (pHead1 == NULL || pHead2 == NULL)
    {
        return NULL;
    }
    ListNode* FirstCommonNode = NULL;
    ListNode* pNode1 = pHead1;
    ListNode* pNode2 = pHead2;
    stack<ListNode*> NodeStack1;
    stack<ListNode*> NodeStack2;
    while (pNode1!=NULL)
    {
        NodeStack1.push(pNode1);
        pNode1 = pNode1->m_pNext;
    }
    while (pNode2!=NULL)
    {
        NodeStack2.push(pNode2);
        pNode2 = pNode2->m_pNext;
    }
    //while (!NodeStack1.empty() && !NodeStack2.empty())
    //{
    //  if (NodeStack1.top()==NodeStack2.top())
    //  {
    //      NodeStack1.pop();
    //      NodeStack2.pop();
    //  }
    //  else
    //  {
    //      return NodeStack1.top()->m_pNext;
    //  }
    //}
//之前使用上面的方案如果遇到两个链表完全相同的情况会出问题
//因为两个链表完全相同的时候，最后栈顶是没有元素的，所以也就不存在m_pNext,改成下面的
    while (!NodeStack1.empty() &&
           !NodeStack2.empty() &&
           NodeStack1.top()==NodeStack2.top())
    {
            FirstCommonNode = NodeStack1.top();
            NodeStack1.pop();
            NodeStack2.pop();
    }
    return FirstCommonNode;
}

// ==书中测试代码======

void DestroyNode(ListNode* pNode);

void Test(char* testName, ListNode* pHead1, ListNode* pHead2, ListNode* pExpected)
{
    printf("Solution1:\n");
    if (testName != NULL)
        printf("%s begins: ", testName);

    ListNode* pResult = FirstCommonNode_Solution1(pHead1, pHead2);
    if (pResult == pExpected)
        printf("Passed.\n");
    else
        printf("Failed.\n");

    printf("Solution2:\n");
    if (testName != NULL)
        printf("%s begins: ", testName);
     pResult = FirstCommonNode_Solution2(pHead1, pHead2);
    if (pResult == pExpected)
        printf("Passed.\n");
    else
        printf("Failed.\n");
}

// 第一个公共结点在链表中间
// 1 - 2 - 3 \
//            6 - 7
//     4 - 5 /
void Test1()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);
    ListNode* pNode6 = CreateListNode(6);
    ListNode* pNode7 = CreateListNode(7);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode6);
    ConnectListNodes(pNode4, pNode5);
    ConnectListNodes(pNode5, pNode6);
    ConnectListNodes(pNode6, pNode7);

    Test("Test1", pNode1, pNode4, pNode6);

    DestroyNode(pNode1);
    DestroyNode(pNode2);
    DestroyNode(pNode3);
    DestroyNode(pNode4);
    DestroyNode(pNode5);
    DestroyNode(pNode6);
    DestroyNode(pNode7);
}

// 没有公共结点
// 1 - 2 - 3 - 4
//            
// 5 - 6 - 7
void Test2()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);
    ListNode* pNode6 = CreateListNode(6);
    ListNode* pNode7 = CreateListNode(7);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode5, pNode6);
    ConnectListNodes(pNode6, pNode7);

    Test("Test2", pNode1, pNode5, NULL);

    DestroyList(pNode1);
    DestroyList(pNode5);
}

// 公共结点是最后一个结点
// 1 - 2 - 3 - 4 \
//                7
//         5 - 6 /
void Test3()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);
    ListNode* pNode6 = CreateListNode(6);
    ListNode* pNode7 = CreateListNode(7);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode7);
    ConnectListNodes(pNode5, pNode6);
    ConnectListNodes(pNode6, pNode7);

    Test("Test3", pNode1, pNode5, pNode7);

    DestroyNode(pNode1);
    DestroyNode(pNode2);
    DestroyNode(pNode3);
    DestroyNode(pNode4);
    DestroyNode(pNode5);
    DestroyNode(pNode6);
    DestroyNode(pNode7);
}

// 公共结点是第一个结点
// 1 - 2 - 3 - 4 - 5
// 两个链表完全重合   
void Test4()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);

    Test("Test4", pNode1, pNode1, pNode1);

    DestroyList(pNode1);
}

// 输入的两个链表有一个空链表
void Test5()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);

    Test("Test5", NULL, pNode1, NULL);

    DestroyList(pNode1);
}

// 输入的两个链表有一个空链表
void Test6()
{
    Test("Test6", NULL, NULL, NULL);
}

void DestroyNode(ListNode* pNode)
{
    delete pNode;
    pNode = NULL;
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();
    return 0;
}
弹指间LDL
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python《剑指offer》算法实现-两个链表的第一个公共结点
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
《剑指offer》面试题23：链表中环的入口节点
Tianzez的博客
05-02 248
　　更多剑指offer面试习题请点击：《剑指offer》（第二版）题集目录索引 1. 题目： 　　一个链表中包含环，如何找出环的入口结点？例如，在图3.8的链表中，环的入口结点是结点3。 2. 解题思路1： 第一步：判断链表是否带环 　　首先利用快慢指针法，确定链表是否带环。用两个指针pFast和pSlow。开始时两者都指向头结点pHead，然后同时往后走。快指针一次走两...
《剑指offer》：删除链表中倒数第k个节点-Python
01-20
为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。 例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。–出自《剑指offer...
Python《剑指offer》算法实现-链表中倒数第k个结点
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
Python《剑指offer》算法实现-合并两个排序的链表
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
wuqd666#ZXBlog#剑指Offer - 14 - 链表中倒数第k个结点1
07-25
然后先让第一个指针first走k-1步，然后两个指针再一起走，当第二个指针second走到末尾(second.next = null)时，第一个指针first就
剑指offer43-计算n个色子掷出各个点数和的概率
LDL
08-19 1444
问题描述：把n个色子掷地上，所有朝上一面的和为S，求出所有可能的S的概率，分析可知，色子有6个面，其数是1~6，而总共有n个色子，那么其和的范围是n~6n，而总共可能出现的组合情况有6^n种。/**************方法一**************/ 通过每次确定一个色子的数字，确定n个色子出现的数字，然后根据其和，相应的次数+1，从第一个色子开始确定，逐个确定色子的数字，一个色子确定后，
直方图内矩形面积
LDL
05-04 1315
输入一组直方图数据，其中每列的宽度为1，求所给直方图包含的最各个高度的矩形面积。比如，对于直方图[2,7,9,4，1],它所包含的各个高度矩形的面积为8，14，9，12，5 给定一个直方图及它的总宽度返回相应面积。 方法一： 方法一的思路是，从前完后遍历直方图，在相应的位置往前后搜索，遇到直方图高度更低的则停止，通过左右的界限来求其宽度。（方法一代码值考虑了值为0到9的情况） #include
统计二进制数中1的个数
LDL
09-26 1036
容易想到，将数与1按位与，然后右移，每次都跟1相与统计1的个数，这种方法对于无符号数是可以的，但是对于有符号数而言，其右移后再高位空出部分会添加1，也就是说，该方法对于无符号数而言会陷入死循环。 方法一 由于左移是始终在空出的低位添加0的，那么不妨使用一个1来和待统计的二进制数进行按位与操作，然后将1进行二进制的左移操作，从低位到高位依次统计每个位置是否为1。int CountNumUseFla
将中缀表达式转换成后缀表达式并计算
LDL
04-26 1002
1、将以字符串形式输入的中缀表达式转换成后缀表达式 初始化一个空栈用于存储操作符 对于中缀表达式从左向右遍历,每得到一个字符，进行判断 a、如果是数字，则直接加入到后缀表达式中，同时判断下一个 字符是也是数字，如果是，也加入到后缀表达式中，如此循 环判断，将连续的数字字符一并识别存储。b、如果是左括号，则把左括号入操作符栈。c、如果是右括号，则从操作符栈中把符号出栈
求两点间距离
LDL
04-12 571
Problem Description 输入两点坐标（X1,Y1）,（X2,Y2）,计算并输出两点间的距离。 Input 输入数据有多组，每组占一行，由4个实数组成，分别表示x1,y1,x2,y2,数据之间用空格隔开。 Output 对于每组输入数据，输出一行，结果保留两位小数。 Sample Input 0 0 0 1 0 1 1 0 Sample Output 1.00 1
剑指offer46-累加和的特殊求法
LDL
08-26 485
题目描述：要求在不使用乘除法，for、while、if、else、switch、case以及条件判断语句（A?B:C）的情况下求累加和，通常求累加和的做法是通过公式，或者是递归，循环等方式#include <iostream> using namespace std; /*************方法一******************/ //利用循环的思路，循环即同一个函数重复执行多次，而在循环
直方图最大容量问题
LDL
05-16 482
给定n个非负整数，表示直方图方柱高度，方柱宽度假定为1，假设用这个形状的容器盛水，求其最大盛水量。
判断二叉搜索树是否为后序遍历序列
LDL
09-26 465
#include <iostream> using namespace std;//给定一个整数数组，判断是否是一个二叉搜索树的后序遍历结果 bool JudgeBSTSequence(int* BinSeq,int length) { int* root = NULL; int* leftStart = NULL; int* rightStart = NULL; /
剑指offer45-圆圈中剩下的最后一个数
LDL
08-26 462
//将0~n-1共n个数字排成一个圆圈，从数字0开始数数，每次从圆圈里删除第m个数字，计算出最后剩下的1个数字。 //分析：首先要注意，在进行数字处理的时候，要让着一串数字成环,而成环的方式是当计数到链表尾部的时候， //返回到头部继续计数。另外，如果是删除的是最后一个元素，那么在删除后，也应该从头开始计数 //#include <iostream> #include<list> using
剑指offer44-扑克牌顺子判断
LDL
08-19 351
问题描述：随机抽出5张扑克牌，判断这5张牌是不是顺子（连续的），其中2~10表示数字本身，A为1，J为11，Q为12，K为13，大小王可以看成是任意数字。 分析：由于是随机抽取的几张牌，因此，需要先对牌进行排序。排序过后，由于大小王比较特殊，可以表示任意数字，假设用0来表示大小王，首先应该统计0的个数，遍历数组的时候，如果碰到对子（即非0而又相等数字，则可以直接判断为非顺子）。如果相邻两个数不是连
剑指offer42-翻转单词顺序和字符串的左旋转
LDL
08-19 247
翻转句子中的单词顺序，输入一个句子，翻转句子中的单词顺序，但是单个单词中的字母顺序不变，如“I am a student.”翻转后为“student. a am I”。翻转方式为，首先将整个句子当成是一个字符串进行翻转，得到“.tneduts a ma I”。然后，以空格作为分隔符，将每个单词分别进行翻转，得到“student. a am I”，而对于整个句子和单个单词的翻转，其翻转的方式是一样的#
大、小断层矿井小波SVM融合智能故障预测matlab代码.zip
最新发布
04-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
输入一个链表输出该链表中倒数第k个节点
09-01
要输出一个链表中倒数第k个节点，可以使用双指针的方法来实现。 首先，定义两个指针p1和p2，都指向链表的头节点。 让p2向后移动k-1个位置，使得p1和p2之间相隔k-1个节点。 同时移动p1和p2，直到p2指向链表的尾节点...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

弹指间LDL

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值