请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
 
现有一个链表 -- head = [4,5,1,9]，它可以表示为:
 
 
示例 1:
 
输入: head = [4,5,1,9], node = 5
 输出: [4,1,9]
 解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
 示例 2:
 
输入: head = [4,5,1,9], node = 1
 输出: [4,5,9]
 解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
  
 
说明:
 
链表至少包含两个节点。
 链表中所有节点的值都是唯一的。
 给定的节点为非末尾节点并且一定是链表中的一个有效节点。
 不要从你的函数中返回任何结果。
 
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
void deleteNode(struct ListNode* node) {
    node->val = (node->next)->val;
    node->next = (node->next)->next;
}
 
 

题目
 
24.两两交换链表中的节点
 
 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
 
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
 
示例:
 
给定 1->2->3->4, 你应该返回 2->1->4->3.
 
思路
 
此处以四个节点为例
 
首先更换前两个节点，将第一个节点指向第三个节点，第二个节点指向第一个节点，如图
但是到第二个两两交换就会产生问题，由于只有四个节点，第三个节点指向NULL，第四个节点指向第三个节点，但是前一个节点也指向第三个节点，没有节点指向第四个节点，如图
这时我们只需将第二个节点指向第四个节点即可
 
特殊情况：因为我们的思路是建立在第一个节点和第二个节点存在的情况下，如果不符合条件则另返回
 
代码实现
 
综上分析，我们需要三个节点来记录前一个节点r1，当前交换的第一个节点p和当前交换的第二个节点r；又因为最后需要返回头结点，我们再申请一个节点去记录头结点（也就是原始链表的第二个节点）
 
struct ListNode* swapPairs(struct ListNode* head){
   	if (!head || !head -> next) {
		return head;
	}
	struct ListNode *p = head;
	struct ListNode *p1 = head->next;
 	struct ListNode *r ,*r1;
 		r1 = head;
 		r = p -> next;
        p -> next = p -> next -> next;
        r -> next = p;
        p = p -> next ;
        
    while(p && p -> next) {
		r1 = r -> next;
    	r = p -> next;
    	p -> next = p -> next -> next;
    	r -> next = p;
    	r1 -> next = r;
    	p = p -> next;
    }
  
    return p1;
}

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
 
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
 
 
 
示例:
 
给定 1->2->3->4, 你应该返回 2->1->4->3.
 
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* swapPairs(struct ListNode* head){
    struct ListNode* dummy = NULL;
    struct ListNode* dummy_temp = NULL;
    struct ListNode* p1 = NULL;
    struct ListNode* p2 = NULL;
    if ((head == NULL) || (head->next == NULL)) {
        return head;
    }
    dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->next = head;
    dummy_temp = dummy;
    while ((dummy_temp->next != NULL) && ((dummy_temp->next)->next != NULL)) {
        p1 = dummy_temp->next;
        p2 = (dummy_temp->next)->next;
        p1->next = p2->next;
        dummy_temp->next = p2;
        p2->next = p1;
        dummy_temp = (dummy_temp->next)->next;
    }
    return dummy->next;
}
 
 

题目
 
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
 
示例 1：
 
 输入：head = [1,2,3,4]
 输出：[2,1,4,3]
 示例 2：
 
输入：head = []
 输出：[]
 示例 3：
 
输入：head = [1]
 输出：[1]
 
提示：
 链表中节点的数目在范围 [0, 100] 内
 0 <= Node.val <= 100
 
来源：力扣（LeetCode）
 链接：https://leetcode-cn.com/problems/swap-nodes-in-pairs
 
思路
 
题目简单，思路也比较简单：
 1、首先明确一个循环中需要四个变量： 交换的两个节点+交换后的小链表赋值给前面的链表节点+后面的链表节点赋值给当前交换后的链表节点；
 明确四个节点变量的作用，进行交换赋值即可；
 2、直到节点为空跳出循环；
 
程序
 
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* swapPairs(struct ListNode* head){
    struct ListNode* last = NULL;
    struct ListNode* pre = head;
    struct ListNode* mid = NULL;
    struct ListNode* next = NULL;
    /*获取链表头*/
    if(pre != NULL && pre->next != NULL){
        head = head->next;
    }
    /*直到没有节点或者剩余一个节点时，跳出循环*/
    while(pre != NULL && pre->next != NULL){
        mid = pre->next;
        next = mid->next;
        /*重新连接链表*/
        pre->next = next;
        mid->next = pre;
        if(last != NULL){
            last->next = mid;
        }
        last = pre;
        pre = next;
    }
    return head;
}