2009年408的算法题

繁星蓝雨

已于 2023-01-31 23:31:14 修改

阅读量1.4k

点赞数 2

分类专栏： 408 # 链表文章标签：算法链表数据结构 408

于 2020-12-17 23:12:01 首次发布

本文链接：https://blog.csdn.net/qq_33375598/article/details/111309566

版权

408 同时被 2 个专栏收录

17 篇文章 37 订阅

订阅专栏

链表

15 篇文章 0 订阅

订阅专栏

文章目录

0 结果
1 题目
2 思路
附录

0 结果

1 题目

在这里插入图片描述

2 思路

2.1 思路1（暴力解：双层循环枚举）

q指向倒数第0个结点（nullptr），p指向倒数第n - i -1个结点（i从0开始），使用双层循环枚举所有的可能，如果p和q指针相等时（即找不到倒数第k个元素），则返回0.

#include <cstdio>
#include <cstdlib>

typedef struct node{
    int data;
    struct node* link;
}NODE;

int ans(NODE* L, int k){
    NODE *p, *q = nullptr;//p为倒数第k个结点,p为倒数第k个结点的下一个结点
    for(int i = 0;i < k;i++){
        p = L->link;
        if(p == q) return 0;//找不到倒数第k个结点
        while (p->link != q)
            p = p->link;
        q = p;
    }
    printf("%d\n", p->data);
    return 1;
}

//使用尾插法创建结点
void create(NODE* &L){
    NODE *r = L;
    for(int i = 2;i < 8;i++){
        NODE* s = (NODE*)malloc(sizeof(NODE));
        s->data = i;
        r->link = s;
        r = s;
    }
    r->link = nullptr;

}
//打印链表
void print(NODE* L){
    NODE* p = L->link;
    while(p!=nullptr){
        printf("%d ", p->data);
        p = p->link;
    }
}

int main(){
    NODE *L = (NODE *) malloc(sizeof (NODE));
    L->link = nullptr;
    create(L);
    int k = 2;//倒数第k个元素
    printf("查找结果：%d", ans(L, k));

    return  0;
}

2.2 思路2（暴力解：递归遍历查询）

递归调用一个一个访问结点，曲剧变量t表示此事访问的是倒数第几个结点，如果t==k说明是倒数第k个结点。

#include <cstdio>
#include <cstdlib>

typedef struct node{
    int data;
    struct node* link;
}NODE;

int t = 0;//t表示当前访问的是倒数第k个结点
void find(NODE* p , int k){
    if(p == nullptr) return;
    find(p->link, k);
    t++;
    if(t == k) printf("%d\n", p->data);
}

int ans(NODE* L, int k){
    find(L->link, k);
    if(t < k) return 0;
    return 1;
}

//使用尾插法创建结点
void create(NODE* &L){
    NODE *r = L;
    for(int i = 2;i < 8;i++){
        NODE* s = (NODE*)malloc(sizeof(NODE));
        s->data = i;
        r->link = s;
        r = s;
    }
    r->link = nullptr;

}
//打印链表
void print(NODE* L){
    NODE* p = L->link;
    while(p!=nullptr){
        printf("%d ", p->data);
        p = p->link;
    }
}

int main(){
    NODE *L = (NODE *) malloc(sizeof (NODE));
    L->link = nullptr;
    create(L);
    int k = 4;//倒数第k个元素
    printf("查找结果：%d", ans(L, k));

    return  0;
}

时间复杂度： $O (n)$
空间复杂度： $O (n)$

2.3 思路3（暴力解：数组保存遍历）

把链表的所有节点值存入数组，然后输出数组中倒数第k个元素即可。

#include <cstdio>
#include <cstdlib>

typedef struct node{
    int data;
    struct node* link;
}NODE;

int ans(NODE* L, int k){
    NODE * A[INT16_MAX];
    NODE * p = L->link;
    int n = 0;
    while(p != nullptr){
        A[n++] = p;
        p = p->link;
    }
    if(n < k) return 0;
    printf("%d\n", A[n - k]->data);
    return 1;
}

//使用尾插法创建结点
void create(NODE* &L){
    NODE *r = L;
    for(int i = 2;i < 8;i++){
        NODE* s = (NODE*)malloc(sizeof(NODE));
        s->data = i;
        r->link = s;
        r = s;
    }
    r->link = nullptr;

}
//打印链表
void print(NODE* L){
    NODE* p = L->link;
    while(p!=nullptr){
        printf("%d ", p->data);
        p = p->link;
    }
}

int main(){
    NODE *L = (NODE *) malloc(sizeof (NODE));
    L->link = nullptr;
    create(L);
    int k = 4;//倒数第k个元素
    printf("查找结果：%d", ans(L, k));

    return  0;
}

时间复杂度： $O (n)$
空间复杂度： $O (n)$

2.4 思路4（最优解1：找规律）

设q指向末尾第k个结点，那么当k小于等于链表长度时，q为正数第t(t为 $n - (k - 1)$ )个结点（假设有n个结点）。

因此先遍历一边链表求出链表长度n，再遍历一次链表找到第t个结点。

#include <cstdio>
#include <cstdlib>

typedef struct node{
    int data;
    struct node* link;
}NODE;

int ans(NODE* L, int k){
    NODE * p = L->link;
    int t , n = 0;
    while(p != nullptr){
        n++;
        p = p->link;
    }
    t = n - k + 1;
    if(t <= 0) return 0;
    p = L;
    while(t--)
        p = p->link;
    printf("%d\n", p->data);
    return 1;
}

//使用尾插法创建结点
void create(NODE* &L){
    NODE *r = L;
    for(int i = 2;i < 8;i++){
        NODE* s = (NODE*)malloc(sizeof(NODE));
        s->data = i;
        r->link = s;
        r = s;
    }
    r->link = nullptr;

}
//打印链表
void print(NODE* L){
    NODE* p = L->link;
    while(p!=nullptr){
        printf("%d ", p->data);
        p = p->link;
    }
}

int main(){
    NODE *L = (NODE *) malloc(sizeof (NODE));
    L->link = nullptr;
    create(L);
    int k = 10;//倒数第k个元素
    printf("查询返回结果：%d", ans(L, k));

    return  0;
}

时间复杂度： $O (n)$
空间复杂度： $O (1)$

2.5 思路5（最优解2:双指针法）

设q指向末尾第k个结点，p指向最后一个结点的下一个结点（空节点，即nullptr），那么当k小于等于链表长度时，q为正数第 $n - k + 1$ 个结点。故有，当p移动 $k$ 个结点后，q再开始移动，当p指向nullptr时，q刚好指向倒数第k个结点；如果k大于链表长度，则p指向链表最后一个结点后，q都未曾移动，即指向链表头节点。
例如：1，2，3，4，5，6
求倒数第二个结点，p，q起始都指向头节点，当p移动到结点2时，下次开始p和q开始同步移动，过程如下

p 1 2 3 4 5 6 nullptr
q     1 2 3 4 5

最后q指向倒数第二个结点。

#include <cstdio>
#include <cstdlib>

typedef struct node{
    int data;
    struct node* link;
}NODE;

int ans(NODE* L, int k){
    NODE *p = L, *q = L;
    int cnt = 0;
    while(p != nullptr){
        p = p->link;
        cnt++;
        if(cnt > k){//当p移动k个结点时，q开始同时指向下一个结点
            q = q->link;
        }
    }
    if(q != L){
        printf("%d\n", q->data);
        return 1;
    }else{
        return 0;
    }
}

//使用尾插法创建结点
void create(NODE* &L){
    NODE *r = L;
    for(int i = 2;i < 8;i++){
        NODE* s = (NODE*)malloc(sizeof(NODE));
        s->data = i;
        r->link = s;
        r = s;
    }
    r->link = nullptr;

}
//打印链表
void print(NODE* L){
    NODE* p = L->link;
    while(p!=nullptr){
        printf("%d ", p->data);
        p = p->link;
    }
}

int main(){
    NODE *L = (NODE *) malloc(sizeof (NODE));
    L->link = nullptr;
    create(L);
    int k = 1;//倒数第k个元素
    printf("查找结果：%d", ans(L, k));

    return  0;
}