链表划分

题目：

给定一个单链表和数值x，划分链表使得所有小于x的节点排在大于等于x的节点之前。

你应该保留两部分内链表节点原有的相对顺序。

您在真实的面试中是否遇到过这个题？ 

Yes

样例

给定链表 1->4->3->2->5->2->null，并且 x=3

返回 1->2->2->4->3->5->null

思路：

一开始先申请一个结点help和work，run，令help等于他们，然后run开始迭代，判断run->next的值和x的大小，比x小的，令run->next->next=work->next，再让work指向run->next，再令work=work->next，work=work->next，这是为了照顾开始的情况，如果比x大，直接run=run->next,如果wok=run的话，直到run->next=null，结束，返回help->next即可。

代码：

/**
 * Definition of ListNode
 * class ListNode {
 * public:
 *     int val;
 *     ListNode *next;
 *     ListNode(int val) {
 *         this->val = val;
 *         this->next = NULL;
 *     }
 * }
 */
class Solution {
public:
    /**
     * @param head: The first node of linked list.
     * @param x: an integer
     * @return: a ListNode 
     */
    ListNode *partition(ListNode *head, int x) {
        // write your code here
        ListNode *help=new ListNode;
        ListNode *work=help;
        ListNode *run=help;
        help->next=head;
        while(run->next!=NULL)
        {  if(run->next->val<x)
            { if(work!=run)
               { ListNode *T=run->next->next;
                 run->next->next=work->next;
                 work->next=run->next;
                 work=work->next;
               }
               else run=run->next;
               work=work->next;
            }
            else run=run->next;
        }
        return help->next;
    }
            
        /*if(head==NULL)//又爆内存！！！！①
            return NULL;
        ListNode *l=new ListNode;
        ListNode *dummy=head;
        ListNode *dummy1=l;
        if(head->val<x) 
          {l->next=head;
           l=l->next;
          }
        while(head->next!=NULL)
        {if(head->next->val<x)
           {ListNode *T=head->next;
           head->next=T->next;
           l->next=T;
           l=l->next;
           
           //delete T;
           }
          else head=head->next;
        }
        l->next=dummy;
        return  dummy1->next;
    }*/
        /*if(head==NULL)
           return NULL;
        ListNode *right=new ListNode;
        ListNode *lift=new ListNode;
        ListNode *dummy1=right;
        ListNode *dummy2=lift;//爆内存呀②
        while(head!=NULL)
        { if(head->val<x)
             { right->next=head;
             right=right->next;
             }
          else {lift->next=head;lift=lift->next;}
          head=head->next;
        }
        right->next=dummy2->next;
        return dummy1->next;
    }*/
    /*if(head==NULL)//又超时！③
        return NULL;
    if(head->next==NULL)
        return head;
    if(head->val<x)
    {  ListNode *dummy=head;
       while(head->next!=NULL)
       {if(head->next->val>=x) break;
        head=head->next;
       }
       ListNode *p=head->next;
       while(p!=NULL)
       {if(p->val<x)
         { ListNode *T=head->next;
           ListNode *Q=p;
           head->next=Q;
           Q->next=T;
           head=Q;
         }
         p=p->next;
       }
       return dummy;
    }
     else
     { ListNode *dummy=head;
       ListNode *temp=new ListNode;
       ListNode *TT=temp;
      while(head->next!=NULL)
        {if(head->next->val<x)
         {ListNode *D=head->next;
         head->next=D->next;
          D->next=dummy;
          //dummy=D;
          TT->next=D;
          TT=D;
         }
         else head=head->next;
        }
        if(temp->next==NULL) 
           return dummy;
        else return temp->next;
     }
    }*/
    /*ListNode *dummy=head;
    while(head->next!=NULL)
    {if(head->next->val>=x) beeak;
     head=head->next;
    }
    if(head->next==NULL)
       return dummy;
    else 
    {   ListNode *TT=head->next;
        ListNode *T=head->next;
        while(T->next!=NULL)
        { if(T->next->val<x)
           {ListNode *Q=T->next;
            T->next=Q->next;
            head->next=Q;
            Q->next=TT;
            head=Q;
           }
           else T=T->next;
        }*/
};
感想：

从上面的代码可以看出，我有三种注释掉的算法，我最一开始想的是分成两个链表来操作，最后再接上这两个链表，就有了②算法，结果内存使用超出了限制，不能过，所以我就又换了种思路，先判断第一个数是不是比x小，分两种情况，在第一种情况下，找到第一个大于等于x的结点head->next，对后面的结点遍历，如果数据比x小，则插到head->next前面，直到结束，至于第二种情况，就类似了，这就是程序③，不过这种算法又超时了，想了好久后，我决定综合一下他俩，出来了①，果然内存又出现使用超出限制。最后思考好久未果，我参考了别人的程序，又自己敲出了最后的代码，不得不服这种思路。