（✌）链表——练习题

已于 2024-06-28 20:49:53 修改
阅读量416 收藏 7
点赞数 5
分类专栏： 数据结构与算法 文章标签： 链表 数据结构
于 2023-12-27 00:09:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68915288/article/details/135233771
版权

🤞1. 反转链表

代码实现：

方法一：非递归 + 无虚拟头结点
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode *p = head;
    struct ListNode *pc = NULL;
    head = NULL;
    while (p) {
        pc = p;
        p = p->next;
        pc->next = NULL;
        if (head == NULL) { // 从无到有
            head = pc;
        } else { // 从少到多，头插
            pc->next = head;
            head = pc;
        }
    }
    return head;
}
方法二：非递归 + 虚拟头结点
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode *head) {
    struct ListNode *h = malloc(sizeof(*h));
    h->next = NULL;
    struct ListNode *p = head, *pc = NULL;
    while (p) {
        pc = p;
        p = p->next;
        pc->next = NULL;
        // 头插
        pc->next = h->next;
        h->next = pc;
    }
    return h->next;
}
方法三：递归
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    // 记录当前节点（头结点）的下一个节点，就是反转以后的尾节点
    struct ListNode *tail = head->next;
    struct ListNode *new_head = reverseList(head->next);
    head->next = tail->next;
    tail->next = head;
    return new_head;
}

🤞2. 反转链表 ||

代码实现：

方法一：递归——>难点
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseBetween(struct ListNode *head, int left, int right) {
    if (left == 1 && right == 1) {
        return head;
    }
    if (left != 1) {
        head->next = reverseBetween(head->next, left - 1, right - 1);
    } else {
        struct ListNode *tail = head->next;
        struct ListNode *new_head = reverseBetween(head->next, left, right - 1);
        head->next = tail->next;
        tail->next = head;
        head = new_head;
    }
    return head;
}
方法二：反转链表（递归） + 虚拟头结点
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

// 反转链表
void reverse(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    struct ListNode *tail = head->next;
    reverse(head->next);
    head->next = tail->next;
    tail->next = head;
}

struct ListNode* reverseBetween(struct ListNode *head, int left, int right) {
    if (left == right) {
        return head;
    }
    struct ListNode *h = malloc(sizeof(*h)); // 虚拟头节点
    h->next = head;
    struct ListNode *pp = h; // 遍历指针
    struct ListNode *p1 = NULL, *p2 = NULL, *p3 = NULL, *p4 = NULL;
    int i = 0;
    while (pp) {
        if (i == left - 1) {
            p1 = pp;
        }
        if (i == left) {
            p2 = pp;
        }
        if (i == right) {
            p3 = pp;
        }
        if (i == right + 1) {
            p4 = pp;
        }
        if (p1 && p2 && p3 && p4) { // 都找到了，跳出循环
            break;
        }
        i++;
        pp = pp->next;
    }
    p3->next = NULL;
    reverse(p2);
    p1->next = p3;
    p2->next = p4;
    return h->next;
}
方法三：非递归 + 虚拟头结点
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

// 反转链表
struct ListNode* reverseList(struct ListNode *head, struct ListNode **tail) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode *p = head;
    struct ListNode *pc = NULL;
    *tail = head;
    head = NULL;
    while (p) {
        pc = p;
        p = p->next;
        pc->next = NULL;
        if (head == NULL) {
            head = pc;
        } else { // 头插
            pc->next = head;
            head = pc;
        }
    }
    return head;
}

struct ListNode* reverseBetween(struct ListNode *head, int left, int right) {
    if (left == right) {
        return head;
    }
    struct ListNode *h = malloc(sizeof(*h)); // 虚拟头节点
    h->next = head;
    struct ListNode *pp = h; // 遍历指针
    struct ListNode *p1 = NULL, *p2 = NULL, *p3 = NULL, *p4 = NULL;
    int i = 0;
    while (pp) {
        if (i == left - 1) {
            p1 = pp;
        }
        if (i == left) {
            p2 = pp;
        }
        if (i == right) {
            p3 = pp;
        }
        if (i == right + 1) {
            p4 = pp;
        }
        if (p1 && p2 && p3 && p4) { // 都找到了，跳出循环
            break;
        }
        i++;
        pp = pp->next;
    }
    p3->next = NULL;
    p2 = reverseList(p2, &p3);
    p1->next = p2;
    p3->next = p4;
    return h->next;
}

🤞3. 环形链表

代码实现：

快慢指针

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
bool hasCycle(struct ListNode *head) {
    // 快慢指针：快指针每次走两步，慢指针每次走一步，二者若重合则链表中有环，否则无环
    struct ListNode *slow = head, *fast = head;
    while (fast && fast->next) {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow) {
            return true;
        }
    }
    return false;
}

🤞4. 两数相加

代码实现：

方法一：逐位相加，模拟进位

设置虚拟头结点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* addTwoNumbers(struct ListNode *l1, struct ListNode *l2) {
    struct ListNode *head = (struct ListNode*)malloc(sizeof(struct ListNode)); // 虚拟头结点
    struct ListNode *tail = head;
    int carry = 0;
    while (l1 || l2 || carry) {
        int a = l1 ? l1->val : 0;
        int b = l2 ? l2->val : 0;
        int sum = a + b + carry;
        carry = sum / 10;
        // 创建一个新结点
        struct ListNode *p = (struct ListNode*)malloc(sizeof(struct ListNode));
        p->val = sum % 10;
        p->next = NULL;
        // 尾插
        tail->next = p;
        tail = p;
        // 指针往后走
        if (l1) {
            l1 = l1->next;
        }
        if (l2) {
            l2 = l2->next;
        }
    }
    return head->next;
}
方法二：不设置虚拟头结点
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* addTwoNumbers(struct ListNode *l1, struct ListNode *l2) {
    int flag = 0; // 标志进位
    struct ListNode *h = NULL; // 返回头结点
    struct ListNode *tail = NULL; // 指向尾结点
    while (l1 || l2 || flag) {
        int sum = 0;
        if (l1) {
            sum += l1->val;
            l1 = l1->next;
        }
        if (l2) {
            sum += l2->val;
            l2 = l2->next;
        }
        sum += flag;
        struct ListNode *p = malloc(sizeof(*p));
        p->next = NULL;
        p->val = sum % 10;
        flag = sum / 10; // 进位
        if (h == NULL) { // 从无到有
            h = p;
            tail = p;
        } else { // 从少到多，尾插 
            tail->next = p;
            tail = p;
        }
    }
    return h;
}
方法三：递归
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
int c = 0;
struct ListNode* addTwoNumbers(struct ListNode *l1, struct ListNode *l2) {
    if (l1 == NULL && l2 == NULL && c == 0) { // 边界条件
        return NULL;
    }
    if (l1) {
        c += l1->val;
        l1 = l1->next;
    }
    if (l2) {
        c += l2->val;
        l2 = l2->next;
    }
    struct ListNode *p = (struct ListNode*)malloc(sizeof(struct ListNode));
    p->val = c % 10;
    c /= 10;
    p->next = addTwoNumbers(l1, l2);
    return p;
}

🤞5. 两数相加 ||

代码实现：

方法一：反转链表
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
// 反转链表
struct ListNode* reverseList(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode *tail = head->next;
    struct ListNode *new_head = reverseList(head->next);
    head->next = tail->next;
    tail->next = head;
    return new_head;
}

// 两数相加
int c = 0;
struct ListNode* func(struct ListNode *l1, struct ListNode *l2) {
    if (l1 == NULL && l2 == NULL && c == 0) { // 边界条件
        return NULL;
    }
    l1 = l1 != NULL ? (c += l1->val, l1->next) : l1;
    l2 = l2 != NULL ? (c += l2->val, l2->next) : l2;
    struct ListNode *p = (struct ListNode*)malloc(sizeof(struct ListNode));
    p->val = c % 10;
    c /= 10;
    p->next = func(l1, l2);
    return p;
}

struct ListNode* addTwoNumbers(struct ListNode *l1, struct ListNode *l2){
    if (l1 == NULL || l2 == NULL) {
        return l1 ? l1 : l2;
    }
    // 反转l1
    l1 = reverseList(l1);
    // 反转l2
    l2 = reverseList(l2);
    struct ListNode *p = func(l1, l2); // 两数相加
    // 反转p
    p = reverseList(p);
    return p;
}
方法二：栈
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

struct ListNode* addTwoNumbers(struct ListNode *l1, struct ListNode *l2) {
    int stack1[100];
    int top1 = -1;
    int stack2[100];
    int top2 = -1;
    // l1进栈
    while (l1) {
        stack1[++top1] = l1->val;
        l1 = l1->next;
    }
    // l2进栈
    while (l2) {
        stack2[++top2] = l2->val;
        l2 = l2->next;
    }
    int c = 0;
    struct ListNode *head = malloc(sizeof(*head));
    head->next = NULL;
    while (top1 != -1 || top2 != -1 || c) {
        int a = top1 == -1 ? 0 : stack1[top1--];
        int b = top2 == -1 ? 0 : stack2[top2--];
        int cur = a + b + c;
        c = cur / 10;
        cur %= 10;
        struct ListNode *p = malloc(sizeof(*p));
        p->val = cur;
        // 头插
        p->next = head->next;
        head->next = p;
    }
    return head->next;
}

🤞6. 删除排序链表中的重复元素

代码实现：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* deleteDuplicates(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode *p = head->next; // 遍历指针
    struct ListNode *pre = head; // 遍历指针的前驱节点
    struct ListNode *pc = NULL;
    while (p) {
        if (pre->val == p->val) {
            pc = p;
            pre->next = p->next;
            p = p->next;
            pc->next = NULL;
            free(pc);
        } else {
            pre = p;
            p = p->next;
        }
    }
    return head;
}

🤞7. 删除排序链表中的重复元素 ||

代码实现：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* deleteDuplicates(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode *h = malloc(sizeof(*h)); // 创建虚拟头结点
    h->next = head;
    struct ListNode *pre = h;
    struct ListNode *p = head, *p_next = head->next, *pc = NULL;
    while (p_next) {
        if (p->val != p_next->val) {
            pre = p;
            p = p->next;
            p_next = p_next->next;
        } else {
            while (p_next && p->val == p_next->val) {
                p_next = p_next->next;
            }
            pre->next = p_next;
            while (p != p_next) {
                pc = p;
                p = p->next;
                pc->next = NULL;
                free(pc);
            }
            if (p_next) {
                p_next = p_next->next;
            }
        }
    }
    return h->next;
}

🤞8. 奇偶链表

代码实现：

分离节点后合并

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* oddEvenList(struct ListNode *head) {
    if (head == NULL) {
        return head;
    }
    struct ListNode *h = head->next;
    struct ListNode *p1 = head;
    struct ListNode *p2 = head->next;
    while (p2 != NULL && p2->next != NULL) {
        p1->next = p2->next;
        p1 = p1->next;
        p2->next = p1->next;
        p2 = p2->next;
    }
    p1->next = h;
    return head;
}

🤞9. 两两交换链表中的节点

代码实现：

方法一：(设置虚拟头结点) 非递归
struct ListNode* swapPairs(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }

    struct ListNode *h = (struct ListNode*)malloc(sizeof(struct ListNode));
    h->next = head;
    struct ListNode *now = h;
    while (now->next && now->next->next) {
        struct ListNode *l = now->next, *r = now->next->next;
        now->next = r;
        l->next = r->next;
        r->next = l;
        now = l;
    }
    return h->next;
}
方法二：(不设置虚拟头结点) 非递归
struct ListNode* swapPairs(struct ListNode *head) {
    // 若节点小于2个，直接返回
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode *first = head;
    struct ListNode *second = head->next;
    // 至少交换一次，返回新头节点指向原head的第二个节点
    struct ListNode *newHead = second;
    struct ListNode *tail = NULL; // 指向每次交换的尾，用于指向以后交换的头

    while (first && second) {
        if (tail == NULL) {
            tail = first;
        } else {
            tail->next = second;
            tail = first;
        }
        first->next = second->next;
        second->next = first;
        first = first->next;
        if (first) {
            second = first->next;
        }
    }
    return newHead;
}
方法三：递归
struct ListNode* swapPairs(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode *first = head;
    struct ListNode *second = head->next;
    head = second;
    first->next = second->next;
    second->next = first;
    first->next = swapPairs(first->next);
    return head;
}

🤞10. 删除链表的倒数第N个节点

代码实现：

方法一：双指针法
struct ListNode* removeNthFromEnd(struct ListNode *head, int n) {
    struct ListNode *h = (struct ListNode*)malloc(sizeof(struct ListNode)); // 虚拟头结点
    h->next = head;
    struct ListNode *slow = h, *fast = head;
    while (n--) {
        fast = fast->next;
    }
    while (fast) { // 让慢指针移到倒数第n个结点的前一个结点
        slow = slow->next;
        fast = fast->next;
    }
    struct ListNode *temp = slow->next;
    slow->next = temp->next;
    temp->next = NULL;
    free(temp);
    return h->next;
}
方法二：常规解法
struct ListNode* removeNthFromEnd(struct ListNode *head, int n) {
    struct ListNode *h = malloc(sizeof(*h)); // 虚拟头结点
    h->next = head;
    struct ListNode *p = head; // 遍历指针
    int len = 0; 
    while (p) { // 统计链表结点长度
        p = p->next;
        len++;
    }
    int i = len - n;
    p = h;
    while (i--) {
        p = p->next; // 让p指向倒数第n个结点的前一个结点
    }
    struct ListNode *pc = p->next;
    p->next = pc->next;
    pc->next = NULL;
    free(pc);
    return h->next;
}

🤞11. 环形链表 ||

代码实现：

使用一个数组来存储已经访问过的节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return NULL;
    }
    struct ListNode *slow = head;
    struct ListNode *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) {
            break;
        }
    }
    if (slow != fast) {
        return NULL;
    }

    struct ListNode *arr[10000];
    int arrSize = 0;
    arr[arrSize++] = head;
    struct ListNode *p = head->next;
    while (p) {
        for (int i = 0; i < arrSize; i++) {
            if (arr[i] == p) {
               return p;
            }
        }
        arr[arrSize++] = p;
        p = p->next;
    }
    return NULL;
}

🤞12. 相交链表

代码实现：

暴力法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode *l1 = headA;
    while (l1) {
        struct ListNode *l2 = headB;
        while (l2) {
            if (l1 == l2) {
                return l1;
            }
            l2 = l2->next;
        }
        l1 = l1->next;
    }
    return NULL;
}

13. 设计链表

代码实现：

🤞14. 从链表中移除节点

代码实现：

方法一：从前往后遍历 —> 超时（时间复杂度：O(n^2)
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeNodes(struct ListNode *head) {
    struct ListNode *h = malloc(sizeof(struct ListNode)); // 虚拟头节点
    h->next = head;
    struct ListNode *p = head; // 遍历指针
    struct ListNode *pre = h; // 遍历指针的前驱节点
    struct ListNode *pp = NULL; // 寻找p右侧是否有比p大的节点
    while (p) {
        pp = p->next;
        while (pp) {
            if (pp->val > p->val) {
                break;
            }
            pp = pp->next;
        }
        if (pp == NULL) { // 没有找到p右侧比p大的节点
            pre = p;
            p = p->next;
        }
        if (pp != NULL) { // 找到了
            // 移除p
            pre->next = p->next;
            p->next = NULL;
            free(p);
            p = pre->next;
        }
    }
    return h->next;
}
方法二：反转链表，如果当前节点值小于前一个节点的值，则移除，最后再反转链表 时间复杂度：O(n)
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

struct ListNode* reverse(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode *tail = head->next;
    struct ListNode *new_head = reverse(head->next);
    head->next = tail->next;
    tail->next = head;
    return new_head;
}

struct ListNode* removeNodes(struct ListNode *head) {
    // 反转链表
    head = reverse(head);
    struct ListNode *pre = head;
    struct ListNode *p = head->next;
    while (p) {
        if (p->val < pre->val) { // 移除
            pre->next = p->next;
            p->next = NULL;
            free(p);
            p = pre->next;
        } else {
            pre = p;
            p = p->next;
        }
    }
    // 反转链表
    head = reverse(head);
    return head;
}
方法三：递归  时间复杂度：O(n)
  • 该节点为空，那么递归函数返回空指针
  • 该节点不为空，那么先对它的右侧节点进行移除操作，得到一个新的子链表，如果子链表的表头节点值大于该节点的值，那么移除该节点，否则将该节点作为子链表的表头节点，最后返回该子链表
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeNodes(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    head->next = removeNodes(head->next);
    if (head->next->val > head->val) {
        return head->next;
    } else {
        return head;
    }
}

🤞15. 合并两个有序链表

代码实现：

方法一：递归
struct ListNode* mergeTwoLists(struct ListNode *list1, struct ListNode *list2) {
    if (list1 == NULL) {
        return list2;
    } else if (list2 == NULL) { 
        return list1;
    } else if (list1->val < list2->val) {
        list1->next = mergeTwoLists(list1->next, list2);
        return list1;
    } else {
        list2->next = mergeTwoLists(list1, list2->next);
        return list2;
    }
}
方法二：常规解法 + 设置虚拟头结点
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode *list1, struct ListNode *list2) {
    if (list1 == NULL) {
        return list2;
    }
    if (list2 == NULL) {
        return list1;
    }
    struct ListNode *head = malloc(sizeof(*head)); // 设置虚拟头结点
    struct ListNode *tail = head; // 尾指针
    while (list1 && list2) {
        if (list1->val < list2->val) {
            tail->next = list1;
            list1 = list1->next;
        } else {
            tail->next = list2;
            list2 = list2->next;
        }
        tail = tail->next;
        tail->next = NULL;
    }
    if (list1) {
        tail->next = list1;
    }
    if (list2) {
        tail->next = list2;
    }
    struct ListNode *result = head->next;
    head->next = NULL;
    free(head);
    return result;    
}
方法三：常规解法 + 不设置虚拟头结点
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
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; // 尾
    while (list1 && list2) {
        if (list1->val < list2->val) {
            if (head == NULL) { // 从无到有
                head = list1;
                tail = list1;
                list1 = list1->next;
            } else { // 从少到多
                tail->next = list1;
                list1 = list1->next;
                tail = tail->next;
                tail->next = NULL;
            }
        } else {
            if (head == NULL) { // 从无到有
                head = list2;
                tail = list2;
                list2 = list2->next;
            } else { // 从少到多
                tail->next = list2;
                list2 = list2->next;
                tail = tail->next;
                tail->next = NULL;
            }
        }
    }
    if (list1) {
        tail->next = list1;
    }
    if (list2) {
        tail->next = list2;
    }
    return head;    
}

🤞16. 快乐数

代码实现：

快慢指针

int getNext(int x) {
    int sum = 0;
    while (x) {
        int bit = x % 10;
        sum += bit * bit;
        x = x / 10;
    }
    return sum;
}

// 快慢指针
bool isHappy(int n) {
    int slow = n, fast = n;

    // slow = getNext(slow);
    // fast = getNext(getNext(fast));
    // while (slow != fast && fast != 1) {
    //     slow = getNext(slow);
    //     fast = getNext(getNext(fast));
    // }

    do {
        slow = getNext(slow);
        fast = getNext(getNext(fast));
    } while (slow != fast && fast != 1);
    return fast == 1;
}

🤞17. 旋转链表

代码实现：

 方法一：在原链表中找到旋转之后的首尾，改变指向
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* rotateRight(struct ListNode *head, int k) {
    if (k == 0 || head == NULL || head->next == NULL) {
        return head;
    }
    int n = 1; // 统计链表节点数量
    struct ListNode *p = head;
    while (p->next != NULL) { // 循环使p指向尾
        p = p->next;
        n++;
    }
    int add = n - k % n;
    if (add == n) {
        return head;
    }
    p->next = head; // 将尾连接头
    while (add--) { // 让p指向最终移动后的尾
        p = p->next;
    }
    struct ListNode *ret = p->next; // ret指向最终移动后的头
    p->next = NULL;
    return ret;
}
方法二：反转链表
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
// 反转链表
struct ListNode* reverse(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode *tail = head->next;
    struct ListNode *new_head = reverse(head->next);
    head->next = tail->next;
    tail->next = head;
    return new_head;
}

struct ListNode* rotateRight(struct ListNode *head, int k) {
    if (head == NULL || head->next == NULL || k == 0) {
        return head;
    }
    int len = 0; // 统计链表结点个数
    struct ListNode *p = head;
    while (p) {
        len++;
        p = p->next;
    }
    int n = k % len;
    if (n == 0) { // 向右移动 n 个位置
        return head;
    }
    // 翻转整个链表
    head = reverse(head);

    struct ListNode *p1 = head, *p2; // p1指向前段待翻转区间的尾  p2指向后段待翻转区间的头 
    while (n - 1) {
        p1 = p1->next;
        n--;
    }
    p2 = p1->next; // p2指向后段待翻转区间的头 
    p1->next = NULL;
    // 翻转前段区间，head变尾，p1变头
    reverse(head);
    // 翻转后段区间，将头赋值给p2
    p2 = reverse(p2);
    head->next = p2;
    return p1;
}

🤞18. K 个一组翻转链表

代码实现：

方法一：递归
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
void reverse(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    struct ListNode *tail = head->next;
    reverse(head->next);
    head->next = tail->next;
    tail->next = head;
}

struct ListNode* reverseKGroup(struct ListNode *head, int k) {
    if (head == NULL || head->next == NULL || k == 1) {
        return head;
    } 
    // 判断剩下的节点数量是否足够
    int n = 0;
    struct ListNode *p = head; // 遍历指针，指向第k+1个
    struct ListNode *pre = NULL; // 遍历指针前驱节点，指向第k个节点
    while (p) {
        pre = p;
        p = p->next;
        n++;
        if (n == k) {
            break;
        }
    }
    if (n != k) { // 后面没有k个节点，直接返回head
        return head;
    }

    pre->next = NULL;
    // 翻转, head变尾，pre变头
    reverse(head);
    head->next = p;

    head->next = reverseKGroup(p, k);
    return pre;
}
方法二：迭代—模拟
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
void reverse(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    struct ListNode *tail = head->next;
    reverse(head->next);
    head->next = tail->next;
    tail->next = head;
}

struct ListNode* reverseKGroup(struct ListNode *head, int k) {
    struct ListNode *new_haed = malloc(sizeof(struct ListNode)); // 虚拟头节点
    new_haed->next = head;
    struct ListNode *h = new_haed; // h:指向每次翻转之后的尾节点，用于连接下次翻转的头节点
    struct ListNode *p = head; // p:遍历指针，指向第k+1个节点,每次要翻转区间的头
    struct ListNode *pre = NULL; // pre：遍历指针的前驱节点，指向第k个节点，每次要翻转的尾
    while (1) {
        int n = 0;
        while (p) {
            pre = p;
            p = p->next;
            n++;
            if (n == k) {
                break;
            }
        }
        if (n != k) {
            break;
        }
        pre->next = NULL;
        h->next = NULL;
        // 反转，head变尾，pre变头
        reverse(head);
        h->next = pre;
        head->next = p;

        h = head; // h指向每次翻转区间的尾
        head = p; // head：每次要翻转区间的头，用于翻转
    }   
    return new_haed->next;
}

嵌入式小聪
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【2025王道数据结构】王道数据结构课后代码题汇总答案C、C++代码实现完整版大全（可直接运行）
CSDN 精品推荐
04-25 1万+
下面内容是本人在复习王道数据结构的过程中, 对一些算法设计题目的全部实现（答案解析全部都是伪码或者函数的部分实现，不可调试运行），不一定是最优的, 但是都能保证端到端测试运行，本文会陆陆续续更新，个人水平有限，可能文章里面存在一些问题，还望各位多多指点。   加油，阿光！！！我看好你哦😋😋😋 以下摘自王道2023年数据结构考研复习指导题目 文章目录 😉第2章：线性表 ✌18页综合应用题 题号 题解链接 1 传送门 2 传送门 3 传送门 4 传送门 5 传送.
IT专业入门——高考假期预习指南，我来做你的引路人
2301_79796701的博客
07-01 1730
🏠认识IT知识体系👀什么是计算机按规模、速度和功能分按照其工作模式分类⚙硬件🌈操作系统🤗编程语言✌对学习语言的一点建议👊对于学python的一点看法⚡网络🐆数据结构与算法♦数据库🧠Web开发🥧Web前端💡Web后端🐅基础预习指南🦌技术路线学习一览学习资源推荐🖊刷题📕书籍推荐
数据结构——算法竞赛中熠熠生辉的两朵金花—“栈“和“队列“
weixin_52621323的博客
12-15 1478
一篇长文，亿点图片，详细演示，带你逐渐把栈和队列在程序设计大赛中的玩法弄明白呀~
一年半´力扣´练习生超详细总结（附数据结构+算法）
热门推荐
像写诗一样优雅地写代码~
07-01 3万+
一年半´力扣´练习生超详细总结（附数据结构+算法） 文章目录一年半´力扣´练习生超详细总结（附数据结构+算法）我与力扣数据结构算法未来计划其他专栏推荐 我与力扣 专栏导航：LeetCode☜欢迎订阅???? 如果你只想做一些经典的题目，方便以后面试或者作为经常练手的习题，非常推荐你刷《剑指offer》，大概100题左右，建议用多种方法求解，擅于总结和思考，总体来说这一本书就够用了。 下面附我《剑指offer》题解的链接：《剑指Offer》题解汇总索引表（leetcode） ???? 2020年4月17日
牛客练习赛114 解题报告 | 珂学家 | 贪心场 + 期望 + 线性基
2301_79125642的博客
08-26 346
本地常规场景很简单，只要将其中一个字符串的内容挨个去除即可，但若遇到字串1和字串2中间有重复的字母则会出现失败的可能，例如s:qwca x:acbd,t:qwa。社招，8月底面试，一面都没过，面试内容会根据简历来，我经历比较杂，当过财务和产品，大家看热闹就好，不用当成标准模版，给大家描述下我的面试问题1，你这边产品经理的。美团测评第一次没有发挥好，还可以报名第二次，鄙人已经报名了美团测评的时长不是从我们开始答题开始计算，而是邮件中写着的时间开始计算，家人们一定要准时点开测评链接美。
（OK）递归函数设计技巧
qq_68915288的博客
10-20 112
二：递归函数设计的三个重要部分。二：递归函数设计的三个重要部分。12. 二叉树的最近公共祖先。3. ✌递归实现指数型枚举。4. ✌递归实现组合型枚举。一：拿起武器：数学归纳法。10. 从链表中移除节点。8. 反转链表 ||
React源码揭秘(三)：Diff算法详解
奇舞周刊
05-25 1414
编者按：本文作者奇舞团前端开发工程师苏畅。代码参照React 16.13.1什么是Diff在前两篇文章中我们分别介绍了 React 的首屏渲染流程1和组件更新流程2，其中首屏渲染会渲染一...
25考研｜408择校避坑指南
m0_54088124的博客
02-05 1214
880的质量也是有口皆碑了，题目给我的感觉就是很能拓宽思路，但是不是像1000题那样的给了一个完全想不到的方向，而是把我原来的比较基础的思路再拔高一层。知能行官方建议说，等级二满格以后，可以用1800测试一下正确率看训练效果，我当时测了三大计算，极限，导数，积分，都是90%左右，其他的专题就没测了。660对于概念挖的很细，可以用来弥补定理和概念理解上的缺漏，880的质量公认的比较高，有一些题目会让脑子里有豁然开朗的清爽感，感觉很多不太明白的知识都点透了。他的好处是特别好上手，起码让我看到了学会数学的希望。
合合信息Embedding模型获得MTEB中文榜单第一
每天多一点干货
04-28 1309
想问问各位牛友，华为暑期实习学得到东西嘛，是不是只有一些特定的卷的部门写的代码量大、学的东西多我投的。md，实习找破防了，四月份就约到一个面试，好多做了笔试和测评就没消息了，三月份几个好机会，手撕没撕出。一个是北京某研究院，朝九晚六，做的工作类似于国企，50%项目统筹，50%代码。中建三局，宁德时代，科锐国际（计算机类），途游游戏，得物，蓝禾，顺丰，康冠科技24春招内推①得物【岗。#华为OD#目标院校毕业，目前是在职（第三年），之前OD机试通过（365），几轮面试也在上周都完成，4.2 一面邀请4.7。
数组和链表——精选推荐 数组和链表.pdf
04-18
"数组和链表" 数组和链表是两种常见的线性数据结构，它们都是由具有相同类型的n(n≥0)个数据元素组成的有限序列。下面我们将详细介绍数组和链表的基本组成部分、特点和Java实现。 一、数组 数组是最常用的线性...
特殊的链表——双向、循环、静态
01-20
双向链表 定义 ：每个节点有两个指针域，分别知道直接前驱和直接后继节点 ， 特点是可以重任意节点出发，从两个方向遍历链表 数据结构 typedef struct node { int data; struct node *font ; struct node *next; ...
链表——用C++模板实现 - Microsues的专栏 - 博客频道 - CSDN1
08-03
链表是一种基础且重要的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C++中，我们可以使用模板来创建通用的链表类，以适应不同类型的元素。以下是对给定文件中链表实现的详细说明： ...
Java算法练习-环形链表插值练习题
10-01
java学习
泛型链表——C语言实现
01-24
使用C语言实现的“泛型链表”，该链表为循环双链表，它的设计参考了C++的STL容器库中的容器list及泛型算法的接口，并使用迭代器来遍历链表。使用时只需要include头文件即可，隐藏了List类型的具体实现。用户并不需要...
数据结构--树和二叉树的一些知识点总结
最新发布
weixin_68489989的博客
07-09 300
数据结构--树和二叉树的一些知识点总结
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 235
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
Redis教程(二十三)：Redis的底层数据结构
十三月的博客
07-09 23
Redis是一种高性能的key-value数据库，广泛用于缓存、消息队列、应用程序会话管理等领域。它之所以能提供高效的数据操作性能，很大程度上归功于其底层使用了多种优化过的数据结构来存储数据。
数据结构第07节：队列
hummhumm的专栏
07-04 550
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
高阶-5 链表——统计节点个数 定义函数，遍历一个不带头结点的链表，统计链表上的节点个数
06-10
好的，根据您的要求，我理解您需要一个 C++ 函数，能够统计一个不带头结点的链表上的节点个数。那么，以下是一个示例代码： ```cpp int countNodes(ListNode* head) { int count = 0; ListNode* cur = head; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值