单链表OJ

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

ListNode* partition(ListNode* pHead, int x)
{
 ListNode *lesshead = (ListNode *)malloc(sixeof(ListNode));
 ListNode *morehead = (ListNode *)malloc(sizeof(ListNode));
 //设置两个哑结点，作为分割后的链表的头结点，但是它没有有效值。
 ListNode *pless = lesshead;
 ListNode *pmore = morehead;
 ListNode *cur = pHead;
  while (cur)
  {
    if (cur->val < x)
    {
      pless->next = cur;
      pless = pless->next;
    }
    else
    {
      pmore->next = cur;
      pmore = pmore->next;
    }
    cur = cur->next;
  }
 pless->next = moreless->next;//第一个链表的尾部连接到第二个链表的头。
 pmore->next = NULL;
 pHead = lesshead->next;//要最后设置新的头结点，防治发生堆溢出。
 free (lesshead);
 free (morehead);//把前面设置的具有辅助功能的哑结点释放掉。
 return pHead;
 }

• 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
  例如，链表1->2->3->3->4->4->5 处理后为 1->2->5。

ListNode* deleteDuplication(ListNode* pHead)
{
 ListNode *prev = NULL;
 ListNode *cur = pHead;
 ListNode *tail = pHead->next;
   if (pHead==NULL || pHead->next==NULL)
   {return pHead;}
   //当没有结点或许只有一个结点的时候，不会出现有重复的数字，直接返回。
   while (tail)//保证有下一个可以和cur比较的数字
   {
     if(cur->val == tail->val)
     {
      tail =tail->next;
      while (tail)//查找重复的结点
      {
       if (cur->val != tail->next)
       break;
       tail = tail->next;
      }
      while (cur != tail)//删除重复的结点，不能直接删除cur，cur的位置还需要标记。
      {
       ListNode *ptmp = cur;
       cur = cur->next;
       free (ptmp);
      }
      if (prev == NULL)
      {
       pHead = tail;
      }
      else
      {
       prev->next = tail;
      }
      if (tail)
      {
        tail = tail->next;//开始下一轮重复值得查找。
      }
    }
  else
  {
   prev = cur;
   cur = tail;
   tail = tail->next;
  }
 }
  return pHead;
}

• 对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。

   测试样例：
   1->2->2->1
   返回：true
  

ListNode *ListReverse (ListNode *head)
{
 ListNode *prev = NULL;
 ListNode *cur = head;
 ListNode *tail = NULL;
  while (cur)
  {
   tail = cur->next;
   cur->next = prev;
   prev = cur;
   cur = tail;
  }
  return prev;//一定要返回新链表的头结点。
}

bool chkPalindrome(ListNode* head)
{
  ListNode *fast = head;
  ListNode *slow = head;
  while (fast && fast->next)//寻找中间结点的位置。
  {
   fast = fast->next->next;
   if (fast)
   slow = slow->next;
  }
  ListNode *Listlater = slow->next;
  slow->next = NULL;
  ListNode *Listbefer = head;
  Listlater = ListReverse(Listlater);
  while (Listbefer && Listlater)
  {
   if (Listbefer != Listlater)
   {
    return false;
   }
   else
   {
    Listbefer = Listbefer->next;
    Listlater = Listlater->next;
   }
  }
 return true;
}