链表题目练习2（简单）-CSDN博客

本文链接：https://blog.csdn.net/2401_85644756/article/details/147701259

一、合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [], l2 = []
输出：[]

示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

思路：创建新链表（初始状态为空），设头结点newHead，尾结点newTail。遍历原链表，l1和l2作比较，谁小谁往新链表尾插，注意若原链表为空，那么新插入的结点既是头结点也是尾结点

若l1或l2走向空（两者不可能同时为空），则l1和l2无法比较大小，跳出循环。然后判断l1和l2谁先走向空，若l1不为空，则将l1剩下的结点尾插到新链表中；若l2不为空，则将l2剩下的结点尾插到新链表中。代码如下：

typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
    //创建空链表
    ListNode* newHead, *newTail;
    newHead = newTail = NULL;
    ListNode* l1 = list1;
    ListNode* l2 = list2;
   //处理链表为空的情况
    if(list1 == NULL)
    {
        return list2;
    }
    if(list2 == NULL)
    {
        return list1;
    }
    while(l1 && l2)
    {
        if(l1->val < l2->val)
        {
           //l1尾插到新链表
            if(newHead == NULL)
           {
             newHead = newTail = l1;
           }
            else
           {
             newTail->next = l1;
             newTail = newTail->next;
           } 
           l1 = l1->next;
        }
        else
        {
            //l2尾插到新链表中
            if(newHead == NULL)
          {
            newHead = newTail = l2;
          }
           else
           {
              newTail->next = l2;
              newTail = newTail->next;   
           }  
            l2 = l2->next;
        }
     }
    //跳出循环，只有两种，l1为空/l2为空
    if(l1)
    {
        newTail->next = l1;
    }
    if(l2)
    {
        newTail->next = l2;
    }
    return newHead;
}

上述代码在尾插部分有些冗余，原因是链表存在为空的情况需要特殊处理，那么如何改进代码呢？创建非空链表来解决此问题。即newHead和newTail不能指向空，而是指向一个有效结点，那么就向操作系统申请一块空间来保证这个结点不为空。

typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
    ListNode* newHead, *newTail;
    //创建非空链表
    // newHead = newTail = NULL; 
    newHead = newTail = (ListNode*)malloc(sizeof(ListNode));
    ListNode* l1 = list1;
    ListNode* l2 = list2;
    if(list1 == NULL)
    {
        return list2;
    }
    if(list2 == NULL)
    {
        return list1;
    }
    while(l1 && l2)
    {
        if(l1->val < l2->val)
        {
            newTail->next = l1;
            newTail = newTail->next; 
            l1 = l1->next;
        }
        else
        {
            newTail->next = l2;
            newTail = newTail->next;     
            l2 = l2->next;
        }
    }
    if(l1)
    {
        newTail->next = l1;
    }
    if(l2)
    {
        newTail->next = l2;
    }
    //向操作系统申请的空间最后要释放掉还给操作系统
    ListNode* ret = newHead->next;
    free(newHead);
    newHead = newTail = NULL;
    return ret;
}

二、相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 2：

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：No intersection
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

思路：要求出两个链表相交的起始结点，可以明确的是：在链表相交时，两个结点的位置是相同的。如何找到结点相同的位置呢？首先我们想到的是遍历两个链表（A和B），那么定义两个指针pa和pb。A、B链表在相交前的长度不同，存在长度差，能否把长度差解决呢？遍历两个链表分别求出A、B链表长度，使用abs函数求出A、B长度差的绝对值（gap），让长度大的链表先走长度差（gap）个结点，此时A、B链表在同一个起跑线上，然后遍历链表，当A、B链表结点位置相同时跳出循环，返回值为longlist或shortlist；当A、B链表不相交时，返回值为NULL

typedef struct ListNode ListNode;
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    //求两个链表长度
    ListNode* pa = headA;
    ListNode* pb = headB;
    int sizeA = 0,sizeB = 0;
    while(pa)
    {
       ++sizeA;
       pa = pa->next;
    }
    while(pb)
    {
        ++sizeB;
        pb = pb->next;
    }
    int gap = abs(sizeA - sizeB);//abs函数用于求绝对值
    //定义长短链表
    ListNode*shortList = headA;
    ListNode*longList = headB;
    if(sizeA > sizeB)
    {
      longList = headA;
      shortList = headB;
    //让长链表先走长度差步
    while(gap--)
    {
        longList = longList->next;
    }
    //longList 和shortList在同一起跑线上
    while(shortList)
    {
        if(shortList == longList)
        {
            return shortList;
        }
        shortList = shortList->next;
        longList = longList->next;
    }
    return NULL;
}

三、链表的回文结构

对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。

测试样例：

1->2->2->1
返回：true

补充：回文数字 12321 55155 1221

回文字符串 abba acbca

思路：创建数组（大小900）遍历原链表，将结点中的值依次存储在数组中


class PalindromeList {
public:
    bool chkPalindrome(ListNode* A) {
       int arr[900] = {0};
       //遍历原链表，将链表中结点的值存储在数组中
        int i = 0;
        ListNode* pcur = A;
        while(pcur)
        {
            arr[i++] = pcur->val;
            pcur = pcur->next;
        }
        int left = 0, right = i - 1;
        //判断是否为回文结构
        while(left < right)
        {
            if(arr[left] != arr[right])
            {
                return false;
            }
            left++;
            right--;
        }
         return true;
    }
};