链表分割

题目描述

编写代码,以给定值x为基准将链表分割成两部分,所有小于x的结点排在大于或等于x的结点之前

给定一个链表的头指针 ListNode* pHead,请返回重新排列后的链表的头指针。注意:分割以后保持原来的数据顺序不变。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        // write code here
        if(!pHead || !pHead->next)
            return pHead;

        ListNode* littleBegin = new ListNode(-1);
        ListNode* bigBegin = new ListNode(-1);
        ListNode* little = littleBegin;
        ListNode* big = bigBegin;

        ListNode* pWork = pHead;
        while(pWork){
            if(pWork->val < x){
                little->next = pWork;
                little = little->next;
            }else{
                big->next = pWork;
                big = big->next;
            }
            pWork = pWork->next;
        }

           little->next = bigBegin->next;
        big->next = nullptr;
        return littleBegin->next;

    }
};//思路为建立两个链表little中存放比x小的元素,big中存放比x大的元素。//之后合并little和big两个链表。
时间: 2024-12-06 20:09:54

链表分割的相关文章

8.链表分割

题目描述 编写代码,以给定值x为基准将链表分割成两部分,所有小于x的结点排在大于或等于x的结点之前 给定一个链表的头指针 ListNode* pHead,请返回重新排列后的链表的头指针.注意:分割以后保持原来的数据顺序不变. 代码如下: import java.util.*; /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public clas

链表:链表分割

题目描述 编写代码,以给定值x为基准将链表分割成两部分,所有小于x的结点排在大于或等于x的结点之前 给定一个链表的头指针 ListNode* pHead,请返回重新排列后的链表的头指针.注意:分割以后保持原来的数据顺序不变. import java.util.*; /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Part

LeetCode OJ:Partition List(分割链表)

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

链表 2.4

编写代码,以给定值x为基准将链表分割成两部分,所有小于x的结点排在大于或者等于x的结点之前. 分析:使用两个链表,若当前结点小于x,则将其插入第一个链表的尾部:否则,将其插入第二个链表的尾部.最后,将两个链表拼接即可. 1 //struct Node { 2 // Node(): val(0), next(0) {} 3 // Node( int value ): val(value), next(0) {} 4 // int val; 5 // Node *next; 6 //}; 7 8 N

【转】链表归并排序插入排序

链表插入排序.链表归并排序 1.链表 1.1链表的存储表示 1 2 3 4 5 6 7 //链表的存储表示 typedef int ElemType; typedef struct LNode {     ElemType data;     struct LNode *next; }LNode, *LinkList; 1.2基本操作 创建链表: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

单向链表反转算法——递归版和迭代版

最近在做笔试题时,遇到一道编程题:单向链表反转算法.一时紧张,没写出来就提前交卷了,然而交完卷就想出来了... 最初想出来的是递归版,遗憾的是没能做到尾递归,后来又琢磨出了迭代版.后来用实际编译运行测试了一遍,能正常运行. 递归版的灵感来源于<Haskell 趣学指南>中非常简洁的快速排序算法的实现,其思想是将单向链表分割头部和尾部.其中头部指是链表的第一个节点,尾部是指除去第一个节点后的子链表.通过递归的方法,将子链表继续分割成头部和尾部,直至尾部指剩下一个节点,无法继续分割,然后将头部和尾

List链表模板类的简单实现(部分方法递归操作)

善哉. 此篇博客,旨在剖析下操作单链表时的递归思想.望各位施主笑纳. 1. 递归删除结点 * 空链表 - 直接返回 * 非空,若未找到待删除元素,递归.若找到,删除节点,返回尾链头 * 回溯,衔接形成新链 1 _Node* myErase_R(const Object& elem, _Node* curr){ 2 //空链 或 无此元素 3 if (curr == NULL) return NULL; 4 5 if (curr->elem == elem){ 6 _Node* tmp = c

单链表排序(插入与归并)

struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; /* * 单链表的插入排序, 插入排序是一种稳定排序 */ class Solution7 { public: ListNode* insertionSortList(ListNode* head) { if(head == NULL || head->next == NULL) return head; ListNode *

链表插入排序、链表归并排序

1.链表 1.1链表的存储表示 //链表的存储表示 typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode, *LinkList; 1.2基本操作 创建链表: /* * 创建链表. * 形参num为链表的长度,函数返回链表的头指针. */ LinkList CreatLink(int num) { int i, data; //p指向当前链表中最后一个结点,q指向准备插入的结点.