目录
- 反转链表
- 合并两个有序链表
- 链表分割
反转链表
链接: link
题目描述：
题目思路：
方法1：改变链表链接的方向
方法1思路：
这力我们需要三个指针n1 n2 n3方便我们进行迭代
初始化n1指向NULL，n2指向第一个节点，n3指向第2个节点，下面是n1 n2 n3 3个指针移动的过程。
1、改变第一个指针n1的指向，链表反转后，第一个节点的指针域指向的是NULL，就上图来看，也就是n2->next=n1;
2、改变指向后，我们接下来的操作就是移动3个指针继续进行链接变向的操作。下面是如何变动三个指针的过程：
将n2的值赋给n1，n3的值赋给n2，n3再向下走一步。
3、下面进行的步骤就是反转链接方向：n2->next = n1。
上述过程就是我们反转的最核心步骤，下面是本题循环终止条件和Bug点：
这里我们要注意，本题要清楚的是，当n1指向最后一个节点的时候，循环就终止了，但是这个点并不是我们所需要的循环的终止条件，循环终止条件是n2为空指针。
本题大致雏形就出来了，但是我们实际进行运行的时候，还会出现空指针的问题，问题的来源就在于n3。
当n2不为空指针，并且n2此时已经指向最后一个节点时，n3已经为空指针，当n2为空指针的时候，n3也要向下走，这就造成了空指针的问题，所以我们要进行处理的是n3，n3不为空指针的时候，n3才可以继续向下走。
最后状态如下图所示：最后我们只需要返回n1就可以了
代码实现：
struct ListNode* reverseList(struct ListNode* head)
{
if(head==NULL)
{
return NULL;
}
struct ListNode* n1 = NULL;
struct ListNode* n2 = head;
struct ListNode* n3 = head->next;
while(n2)
{
//改变链表指向
n2->next = n1;
//迭代
n1 = n2;
n2 =n3;
if(n3)//如果n3不为空，则n3向下走
{
n3 = n3->next;
}
}
return n1;
}
方法2：依次取节点进行头插
方法2思路：
定义如上图3个指针变量，cur指向当前节点，next指向当前节点的下一个节点，rhead是链表反转之后新的头。
初始化rhead = NULL，cur = head，next = cur->next;
下面进行头插：
cur->next = rhead，rhead = cur，cur = next，next = next->next
以上就是本题头插的核心步骤，下面是本题循环终止条件和bug点：
当cur指向空时，循环终止，但是当cur指向空时,也会出现next空指针的问题，在cur指向最后一个节点时，next就指向空了,所以这里我们也要对next进行一下判断。
代码实现：
struct ListNode* reverseList(struct ListNode* head)
{
if(head==NULL)
{
return NULL;
}
struct ListNode* rhead = NULL;
struct ListNode* cur = head;
struct ListNode* next = cur->next;
while(cur)
{
cur->next = rhead;
rhead = cur;
cur=next;
if(next)
{
next = next->next;
}
}
return rhead;
}
合并两个有序链表
链接: link
题目描述：
题目思路：带哨兵位解法
什么是带哨兵位？
带哨兵位就是在一条链表的前面，有一个空的节点不存放任何的值，如下图：
动态申请1个空间的哨兵位作为新的头，之后进行链接。
1、如果List1的值比List2的值小，那么head->next就是我们合并后链表新的头，之后让List1指向下一个节点，并且tail指向刚刚被插入的节点。
与此同时如果List2的值比List1的值小，那么head->next就是我们合并后链表新的头，之后让List2指向下一个节点，并且tail指向刚刚被插入的节点。
2、有了新链表的头之后，剩下的步骤就是比较两个节点的大小，那个节点值大，就将哪个节点拿下来尾插，并且让尾指针tail指向该尾插的节点。
3、在进行不断的尾插的过程中肯定会有一条链表为空，如果是List1为空，那么直接让tail->next链接List2，否则链接List1。
注意：
1、我们还要注意一点就是，很有可能给我们的两条链表有一条是空链表，此时只需要返回那条不为空的链表就好。
2、动态申请的两个节点最后要记得释放
代码实现：
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
if(list1==NULL)
{
return list2;
}
if(list2==NULL)
{
return list1;
}
if(list1==NULL&&list2==NULL)
{
return NULL;
}
struct ListNode* head = NULL;
struct ListNode* tail = NULL;
head = tail = (struct ListNode*)malloc(sizeof(struct ListNode));
while(list1&&list2)
{
if(list1->val<list2->val)
{
tail->next = list1;
tail=tail->next;
list1= list1->next;
}
else
{
tail->next = list2;
tail=tail->next;
list2= list2->next;
}
}
if(list1)
{
tail->next = list1;
}
if(list2)
{
tail->next = list2;
}
struct ListNode* del = head;
head = head->next;
free(del);
return head;
}
链表分割
链接: link
题目描述：
题目思路：
假设给定一串链表：
假设x的值我们设置为3，则分割链接后就是下面的结果：
本题思路依然是构造两个带有哨兵位的链表，将小于3的拿下来尾插到链表1，将大于3的拿下来尾插到链表2，最后将链表2链接到链表1的后面，返回链表1的头,同时释放两个哨兵位节点。
注意：第二个链表的尾指针最后要置空，否则链表中会出现环。
代码实现：
class Partition {
public:
ListNode* partition(ListNode* pHead, int x) {
struct ListNode* lesshead,*lesstail,*greaterhead,*greatertail;
lesshead = lesstail = (struct ListNode*)malloc(sizeof(struct ListNode));
greaterhead = greatertail = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* cur = pHead;
while(cur)
{
if(cur->val<x)
{
lesstail->next = cur;
lesstail = lesstail->next;
}
else
{
greatertail->next = cur;
greatertail= greatertail->next;
}
cur=cur->next;
}
lesstail->next = greaterhead->next;
greatertail->next = NULL;
pHead = lesshead->next;
free(lesshead);
free(greaterhead);
return pHead;
}
};
