链表复习，例题分析

BlackMonkeyHH

已于 2022-12-04 17:12:42 修改

阅读量241

点赞数

文章标签： c++ 链表算法

于 2022-12-04 17:12:19 首次发布

本文链接：https://blog.csdn.net/BlackMonkeyHH/article/details/128169858

版权

一、什么是链表？

相较于数组来解释：

从存储上：数组是申请了一块连续的内存空间，支持随机访问，存储的内容只有值；链表由节点组成，每个节点分配一个空间，存储的内容包括值域和指针域，值域存储值，指针域存储该节点的前驱，后继节点，因此链表不支持随机访问；

从特点上：数组支持随机访问，因此查询效率高，但因为地址连续，删除插入数据时只能通过移动其他元素，不能直接释放地址，不像链表节点与节点间存在前后的关系，效率很低

二、链表实现

1.单链表结构

利用结构体实现链表节点定义值域，指针域以及相应的构造函数；

2.与之相关的例题：

力扣707设计链表

思路：采取双链表实现

1.获取节点：通过遍历找到节点，因为采取双链表，如果靠近头就从头遍历，反之；

2.添加节点：添加头和添加尾可统一用添加节点实现，找到相应节点在其前面插入；

3.删除节点：遍历找到节点，删除节点

问题：在删除和添加节点时，需要用到对应节点的前驱节点，考虑到边界问题，采用哨兵节点；

struct DLinkListNode {       //节点结构体
    int val;
    DLinkListNode *prev, *next;
    DLinkListNode(int _val) : val(_val), prev(nullptr), next(nullptr) {}
};

class MyLinkedList {
public:
    MyLinkedList() {
        this->size = 0;
        this->head = new DLinkListNode(0);   //哨兵
        this->tail = new DLinkListNode(0);
        head->next = tail;
        tail->prev = head;
    }
    
    int get(int index) {
        if (index < 0 || index >= size) {   //索引超范围
            return -1;
        }
        DLinkListNode *curr;
        if (index + 1 < size - index) {
            curr = head;
            for (int i = 0; i <= index; i++) {
                curr = curr->next;
            }
        } else {
            curr = tail;
            for (int i = 0; i < size - index; i++) {
                curr = curr->prev;
            }
        }
        return curr->val;
    }
    
    void addAtHead(int val) {
        addAtIndex(0, val);
    }
    
    void addAtTail(int val) {
        addAtIndex(size, val);
    }
    
    void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        index = max(0, index);     //排除小于0的
        DLinkListNode *pred, *succ;
        if (index < size - index) {   //找index之前的位置
            pred = head;
            for (int i = 0; i < index; i++) {
                pred = pred->next;
            }
            succ = pred->next;
        } else {
            succ = tail;
            for (int i = 0; i < size - index; i++) {
                succ = succ->prev;
            }
            pred = succ->prev;
        }
        size++;
        DLinkListNode *toAdd = new DLinkListNode(val);  //插入
        toAdd->prev = pred;
        toAdd->next = succ;
        pred->next = toAdd;
        succ->prev = toAdd;
    }
    
    void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        DLinkListNode *pred, *succ;
        if (index < size - index) {
            pred = head;
            for (int i = 0; i < index; i++) {
                pred = pred->next;
            }
            succ = pred->next->next;
        } else {
            succ = tail;
            for (int i = 0; i < size - index - 1; i++) {
                succ = succ->prev;
            }
            pred = succ->prev->prev;
        }
        size--;
        DLinkListNode *p = pred->next;
        pred->next = succ;
        succ->prev = pred;
        delete p;
    }
private:
    int size;
    DLinkListNode *head;
    DLinkListNode *tail;
};

三.例题

1.力扣203移除元素

思路：移除元素，先找到元素，更改其前驱节点的后继，在释放该元素，考虑到边界问题，采用哨兵节点,双指针做法；

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val)  
    {
        if(head==nullptr)return nullptr;
        ListNode *pre = new ListNode();
        pre->next = head;
        ListNode * ans = new ListNode();
        ans = pre;
        while(head)
        {
            if(head->val==val)
            {
                pre->next = head->next;
                ListNode* p =head;
                head=head->next; 
                delete p;
            }
            else{
                pre=pre->next;
                head=head->next; 
            }
                      
        }
        return ans->next;
    }
};

2.206反转链表

思路：双指针，改变指向，事先记录下后继

class Solution {
public:
    ListNode* reverseList(ListNode* head) 
    {
        if(head==nullptr)return nullptr;
        if(head->next==nullptr)return head;
        ListNode * pre =new ListNode();
        ListNode* cur;
        pre=head->next;
        head->next=nullptr;
        while(cur)
        {
            cur=pre->next;
            pre->next=head;
            head=pre;
            pre=cur;
        }
           
          return head;  
       
    }
};

3.24

思路：双指针，反转两节点，反转后的后继需要后面两节点反转，所以采用递归，递归前进反转两节点，回退在连接；

class Solution {
public:

    ListNode* swapp(ListNode*cur,ListNode*pre)
    {
        if(pre==nullptr)return cur;
        ListNode*p = pre->next;
        cur->next=nullptr;
         pre->next=cur;
         if(p==nullptr)return pre;
         cur->next = swapp(p,p->next);
         return pre;
    }
    ListNode* swapPairs(ListNode* head) 
    {
         if(head==nullptr)return nullptr;
         if(head->next==nullptr)return head;
         ListNode* pre=head->next;
         ListNode*ans= swapp(head,pre);
         
         return ans;
    }
};

4.19

思路：链表不支持随机访问，也没有size，我们可以利用快慢指针，快指针比慢指针先走n当快指针到达末尾，慢指针到了目标节点；删除节点因此利用哨兵节点；

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) 
    {     
         
        ListNode *p=new ListNode();
        
        if(head==nullptr)return p;
        p->next=head;
        ListNode *newhead=p; 
       while(n>0) 
       {
           head=head->next;
           n--;
       }
       while(head!=nullptr)
       {
           head=head->next;
           p=p->next;
       }
           p->next=p->next->next;
           return newhead->next;

5.02.07

思路：如果相交假设a为a+c，b为b+c，首个相交节点在c，我们让a走完a接着走b，b走完n接着a

这样ab会同时到达c；

如果不相交，他们会同时到达空；

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) 
    {
        ListNode *pa=headA;
        ListNode *pb=headB;
        if(pa==nullptr||pb==nullptr)return nullptr;
        while(pa!=pb)
        {
           pa=pa==nullptr?headB:pa->next; 
           pb=pb==nullptr?headA:pb->next;
        }
        return pa;
    }
};

6.环形链表

思路：如何判断是否成环，通过快慢指针，如果成环两者一定会相遇；

根据所走路径推出：

假设相遇时慢指针走了a+b，快指针走了a+b+c+b（这里让快指针速度是慢指针的二倍），

推出，a=c，也就是从相遇点和起点同时出发，两者相遇的点就是成环点；

class Solution {
public:
    ListNode *detectCycle(ListNode *head) 
    {
        ListNode *slow = head, *fast = head;
        if(fast==nullptr)return nullptr;
        while (fast&&fast ->next) {
            slow = slow->next;           
            fast = fast->next->next;
            if (fast == slow) {
                ListNode *ptr = head;
                while (ptr != slow) {
                    ptr = ptr->next;
                    slow = slow->next;
                }
                return ptr;
            }
        }
        return nullptr;


    }
};