0
点赞
收藏
分享

微信扫一扫

【数据结构】“单链表”的练习题(二)

修炼之士 2023-08-12 阅读 42

在这里插入图片描述

文章目录


前言:

最近在刷题的铁子们,你们在做题的时候一定要画图,人的思维固然很强,但是把图画好是真香啊!遇到BUGl了照着图分析,十分简洁明朗,事半功倍。

链表的回文结构

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

思路:
1.找到中间节点
2.从中间节点往后逆置
3.定义快慢指针,向后遍历判断是否相等。
在这里插入图片描述

class PalindromeList {
public:
    struct ListNode* middleNode(struct ListNode* head)
    {
        struct ListNode* slow = head,*fast = head;
        while(fast&& fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }

    struct ListNode* reveseList(struct ListNode* head)
    {
        struct ListNode* cur = head;
        struct ListNode* newhead = nullptr;
        while(cur)
        {
            struct ListNode* next = cur->next;
            cur->next = newhead;
            newhead  = cur;
            cur = next;
        } 
        return newhead;
    } 
    bool chkPalindrome(ListNode* head) {
        // write code here
        struct ListNode* mid = middleNode(head);
        struct ListNode* rmid = reveseList(mid);

        while(rmid && head)
        {
            if(rmid->val !=head->val)
            {
                return false;
            }
            rmid = rmid->next;
            head = head->next;
        }
        return true;
    }
};

160.相交链表

题目:

思路:
1.分别计算listA,listB链表的长度
2.取两绝对值,对齐两个链表,同时开始遍历,当相同就相交了。
在这里插入图片描述

代码:

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode* curA = headA,*curB = headB;
    //分别计算A,B链表的长度
    int lenA =1,lenB =1;
    while(curA->next)
    {
        curA = curA->next;
        lenA++;
    }
     while(curB->next)
    {
        curB = curB->next;
        lenB++;
    }
    //此时curA,B都已指向最后节点,如果不相等,则说明不相交
    if(curA != curB)
    {
        return NULL;
    }
    //求出相差的步数
    int n = abs(lenA-lenB);
    struct ListNode* LongList = headA,* ShortList = headB;
    if(lenA<lenB)
    {
        LongList = headB;
        ShortList = headA;
    }
    //先让长的链表走n步,与短链表对齐
    while(n--)
    {
        LongList = LongList->next;
    }
    //同时走,找相同;
    while(LongList!=ShortList)
    {
        LongList = LongList->next;
        ShortList = ShortList->next;
    }
    return ShortList;
}

在这里插入图片描述

141.环形链表(LeetCode)

给你一个链表的头节点 ,判断链表中是否有环。head

如果链表中有某个节点,可以通过连续跟踪 指针再次到达,则链表中存在环。为了表示给定链表中的环,评测系统内部使用整数 来表示链表尾连接到链表中的位置(索引从 0 开始)。注意:pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。nextpos

如果链表中存在环 ,则返回 。否则,返回 。truefalse
在这里插入图片描述

思路:

在这里插入图片描述
代码:

bool hasCycle(struct ListNode *head) {
    struct ListNode *fast = head,*low = head;
    while(fast && fast->next)
    {
        fast = fast->next->next;
        low = low->next;
        if(fast == low)
        {
            return true;
        }
    }
    return false;
}

在这里插入图片描述

leetcode142.环形链||

题目要求:

思路分析:
🔸如果链表存在环,则fast和slow会在环内相遇,定义相遇点到入口点的距离为X,定义环的长度为C,定义头到入口的距离为L,fast在slow进入环之后一圈内追上slow,则会得知:
🔸slow所走的步数为:L + X
🔸fast所走的步数为:L + X + N * C
并且fast所走的步数为slow的两倍,故:
🔸2*(L + X) = L + X + N * C
即: L = N * C - X
所以从相遇点开始slow继续走,让一个指针从头开始走,相遇点即为入口节点

struct ListNode *detectCycle(struct ListNode *head) {

    struct ListNode* fast,*slow;

    slow = fast = head;

    while(fast && fast->next)

    {

        slow = slow->next;

        fast = fast->next->next;

        if(slow == fast)

        {

            struct ListNode* meet = slow;

            while(head != meet)

            {

                head = head->next;

                meet = meet->next;

            }

            return meet;

        }

    }

    return NULL;

}

LeetCode138.复制带随机指针的链表

题目要求:
在这里插入图片描述
在这里插入图片描述

·读题·:首先,这道题目的意思是完整的复制一遍链表,难点在于每个节点有一个随机指针,由于题目要求不能指向原来链表,所以他的复制成了一个难点。

解决步骤:
1.在原链表每个节点之后插入一个复制节点 (复制前一个节点)。
2.给复制节点中的random进行指向。
3.把所有的复制节点拿下来整理成新列表,
思路图:
在这里插入图片描述

代码:

struct Node* copyRandomList(struct Node* head) {
	struct Node* cur = head;
    //复制每个节点并插入到相应节点之后
    while(cur)
    {
        struct Node* next = cur->next;
        struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
        //给copy赋值内容
        copy->val = cur->val;
        //插入
        cur->next = copy;
        copy->next = next;
        //向后移动过cur指针和next指针
        cur = next;
    }


    //处理random指向

    cur = head;
    while(cur)
    {
        struct Node* copy = cur->next;
        if(cur->random==NULL)
        {
            copy->random = NULL;
        }
        else
        {
            //精华所在
            copy->random = cur->random->next;//指向原链表的复制节点
        }
        cur = copy->next;
    }


    //将新链表整理出来
    cur = head;
    //制造一个哨兵位作为新链表的头结点,便于插入 
    struct Node* copyhead = (struct Node*)malloc(sizeof(struct Node));
    copyhead->val = 1;
    copyhead->next = NULL;
    copyhead->random = NULL;
    //定义一个节点,遍历新链表。为了保存原链表的头。
    struct Node* pcopyhead = copyhead;
    while(cur)
    {
        struct Node* copy = cur->next;
        struct Node* next = copy->next;
        //尾插到新链表
        pcopyhead->next = copy;
        pcopyhead = pcopyhead->next;
        //恢复原链表
        cur->next = next;
        cur = next;

    }
    return copyhead->next;
}

在这里插入图片描述
注意点:切记如果使用了哨兵位那么一定要给它进行初始化。

举报

相关推荐

0 条评论