1.单链表相关经典算OJ题目1：移除链表元素

思路一

直接在原链表里删除val元素，然后让val前一个结点和后一个节点连接起来。

这时我们就需要3个指针来遍历链表：

pcur  —— 判断节点的val值是否于给定删除的val值相等

prev ——保存pcur的前一个节点，为删除节点后，连接pcur之后的节点做准备

del —— 保存pcur之后的一个节点，为删除节点之后，连接链表做准备，和继续遍历链表

那么一开始它们的位置应该怎么放呢？

链表肯定是从第一个节点开始遍历的，那么 pcur 肯定就指向第一个节点，del可以先不给值，等到要删除的时候在把pcur之后的节点赋值给它

prev是在pcur前面的一个节点，我们会发现，当第一次遍历时，pcur前面并没有节点，那么我们就创造一个节点：哨兵卫（Sentinel），于链表连接，再让prev指向它。之后我们在返回新的链表的时候，我们返回 哨兵卫（Sentinel）的下一个节点即可。

代码 ：

typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) {//创建哨兵卫节点并于链表连接ListNode* newhead = (ListNode*)malloc(sizeof(ListNode));newhead->next = head;ListNode* prev = newhead;ListNode* pcur = head;ListNode* del;当我们pcur走到尾节点指向的NULL处时停止循环while(pcur){//当符合给定的val值，删除if(pcur->val == val){del = pcur->next;   //记录pcur下一个节点位置free(pcur);         //删除pcur节点prev->next = del;   //将pcur前后的节点连接起来pcur = del;         //走向下一个节点}//当不符合给定的val值，继续遍历链表else{      prev = pcur;pcur = pcur->next;}}//释放不要的哨兵卫节点并返回新的链表ListNode* p = newhead->next;free(newhead);return p;
}

 思路二

直接创建一个新的链表，遍历原链表，将不是val值的节点尾插到新的链表中

需要用到两个指针：

pcur —— 用来遍历原链表，找不是val值的节点

ptail —— 新链表的尾节点，将来尾插至此节点后面

代码：

typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) {//创建哨兵卫节点，这里是为了防止对NULL指针解引用。ListNode* newhead = (ListNode*)malloc(sizeof(ListNode));newhead->next =  NULL;ListNode* newtail,* pcur;newtail = newhead;pcur = head;//当pcur走到原尾节点->NULL时停止循环while (pcur){//如果和给定的val值节点不相等，则尾插至新链表中if (pcur->val != val){newtail->next = pcur;newtail = newtail->next;}pcur = pcur->next;    //pcur继续遍历原链表}newtail->next = NULL;  //出了循环之后，记得把新的链表的尾节点指向NULL,保证不会带出多余节点//释放哨兵卫节点ListNode* p = newhead->next;free(newhead);return p;
}

 2.单链表相关经典算OJ题目2：反转链表

思路一

创建一个新的链表，将原链表的节点依次拿到新链表进行头插

需要两个指针：

pcur —— 遍历原链表

newhead —— 作为新链表的第一个节点

代码：

typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {//如果链表为NULL则不用反转if(head == NULL){return head;}ListNode* newhead = NULL;ListNode* pcur = head;ListNode* Transfer = NULL;//开始反转while(pcur){Transfer = pcur;   // 保存当前节点的指针pcur = pcur->next; // 移动到下一个节点Transfer->next = newhead;  // 反转当前节点的next指针，指向新的头节点newhead = Transfer;   // 更新新链表的头节点}return newhead;
}

思路二

创建三个指针，完成链表的反转：

n1 : 记录n2前一个节点

n2 : 用来遍历链表

n3 : 记录n2后一个节点

代码：

typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {//链表为NULL时不用反转if (head == NULL) {return head;}ListNode* n1 = NULL;ListNode* n2 = head;ListNode* n3 = n2->next;当n2遍历完链表时循环停止while (n2){n2->next = n1;   //让n2节点指向n1节点n1 = n2;         //让n1走至下一个节点n2 = n3;         //让n2走至下一个节点// 因为n3比n2快一步，当n2走至尾节点的时候，n3已经为NULL了，不处理的话会造成NULL的解引用if (n3 != NULL)   n3 = n3->next;   //让n3走至下一个节点}//当循环结束时n1会成为新的第一个节点return n1;}

 3.单链表相关经典算OJ题目3：链表的中间节点

思路 

这一题说难也不难，相信想一下大部分的码农都可以写出来

这里我就介绍一个更妙的方法：快慢指针法

什么是快慢指针法？顾名思义，就是创造两个指针，一个指针走的慢一点，一个指针走的快一点，对应到我们这一题上就是，同一时间内，一个指针走一步，一个指针走两步：2 × slow = fast

那么它是否可以应对题目给出的条件呢？当中间节点有两个时，返回第二个中间节点

两个中间节点

单中间节点

 

可以看见无论是双中间节点 还是 单中间节点这个方法都可以完美解决，我们也可以观察出循环的结束条件为：当 fast 指针为NULL 或 fast指针下一个节点为NULL时停止

代码：

typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head) {//创建快慢指针ListNode *slow,*fast = NULL;链表不为NULL时快慢指针从第一个节点开始遍历if(head != null);slow = fast = head;//当 fast 指针为NULL 或 fast指针下一个节点为NULL时停止//这两个表达式位置不可以换，若换，当fast为NULL时会出现对NULL指针解引用//如果换，当fast为NULL时，第一个表达式为假，第二个表达式就不执行了，不会出现NULL指针解引用while(fast ！= NULL && fast->next){slow = slow->next;        //慢指针走一个节点fast = fast->next->next;  //快指针走两个节点}return sl
}

  4.单链表相关经典算OJ题目4：合并两个有序数组

  

思路 

创建新链表，并且通过遍历两个原来的链表比较大小来添加至新的链表中

代码：

typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {//设置哨兵节点当新链表的第一个节点ListNode* newhead = (ListNode*)malloc(sizeof(ListNode));newhead->next = NULL;ListNode* newtail = newhead; //只有一个节点，第一个节点 = 尾节点//创建l1 l2 指针遍历原链表list1 list2ListNode* l1 = list1;ListNode* l2 = list2;//当遍历完一个链表时，循环停止，不可能出现两个链表同时遍历完的情况while(l1 != NULL && l2 != NULL){//l1 或 l2 指向的值，小的放入新链表，并让其指针l1或l2 与 newtail指针往后走if(l1->val < l2->val){newtail->next = l1;l1 = l1->next;newtail = newtail->next;}else{newtail->next = l2;l2 = l2->next;newtail = newtail->next;}}//将没有遍历完的链表，将其内的元素一次性插入新链表中if(l1 != NULL){newtail->next = l1;}else{newtail->next = l2;}//存储哨兵卫后面的节点，并释放哨兵卫节点ListNode* p = newhead->next;free(newhead);return p;    //返回新的头节点
}

  5.单链表相关经典算OJ题目5：环形链表的约瑟夫问题

思路

利用我们的环形链表，依次的去遍历链表，使用count计数器计数，当count = m时删除节点，当环形链表只剩一个节点（这个节点下一个节点指向自己）时，就说明找到了最后留下的人。

这时我们需要用到两个指针：

pcur —— 遍历环形链表

prev —— 保存pcur的前一个节点，为删除节点做准备

代码：

typedef struct ListNode ListNode;//创建新节点
ListNode* Buynode(int x){ListNode* p = (ListNode*)malloc(sizeof(ListNode));p->val = x;p->next = NULL;return p;
}//创建环形链表
ListNode* creatCircle(int n){ListNode* head,*ptail;    head = Buynode(1);      //创建第一个节点val值为1ptail = head;for(int i = 2;i <= n;i++)     //继续创建节点,直到节点数 = n ，从第一个节点val = 1{                             //第二个 = 2....一直到n个节点，其val = nptail->next = Buynode(i);ptail = ptail->next;}// 让链表的头尾相连ptail->next = head;//因为要用到第一个节点的上一个节点，所以返回ptailreturn ptail;
}int ysf(int n, int m ) {ListNode* prev,*pcur;    //创建所需要的指针prev = creatCircle(n);   //创建环形链表pcur = prev->next;       //pcur从没有相连的第一个节点开始遍历int count = 1;           //创建计数器//开始循环，当环形链表中的节点指向自己时，说明只剩一个节点，循环结束while(pcur->next != pcur){//如果计数器 == m 则删除该节点if(count == m){prev->next = pcur->next;  //prev->next指向需删除节点的下一个节点free(pcur);               //删除该节点pcur = prev->next;        //pcur走向已删除节点的下一个节点count = 1;                //重置计数器}//如果计数器 != m 则删除该节点else{prev = pcur;            //两个指针都走向各自的下一个节点pcur = pcur->next;count++;                //计数器++}}return pcur->val;     //返回最后一个节点的val值
}

    6.单链表相关经典算OJ题目 6 ：分割链表

思路一 

修改原链表，把小于特定的 x 值尾插到链表后面

pcur —— 遍历链表直到原尾节点

prev —— pcur的前一个节点，为了删除节点准备

patil —— 原尾节点

newpatil —— 新的尾节点

newhead —— 一个哨兵节点作为新的头节点

代码：

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x){//如果链表尾为NULL则不用分割if(head == NULL){return head;}//创建哨兵卫并于链表第一个节点连接，让它成为新的第一个节点ListNode* newhead = (ListNode*)malloc(sizeof(ListNode));newhead->next = head;//分割链表需要用到的指针ListNode* prev,*pcur,*ptail,*newptail;prev = newhead;pcur = head;//找尾节点while(pcur->next != NULL){pcur = pcur->next;}ptail = pcur;newptail = pcur;pcur = head;   //pcur重新回到原第一个节点//当pcur遍历到原尾节点的时候停止循环while(pcur != ptail){//如果节点的val值比x大，则把节点尾插至链表if(pcur->val >= x)   {prev->next = pcur->next;      //先让prev的下一个节点指向pcur下一个节点newptail->next = pcur;       //pcur节点尾插至链表后newptail = newptail->next;  //新的尾节点pcur = prev->next;         //让pcur走到prev指向的下一个节点}//否者pcur与prev各自往后走一个节点else{prev = pcur;pcur = pcur->next;}}newptail->next = NULL;断绝尾节点后面还带着其它节点ListNode* p = newhead->next;free(newhead);return p;
}

思路二

创建一个新的链表，把大于等于x的节点尾插到新的链表中，小于x的节点头插至链表中

 代码：

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x){if(head == NULL){return head;}//新链表起码要有一个节点，不然不知道是头插还是尾插ListNode* newhead,*pcur,*newptail,*del;newhead = newptail = pcur = head;   //把原链表的第一个节点给到新链表//这时新链表 头 = 尾 pcur = del = pcur->next;   //pcur走到原链表的第二个节点//当pcur走到NULL时说明已经遍历完原链表while(pcur){//尾插if(pcur->val >= x){if(del)                     //怕出现NULL指针解引用del = pcur->next;          //存储pcur下一个节点，不然待会找不到newptail->next = pcur;     //让新链表尾节点指向pcurnewptail = newptail->next;   //更习新链表的尾节点pcur = del;                 //pcur走向下一个节点}//头插else{if(del)                    //怕出现NULL指针解引用del = pcur->next;          //存储pcur下一个节点，不然待会找不到pcur->next = newhead;      //pcur的这个节点头插至新链表第一个节点处newhead = pcur;            //更新新链表的第一个节点pcur = del;                 //pcur走向下一个节点}}//让新链表的尾节点指向NULl，防止有别的节点被带上newptail->next = NULL;return newhead;
}

思路三：

创建 一大  一小 两个链表 ，把大于等于点放到大链表中，小于x的节点放到小链表中，当原链表的节点被全部放置完毕，把大链表链接到小链表后面。

 代码：

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x){//链表为NULL直接返回链表if(head == NULL){return head;}//创建大链表的第一个节点，和尾节点ListNode* Bnewhead,*Bnewptail;Bnewhead = Bnewptail = (ListNode*)malloc(sizeof(ListNode));//创建小链表的第一个节点，和尾节点ListNode* Snewhead,*Snewptail;Snewhead = Snewptail = (ListNode*)malloc(sizeof(ListNode));ListNode* pcur = head;   //遍历原链表指针while(pcur){//尾插至大链表if(pcur->val >= x){Bnewptail->next = pcur;       //将大于等于x的pcur节点尾插至大链表Bnewptail = Bnewptail->next;  //更新大链表尾节点}//尾插至小链表else{Snewptail->next = pcur;       //将小于x的pcur节点尾插至小链表Snewptail = Snewptail->next;   //更新小链表尾节点} pcur = pcur->next;              //让pcur继续遍历原链表下一个节点}Bnewptail->next = NULL;     //让大链表的尾节点的下一个节点指向NULL防止它带出其他节点Snewptail->next = Bnewhead->next;   //让小链表的尾节点的下一个节点指向大链表的第一个节点//释放动态申请的空间ListNode* ret= Snewhead->next;   //存储大小合并后的链表的第一个有效节点free(Bnewhead);                 free(Snewhead);Bnewhead = Snewhead = NULL;//返回新链表return ret;}