<数据结构>五道LeetCode链表题分析.环形链表,反转链表,合并链表,找中间节点.

简介: <数据结构>五道LeetCode链表题分析.环形链表,反转链表,合并链表,找中间节点

一.反转链表


1.头插法

//头插法
struct ListNode* reverseList(struct ListNode* head)
{
    if(head==NULL)
    {
        return NULL;
    }
    struct ListNode*newhead=NULL;
    struct ListNode*next=head->next;
    while(head!=NULL)
    {
         next=head->next;
         head->next=newhead;//将head头查到newhead上
         newhead=head;//newhead为新的头
         head=next;  //head 接着往下走
    }
    return newhead;
}

2.迭代法

//迭代法
struct ListNode* reverseList(struct ListNode* head)
{
 
    if(head==NULL||head->next==NULL)
    {
        return head;
    }
    struct ListNode*n1=NULL; //利用三个指针 循环往下走
    struct ListNode*n2=head; //来调转链表指向
    struct ListNode*n3=n2->next; 
    while(n3->next!=NULL)
    {
        n2->next=n1;
        n1=n2;
        n2=n3;
        n3=n2->next;
    }
    n2->next=n1;
    n3->next=n2;
    return n3;
}

二.链表的中间节点


1.快慢指针法

//快慢指针法:fast指针一次走两步,slow指针一次走一步,
//          当fast为NULL或fast->next为NULL时(分奇偶),此时的slow为mid
struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode*slow=head;
    struct ListNode*fast=head;
    while(fast!=NULL&&fast->next!=NULL)
    {
        fast=fast->next->next;
        slow=slow->next;
    }
    return slow;
}

2.指针数组法

//不推荐此方法 空间复杂度为O(N)
struct ListNode* middleNode(struct ListNode* head)
{
   struct ListNode*arr[100]={NULL};
    int count=0;
    struct ListNode*p1=head;
    while(p1!=NULL)
    {
        arr[count]=p1;
        count++;
        p1=p1->next;
    }
    return arr[count/2];
 
}

三.合并两个有序链表


尾插法

//尾插法:创建一个新的头,比较大小,小的尾插到后面
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    if(list1==NULL)             // 特殊情况
       return list2;
    if(list2==NULL)
       return list1;
    struct ListNode*head=NULL;
    struct ListNode*tail=NULL;
    if(list1->val<=list2->val) //先把第一个给head和tail 保证不为空
    {
 
        tail=list1;
        head=list1;
        list1=list1->next;
    }
    else
    {
        tail=list2;
        head=list2;
        list2=list2->next;
    }
    while(list1!=NULL&&list2!=NULL)  //比较大小 小的尾插
    {
        if(list1->val<=list2->val)
        {
            tail->next=list1;
            tail=tail->next;
            list1=list1->next;
        }
        else
        {
 
            tail->next=list2;
            tail=tail->next;
            list2=list2->next;
        }
    }
    if(list1==NULL)              //最后有一个到头,直接接上后面
    {
        tail->next=list2;
    }
    else
    {
        tail->next=list1;
    }
    return head;
}

四.环形链表(1)


快慢指针法

//先让fast进入循环,然后slow进入,最后fast与slow相遇
bool hasCycle(struct ListNode *head)
{
    struct ListNode *slow=head;
    struct ListNode *fast=head;
    while(fast!=NULL&&fast->next!=NULL)
    {
        slow=slow->next;
        fast=fast->next->next;
        if(fast==slow)
        {
            return true;
        }
    }
    return false;
}

五.环形链表(2)


思路分析:

代码实现:

//快慢指针
struct ListNode *detectCycle(struct ListNode *head) 
{
    struct ListNode *slow=head;
    struct ListNode *fast=head;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
        if(fast==slow)                 //先快慢指针相遇
        {
            struct ListNode *meet=slow;
            while(meet!=head)
            {
                meet=meet->next;       //再一个从meet走,一个从head走
                head=head->next;
            }
            return head;               //相遇时为环形链表的入口
        }
    }
    return NULL;
 
}
目录
相关文章
|
14天前
|
存储 Java 索引
【数据结构】链表从实现到应用,保姆级攻略
本文详细介绍了链表这一重要数据结构。链表与数组不同,其元素在内存中非连续分布,通过指针连接。Java中链表常用于需动态添加或删除元素的场景。文章首先解释了单向链表的基本概念,包括节点定义及各种操作如插入、删除等的实现方法。随后介绍了双向链表,说明了其拥有前后两个指针的特点,并展示了相关操作的代码实现。最后,对比了ArrayList与LinkedList的不同之处,包括它们底层实现、时间复杂度以及适用场景等方面。
31 10
【数据结构】链表从实现到应用,保姆级攻略
|
1月前
|
算法
LeetCode第24题两两交换链表中的节点
这篇文章介绍了LeetCode第24题"两两交换链表中的节点"的解题方法,通过使用虚拟节点和前驱节点技巧,实现了链表中相邻节点的交换。
LeetCode第24题两两交换链表中的节点
|
1月前
|
存储 C语言
【数据结构】c语言链表的创建插入、删除、查询、元素翻倍
【数据结构】c语言链表的创建插入、删除、查询、元素翻倍
【数据结构】c语言链表的创建插入、删除、查询、元素翻倍
|
1月前
【数据结构】双向带头(哨兵位)循环链表 —详细讲解(赋源码)
【数据结构】双向带头(哨兵位)循环链表 —详细讲解(赋源码)
31 4
|
1月前
|
Python
【Leetcode刷题Python】剑指 Offer 22. 链表中倒数第k个节点
Leetcode题目"剑指 Offer 22. 链表中倒数第k个节点"的Python解决方案,使用双指针法找到并返回链表中倒数第k个节点。
40 5
|
1月前
|
Python
【Leetcode刷题Python】剑指 Offer 18. 删除链表的节点
Leetcode题目"剑指 Offer 18. 删除链表的节点"的Python解决方案,通过使用双指针法找到并删除链表中值为特定数值的节点,然后返回更新后的链表头节点。
31 4
|
30天前
|
存储 Java 程序员
"揭秘HashMap底层实现:从数组到链表,再到红黑树,掌握高效数据结构的秘密武器!"
【8月更文挑战第21天】HashMap是Java中重要的数据结构,采用数组+链表/红黑树实现,确保高效查询与更新。构造方法初始化数组,默认容量16,负载因子0.75触发扩容。`put`操作通过计算`hashCode`定位元素,利用链表或红黑树处理冲突。`get`和`remove`操作类似地定位并返回或移除元素。JDK 1.8优化了链表转红黑树机制,提升性能。理解这些原理能帮助我们更高效地应用HashMap。
30 0
|
1月前
|
存储 算法
【初阶数据结构篇】顺序表和链表算法题
此题可以先找到中间节点,然后把后半部分逆置,最近前后两部分一一比对,如果节点的值全部相同,则即为回文。
|
1月前
|
存储 测试技术
【初阶数据结构篇】双向链表的实现(赋源码)
因为头结点的存在,plist指针始终指向头结点,不会改变。
|
1月前
|
存储 测试技术
【初阶数据结构篇】单链表的实现(附源码)
在尾插/尾删中,都需要依据链表是否为空/链表是否多于一个节点来分情况讨论,目的是避免对空指针进行解引用造成的错误。