国际空间研究组织 | ISRO CS 2009 | 问题 4

问题描述

将一个链表按给定值x分成两部分，小于x的节点在前，大于等于x的节点在后，两部分节点的相对位置不能改变。

给定一个链表的头指针 ListNode* pHead，请返回重新排列后的链表的头指针。

注意：分割以后保持原来的数据顺序不变。

代码实现

C++代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* pHead, int x) {
        if(!pHead) return NULL;
        ListNode *p1 = new ListNode(-1);//新建两个链表，一个存储小于x的节点，一个存储大于等于x的节点
        ListNode *p2 = new ListNode(-1);
        ListNode *pCurr1 = p1;//pCurr1指向小于x的链表的当前位置
        ListNode *pCurr2 = p2;//pCurr2指向大于等于x的链表的当前位置
        ListNode *pCurr = pHead;//pCurr指向待分割链表的当前位置
        while(pCurr){
            if(pCurr->val < x){
                pCurr1->next = pCurr;
                pCurr1 = pCurr1->next;
            }else{
                pCurr2->next = pCurr;
                pCurr2 = pCurr2->next;
            }
            pCurr = pCurr->next;
        }
        pCurr2->next = NULL;//注意将大于等于x的链表的最后一个节点指向NULL
        pCurr1->next = p2->next;//将小于x的链表的末尾节点指向大于等于x的链表的头节点
        return p1->next;//返回小于x的链表的头节点
    }
};

Python代码

#Definition for singly-linked list.
#class ListNode(object):
#    def __init__(self, x):
#        self.val = x
#        self.next = None

class Solution(object):
    def partition(self, head, x):
        """
        :type head: ListNode
        :type x: int
        :rtype: ListNode
        """
        if not head:
            return None
        p1 = ListNode(-1)#新建两个链表，一个存储小于x的节点，一个存储大于等于x的节点
        p2 = ListNode(-1)
        pCurr1 = p1#pCurr1指向小于x的链表的当前位置
        pCurr2 = p2#pCurr2指向大于等于x的链表的当前位置
        pCurr = head#pCurr指向待分割链表的当前位置
        while pCurr:
            if pCurr.val < x:
                pCurr1.next = pCurr
                pCurr1 = pCurr1.next
            else:
                pCurr2.next = pCurr
                pCurr2 = pCurr2.next
            pCurr = pCurr.next
        pCurr2.next = None#注意将大于等于x的链表的最后一个节点指向NULL
        pCurr1.next = p2.next#将小于x的链表的末尾节点指向大于等于x的链表的头节点
        return p1.next#返回小于x的链表的头节点

Java代码

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode partition(ListNode head, int x) {
        if(head == null) return null;
        ListNode p1 = new ListNode(-1);//新建两个链表，一个存储小于x的节点，一个存储大于等于x的节点
        ListNode p2 = new ListNode(-1);
        ListNode pCurr1 = p1;//pCurr1指向小于x的链表的当前位置
        ListNode pCurr2 = p2;//pCurr2指向大于等于x的链表的当前位置
        ListNode pCurr = head;//pCurr指向待分割链表的当前位置
        while(pCurr != null){
            if(pCurr.val < x){
                pCurr1.next = pCurr;
                pCurr1 = pCurr1.next;
            }else{
                pCurr2.next = pCurr;
                pCurr2 = pCurr2.next;
            }
            pCurr = pCurr.next;
        }
        pCurr2.next = null;//注意将大于等于x的链表的最后一个节点指向NULL
        pCurr1.next = p2.next;//将小于x的链表的末尾节点指向大于等于x的链表的头节点
        return p1.next;//返回小于x的链表的头节点
    }
}

复杂度分析

• 时间复杂度：O(n)，其中n为链表的长度，遍历一遍链表即可完成链表的分割。
• 空间复杂度：O(1)，除去输入输出的空间，我们只需要额外创建两个ListNode类型的指针，所以空间复杂度是O(1)。