[C++]LeetCode: 19 Partition List

最新推荐文章于 2022-04-20 20:28:42 发布

Cindy_niu

最新推荐文章于 2022-04-20 20:28:42 发布

阅读量512

点赞数

分类专栏： LeetCode 文章标签： Two Pointes Linked List

本文链接：https://blog.csdn.net/cinderella_niu/article/details/41209845

版权

LeetCode 专栏收录该内容

132 篇文章 1 订阅

订阅专栏

题目：

Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

For example,
Given 1->4->3->2->5->2 and x = 3,
return 1->2->2->4->3->5.

方法一：建立两个链表（简洁清晰）

思路：改变链表顺序，先返回小于x的节点，之后链接大于等于x的节点，同时不能改变节点间的相对前后关系.链表可以用哨兵的思想，建立链接关系。(建立两个链表，然后最后链接到一起)

Attention:关键是要先建立两个虚拟头结点，保存链表的头结点信息。

算法复杂度：O(n)
AC Code:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *partition(ListNode *head, int x) {
        //改变链表顺序，先返回小于x的节点，之后链接大于等于x的节点，同时不能改变节点间的相对前后关系。
        //思路：链表可以用哨兵的思想，建立链接关系。关键是要先建立两个虚拟头结点，保存链表的头结点信息。
              
        if(head == NULL || head->next == NULL)
            return head;
        
        ListNode* lefthead = new ListNode(0);
        ListNode* righthead = new ListNode(0);
        ListNode* leftlist = lefthead;
        ListNode* rightlist = righthead;
        ListNode* ret = head;
        
        while(head)
        {
            if(head->val < x)
            {
                leftlist->next = head;
                leftlist = leftlist->next;
            }
            else
            {
                rightlist->next = head;
                rightlist = rightlist->next;
            }
            
            head = head->next;
        }
        
        leftlist->next = righthead->next;
        rightlist->next = 0;
        ret = lefthead->next;
        delete lefthead;
        delete righthead;
        return ret;
           
        
    }
};

方法二：双指针的方法（拓宽思路，熟悉双指针的方法）

思路：一次遍历，遇小前叉，关键是要维护一个指向要插入位置的node*

AC Code:

class Solution {
public:
    ListNode *partition(ListNode *head, int x) {
        ListNode* hair = new ListNode(0);
        hair->next = head;
        ListNode* insertPoint = hair; //insert after this pointer
        ListNode* last = hair;
        while(head){
            if(head->val < x){
                if(insertPoint->next != head){//要是没有这句，如果第一个就比x小，会先delete再insert回原样
                    //backup 
                    ListNode* nextNode = head->next;

                    //do delete , last不用动
                    last->next = head->next;

                    //do insert
                    ListNode* temp = insertPoint->next;
                    insertPoint->next = head;
                    head->next = temp;

                    //update head
                    insertPoint = head;
                    head = nextNode; 
                    //last不用动

                }else{ //insertPoint->next == head
                    //update insert point
                    insertPoint = head;
                    head = head->next;
                    last = last->next;
                }
            }else{
                head = head->next;  //head 一定比insertPoint跑的远，因为本身就起点靠前，跑的又快
                last = last->next;
            }

        }
        return hair->next;
    }
};