3.1打卡 剑指offer两题

一、两个链表的第一个公共结点

描述：

输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

数据范围： n≤1000
要求：空间复杂度 O(1)，时间复杂度 O(n)

例如，输入{1,2,3},{4,5},{6,7}时，两个无环的单向链表的结构如下图所示：

示例1：

输入：{1,2,3},{4,5},{6,7}

返回值：{6,7}

说明：第一个参数{1,2,3}代表是第一个链表非公共部分，第二个参数{4,5}代表是第二个链表非公共部分，最后的{6,7}表示的是2个链表的公共部分 这3个参数最后在后台会组装成为2个两个无环的单链表，且是有公共节点的

思路：

假设一个链表比另一个链表长K个结点，我们先在长的链表上遍历K个结点，之后再同步遍历，此时我们就能保证同时到达最后一个节点。由于两个链表从第一个公共结点开始到链表的尾结点，这一部分是重合的，因此，他们肯定也是同时到达第一个公共结点的。于是在遍历中，第一个相同的结点就是第一个公共的结点。

根据这一思路，我们先要分别遍历两个链表，得到它们的长度，并求出两个长度之差。在长的链表上先遍历长度之差个结点，之后再同步遍历两个链表，直到找到相同的结点，或者一直到链表结束。

代码：

struct ListNode {
    int val;
    struct ListNode *next;
  };

struct ListNode* FindFirstCommonNode(struct ListNode* pHead1, struct ListNode* pHead2 ) {
    // write code here
   if(pHead1 == NULL || pHead2== NULL){
        return NULL;
    }
    struct ListNode *p1 = pHead1;
    struct ListNode *p2 = pHead2;
    int len1=0,len2=0;
    while(p1!=NULL){
        p1 = p1->next;
        len1++;
    }
    while(p2!=NULL){
        p2 = p2->next;
        len2++;
    }
    struct ListNode* longList,*shortList;
    int dist;
    if(len1>len2){
        longList=pHead1;
        shortList=pHead2;
        dist=len1-len2;
    }else{
        longList=pHead2;
        shortList=pHead1;
        dist=len2-len1;
    }
    while(dist--)
        longList=longList->next;
    while(longList!=NULL){
        if(longList==shortList)
            return longList;
        else{
            longList=longList->next;
            shortList=shortList->next;
        }
    }
    return NULL;
}

二、合并两个排序的链表

描述：

输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。

数据范围： 0≤n≤10000  ，−1000≤节点值≤1000 要求：空间复杂度 O(1)，时间复杂度 O(n)

如输入{1,3,5},{2,4,6}时，合并后的链表为{1,2,3,4,5,6}，所以对应的输出为{1,2,3,4,5,6}，转换过程如下图所示：

或输入{-1,2,4},{1,3,4}时，合并后的链表为{-1,1,2,3,4,4}，所以对应的输出为{-1,1,2,3,4,4}，转换过程如下图所示：

 示例

 输入：{1,3,5},{2,4,6}

返回值：{1,2,3,4,5,6}

  struct ListNode {
 	int val;
 	struct ListNode *next;
  };
struct ListNode* Merge(struct ListNode* pHead1, struct ListNode* pHead2 ) {
struct ListNode* vhead = (struct ListNode*)malloc(sizeof(struct ListNode)); //新建一个头结点
    vhead->val = -1;
    struct ListNode *p = vhead;   //用一个指针指向该头结点
        while (pHead1 && pHead2)    //两个链表都未比较完
       {
            if (pHead1->val <= pHead2->val) //表1的值更小
           {
                p->next = pHead1;    //先将结点连接到新表，再让原表指针后移一位，二者顺序不可换
                pHead1 = pHead1->next;
            }
            else {
                p->next = pHead2;
                pHead2 = pHead2->next;
            }
            p = p->next;  //加入一个新结点后，新表指针也后移一位
        }
        p->next = pHead1 ? pHead1 : pHead2;  //都比较完后，哪个表非空则直接加入到新表中
        return vhead->next;  //返回第一个结点
}