Leetcode 之链表问题（一）

最新推荐文章于 2025-11-25 12:02:55 发布

原创最新推荐文章于 2025-11-25 12:02:55 发布 · 1.2k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #leetcode #list

Leetcode 专栏收录该内容

287 篇文章

订阅专栏

本文介绍两种链表操作：一是合并K个已排序的链表并返回一个排序后的链表，讨论了其复杂度；二是每两个节点一组进行交换，提供了一种递归解决方案。

1. Merge k sorted lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

//Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
ListNode *merge2Lists(ListNode *head1, ListNode *head2){
        ListNode *head = new ListNode(INT_MIN);
        ListNode *pre = head;
        while(head1 != NULL && head2 != NULL){
            if(head1->val <= head2->val){
                pre->next = head1;
                head1 = head1->next;
            }else{
                pre->next = head2;
                head2 = head2->next;
            }
            pre = pre->next;
        }
        if(head1 != NULL){
            pre->next = head1;
        }
        if(head2 != NULL){
            pre->next = head2;
        }
        pre = head->next;
        delete head;
        return pre;
    }
ListNode *mergeKLists(vector<ListNode *> &lists) {
        if(lists.size() == 0) return NULL;
        ListNode *p = lists[0];
        for(int i=1; i<lists.size(); i++){
            p = merge2Lists(p, lists[i]);
        }
        return p;
    }

Swap Nodes in Pairs

Given a linked list, swap every two adjacent nodes and return its head.

For example,
Given 1->2->3->4, you should return the list as 2->1->4->3.

Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.

递归解法

ListNode *swapPairs(ListNode *head) {
       if(head == NULL || head->next == NULL)
        return head;
    ListNode *newPair = head->next->next;
    ListNode *newHead = head->next;
    head->next->next = head;
    head->next = swapPairs(newPair);
    return newHead; 
    }