一、移除链表元素
移除链表中值为val的元素，并返回新的头节点
思路：
题目上这样说，我们就可以创建一个新的链表，将值不为val的节点，尾插到新的链表当中，最后返回新链表的头节点。
typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) {
if(head==NULL)
{
return NULL;
}
ListNode* newhead = (ListNode*)malloc(sizeof(ListNode));
ListNode* ptail = head;
ListNode* pcur = newhead;
while (ptail) {
if (ptail->val != val) {
pcur->next = ptail;
pcur = pcur->next;
}
ptail = ptail->next;
}
pcur->next=NULL;
ListNode* ret = newhead->next;
free(newhead);
newhead = NULL;
return ret;
}当然，这个题还有其他思路。
二、反转链表
将链表反转，并返回反转后的链表的头节点
思路：
创建三个指针变量，l1，l2，l3（指针初始指向如下图），遍历链表，先让l3=l2->next；再将l2的next指针指向l2；再l1指向l2，l2指向l3（l2下一个节点）；直到遍历结束，结束条件为（l2等于NULL）此时l1指向的就是反转后的链表的头节点。
根据题目给的示例来分析
遍历数组，循环进行一次
l2不等于NULL循环继续
l2不等于NULL循环继续
l2不等于NULL循环继续
l2仍然不等于NULL，循环继续
到这里，l2已经遍历到了NULL，循环结束，此时l1指向的就是反转后链表的头节点，直接返回即可。
typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {
ListNode* l1,*l2,*l3;
l1=NULL;
l2=head;
while(l2)
{
l3=l2->next;
l2->next=l1;
l1=l2;
l2=l3;
}
return l1;
}三、链表的中间节点
看到这个题，本人一开始的想法是：遍历一遍链表，记录链表的节点个数，然后再遍历一次链表，寻找链表的中间节点；这样实现非常麻烦，现在使用一种新的方法来解决这个问题
思路：快慢指针
定义两个快慢指针，fast和slow刚开始都指向链表的头节点，fast每次向前走两个节点，而slow指针每次向前走一个节点；最后当fast指针或者fast的next指针为NULL遍历结束；此时slow指向的就是链表的中间节点。
根据题所给的示例分析：
链表个数为奇数
fast=fsat->next->next;
slow=slow->next;
遍历到这里，fast的next指针为空，循环结束；此时slow指向的就是链表的中间节点。
链表的节点数为偶数
fast=fsat->next->next;
slow=slow->next;
循环到这里，fast为空，循环结束，此时slow指向的节点就是链表的中间节点。
typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head) {
if(head==NULL)
{
return NULL;
}
ListNode* fast=head;
ListNode* slow=head;
while(fast&&fast->next)
{
fast=fast->next->next;
slow=slow->next;
}
return slow;
}四、合并两个有序链表
合并两个有序链表，这里创建一个新的链表，将两个链表中较小小的数据依次尾插到新链表中，最后返回新链表的头节点即可。
注意：这里需要注意，初始的两个链表可能为空，这里需要进判断，如果list1为空，就返回list1；如果list2为空，就返回list1。
根据题目示例分析
比较l1和l2指向的节点的值大小，l1->val=l2->val（l1的不小于l2的），将l2指向节点尾插到新链表
此时，l1->val < l2->val，将l1指向的节点尾插到新链表
此时，l1->val < l2->val，将l1指向的节点尾插到新链表
比较l1和l2指向的节点的值大小，l2->val < l1->val，将l2指向节点尾插到新链表
比较l1和l2指向的节点的值大小，l1->val=l2->val（l1的不小于l2的），将l2指向节点尾插到新链表
l2为空，循环结束，这里l1的节点还没全部插到新链表中，这里直接 ptail->next=l1;即可。
注：这里使用动态内存来给newhead开辟空间，记得将其释放掉，养成好习惯。
typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
if(list1==NULL)
{
return list2;
}
if(list2==NULL)
{
return list1;
}
ListNode* l1=list1;
ListNode* l2=list2;
ListNode* newhead=(ListNode*)malloc(sizeof(ListNode));
ListNode* ptail=newhead;
while(l1 && l2)
{
if(l1->val<l2->val)
{
ptail->next=l1;
l1=l1->next;
}
else
{
ptail->next=l2;
l2=l2->next;
}
ptail=ptail->next;
}
if(l1)
{
ptail->next=l1;
}
if(l2)
{
ptail->next=l2;
}
ListNode* ret=newhead->next;
free(newhead);
newhead=NULL;
return ret;
}五、链表分割
将链表小于x的节点排在其余节点之前，不能改变原来顺序，最后返回排序好的链表的头指针。
思路：
创建两个链表，一个链表l1，存放值小于val的节点；另一个链表l2，存放值大于等于val的节点。最后将两个链表连接起来，返回l1链表的头节点即可。
这里需要注意：再l2链表的结尾，要将尾节点的next指针置为NULL；
#include <cstddef>
class Partition {
public:
ListNode* partition(ListNode* pHead, int x) {
// write code here
ListNode* list1,*l1;
l1=list1=(ListNode*)malloc(sizeof(ListNode));
ListNode* list2, *l2;
l2=list2=(ListNode*)malloc(sizeof(ListNode));
ListNode* ptail=pHead;
while(ptail)
{
if(ptail->val<x){
//尾插到l1里
l1->next=ptail;
l1=l1->next;
}
else{
l2->next=ptail;
l2=l2->next;
}
ptail=ptail->next;
}
l2->next=NULL;
l1->next=list2->next;
ListNode* ret=list1->next;
free(list1);
free(list2);
list1=list2=NULL;
return ret;
}
};
