2012年408的算法题

繁星蓝雨

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

阅读量1.1k

点赞数 1

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

于 2020-12-16 22:47:27 首次发布

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

版权

链表公共后缀双指针法时间复杂度空间复杂度

关键词由CSDN通过智能技术生成

408 同时被 2 个专栏收录

17 篇文章 37 订阅

订阅专栏

链表

15 篇文章 0 订阅

订阅专栏

文章目录

0 结果
1 题目
2 思路
附录

0 结果

1 题目

在这里插入图片描述

2 思路

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

双层循环枚举str1和str2相同后缀的起始位置（固定str1的一个结点对比str2的所有结点）。

#include <cstdio>
#include <cstdlib>
#include <string.h>

typedef struct node{
    char data;
    struct node* next;
}NODE;

NODE* ans(NODE* str1, NODE* str2){
    NODE* p =  str1->next;
    NODE* q;
    while(p != nullptr){//外层循环遍历str1
        q = str2->next;
        while (q != nullptr){//内层循环遍历str2
            if(p == q){
                return p;
            }
            q = q->next;
        }
        p = p->next;
    }
    return nullptr;
}

//使用尾插法创建结点
void create(NODE* &L1, NODE* &L2){
    NODE *r1 = L1, *r2 = L2, *p;
    int num;
    char word1[] = "loading";
    char word2[] = "being";
    for(int i = 0;i < strlen(word1);i++){
        NODE *s = (NODE*)malloc(sizeof(NODE));
        s->data = *(word1 + i);
        r1->next = s;
        r1 = s;
    }
    r1->next = NULL;
    p = L1;
    while(p->next != NULL){
        p = p->next;
        if(p->data == 'i') break;
    }
    for(int i = 0;i < sizeof(word2) - 1;i++){
        NODE *s = (NODE*)malloc(sizeof(NODE));
        s->data = *(word2 + i);
        if(s->data == 'i'){
            r2->next = p;
            break;
        }
        r2->next = s;
        r2 = s;
    }
}
//打印数据
void print(NODE* L){
    NODE* p = L;
    while(p!=NULL){
        printf("%c", p->data);
        p = p->next;
    }
}

int main(){
    NODE *str1, *str2;
    str1 = (NODE*)malloc(sizeof(NODE));
    str1->next = NULL;
    str2 = (NODE*)malloc(sizeof(NODE));
    str2->next = NULL;
    create(str1, str2);
    NODE* s = ans(str1, str2);
    //printf("%c", s->data);
    print(s);
    return  0;
}

时间复杂度: $O(n^2)$
空间复杂度: $O (1)$

2.2 思路2 （暴力解：链表转数组，数组保存结点地址）

把两个链表的结点地址分别保存到两个数组中，从末尾遍历两个数组找到第一个起始公共位置。

#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <algorithm>

typedef struct node{
    char data;
    struct node* next;
}NODE;

NODE* ans(NODE* str1, NODE* str2){
    NODE* S1[INT16_MAX];
    NODE* S2[INT16_MAX];
    NODE* p = str1->next;
    NODE* q = str2->next;
    int len1 = 0, len2 = 0;
    while(p != nullptr){
        S1[len1++] = p;
        p = p->next;
    }
    while(q != nullptr){
        S2[len2++] = q;
        q = q->next;
    }
    if(S1[len1 - 1] != S2[len2 - 1]) return nullptr;
    for(int i = 1;i < std::min(len1, len2);i++){
        if(S1[len1 - i] != S2[len2 - i])
            return S1[len1 - i + 1];//输出起始位置
    }
    return S1[len1 - std::min(len1, len2)];//有一条链遍历完了

}

//使用尾插法创建结点
void create(NODE* &L1, NODE* &L2){
    NODE *r1 = L1, *r2 = L2, *p;
    int num;
    char word1[] = "loading";
    char word2[] = "being";
    for(int i = 0;i < strlen(word1);i++){
        NODE *s = (NODE*)malloc(sizeof(NODE));
        s->data = *(word1 + i);
        r1->next = s;
        r1 = s;
    }
    r1->next = NULL;
    p = L1;
    while(p->next != NULL){
        p = p->next;
        if(p->data == 'i') break;
    }
    for(int i = 0;i < sizeof(word2) - 1;i++){
        NODE *s = (NODE*)malloc(sizeof(NODE));
        s->data = *(word2 + i);
        if(s->data == 'i'){
            r2->next = p;
            break;
        }
        r2->next = s;
        r2 = s;
    }
}
//打印数据
void print(NODE* L){
    NODE* p = L;
    while(p!=NULL){
        printf("%c", p->data);
        p = p->next;
    }
}

int main(){
    NODE *str1, *str2;
    str1 = (NODE*)malloc(sizeof(NODE));
    str1->next = NULL;
    str2 = (NODE*)malloc(sizeof(NODE));
    str2->next = NULL;
    create(str1, str2);
    NODE* s = ans(str1, str2);
    //printf("%c", s->data);
    print(s);
    return  0;
}

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

2.3 思路3（最优解：双指针法）

1，分别求两个链表的长度（ $len_1，len_2$ ）；
2，让长的链表往后移动 $len_1-len_2$ 的绝对值次，使得两个链表剩余未访问的结点数相等；
3 ，然后链表的指针同步往后移动比较，直到指向同一个结点。

#include <cstdio>
#include <cstdlib>
#include <string.h>

typedef struct node{
    char data;
    struct node* next;
}NODE;

NODE* ans(NODE* str1, NODE* str2){
    NODE *p = str1, *q = str2;
    int len1 = 0, len2 = 0;
    while(p != NULL){//求长度
        p = p->next;
        len1++;
    }
    while(q != NULL){
        q = q->next;
        len2++;
    }
    p = str1;
    q = str2;
    if(len1 > len2){
        int dis = len1 - len2;
        while (dis--){
            p = p->next;
        }
    }else{
        int dis = len2 - len1;
        while (dis--){
            q = q->next;
        }
    }
    while(p->next != q->next && p->next != NULL){
        p = p->next;
        q = q->next;
    }
    return  p->next;
    //while(p->next != NULL){
    //if(p->next == q->next){
    //  return p->next;
    //}else{
    //   p = p->next;
    //     q = q->next;
    //   }
    // }
    //   return  NULL;
}

//使用尾插法创建结点
void create(NODE* &L1, NODE* &L2){
    NODE *r1 = L1, *r2 = L2, *p;
    int num;
    char word1[] = "loading";
    char word2[] = "being";
    for(int i = 0;i < strlen(word1);i++){
        NODE *s = (NODE*)malloc(sizeof(NODE));
        s->data = *(word1 + i);
        r1->next = s;
        r1 = s;
    }
    r1->next = NULL;
    p = L1;
    while(p->next != NULL){
        p = p->next;
        if(p->data == 'i') break;
    }
    for(int i = 0;i < sizeof(word2) - 1;i++){
        NODE *s = (NODE*)malloc(sizeof(NODE));
        s->data = *(word2 + i);
        if(s->data == 'i'){
            r2->next = p;
            break;
        }
        r2->next = s;
        r2 = s;
    }
}
//打印数据
void print(NODE* L){
    NODE* p = L;
    while(p!=NULL){
        printf("%c", p->data);
        p = p->next;
    }
}

int main(){
    NODE *str1, *str2;
    str1 = (NODE*)malloc(sizeof(NODE));
    str1->next = NULL;
    str2 = (NODE*)malloc(sizeof(NODE));
    str2->next = NULL;
    create(str1, str2);
    NODE* s = ans(str1, str2);
    //printf("%c", s->data);
    print(s);
    return  0;
}