数据结构刷题-链表

最新推荐文章于 2025-12-19 16:22:21 发布

原创最新推荐文章于 2025-12-19 16:22:21 发布 · 166 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #数据结构 #c++

数据结构专栏收录该内容

2 篇文章

订阅专栏

1、链表的定义

struct ListNode{
    int val; //节点上存储的元素
    ListNode* next;//指向下一个节点的指针
    ListNode(int x) : val(x), next(nullptr){}//节点的构造函数
    //注意：不写这个构造函数，C++也会默认生成一个构造函数，但是默认生成的构造函数，不会初始化任何成员变量。
    // 如果不定义而是使用默认构造函数，那么在初始化的时候就不能直接给变量赋值
};

// C++中，删除节点，最好手动释放这个节点和这块内存。

2、用虚拟头节点会方便的多

删除节点

class Solution{
public:
    ListNode * removeElements(ListNdoe* head, int val){
        // 删除头节点
        
        while(head != NULL && head -> val == val){
            ListNode* tmp = head;
            head = head -> next;
            delete tmp;
        }

        //删除非头节点(确保有两个以上节点：头节点+非头节点)
        ListNode* cur = head;
        // 检查当前节点cur不为NULL，并且下一个节点cur->next也不为null。如果两个条件成立，则意味着链表中至少还有两个节点，循环可以继续迭代。
        while(cur != NULL && cur -> next != NULL){ //头节点不为NULL，且下一个节点也不为NULL
            if(cur->next->val == val){ // 若下一个节点的值为要删除的val，则删除
                ListNdoe* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }else{
                cur = cur->next;
            }
        }
        return head;
    }
};

给链表添加一个虚拟头节点并将其设为新的头节点

作用：从链表中删除所有值等于val的节点，并且返回删除后的链表头节点。

class Solution {
public:
    ListNode* removeElement(ListNode* head, int val){
        ListNode* dummyHead = new ListNode(0); //设置一个虚拟头节点
        dummyHead->next = head;//将虚拟头节点指向head，方便后面执行删除操作
        ListNode* cur = dummyHead;
        while(cur->next != NULL) {
            if(cur->next->val == val){
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;//使用C++时需要手动释放内存（动态分配内存：在合适的时候，手动释放内存，以避免内存泄漏）
            }else{
                cur = cur -> next;
            }
        }
        head = dummyHead->next;
        delete dummyHead; //使用C++时需要手动清理内存
        return head;

    }
}

3、链表常见的六个操作

class MyLinkedList{
public:
    //定义链表结点的结构体
    struct LinkedNode{
        int val;
        ListNode* next;
        LinkedNode(int val):val(val),next(nullptr){}//构造函数：接收一个整型参数val，并用该参数初始化val成员变量，将next成员变量初始化一个空指针。
    };

    //初始化链表
    MyLinkedList(){
        //这里定义的头节点是一个虚拟头节点，而不是真正的链表头节点
        _dummyHead = new ListNode(0);
        _size = 0;
    }

    //获取第index个节点的数值，如果index是非法数值则直接返回-1
    //注意index是从0开始的，第0个节点就是头节点
    int get(int index){
        if(index > (_size - 1)|| index < 0){
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){
            cur = cur->next;
        }
        return cur->val;
    }
    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头节点
	void addHead(int val){
	    LinkedNode* newNode = new LinkedNode(val);
	    newNode->next = _dummyHead->next;
	    _dummyHead->next = newNode;
	    _size++;
	}
	//在链表最后面添加一个节点
	void addAtTail(int val){
	    LinkedNode* newNode = new LinkedNode(val);
	    LinkedNode* cur = _dummyHead;
	    while(cur->next != nullptr){
	        cur = cur->next;
	    }
	    cur->next = newNode;
	    _size++;
	}
	//在第index个节点之前插入一个新节点
	//如果index为0，那么新插入的节点为链表新的头节点
	//如果index等于链表长度，则说明新插入的节点为链表的尾节点
	//如果index大于链表的长度，则返回空
	void addAtIndex(int index, int val){
	    if(index > _size){
	        return;
	    }
	    LinkedNode* newNode = new LinkedNode(val);
	    LinkNode* cur = _dummyHead;
	    while(index--){
	        cur = cur->next;
	    }
	    newNode->next = cur->next;
	    cur->next = newNode;
	    _size++;
	}
	//删除第index个节点，如果index大于或等于链表的长度，则直接返回
	// 注意index是从0开始的
	void deleteAtIndex(int index){
	    if(index >= _size||index < 0){
	        return;
	    }
	    LinkedNode* cur = _dummyHead;
	    while(index--){
	        cur =cur->next;
	    }
	    LinkedNode* tmp = cur -> next;
	    cur->next = cur->next->next;
	    delete tmp;
	    __size++;
	}
	// 打印链表
	void printLinkedList(){
	    LinkedNode* cur = _dummyHead;
	    while(cur->next != nullptr){
	        cout << cur->next->val << " ";
	        cur = cur -> next;
	    }
	    cout<<endl;
	}

private:
    int _size;
    LinkedNode* _dummyHead;
};

4、反转列表

题目描述：反转一个单链表。要求是不能申请额外的内存空间

思路：如果定义一个新的链表元素的反转，则是对内存空间的浪费，其实只需要改变链表的next指针的指向，直接将链表反转即可，而不用重新定义一个新的链表

方法一：双指针法

class Slution{
public:
    ListNode* reverseList(ListNode* head){
        ListNode* temp;
        ListNode* cur = head;
        ListNode* pre = nullptr;
        //当cur为空的时候循环结束，不断的将cur指向pre的过程
        while(cur){
            //保存cur的下一个节点，因为接下来要改变cur->next的指向了
            temp = cur->next;;
            cur -> next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

方法二：递归法

class Slution{
public:
    ListNode* reverse(ListNode* pre, ListNdoe* cur) //反转链表
    {
        // 每次递归将当前节点的next指针指向前一个节点，然后递归到下一个节点。
        // 当前节点为nullptr的时候，递归结束，返回前一个节点pre
        if(cur == nullptr) return pre;
        ListNode* temp = cur -> next;
        cur -> next = pre;
        return reverse(cur , temp);
    }
    ListNode* reverseList(ListNode* head){
        return reverse(nullptr, head);
    }

};

5、删除链表的倒数第n个节点

题目描述：删除链表的倒数第n个节点（n从1开始）。

思路：如果要删除倒数第n个节点，则让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾，删除slow所指向的结点就可以了。

该实现使用了双指针技巧来遍历链表。创建一个虚拟头节点，将其next指针设置为原始头节点。然后使用两个指针，slow和fast，遍历链表。
快指针在慢指针的前面移动n步。然后，两个指针都向前移动，直到快指针到达链表的末尾。
此时，慢指针指向倒数第n个节点的前一个节点。实现通过将慢指针的下一个指针更新为指向倒数第n个节点后面的节点来删除倒数第n个节点。

为了删除倒数第n个节点，使用快慢指针法，让指针fast索引减去指针slow索引的差值为n+1。为什么是n+1，因为删除倒数第n个节点，需要找到其前置节点，改变前置节点的指针域即可删除节点

class Slution{
public:
    ListNode* removeNthFromEnd(ListNode* head, int n){
        ListNode* dummyHead = new ListNode(0);//定义虚拟头节点
        dummyHead->next = head; 
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast != nullptr){
            fast = fast -> next;
        }
        //fast在提前移动一步，因为需要让slow指向删除节点的上一个节点
        fast = fast ->next;
        while(fast!=nullptr){
            fast = fast -> next;
            slow = slow -> next;
        }
        slow ->next= slow ->next->next;
        return dummyHead->next;
    }
};

6、环形链表

题目描述：判断链表是否有环，如果有环，则找到入环的第一个节点，如果无环，则返回NULL。

思路：1、判断链表是否循环；2、如果有环，如何找到这个环的入口

算法步骤如下：

定义两个指针 fast 和 slow，初始值都为头结点 head。

使用 while 循环，判断 fast 指针和 fast 的下一个节点是否都不为 NULL，如果有一个为 NULL，说明链表没有环，退出循环。

在循环中，每次慢指针 slow 只向前移动一步，快指针 fast 则向前移动两步。

当快指针追上慢指针时，说明链表有环。此时从头结点 head 和相遇点同时出发，同时移动指针，直到两个指针相遇。相遇点即为环的入口节点。

如果没有找到环，则返回 NULL。

这个算法的时间复杂度为 O(n)，其中 n 是链表的长度，空间复杂度为 O(1)，因为只使用了常数级别的额外空间。

/* 检测链表是否有环，如果有环，找到如环的第一个节点；如果没有环，则返回NULL。*/
class Slution{
public:
    ListNode* detectCycle(ListNode* head)
    {
        //使用快慢指针，判断是否有环
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != nullptr && fast->next != nullptr){
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast){
                //判断存在环，找环入口
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while(index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2;
            }
        }
        return nullptr;
    }
};