初级算法-链表

一、给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：

输入：head = [1], n = 1
输出：[]
示例 3：

输入：head = [1,2], n = 1
输出：[1]

提示：

链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
int length(struct ListNode* head)
{
    int len = 0;
    while(head){
        len++;
        head = head->next;
    }
    return len;
}
struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    struct ListNode* pro = malloc(sizeof(struct ListNode));
    pro->val = 0;pro->next = head;
    int last = length(head);

    struct ListNode* cur = pro;
    for(int i = 0;i < last - n;i++)
    {
        cur=cur->next;//这里首先要找到要删除链表的前一个结点
    }
    cur->next = cur->next->next;//然后让前一个结点的next指向要删除节点的next
    struct ListNode* ans = cur->next;
    free(pro);
    return ans;
}

二、删除链表中的节点

请编写一个函数，用于 删除单链表中某个特定节点 。在设计函数时需要注意，你无法访问链表的头节点 head ，只能直接访问 要被删除的节点 。

题目数据保证需要删除的节点 不是末尾节点 。

示例 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
示例 3：

输入：head = [1,2,3,4], node = 3
输出：[1,2,4]
示例 4：

输入：head = [0,1], node = 0
输出：[1]
示例 5：

输入：head = [-3,5,-99], node = -3
输出：[5,-99]

提示：

链表中节点的数目范围是 [2, 1000]
-1000 <= Node.val <= 1000
链表中每个节点的值都是唯一的
需要删除的节点 node 是 链表中的一个有效节点 ，且 不是末尾节点

void deleteNode(struct ListNode* node) {
    node->val = node->next->val;
    node->next=node->next->next;
}

三、反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：

输入：head = [1,2]
输出：[2,1]
示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

struct ListNode* reverseList(struct ListNode* head){
    if(head == NULL || head->next == NULL)
    return head;

    struct ListNode* newhead = reverseList(head->next);
    head->next->next = head;
    head->next = NULL;
    return newhead;
}

四、合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：

输入：l1 = [], l2 = []
输出：[]
示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

提示：

两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    if (list1 == NULL || list2 == NULL)
            return list2 == NULL ? list1 : list2;

    if(list1->val < list2->val){
    list1->next = mergeTwoLists(list1->next, list2);
    return list1; 
    }
    else{
    list2->next = mergeTwoLists(list1, list2->next);
    return list2; 
    }
}

五、回文链表
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

示例 1：

输入：head = [1,2,2,1]
输出：true
示例 2：

输入：head = [1,2]
输出：false

//方法一：将值复制到数组中后用双指针法
bool isPalindrome(struct ListNode* head) {
    int vals[5001], vals_num = 0;
    while(head != NULL)
    {
        vals[vals_num++] = head->val;
        head = head->next;
    }
    for(int i = 0, j = vals_num - 1;i < j; ++i, --j){
        if(vals[i] != vals[j]){
            return false;
}
}
    return true;
}
/*********************************************************************************************/
//方法二：递归
struct ListNode* frontPointer;
bool recursivelyCheck(struct ListNode* currentNode) {
	if(currentNode != NULL)
    {
        if(!recursivelyCheck(currentNode->next))//检查下一个节点是否为NULL
            return false;
        if(currentNode->val != frontPointer->val)
            return false;
        
        frontPointer = frontPointer->next;//指向下一个节点作比较，注意frontPointer为全局变量
    }
    return true;
}
bool isPalindrome(struct ListNode* head){
	frontPointer = head;
    return recursivelyCheck(head);
}

六、环形链表
给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

/** 方案一 哈希表 遍历所有的节点，每次遍历到节点的时候，判断该节点此前是否被访问过
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct hashTable{
	struct ListNode* key;//键
    UT_hash_handle hh;//每个结构中要有一个UT_hash_handle成员
    };
struct hashTable* hashtable;
struct hashTable* find(struct ListNode*ikey){
    struct hashTable* tmp;
    HASH_FIND_PTR(hashtable,&ikey,tmp);//查找指针键值　1.哈希表 2.id的地址 3.输出的变量
    return tmp;//找不到时tmp返回NULL
}
void insert(struct ListNode* ikey){
    struct hashTable* tmp = malloc(sizeof(struct hashTable));
    tmp->key = ikey;
    HASH_ADD_PTR(hashtable,key,tmp);
}
bool hasCycle(struct ListNode* head){
    hashtable = NULL;
    while(head != NULL){
	if(find(head) != NULL){
	return true;
    }
        insert(head);
        head = head->next;
    }
    return false;
}

对于c语言哈希表的详解，可以看此文章哈希表uthash的使用方法详解（附下载链接）
方案二，快慢指针（Floyd算法）

    bool hasCycle(struct ListNode* head){
    	if(head == NULL || head->next == NULL)
        {
			return false;
        }
    struct ListNode* slow = head;
    struct ListNode* fast = head->next;
    //如果slow 与 fast 重合，跳出循环，所以设置位不同节点，一个为头结点，一个为头结点的下一个节点。也可以使用do while，这样两个都可以设置为头结点
    while(slow != fast){
		if(slow == NULL || fast == NULL)
            return false;
        
        slow = slow->next;
        fast = fast->next->next;
    }
    return true;
}```