数据结构--链表题（可以加深友友们对链表的理解）

最新推荐文章于 2024-10-16 07:16:00 发布

昨天；明天。今天。

最新推荐文章于 2024-10-16 07:16:00 发布

阅读量521

点赞数 6

分类专栏：数据结构与算法文章标签：链表数据结构 list

本文链接：https://blog.csdn.net/Dingyuan0/article/details/124647195

版权

数据结构与算法专栏收录该内容

22 篇文章 0 订阅

订阅专栏

本文介绍了链表相关的八种常见操作，包括删除指定值节点、链表反转、找到链表中间节点、查找倒数第k个节点、合并两个有序链表、按值分割链表、判断回文结构以及寻找两个链表的交点。每个操作提供了详细的解题思路和C语言实现。

摘要由CSDN通过智能技术生成

# （1）链表题：

删除链表中等于给定值 val 的所有节点。
链接： OJ链接.
反转一个单链表。
链接： OJ链接.
给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
链接： OJ链接.
输入一个链表，输出该链表中倒数第k个结点。
链接： OJ链接.
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的
链接： OJ链接.
编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前。
链接： OJ链接.
链表的回文结构。
链接： OJ链接.
输入两个链表，找出它们的第一个公共结点。
链接： OJ链接.

（2）代码区域：

1、删除链表中等于给定值 val 的所有节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeElements(struct ListNode* head, int val)
{

    struct ListNode* newhead, *tail, *next, *cur;
    tail=head;
    //哨兵位
    cur = newhead = (struct ListNode*)malloc(sizeof(struct ListNode));
    next = cur->next = NULL;

    while(tail != NULL)
    {

        if(tail->val != val)
        {
            cur = cur->next = tail;

            tail = tail->next;

        }
        else
        {
            next = tail;

            tail = tail->next;
            next = NULL;   

        }


    }
    cur->next = NULL;

    //释放
    tail = newhead;
    newhead = newhead->next;
    free(tail);
    tail=NULL;


    return newhead;

}

2、反转一个单链表。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head)
{
    struct ListNode* newhead, *cur, *next;
    newhead=NULL, cur=head;

    while(cur !=NULL)
    {
        next=cur->next;
        cur->next=newhead;
        newhead=cur;

        cur=next;
    }

    return newhead;
}

3、给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode* fast, *slow;
    slow=fast=head;

    while((fast != NULL) && (fast->next != NULL))
    {

        fast=fast->next->next;
        slow=slow->next;
    }

    return slow;
}

4、输入一个链表，输出该链表中倒数第k个结点。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 */

/**
 * 
 * @param pListHead ListNode类 
 * @param k int整型 
 * @return ListNode类
 */
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) 
{
    // write code here
    //链表为NULL是返回NULL。
    if(pListHead == NULL)
    {
        return NULL;
    }
    
    struct ListNode* cur, *tail;
    tail=cur=pListHead;
    
    
    //cur 先走k步
    while(k--)
    {
        if(cur != NULL)
            cur=cur->next;
        else
            return NULL;
    }
    //然后一起走
    while(cur != NULL)
    {
        
        tail=tail->next;
        cur=cur->next;
        
    }
    
    return tail;
}

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

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    struct ListNode* n1, *n2, *next1, *next2, *tail, *newhead;
    n1=list1, n2=list2, next1=NULL, next2=NULL;
    
    newhead = tail = (struct ListNode*)malloc(sizeof(struct ListNode));
    tail->next = NULL;

    //list1 == NULL
    if(list1 == NULL)
    {
        return list2;
    }
    else if(list2 == NULL)
    {
        return list1;
    }

    while((n1 !=NULL) && (n2 !=NULL))
    {
        
        if(n1->val <= n2->val)
        {
            next1 = n1->next;
            tail = tail->next = n1;
            n1=next1;
        }
        else
        {
            next2 = n2->next;
            tail = tail->next = n2;
            n2=next2;
        }
    }

    if(n2 != NULL)
    {
        tail->next=n2;
    }

    if(n1 != NULL)
    {
        tail->next=n1;
    }
    //释放
    tail=newhead;
    newhead=newhead->next;
    free(tail);
    tail=NULL;


    return newhead;

}

6、编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) 
    {
        
        // write code here
        struct ListNode* shortHead, *longHead, *List, *cur;
        shortHead=(struct ListNode*)malloc(sizeof(struct ListNode));
        longHead=(struct ListNode*)malloc(sizeof(struct ListNode));
        shortHead->next=longHead->next=NULL;
        List=NULL;
        
        cur=pHead;
        
        //小于x存于shortHead，大于存于longHead
        struct ListNode* next1=shortHead;
        struct ListNode* next2=longHead;
        while(cur != NULL)
        {
            
            if(cur->val < x)
            {
                
                next1->next=cur;
                next1=next1->next;
            }
            else
            {
                next2->next=cur;
                next2=next2->next;
            }
            cur=cur->next;
            
        }
        //longHead链表最后next指向空
        next2->next=NULL;
        
         //两个链表链接。
        next1->next=longHead->next;
        List=shortHead->next;
        
        //释放
        free(shortHead);
        free(longHead);
        
        return List;
        
    }
};

7、链表的回文结构。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
struct ListNode* Mid(struct ListNode* head)
{
    
    struct ListNode* fast, *slow;
    fast=slow=head;
    
    //fast走一步， slow走俩步
    while((fast) && (fast->next))
    {
        
        fast=fast->next->next;
        slow=slow->next;
        
    }
    return slow;
    
}

struct ListNode* reverseList(struct ListNode* head)
{
    
    if(head==NULL)
        return NULL;
    
    struct ListNode* n1, *n2, *n3;
    n1=NULL;
    n2=head;
    n3=n2->next;
    
    while(n3)
    {
        
        //倒序
        n2->next=n1;
        //迭代
        
        n2=n3;
        n3=n3->next;
        
    }
    
    return n2;
    
}

class PalindromeList {
public:
    bool chkPalindrome(ListNode* A) 
    {
        // write code here
        //找中间的数。
        struct ListNode* mid= Mid(A);
        //倒置后面一半的数字。
        struct ListNode* rhead= reverseList(mid);
        
        if(A && rhead)
        {
            
            if(A->val != rhead->val)
            {
                return false;
            }
            else
            {
                mid=mid->next;
                rhead=rhead->next;
            }
            
        }
        
        return true;
        
    }
};

8、输入两个链表，找出它们的第一个公共结点。

*/
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    if(headA==NULL || headB==NULL)
        return NULL;
    

    struct ListNode *curA, *curB;
    curA=headA, curB=headB;

    int lenA, lenB;
    lenA=1, lenB=1;

    //分别算两个的长度。
    while(curA->next)
    {
        lenA++;
        curA=curA->next;
    }
    while(curB->next)
    {
        lenB++;
        curB=curB->next;
    }

	//如果两个链表是相交，最后一个必须相等。
    if(curA != curB)
        return NULL;


    struct ListNode * shortList=headA;
    struct ListNode * longList=headB;

    if(lenA > lenB)
    {
        shortList=headB;
        longList=headA;
    }

    int k =abs(lenA-lenB);

    //长链表先走k步
    while(k--)
    {
        longList=longList->next;
    }
    //然后一起走
    while(shortList != longList)
    {
        longList=longList->next;
        shortList=shortList->next;
    }

    return shortList;

}

## （3）解题思路：

1.删除链表中等于给定值 val 的所有节点
解题思路：从头节点开始进行元素删除，每删除一个元素，需要重新链接节点。
分析图
2.反转一个单链表
解题思路：此题一般常用的方法有两种，三指针翻转法和头插法
1. 三指针翻转法
记录连续的三个节点，原地修改节点指向
2. 头插法
每一个节点都进行头插

3.给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
解题思路：
通过快慢指针找到中间节点，快指针每次走两步，慢指针每次走一步，当快指针走到结尾的时候，慢指针正好走到中间位置

4.输入一个链表，输出该链表中倒数第k个结点。
解题思路：
快慢指针法 fast, slow, 首先让fast先走k步，然后fast,slow同时走，fast走到末尾时，slow走到倒数第k个节点。

5.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
解题思路：
此题可以先创建一个空链表（哨兵），然后依次从两个有序链表中选取最小的进行尾插操作进行合并。（拿下来的过程跟尾插相似）

6.编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前。
解题思路
（当然需要两个哨兵）创建两个链表，分别存放小于x的节点和大于等于x的节点，分别进行尾插
（注意：链接后最后一个的地址要为空，不然就是环形链表。）

7.链表的回文结构。
解题思路：
此题可以先找到中间节点，然后把后半部分逆置，最近前后两部分一一比对，如果节点的值全部相同，则即为回文。
（注意：我们后半部分逆置后就像一个环形链表（例如：12321逆置后为12123；可能小伙伴会以为这样比较会出错其实不然，2存的地址没改，2之后还能找到3相当与 12（3）123））

8.输入两个链表，找出它们的第一个公共结点。
解题思路：
此题可以先计算出两个链表的长度，让长的链表先走相差的长度，然后两个链表同时走，直到遇到相同的节点，即为第一个公共节点。