算法之链表｜ 青训营

理论基础链表

单链表

单链表是一种通过指针串联在一起的线性结构，每个节点由两部分组成：一个是数据域，一个是指针域。最后一个节点的指针域指向null（空指针的意思）。单链表中的指针域只能指向节点的下一个节点。

双链表

双链表每个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。这样的设计使得双链表可以向前和向后进行查询操作。

循环链表

循环链表，顾名思义，就是链表首尾相连。

链表的定义

cppCopy code
// 单链表
struct ListNode {
    int val;          // 节点上存储的元素
    ListNode* next;   // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数
};

移除链表元素（虚拟头结点）

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

  • 直接使用原来的链表进行删除操作，并单独处理移除头结点的情况。
  • 设置一个虚拟头结点在进行删除操作。
cppCopy code
ListNode* removeElements(ListNode* head, int val) {
    // 删除头结点
    while (head != NULL && head->val == val) {
        ListNode* tmp = head;
        head = head->next;
        delete tmp;
    }

    // 删除非头结点
    ListNode* cur = head;
    while (cur != NULL && cur->next != NULL) {
        if (cur->next->val == val) {
            ListNode* tmp = cur->next;
            cur->next = cur->next->next;
            delete tmp;
        } else {
            cur = cur->next;
        }
    }
    return head;
}

cppCopy code
ListNode* removeElements(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;
        } else {
            cur = cur->next;
        }
    }
    head = dummyHead->next;
    delete dummyHead;
    return head;
}

设计链表（虚拟头结点）

cppCopy code
// 定义链表节点结构体
struct LinkedNode {
    int val;
    LinkedNode* next;
    LinkedNode(int val) : val(val), next(nullptr) {}
};

// 定义链表类
class MyLinkedList {
private:
    LinkedNode* _dummyHead;
    int _size;

public:
    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 定义虚拟头结点，不是真正的链表头结点
        _size = 0;
    }

    // 获取第index个节点的值，如果index非法则返回-1
    int get(int index) {
        if (index >= _size || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while (index--) {
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，成为新的头结点
    void addAtHead(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超过链表长度则返回空
    void addAtIndex(int index, int val) {
        if (index > _size) return;
        if (index < 0) index = 0;
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while (index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    // 删除第index个节点，index大于等于链表的长度则直接返回
    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;
        tmp = nullptr;
        _size--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead->next;
        while (cur != nullptr) {
            std::cout << cur->val << " ";
            cur = cur->next;
        }
        std::cout << std::endl;
    }
};

反转链表

链表反转只需要改变链表的next指针的指向，直接将链表反转。

  • 定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。
  • 开始遍历链表，将cur->next节点用tmp指针保存一下，然后将cur->next指向pre，再更新pre和cur的位置。
  • 最后返回pre节点即为反转后的头结点。
双指针法
 ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;
            cur = temp;
        }
        return pre;
    }
递归法
 ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }

两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

cppCopy code
ListNode* swapPairs(ListNode* head) {
    ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
    dummyHead->next = head;
    ListNode* cur = dummyHead;
    while (cur->next != nullptr && cur->next->next != nullptr) {
        ListNode* tmp = cur->next; // 记录临时节点
        ListNode* tmp1 = cur->next->next->next; // 记录临时节点

        cur->next = cur->next->next; // 步骤一
        cur->next->next = tmp; // 步骤二
        cur->next->next->next = tmp1; // 步骤三

        cur = cur->next->next; // cur移动两位，准备下一轮交换
    }
    return dummyHead->next;
}

删除链表的倒数第N个节点（快慢指针）

给定一个链表，删除链表的倒数第 n 个节点，并返回链表的头指针。

  • 使用双指针法，快指针（fast）先移动 n+1 步，然后慢指针（slow）开始移动。当快指针到达链表末尾时，慢指针正好指向要删除节点的前一个节点。
  • 删除节点操作，将慢指针指向的节点的next指针指向要删除节点的下一个节点。
cppCopy code
ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* dummyHead = new ListNode(0);
    dummyHead->next = head;
    ListNode* slow = dummyHead;
    ListNode* fast = dummyHead;
    while (n-- && fast != NULL) {
        fast = fast->next;
    }
    fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点
    while (fast != NULL) {
        fast = fast->next;
        slow = slow->next;
    }
    slow->next = slow->next->next;
    return dummyHead->next;
}

链表相交

给定两个单链表的头节点 headA 和 headB ，请你找出并返回两个链表相交的起始节点。如果两个链表没有交点，返回 null 。

  • 判断链表是否相交：使用双指针法，分别遍历两个链表，当一个链表遍历完后，切换到另一个链表继续遍历，直到两个指针相遇。如果相遇的节点不为空，则说明链表相交，返回相遇的节点；如果都遍历到末尾，且没有相遇，则说明链表不相交，返回 null。
cppCopy code
ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
    ListNode* curA = headA;
    ListNode* curB = headB;
    int lenA = 0, lenB = 0;

    // 计算链表A和链表B的长度
    while (curA != NULL) {
        lenA++;
        curA = curA->next;
    }
    while (curB != NULL) {
        lenB++;
        curB = curB->next;
    }

    curA = headA;
    curB = headB;
    // 让curA为最长链表的头，lenA为其长度
    if (lenB > lenA) {
        swap(lenA, lenB);
        swap(curA, curB);
    }

    // 求长度差
    int gap = lenA - lenB;
    // 让curA和curB在同一起点上（末尾位置对齐）
    while (gap--) {
        curA = curA->next;
    }

    // 遍历curA 和 curB，遇到相同则直接返回
    while (curA != NULL) {
        if (curA == curB) {
            return curA;
        }
        curA = curA->next;
        curB = curB->next;
    }

    return NULL;
}

环形链表II

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

  • 判断链表是否有环：使用快慢指针法，分别定义快指针 fast 和慢指针 slow，快指针每次移动两个节点，慢指针每次移动一个节点，如果 fast 和 slow 指针在途中相遇，则说明链表有环。
  • 如果链表有环，如何找到入环节点：设链表起点到入环点的距离为 a，入环点到快慢指针相遇点的距离为 b，相遇点再回到入环点的距离为 c。那么有 fast = 2 * slow 和 fast = slow + n * 环的长度。根据这两个公式，可以推导出 a = (n - 1) * 环的长度 + (环的长度 - c)。所以，当快慢指针相遇后，再用一个指针从链表起点出发，与慢指针一起前进，当它们相遇时，相遇点即为入环节点。
cppCopy code
ListNode* detectCycle(ListNode* head) {
    ListNode* fast = head;
    ListNode* slow = head;

    // 判断链表是否有环
    while (fast != NULL && fast->next != NULL) {
        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 NULL;
}
posted @ 2023-07-29 22:50  LucianaiB  阅读(9)  评论(0)    收藏  举报  来源