leetcode_1_22-链表中倒数第k个节点

个人目标：考研，同时注重算法能力。
开始日期：2020/2/29
水平：菜的一批
刷题目的：为复试做准备,和找工作。
学习引路：
资源：
https://space.bilibili.com/300173531?spm_id_from=333.788.b_765f7570696e666f.2
leetcode
公众号：labuladong
B站：花花酱

方法论：
（若是着急着工作）
1.时间规划（集中式大量刷题 保持题感 养成刷题习惯）
2.按照类型去刷题（数据类型 算法） 网站页面旁边有筛选功能 up🐷置顶了刷题目录
3.不能死记硬背 要理解题目套路举一反三（这点很重要！）
4.对于新手来说 看答案是可以的（新手不一定能想出来最优解）
5.用笔记本 ipad学习（Goodnotes）
6.利用网上资源 搜索题解视频（微信公众号labuladong）油管和B站的在置顶链接上
7.刷题刷三遍原则：1.题目到手，5分钟思考，没有思路就看答案。2.有思路，不看答案一道题不要写超过60分钟。3.重刷要能够在20分钟内解决。4.多看人家的写法。取其精华。

1.题目：

2.代码以及解题思路

code_1：
无从下手，不知道链表创建，参数都是不用写的。后来查了资料才知道只用在已有模板内写就够了。
解题思路：
1.尾插法创建列表
2.算出列表的长度-k,算出指针要停留的位置
3.然后输出后面链表
总结：第一次，不了解，c的知识也忘的差不多。

1.创建

/**Definition for singly-linked list. **/

struct ListNode {
     int val;
     struct ListNode *next;
};

struct ListNode* getKthFromEnd(struct ListNode* head, int k){
    int list_count = 0
    int list_print_begin = 0
    int *q = head
    while(head->next != NULL)
    {
        head = head->next;
        list_count ++;
    }
    list_count += 1;
    list_print_begin = list_count - k
    head = q
    
    for(int i = 0; i < list_print_begin; i++ )
    {
        head = head->next;
    }
    while(1)
    {   
        printf("%d", head->data)
        if(head->next == NULL)
        {   
            break;
        }
        head = head->next;
    }


} 


void main()
{   
    int *head_A 
    int key = 0;
    int a[5] = {0}
    for(i = 0; i<5; i++)
        scanf("d%", &a[i])
    head_A = creatlistA(ListNode *&A, a[], 5)
    printf("请输入一个数：")
    scanf("%d", &key)
    getKthFromEnd(head_A, key)

}



void creatlistA(ListNode *&A, int a[], int n)
{   
    ListNode *s, *r;
    int i;
    A = (ListNode *)malloc(sizeof(ListNode));
    A -> = NULL;
    r = A;
    for(i = 0; i < n; ++i)
    {
        s = (ListNode*)malloc(sizeof(ListNode));
        s->data = a[i];
        r->next = s;
        r = r->next;
    }
    r->next = NULL;
    return A;
}

code_2
方法：双指针

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* getKthFromEnd(struct ListNode* head, int k){
    struct ListNode* p_fast = head;
    struct ListNode* p_slow = head;
    while(k--)
    {
        p_fast = p_fast->next;
    }

    while(p_fast != NULL)
    {
        p_fast = p_fast->next;
        p_slow = p_slow->next;
    }
    return p_slow;
}

要点：
假设五个元素的链表，k=2
快指针先走2步，然后两个指针同时走，当快指针刚走出链表，其实就是走了5步，而5-2就是慢指针要走的步数，也是定位点。然后输出链表。

code_3
双指针法：python实现

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        # fast_p = ListNode(1)
        # slow_p = ListNode(2)
        fast_p = slow_p = head

        while k:
            fast_p = fast_p.next
            k -= 1
        while fast_p is not None:
            fast_p = fast_p.next
            slow_p = slow_p.next
        
        return slow_p

3.总结

1.用python写同样的这种偏向于底层操作，发现各方面都不敌c这种编译性语言。难怪有一些python的包是用c写的。
2.方法很巧妙，要多刷题
当指针->next 已经为空，再进行p = p ->next时候 p 指针 = NULL，
而且p指针已经没有数据域和next指针域了。