链表算法之链表分化

对于一个链表，我们需要用一个特定阈值完成对它的分化，使得小于等于这个值的结点移到前面，大于该值的结点在后面，同时保证两类结点内部的位置关系不变。

给定一个链表的头结点head，同时给定阈值val，请返回一个链表，使小于等于它的结点在前，大于等于它的在后，保证结点值不重复。

测试样例：

{1,4,2,5},3

{1,2,4,5}

思路：新建两个链表，将原来链表中的数分别与限制数比较，大于它的放到一个链表中，小于它的放到另外一个链表中。最后将两个链表连接起来。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Divide {
public:
    ListNode* listDivide(ListNode* head, int val) {
       
        ListNode* mix=NULL;//比bal小的放到里面
        ListNode* headmix=NULL;
        ListNode* max=NULL;
        ListNode* headmax=NULL;
        ListNode* p;
        p=head;
        while(p)
            {
            if(p->val<=val)           //如果小于放到mix里面
                {
             if(headmix==NULL)  //第一个放入之前headmix是空的，所以让headmix等于第一个
                 {
               headmix=p;   
                 mix=headmix;
             }
              else{
                  mix->next=p;
                  mix=mix->next;
              }
            }
            if(p->val>val)
                {
                   if(headmax==NULL)
                 {
               headmax=p;
                 max=headmax;
             }
              else{
                  max->next=p;
                  max=max->next;
              }
            }
           p=p->next;
             
        }
        if(headmix == NULL){
            max->next = NULL;
            return headmax;
        }
        if(headmax == NULL){
            mix->next = NULL;
            return headmix;
        }
        mix->next = headmax;
        max->next = NULL;
        return headmix;
    }
     
};