王道数据结构第二章试题参考代码（附带运行效果展示）

虽然说是参考 不过是我自己写的 经过我并不严谨但还算凑合的测试 代码应该都没什么问题且符合题意 语言为C++

写这个的主要目的就是我很讨厌答案里面给的那种 形参是个指针变量 还要加个引用 你是从俄罗斯来的人吗 别的没学会就学会一手套娃？

王道p40 问题1

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLInkwithouthead(LinkList s)
{
    while (s != nullptr)
    {
        cout <<setw(5)<< s->data;
        s = s->next;
    }
}
void digui_delete(LinkList &s, int x)
{
    if(s == nullptr)
    {
        return;
    }
    else if(s->data==x)
    {
        s = s->next;
        digui_delete(s, x);
    }
    else
    {
        digui_delete(s->next, x);
    }
    
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a={5,NULL };
    LinkList s = &a;
    for (int i = 0; i < 10; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL};
        s->next = newnode;
        s = s->next;
    }
    s = &a;
    printLInkwithouthead(s);
    cout << endl;
    digui_delete(s, 5);
    printLInkwithouthead(s);
}

王道 p40 问题2 时间复杂度O（n） 空间复杂度O（1）

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void funx(LinkList s, int x)
{
    LinkList p = s->next;
    if (p == NULL)
    {
        return;
    }
    else if (p->data == x)
    {
        if (p->next == NULL)
        {
            s->next = NULL;
            free(p);
            return;
        }
        else
        {
            p->data = p->next->data;
            LinkList next = p->next;
            p->next = p->next->next;
            free(p->next);
            funx(s, x);
        }
    }
    else
    {
        funx(p, x);
    }
    
}
void printLink(LinkList s)
{
    while (s->next != NULL)
    {
        s = s->next;
        cout<<setw(4)<< s->data;
    }
    cout << endl;
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a={ -1,NULL };
    LinkList s = &a;
    for (int i = 0; i < 10; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL};
        s->next = newnode;
        s = s->next;
    }
    LinkList p = &a;
    cout << "输出链表" << endl;
    printLink(p);
    funx(p, 3);
    printLink(p);
}

当然也能用尾指针的办法解决这个问题

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout << setw(4) << s->data;
    }
    cout << endl;
}
void rear_deletex(LinkList s, int x)
{
    LinkList rear = s;
    s = s->next;
    rear->next = NULL; //注意这一行代码 考虑全是x得情况 如果没有这个 那么输出会保持不变
    while (s != NULL)
    {
        if (s->data != x)
        {
            rear->next = s;
            rear = rear->next;
            s = s->next;
            rear->next = NULL;
        }
        else
        {
            LinkList p = s;
            s = s->next;
            free(p);
        }
    }
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a={-1,NULL }; //头结点
    LinkList s = &a;
    for (int i = 0; i < 10; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL};
        s->next = newnode;
        s = s->next;
    }
    s = &a;
    int x = 5;
    printLink(s);
    rear_deletex(s, x);
    printLink(s);
}

问题4

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void minList(LinkList head)
{
    LinkList premin = head;
    LinkList p = head;
    LinkList mins = p->next;
    if (p ->next == nullptr)
    {
        cout << "空链表 说锤子" << endl;
        return;
    }
    else
    {
        while(p->next!=nullptr)
        {
            LinkList s = p;
            p = p->next;
            if (p->data < mins->data)
            {
                premin = s;
                mins = p;
            }
        }
    }
    premin->next = mins->next;
    free(mins);
}
void printLink(LinkList s)
{
    while (s->next != NULL)
    {
        s = s->next;
        cout << setw(4) << s->data;
    }
    cout << endl;
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a={-1,NULL }; //头结点
    LinkList s = &a;
    for (int i = 0; i < 10; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL};
        s->next = newnode;
        s = s->next;
    }
    s = &a;
    printLink(s);
    minList(s);
    printLink(s);
}

问题五 就地逆置 这种一般递归吧 确实应该是就地逆置吧 我也没用什么别的东西 也有可能不是 因为从本质上来说 p这个变量可以用end代替 我想空间复杂度应该是O(1)的

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout << setw(4) << s->data;
    }
    cout << endl;
}
void digui_reverse(LinkList Head, LinkList end, LinkList &front)
{
    LinkList p = end;
    if (p == nullptr)
    {
        return;
    }
    if (p->next != nullptr)
    {
        digui_reverse(Head, p->next, front);
        if (p == front->next)
        {
            p->next = nullptr;
        }
        else
        {
            p->next = front->next;
            front->next = p;
            front = p;
        }
    }
    else
    {
        p->next = front->next;
        front->next = p;
        front = p;
    }
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    LinkList s = &a;
    for (int i = 0; i < 10; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    s = &a;
    int x = 5;
    printLink(s);
    LinkList front = s;
    digui_reverse(s, s->next, front);
    printLink(s);
}

这个算法写了挺久的因为递归很麻烦 看看书上怎么写吧 书上介绍了一种非常简单的头插法 、

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout << setw(4) << s->data;
    }
    cout << endl;
}
void digui_reverse(LinkList Head)
{
    LinkList p = Head->next;
    LinkList temp;
    if (p == nullptr) //空你说锤子
    {
        return;
    }
    while (p != nullptr)
    {
        temp= p->next;
        p->next = Head->next;
        Head->next = p;
        if (p->next == p)
        {
            p->next = nullptr;
        }
        p = temp;
    }
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    LinkList s = &a;
    for (int i = 0; i < 1; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    s = &a;
    int x = 5;
    printLink(s);
    LinkList front = s;
    digui_reverse(s);
    printLink(s);
}

当然也可以通过将头结点next域置为NULL的方式来确保链表最后指针域为空 当然你也可以简单粗暴的反转指针 阿巴阿巴

问题六 因为需要检测和头文件 构建链表 代码显然是要远超答案的 时间复杂度O（n^2） 空间复杂度O（1）

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout << setw(4) << s->data;
    }
    cout << endl;
}
void sort_linkList(LinkList P)
{
    LinkList nowp = P->next;//表示第一个节点
    if (nowp == NULL || nowp->next == NULL)//表示没有节点或者只有一个节点
    {
        return;//显然不需要做任何操作
    }
    nowp = nowp->next; //表示第二个节点
    P->next->next = NULL; //断链 使得链表只接上首节点
    while (nowp != NULL) //该节点不为空
    {
        LinkList temp = nowp->next; //接上断链部分
        LinkList pre = P;
        LinkList compa = P->next; //表示比较的第一个节点
        while (compa != NULL)
        {
            if (compa->data >= nowp->data) //表示插入位置
            {
                nowp->next = compa;
                pre->next = nowp; //插入节点
                break;
            }
            else
            {
                pre = compa;
                compa = compa->next;
            }
        }
        if (compa == NULL) //表示进行到了最后 这个节点是最大的
        {
            pre->next = nowp;
            pre->next->next = NULL;
        }
        nowp = temp;
    }
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    LinkList s = &a;
    for (int i = 0; i < 10; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    s = &a;
    int x = 5;
    printLink(s);
    sort_linkList(s);
    printLink(s);
}

问题7

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout << setw(4) << s->data;
    }
    cout << endl;
}
void delete_linklist(LinkList p,int max,int min)
{
    LinkList nowp = p->next; //第一个节点
    LinkList pre = p;
    if (nowp == nullptr)
    {
        return;
    }
    while (nowp != nullptr)
    {
        if (nowp->data > min&& nowp->data < max)
        {
            pre->next = nowp->next;
            nowp = pre->next;
        }
        else
        {
            pre = nowp;
            nowp = nowp->next;
        }
    }
}
int main()
{

    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    LinkList s = &a;
    for (int i = 0; i < 10; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    s = &a;
    int x = 5;
    printLink(s);
    delete_linklist(s, 20, 10);
    printLink(s);
}

问题8

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout << setw(4) << s->data;
    }
    cout << endl;
}
void Fun(LinkList A, LinkList B, int lengthA, int lengthB)
{
    LinkList longN = lengthA > lengthB ? A : B;
    LinkList shortN = lengthA < lengthB ? A : B;
    int lengthx = abs(lengthA - lengthB);
    for (int i = 0; i < lengthx; i++)
    {
        longN = longN->next;
    }
    while (longN != nullptr)
    {
        if (longN == shortN)
        {
            cout << longN->data << endl;
            break;
        }
        longN = longN->next;
        shortN = shortN->next;
    }
}
int main()
{

    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    Lnode b = { -1,NULL };
    Lnode c = { -1,NULL };
    LinkList s = &a;
    LinkList d = &b;
    LinkList f = &c;
    int lengthA;
    int lengthB;
    int lengthC;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    cout << "请输入链表B长度" << endl;
    cin >> lengthB;
    cout << "请输入链表C长度" << endl; //C为共同内容
    cin >> lengthC;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    for (int i = 0; i < lengthB; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        d->next = newnode;
        d = d->next;
    }   
    for (int i = 0; i < lengthC; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        f->next = newnode;
        f = f->next;
    }
    d->next = static_cast<LinkList>(&c)->next;
    s->next = static_cast<LinkList>(&c) -> next;
    s = &a;
    d = &b;
    int x = 5;
    printLink(s);
    printLink(d);
    Fun(s, d, lengthA + lengthC, lengthB + lengthC);

}

第9题 显然可以通过头插法排序的方式有序化链表

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout <<left << setw(4) << s->data;
    }
    cout << endl;
}
void fun(LinkList s)
{
    LinkList nowp = s->next;
    s->next = nullptr;
    while (nowp != nullptr)
    {
        LinkList temp = nowp->next;
        LinkList rear = s;
        LinkList ori = s->next;
        while (ori != nullptr)
        {
            if (ori->data > nowp->data)
            {
                nowp->next = ori;
                rear->next = nowp;
                break;
            }
            rear = ori;
            ori = ori->next;
        }
        if (ori == nullptr)
        {
            nowp->next = nullptr;
            rear->next = nowp;
        }
        nowp = temp;
    }
}
void fun2(LinkList s)
{
    s = s->next;
    LinkList temp=s;
    while (s!= nullptr)
    {
        cout << s->data<<endl;
        temp->next = s->next;
        free(s);
        s = temp->next;
    }
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    LinkList s = &a;
    int lengthA;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    s = &a;
    printLink(s);
    fun(s);
    printLink(s);
    fun2(s);
    printLink(s);
}

第10题 虽然不难 但是不要忘记把生成的两个链表表尾最后置为nullptr

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout <<left << setw(4) << s->data;
    }
    cout << endl;
}
void fun(LinkList s,LinkList p,LinkList t)
{
    LinkList tail1 = p; //尾指针1
    LinkList tail2 = t; //尾指针2
    int count = 0;
    s = s->next; //表示s的第一个节点
    while (s != nullptr)
    {
        ++count;
        if (count % 2 == 1) //奇数
        {
            tail1->next = s;
            tail1 = tail1->next;
        }
        else
        {
            tail2->next = s;
            tail2 = tail2->next;
        }
        s = s->next;
    }
    tail1->next = NULL;
    tail2->next = NULL;
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    Lnode b = { -1,NULL }; //头结点
    Lnode c = { -1,NULL }; //头结点
    LinkList s = &a;
    LinkList p = &b;
    LinkList t = &c;
    int lengthA;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    s = &a;
    printLink(s);
    fun(s, p, t);
    printLink(p);
    printLink(t);
}

第十一题 链表二用头插法逆置就可以了 大部分代码和第十题相同

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout <<left << setw(4) << s->data;
    }
    cout << endl;
}
void fun(LinkList s,LinkList p,LinkList t)
{
    LinkList tail1 = p; //尾指针1
    LinkList head = t; //尾指针2
    LinkList temp;
    int count = 0;
    s = s->next; //表示s的第一个节点
    while (s != nullptr)
    {
        temp = s->next;
        ++count;
        if (count % 2 == 1) //奇数
        {
            tail1->next = s;
            tail1 = tail1->next;
        }
        else
        {
            s->next = head->next;
            head->next = s;
        }
        s = temp;
    }
    tail1->next = NULL;
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    Lnode b = { -1,NULL }; //头结点
    Lnode c = { -1,NULL }; //头结点
    LinkList s = &a;
    LinkList p = &b;
    LinkList t = &c;
    int lengthA;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    s = &a;
//  printLink(s);
    fun(s, p, t);
    printLink(p);
    printLink(t);
}

第十二题 递增有序 之前忘记保存了 但应该没问题

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout <<left << setw(4) << s->data;
    }
    cout << endl;
}

void fun(LinkList s)
{
    LinkList rear = s;
    LinkList nowp = s->next;
    if (nowp == nullptr)
    {
        return;
    }
    rear = nowp;
    nowp = nowp->next;
    while (nowp != nullptr)
    {
        if (nowp->data == rear->data)
        {
            rear->next = nowp->next;
            free(nowp);
            nowp = rear->next;
        }
        else
        {
            rear = nowp;
            nowp = nowp->next;
        }
    }
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    Lnode b = { -1,NULL }; //头结点
    Lnode c = { -1,NULL }; //头结点
    LinkList s = &a;
    LinkList p = &b;
    LinkList t = &c;
    int lengthA;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    s = &a;
    printLink(s);
    fun(s);
    printLink(s);
}

第十三题

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout <<left << setw(4) << s->data;
    }
    cout << endl;
}

void fun(LinkList s,LinkList p)
{
    //为了装逼 我们直接把最后生成的链表放在s的头结点后面
    LinkList now1 = s->next;
    LinkList now2 = p->next;
    s->next = NULL; //一号断链
    LinkList temp;
    while (now1 != NULL && now2 != NULL) //两个链表都没有结束
    {
        if (now1->data > now2->data)
        {
            //接上now2 
            temp = now2->next;
            now2->next = s->next;
            s->next = now2;
            now2 = temp;
        }
        else
        {
            temp = now1->next;
            now1->next = s->next;
            s->next = now1;
            now1 = temp;
        }
    }
    // 循环结束 表示可比较部分比较完毕
    if (now1 == nullptr) //now1 已经全部添加到新的链表中
    {
        while (now2 != nullptr)
        {
            temp = now2->next;
            now2->next = s->next;
            s->next = now2;
            now2 = temp;
        }
    }
    else
    {
        while (now1 != nullptr)
        {
            temp = now1->next;
            now1->next = s->next;
            s->next = now1;
            now1 = temp;
        }
    }
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    Lnode b = { -1,NULL }; //头结点
    Lnode c = { -1,NULL }; //头结点
    LinkList s = &a;
    LinkList p = &b;
    LinkList t = &c;
    int lengthA,lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    cout << "请输入链表B长度" << endl;
    cin >> lengthB;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    for (int i = 0; i < lengthB; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        p->next = newnode;
        p = p->next;
    }
    s = &a;
    p = &b;
    printLink(s);
    printLink(p);
    fun(s, p);
    printLink(s);
}

第十四题 这道题要求生成的链表不利用原来的节点 那么子函数中需要使用new来创建新的链表节点 否则 子函数无法返回对应的节点标识

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout << left << setw(4) << s->data;
    }
    cout << endl;
}

void fun(LinkList s, LinkList p, LinkList t)
{
    //t为最后返回的节点 不需要设置引用
    LinkList now1;
    LinkList now2;
    LinkList now3;
    now1 = s->next;
    now2 = p->next;
    now3 = t;
    while (now1 != NULL && now2 != NULL)
    {
        if (now1->data < now2->data)
        {
            now1 = now1->next;
        }
        else if(now1->data>now2->data)
        {
            now2 = now2->next;
        }
        else
        {
            LinkList newp =new Lnode{ now1->data,NULL };
            now3->next = newp;
            now3 = now3->next;
            now1 = now1->next;
            now2 = now2->next;
        }
    }
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    Lnode b = { -1,NULL }; //头结点
    Lnode c = { -1,NULL }; //头结点
    LinkList s = &a;
    LinkList p = &b;
    LinkList t = &c;
    int lengthA, lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    cout << "请输入链表B长度" << endl;
    cin >> lengthB;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    for (int i = 0; i < lengthB; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        p->next = newnode;
        p = p->next;
    }
    s = &a;
    p = &b;
    printLink(s);
    printLink(p);
    fun(s, p,t);
    //printLink(t);
    printLink(t);
}

第十五题

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout << left << setw(4) << s->data;
    }
    cout << endl;
}
void fun(LinkList s, LinkList p)
{
    //t为最后返回的节点 不需要设置引用
    LinkList now1;
    LinkList now2;
    LinkList now3;
    now1 = s->next;
    now2 = p->next;
    now3 = s;
    s->next = NULL;
    while (now1 != NULL && now2 != NULL)
    {
        if (now1->data < now2->data)
        {
            now1 = now1->next;
        }
        else if(now1->data>now2->data)
        {
            now2 = now2->next;
        }
        else
        {
            now3->next = now1;
            now3 = now3->next;
            now1 = now1->next;
            now2 = now2->next;
        }
    }
    now3->next = NULL;
}
int* fun1()
{
    int a[10];
    return a;
}
int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    Lnode b = { -1,NULL }; //头结点
    Lnode c = { -1,NULL }; //头结点
    LinkList s = &a;
    LinkList p = &b;
    LinkList t = &c;
    int lengthA, lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    cout << "请输入链表B长度" << endl;
    cin >> lengthB;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    for (int i = 0; i < lengthB; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        p->next = newnode;
        p = p->next;
    }
    s = &a;
    p = &b;
    printLink(s);
    printLink(p);
    fun(s, p);
    printLink(s);
}

第十六题 这题应该可以使用KMP算法 但是我忘了 先用暴力算法凑合做做吧
暴力算法本身也不具有太大难度 熟练之后应该还是挺简单的

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    while (s->next != NULL)
    {
        s = s->next;
        cout << left << setw(4) << s->data;
    }
    cout << endl;
}
void fun(LinkList s, LinkList p)
{
    LinkList now1 = s->next;
    LinkList temp = now1;
    LinkList now2 = p->next;
    if (now2 == nullptr)
    {
        return;
    }
    while (now1 != nullptr)
    {
        if (now2->data == now1->data)
        {
            temp = now1;
            while (now1!=NULL&&now2!=NULL)
            {
                if (now1->data == now2->data)
                {
                    now1 = now1->next;
                    now2 = now2->next;
                    continue;
                }
                else
                {
                    now1 = temp->next;
                    now2 = p->next;
                    break;
                }
            }
            if (now2 == NULL)
            {
                cout << "是对应的字串" << endl;
                return;
            }
            else if(now1==NULL)
            {
                cout << "不是对应的字串"<< endl;
                return;
            }
        }
        else
        {
            now1 = now1->next;
        }
    }
    if (now1 == NULL)
    {
        cout << "不是对应的字串" << endl;
    }
}

int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    Lnode b = { -1,NULL }; //头结点
    Lnode c = { -1,NULL }; //头结点
    LinkList s = &a;
    LinkList p = &b;
    LinkList t = &c;
    int lengthA, lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    cout << "请输入链表B长度" << endl;
    cin >> lengthB;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    for (int i = 0; i < lengthB; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        p->next = newnode;
        p = p->next;
    }
    s = &a;
    p = &b;
    printLink(s);
    printLink(p);
    fun(s, p);
}

第十七题

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
    struct Lnode* prior;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    LinkList now = s->next;
    while (now != s)
    {
        cout <<left<<setw(4)<< now->data;
        now = now->next;
    }
    cout << endl;
}
void fun(LinkList s)
{
    LinkList up = s->prior;
    LinkList down = s->next;
    while (up->data == down->data)
    {
        up = up->prior;
        down = down->next;
        if (up == down)
        {
            cout << "是对称的" << endl;
            return;
        }
    }
    cout << "不对称" << endl;
}

int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL,NULL }; //头结点
    Lnode b = { -1,NULL,NULL }; //头结点
    int LnodeLengthA;
    cout << "输入链表长度" << endl;
    cin >> LnodeLengthA;
    LinkList A = &a;
    for (int i = 0; i < LnodeLengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode =new Lnode { data,NULL,NULL };
        newnode->prior= A;
        A->next = newnode;
        A = newnode;
    }
    A->next = &a;
    (&a)->prior = A;
    A = &a;
    printLink(A);
    fun(A);
}

第十八题

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    LinkList p = s;
    while (p->next !=s)
    {
        p = p->next;
        cout << left << setw(4) << p->data;
    }
    cout << endl;
}
void fun(LinkList s, LinkList p)
{
    LinkList B = p;
    LinkList A = s;
    LinkList rearA;
    LinkList rearB;
    while (A->next != s)
    {
        A = A->next;
    }
    while (B->next != p)
    {
        B = B->next;
    }
    rearA = A; //表示链表s的最后一个节点
    rearB = B; //表示链表p的最后一个节点
    rearA->next = p->next;
    rearB->next = s;
}

int main()
{
    cout << "请生成链表" << endl;
    Lnode a = { -1,NULL }; //头结点
    Lnode b = { -1,NULL }; //头结点
    Lnode c = { -1,NULL }; //头结点
    LinkList s = &a;
    LinkList p = &b;
    LinkList t = &c;
    int lengthA, lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    cout << "请输入链表B长度" << endl;
    cin >> lengthB;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    for (int i = 0; i < lengthB; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        p->next = newnode;
        p = p->next;
    }
    s->next = &a;
    p->next = &b;
    s = &a;
    p = &b;
    printLink(s);
    printLink(p);
    fun(s, p);
    printLink(s);
}

第十九题 首先这个free 不知道怎么就不能用了 然后重启之后又能用了 阿巴阿巴 神奇的vs 然后这个循环要注意一下 明明不是很难 写了半年

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    LinkList p = s;
    while (p->next !=s)
    {
        p = p->next;
        cout << left << setw(4) << p->data;
    }
    cout << endl;
}
void fun(LinkList s)
{
    LinkList p;
    while (s->next !=s)  //表示链表不为空
    {
        p = s->next;
        int min = p->data;
        LinkList minp=p;
        LinkList minpriorp=s;
        LinkList prior = s;
        while (p!= s)//表示还没有一轮
        {
            if (min > p->data)
            {
                minp = p;
                minpriorp = prior;
                min = p->data;
            }
            prior = p;
            p = p->next;
        }
        minpriorp->next = minp->next;
        delete minp;
        printLink(s);
    }
    delete s;
}

int main()
{
    cout << "请生成链表" << endl;
    LinkList A = new Lnode{-1,NULL};
    LinkList s = A;
    int lengthA, lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    s->next = A;
    printLink(A);
    fun(A);
}

第二十题 需要考虑一些特殊情况 例如 检测到的节点在末尾 或者 检测节点位置和插入位置相同等等

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    int num;
    struct Lnode* next;
    struct Lnode* prior;
}Lnode, *LinkList;
void printLink(LinkList s) //带头节点输出
{
    LinkList p = s;
    while (p->next !=NULL)
    {
        p = p->next;
        cout << left << setw(4) << p->data;
    }
    cout << endl;
}
void fun(LinkList s,int xw)
{
    //其实也就是访问 data为x的节点
    LinkList p = s->next;
    while (p!=nullptr&&p->data != xw)
    {
        p = p->next;
    }
    if (p == nullptr)
    {
        cout << "这个值在链表中不存在 亲";
        return;
    }
    else //这个点就是我们要找的点
    {
        p->num++;//此行根据从左到右规则运算
        LinkList newnum = s->next;
        while (newnum->num > p->num)
        {
            newnum = newnum->next;
        }
        //退出 要么newnum是最后一个 要么是表示第一个频率等于或者小于p的节点
        //当然也有可能就是p本身 显然如果newnum是最后一个 那么必然也就是p本身
        //p应当插入newnum的前方
        if (p != newnum)
        {
            p->prior->next = p->next; //从链表中暂时删除p
            if (p->next != nullptr)
            {
                p->next->prior = p->prior;
            }
            p->prior = newnum->prior;
            newnum->prior->next = p;
            newnum->prior = p;
            p->next = newnum;
        }
    }
}

int main()
{
    cout << "请生成链表" << endl;
    LinkList A = new Lnode{-1,0,NULL,NULL};
    LinkList s = A;
    int lengthA, lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,0,NULL,NULL };
        s->next = newnode;
        newnode->prior = s;
        s = s->next;
    }
    //构建非循环双向链表
    printLink(A);
    for (int i = 0; i < 10; i++)
    {
        int data;
        cin >> data;
        fun(A, data);
        printLink(A);
    }
}

第二十一题 此题为2009真题 注意一下循环终止条件即可 不算难题

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, *LinkList;
void printLink(LinkList s) //带头节点输出
{
    LinkList p = s;
    while (p->next !=NULL)
    {
        p = p->next;
        cout << left << setw(4) << p->data;
    }
    cout << endl;
}
void fun(LinkList Head, int x)//功能函数
{
    //通过设置第二个指针的方式可以解决这个问题
    int num = -x;
    LinkList Work=Head;
    LinkList realNum=Head;
    while (Work->next != nullptr)
    {
        Work = Work->next;
        num++;
        if (num >= 0)
        {
            realNum = realNum->next;
        }
    }
    if (realNum == Head)
    {
        cout << "您给的值有点太大了亲" << endl;
    }
    else
    {
        cout << realNum->data;
    }
}
int main()
{
    cout << "请生成链表" << endl;
    LinkList A = new Lnode{-1,NULL};
    LinkList s = A;
    int lengthA, lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    //构建链表
    printLink(A);
    int num;
    cin >> num;
    fun(A, num);
}

第二十二题 此题为2012 408真题
这道题思想和第八题完全相同 此处不再赘述 只需要先获取两个链表长度然偶右对齐即可
等第二次复习再写吧

第二十三题 可使用辅助数组 这应该是最容易想到的 使用hash表也行 不过就需要知道怎么使用哈希表了 总而言之 哈希表的使用还是很简单的

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, *LinkList;
void printLink(LinkList s) //带头节点输出
{
    LinkList p = s;
    while (p->next!=NULL)
    {
        p = p->next;
        cout << left << setw(4) << p->data;
    }
    cout << endl;
}
void fun(LinkList Head)//功能函数
{
    map<int, int> hashmap;
    LinkList p = Head->next;
    LinkList rear = Head;
    while (p != nullptr)
    {
        if (hashmap[abs(p->data)] == 0) //震惊 这都行 保险也可以写 if(hashmap.find(abs(p->data))==hashmap.end())
        {
            
            hashmap[(abs(p->data))]++;
            rear = p;
            p = p->next;
        }
        else //表示这个节点应该要去世了
        {
            rear->next = p->next;
            free(p);
            p = rear->next;
        }
    }
}
int main()
{
    cout << "请生成链表" << endl;
    LinkList A = new Lnode{-1,NULL};
    LinkList s = A;
    int lengthA, lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    //构建链表
    printLink(A);
    fun(A);
    printLink(A);
}

第二十四题 这题。。我觉的和上面那个可以用同种办法解决 同样哈希表 不过测试用例比较难写就是了
不过这道题答案的方法也很巧妙 可以一试 如果要求空间复杂度为1 那么答案上这种还是很有可取之处的

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, *LinkList;
void printLink(LinkList s) //带头节点输出
{
    LinkList p = s;
    while (p->next!=NULL)
    {
        p = p->next;
        cout << left << setw(4) << p->data;
    }
    cout << endl;
}
void fun(LinkList Head)//功能函数
{
    map<LinkList, int> hashmap;
    LinkList p = Head->next;
    LinkList rear = Head;
    while (p != nullptr)
    {
        if (hashmap[p] == 0) //震惊 这都行 保险也可以写 if(hashmap.find(abs(p->data))==hashmap.end())
        {
            hashmap[p]++;
            rear = p;
            p = p->next;
        }
        else //表示兄弟这个节点不是第一次访问了
        {
            cout << "兄弟你不是第一次来这里了" << endl;
            cout << p->data << endl;
            return;
        }
    }
    cout << "没有循环节点" << endl;
}
int main()
{
    cout << "请生成链表" << endl;
    LinkList A = new Lnode{-1,NULL};
    LinkList B = new Lnode{ -1,NULL };
    LinkList s = A;
    LinkList t = B;
    int lengthA, lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    cout << "请输入链表B长度" << endl;
    cin >> lengthB;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    for (int i = 0; i < lengthB; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        t->next = newnode;
        t = t->next;
    }
    //构建链表
    s->next = B->next;
    t->next = s;
    fun(A);
}

第二十五题 这题看起来不简单 是2019年真题
我写的递归方法比较复杂看不懂可以看下面答案的推荐方法
但两种方法都需要找到链表的中点位置
我最开始想到的就是递归 但是递归的话 不是很好操作 需要使用引用逐层返回插入点的插入位置

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    LinkList p = s;
    while (p->next != NULL)
    {
        p = p->next;
        cout << left << setw(4) << p->data;
    }
    cout << endl;
}
void digui(LinkList head,LinkList& now1, LinkList now2)
{
    if (now2->next != nullptr) //表示第二队列还没有到最后一个点处
    {
        LinkList temp = now2;
        digui(head,now1, now2->next); //递归结束返回时 
                //假设其为倒数第二层 那么其原来的节点已经被删除
        now2->next = now1->next;
        now1->next = now2;
        now1 = now1->next->next;
    }
    else
    {
        //已经是最后一个节点
        now2->next = now1->next;
        now1->next = now2;
        now1 = now1->next->next;
    }
    printLink(head);
}
void fun(LinkList Head)//功能函数
{
    LinkList n1 = Head;
    LinkList n2 = Head;
    if (Head->next == nullptr || Head->next->next == nullptr)
    {
        //表示链表为空或者只有一个元素
        return;
    }
    while (n1!=nullptr&&n1->next != nullptr)
    {
        n1 = n1->next; //n1前进两步 n2前进一步
        n1 = n1->next;
        n2 = n2->next;
    }
    //此时n2指向的位置是前半部分的最后一个元素
    LinkList temp = n2->next;
    n2->next = NULL;
    n1 = Head->next;
    digui(Head,n1, temp);
}

int main()
{
    cout << "请生成链表" << endl;
    LinkList A = new Lnode{ -1,NULL };
    LinkList s = A;
    int lengthA, lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    //构建链表
    printLink(A);
    fun(A);
    printLink(A);
}

答案给的方法很巧妙

#include<iostream>
#include<iomanip>
#include<string>
#include<fstream>
#include<cmath>
#include<vector>
#include<stack>
#include<cstdio>
#include<array>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, * LinkList;
void printLink(LinkList s) //带头节点输出
{
    LinkList p = s;
    while (p->next != NULL)
    {
        p = p->next;
        cout << left << setw(4) << p->data;
    }
    cout << endl;
}
void fun(LinkList Head)//功能函数
{
    LinkList n1 = Head;
    LinkList n2 = Head;
    if (Head->next == nullptr || Head->next->next == nullptr)
    {
        //表示链表为空或者只有一个元素
        return;
    }
    while (n1!=nullptr&&n1->next != nullptr)
    {
        n1 = n1->next; //n1前进两步 n2前进一步
        n1 = n1->next;
        n2 = n2->next;
    }
    //此时n2指向的位置是前半部分的最后一个元素
    LinkList temp = n2->next;
    n2->next = NULL;
    while (temp != nullptr)
    {
        LinkList temp2 = temp->next;
        temp->next = n2->next;
        n2->next = temp;
        temp = temp2;
    }
    //后半段逆置完成 n2的值并未发生变化
    n1 = Head->next;
    LinkList t = n2;
    n2 = n2->next;
    t->next = NULL;
    while (n2 != nullptr)
    {
        LinkList temp = n2->next;
        n2->next = n1->next;
        n1->next = n2;
        n2 = temp;
        n1 = n1->next->next;
    }
}
int main()
{
    cout << "请生成链表" << endl;
    LinkList A = new Lnode{ -1,NULL };
    LinkList s = A;
    int lengthA, lengthB;
    cout << "请输入链表A长度" << endl;
    cin >> lengthA;
    for (int i = 0; i < lengthA; i++)
    {
        int data;
        cin >> data;
        LinkList newnode = new Lnode{ data,NULL };
        s->next = newnode;
        s = s->next;
    }
    //构建链表
    printLink(A);
    fun(A);
    printLink(A);
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

友情链接更多精彩内容