19版考研数据结构王道课后习题代码-线性表【完】

最新推荐文章于 2024-07-03 11:56:24 发布
最新推荐文章于 2024-07-03 11:56:24 发布
阅读量296 收藏 2
点赞数
分类专栏： 考研
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36927714/article/details/102308313
版权 
#include <iostream>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <stack>
using namespace std;
#define maxSize 101

/*
//设计递归算法，删除不带头节点的单链表中所有值为x的节点 P37 1
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void Delete(List &t,int x)
{
    if(t)
    {
        if(t->data==x)
    {
        LNode *p=t;
        t=t->next;
        free(p);
        Delete(t,x);
    }
    Delete(t->next,x);
    }
}
int main()
{
    LNode *t;
    int n,t0;
    cin>>n;
    cin>>t0;
    t=(LNode*)malloc(sizeof(LNode));
    t->data=t0;
    t->next=NULL;
    LNode *q=t;
    for(int i=1;i<n;i++)
    {
        cin>>t0;
        LNode *s=(LNode*)malloc(sizeof(LNode));
        s->data=t0;
        q->next=s;
        q=s;
        q->next=NULL;
    }

    Delete(t,3);
    while(t)
    {
        cout<<t->data<<" ";
        t=t->next;
    }
}
*/

/*
//删除带头节点的单链表中值为x的节点 P37 2
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
void Delete(LNode *&t,int x)
{
    LNode *pre=t;
    LNode *p=pre->next;
    while(p)
    {
        if(p->data==x)
        {
            pre->next=p->next;
            p=pre->next;
        }
        else
        {
            pre=pre->next;
            p=pre->next;
        }
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Delete(t,3);
    while(t->next)
    {
        cout<<t->next->data<<" ";
        t=t->next;
    }
}

*/


/*
//从尾到头反向输出单链表的值 P37 3
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
void Reverse(LNode *t)
{
    int stack[maxSize];
    int top=-1;
    while(t->next)
    {
        stack[++top]=t->next->data;
        t=t->next;
    }
    while(top!=-1)
    {
        cout<<stack[top--]<<" ";
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Reverse(t);
}
5
4 2 1 6 7
7 6 1 2 4
*/


/*
//删除单链表的最小值节点 P37 4
//用minpre和minp来删除节点！！
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void Delete(LNode *&t)
{
    LNode *minpre,*minp;
    int min;
    LNode *pre=t;
    LNode *p=t->next;
    minp=p;
    minpre=pre;
    min=p->data;
    while(p)
    {
        if(p->data<min)
        {
            min=p->data;
            minp=p;
            minpre=pre;
        }
        p=p->next;
        pre=pre->next;
    }
    minpre->next=minp->next;
    free(minp);
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Delete(t);
    while(t->next)
    {
        cout<<t->next->data<<" ";
        t=t->next;
    }
}
 */

/*
//将带头节点的单链表就地逆置 P37 5
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void Reverse(LNode *&t)
{
    LNode *p=t;
    LNode *q=p->next;
    LNode *r=q->next;
    q->next=NULL;   //易错点!!!一点要让q后面为空！！！
    LNode *s;
    while(r)
    {
        s=r->next;
        r->next=q;
        p->next=r;
        q=r;
        r=s;
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Reverse(t);
    while(t->next)
    {
        cout<<t->next->data<<" ";
        t=t->next;
    }
}
*/


/*
//使带头节点的单链表单增 P37 6  使用直接插入排序
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void SelectSort(LNode *&t)
{
    LNode *prer=t->next;
    LNode *r=t->next->next;
    while(r)
    {
        LNode *pre=t;
        LNode *p=t->next;
        while(p->data<=r->data&&p!=r)  //易错点！！要加上等号且p不能超过r！！
        {
            p=p->next;
            pre=pre->next;
        }
        if(p->data>r->data)
        {
            prer->next=r->next;
            r->next=p;
            pre->next=r;
            r=prer->next;
        }
        else
        {
            r=r->next;
            prer=prer->next;
        }
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    SelectSort(t);
    while(t->next)
    {
        cout<<t->next->data<<" ";
        t=t->next;
    }
}
//7
//3 1 4 1 2 9 1
//1 1 1 2 3 4 9
*/


/*
//删除介于给定两个值之间的元素 P37 7
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void Delete(LNode *t,int a,int b)
{
    LNode *pre=t;
    LNode *p=pre->next;
    while(p)
    {
        if(p->data>=a&&p->data<=b)
        {
            pre->next=p->next;
            p=pre->next;
        }
        else
        {
            pre=pre->next;
            p=p->next;
        }
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Delete(t,2,5);
    while(t->next)
    {
        cout<<t->next->data<<" ";
        t=t->next;
    }
}


7
3 2 1 5 6 7 3
1 6 7
*/


/*
//找出两个链表的公共节点 P37 8  公共节点不只是值相同，而是同一个节点的意思。形状像Y，而不是X，从第一个公共节点到尾节点，这一部分是重合的
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
int strlen(LNode *t)
{
    int cnt=0;
    while(t->next)
    {
        cnt++;
        t=t->next;
    }
    return cnt;
}
LNode *Find(LNode *l1,LNode *l2)
{
    int len1=strlen(l1);
    int len2=strlen(l2);
    LNode *longlist,*shortlist;
    int longlen,shortlen;
    if(len1>len2)
    {
        longlist=l1;
        longlen=len1;
        shortlist=l2;
        shortlen=len2;
    }
    else
    {
        longlist=l2;
        longlen=len2;
        shortlist=l1;
        shortlen=len1;
    }
    int t=longlen-shortlen;
    while(t)
    {
        longlist=longlist->next;
        t--;
    }
    while(longlist&&shortlist)
    {
        if(longlist==shortlist)
        {
            return longlist;
        }
        else
        {
            shortlist=shortlist->next;
            longlist=longlist->next;
           // cout<<longlist->data<<" "<<shortlist->data<<endl;
        }
    }
    return NULL;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i<n2;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t3=(LNode*)malloc(sizeof(LNode));
    t3->next=NULL;
    int n3;
    cin>>n3;
    cin>>t0;
    t3->data=t0;
    LNode *q3=t3;
    for(int i=1;i<n3;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q3->next=p;
        q3=p;
        q3->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    q->next=t3;
    q2->next=t3;
    
//    while(t->next)
//    {
//        cout<<t->next->data<<" ";
//        t=t->next;
//    }
//    cout<<endl;
//    while(t2->next)
//    {
//        cout<<t2->next->data<<" ";
//        t2=t2->next;
//    }
    
    LNode *s=Find(t,t2);
    cout<<s->data;
}
*/


/*
//按递增顺序输出节点元素的数据，并释放节点所占的空间  P37 9  每次找出单链表中最小的元素，输出，删除
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void Sort(LNode *head)
{
    while(head->next)
    {
        LNode *p=head->next;
        int min=p->data;
        LNode *minp=p;
        LNode *minpre=head;
        LNode *pre=head;
        while(p)
        {
            if(p->data<min)
            {
                min=p->data;
                minp=p;
                minpre=pre;
            }
        p=p->next;
        pre=pre->next;
        }
        cout<<min<<" ";
        minpre->next=minp->next;
        free(minp);
    }
    free(head);
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Sort(t);
}


6
3 6 4 1 2 8
1 2 3 4 6 8
*/

/*
//将单链表A分解为A和B，A含序号为奇数的元素，B含偶数 P37 10
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
void Split(LNode *a)
{
    int i=0;
    LNode *p=a;
    LNode *ra=(LNode*)malloc(sizeof(LNode));
    ra->next=NULL;
    LNode *b=(LNode*)malloc(sizeof(LNode));
    b->next=NULL;
    LNode *rb;
    rb=b;
    while(p->next)
    {
        i++;
        p=p->next;
        if(i%2==1)
        {
            ra->next=p;
            ra=p;
        }
        else
        {
            rb->next=p;
            rb=p;
        }
    }
    ra->next=NULL;
    rb->next=NULL;
    while(a->next)
    {
        cout<<a->next->data<<" ";
        a=a->next;
    }
    cout<<endl;
    while(b->next)
    {
        cout<<b->next->data<<" ";
        b=b->next;
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Split(t);
}
*/


/*
//就地算法，拆分单链表 P37 11
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
void Split(LNode *t)
{
    LNode *p=t->next;
    int i=0;
    LNode *a=(LNode*)malloc(sizeof(LNode));
    a->next=NULL;
    LNode *ra=a;
    LNode *b0=(LNode*)malloc(sizeof(LNode));
    b0->next=NULL;
    LNode *b=b0;
    while(p)
    {
        i++;
        if(i%2==1)
        {
            ra->next=p;
            ra=p;
            p=p->next;   //易错点
            ra->next=NULL;
        }
        else
        {
            LNode *q=p;
            p=p->next;   //注意上下这两个易错点处，改变q会把p也改变，因此p要后移才能保存p的后继节点！！
            q->next=b->next;
            b->next=q;
        }
    }
    
    while(a->next)
    {
        cout<<a->next->data<<" ";
        a=a->next;
    }
    while(b0->next)
    {
        cout<<b0->next->data<<" ";
        b0=b0->next;
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Split(t);
}

5
3 2 1 2 4
3 1 4 2 2
*/

/*
//删除表中重复元素 P37 12
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
void Delete(LNode *t)
{
    LNode *p=t->next;
    LNode *q=p->next;
    while(q)
    {
       if(q->data==p->data)
       {
           p->next=q->next;
           q=p->next;
       }
        else
        {
            p=p->next;
            q=q->next;
        }
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Delete(t);
    while(t->next)
    {
        cout<<t->next->data<<" ";
        t=t->next;
    }
}

7
1 2 2 2 2 3 3
1 2 3
*/


/*
//将两个单增链表合并为一个单减链表 P37 13
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
LNode *Merge(LNode *t1,LNode *t2)
{
    LNode *p=t1->next;
    LNode *q=t2->next;
    LNode *s0=(LNode*)malloc(sizeof(LNode));
    s0->next=NULL;
    LNode *s=s0;
    while(p&&q)
    {
        while(p&&q&&p->data<q->data)
        {
            LNode *x1=p;
            p=p->next;   //易错点！！注意这一句的顺序！！！p先移动，再改变x1的指针，否则p会被丢失！！
            x1->next=NULL;
            x1->next=s->next;
            s->next=x1;
        }
        while(p&&q&&p->data>=q->data)
        {
            LNode *x2=q;
            q=q->next;
            x2->next=NULL;
            x2->next=s->next;
            s->next=x2;
        }
    }
    while(p)
    {
        LNode *x1=p;
        p=p->next;
        x1->next=NULL;
        x1->next=s->next;
        s->next=x1;
    }
    while(q)
    {
        LNode *x2=q;
        q=q->next;
        x2->next=NULL;
        x2->next=s->next;
        s->next=x2;
    }
    return s;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i<n2;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *s=Merge(t,t2);
    while(s->next)
    {
        cout<<s->next->data<<" ";
        s=s->next;
    }
}

3
1 2 3
4
2 3 4 5
5 4 3 3 2 2 1
*/


/*
//从A，B公共元素中产生单链表C  P37 14
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
LNode *Common(LNode *a,LNode *b)
{
    LNode *c=(LNode*)malloc(sizeof(LNode));
    c->next=NULL;
    LNode *cc=c;
    LNode *p=a->next;
    LNode *q=b->next;
    while(p&&q)
    {
        while(p&&q&&p->data<q->data)
        {
            p=p->next;
        }
        while(p&&q&&p->data>q->data)
        {
            q=q->next;
        }
        if(p&&q&&p->data==q->data)  //这一句也要加上p&&q都存在！！！
        {
            LNode *x=(LNode*)malloc(sizeof(LNode));
            x->data=p->data;
            cc->next=x;
            cc=x;
            cc->next=NULL;
            p=p->next;
            q=q->next;
        }
    }
    return c;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i<n2;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    LNode *s=Common(t,t2);
    while(s->next)
    {
        cout<<s->next->data<<" ";
        s=s->next;
    }
}

3
1 3 5
6
1 2 3 4 7 8
1 3

*/


/*
//求交集 P37 15
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
LNode *Common(LNode *a,LNode *b)
{
    LNode *ra=a->next;
    LNode *rb=b->next;
    LNode *r=a;
    LNode *u;
    while(ra&&rb)
    {
        while(ra&&rb&&ra->data<rb->data)
        {
            u=ra;
            ra=ra->next;
            free(u);
        }
        while(ra&&rb&&ra->data>rb->data)
        {
            u=rb;
            rb=rb->next;
            free(u);
        }
        if(ra&&rb&&ra->data==rb->data)
        {
            r->next=ra;
            r=ra;
            ra=ra->next;
            u=rb;
            rb=rb->next;
            free(u);
        }
    }
    while(ra)
    {
        u=ra;
        ra=ra->next;
        free(u);
    }
    while(rb)
    {
        u=rb;
        rb=rb->next;
        free(u);
    }
    r->next=NULL;
    free(b);
    return a;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i<n2;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    LNode *s=Common(t,t2);
    while(s->next)
    {
        cout<<s->next->data<<" ";
        s=s->next;
    }
}

3
2 4 7
5
1 2 3 4 8
2 4
*/


/*
//判断连续子序列  P38  16
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
int Sequence(LNode *a,LNode *b)
{
    LNode *ra=a->next;
    LNode *rb=b->next;
    while(ra&&rb)
    {
        LNode *s=ra;
        while(ra&&rb&&ra->data==rb->data)
        {
            ra=ra->next;
            rb=rb->next;
        }
        if(rb==NULL)
        {
            return 1;
        }
        else
        {
            ra=s->next;
            rb=b->next;
        }
    }
    return 0;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i<n2;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    int d=Sequence(t,t2);
    cout<<d<<endl;
}
*/


/*
//判断带头节点的循环双链表是否对称 P38 17
typedef struct LNode
{
    int data;
    LNode *next,*prior;
}LNode;
int Judge(LNode *t)
{
    LNode *a=t->next;
    LNode *b=t->prior;
    while(b!=t&&a!=t)
    {
        if(a->data!=b->data)
        {
            return 0;
        }
        a=a->next;
        b=b->prior;
    }
    return 1;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        p->prior=q;
        q=p;
    }
    q->next=t;
    t->prior=q;
    int d=Judge(t);
    cout<<d;
}
6
2 7 4 4 7 2
1
*/


/*
//连接两个循环单链表。P38 18。使用不带头节点的循环单链表！
typedef struct LNode
{
    int data;
    LNode *next,*prior;
}LNode;
LNode *Merge(LNode *h1,LNode *h2)
{
    LNode *a=h1;
    while(a->next!=h1)
    {
        a=a->next;
    }
    a->next=h2;
    a=h2;
    while(a->next!=h2)
    {
        a=a->next;
    }
    a->next=h1;
    return h1;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    int n,t0;
    cin>>n;
    cin>>t0;
    t->data=t0;
    LNode *q=t;
    for(int i=1;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
    }
    q->next=t;
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    int n2;
    cin>>n2;
    cin>>t0;
    t2->data=t0;
    LNode *q2=t2;
    for(int i=1;i<n2;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
    }
    q2->next=t2;
    LNode *s=Merge(t,t2);
    LNode *d=s;   //易错点：记得保留头节点！！
    while(s->next!=d)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    cout<<s->data;
}

3
4 2 1
4
2 6 3 1
4 2 1 2 6 3 1
*/


/*
//删除循环单链表中的最小值。P38 19
typedef struct LNode
{
    int data;
    LNode *next,*prior;
}LNode;
void Delete(LNode *t)
{
    LNode *p,*pre;
    while(t->next!=t)
    {
        p=t->next;
        pre=t;
        int min=p->data;
        LNode *minp=p;
        LNode *minpre=t;
        while(p!=t)   //易错点！！！注意是p而不是p->next
        {
            if(p->data<min)
            {
                min=p->data;
                minp=p;
                minpre=pre;
            }
            p=p->next;
            pre=pre->next;
        }
        cout<<min<<" ";
        minpre->next=minp->next;
        free(minp);
    }
    free(t);
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
    }
    q->next=t;
    Delete(t);
}


6
1 3 4 3 2 1
1 1 2 3 3 4
*/

/*
//对双向链表进行排序，先按访问频度，再按最近访问时间 P38 20
typedef struct LNode
{
    int data,freq;
    LNode *next,*prior;
}LNode;
LNode *Locate(LNode *t,int x)
{
    LNode *p=t->next;
    while(p!=NULL&&p->data!=x)
    {
        p=p->next;
    }
    p->prior->next=p->next;
    p->next->prior=p->prior;
    p->freq++;
    LNode *q=t->next;
    while(q!=NULL&&q->freq>p->freq)
    {
        q=q->next;
    }
    p->next=q;
    q->prior->next=p;
    p->prior=q->prior;
    q->prior=p;
    return p;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        p->prior=q;
        q=p;
        q->next=NULL;
    }
    LNode *s=Locate(t,2);
    
}
*/

/*
//查找链表中倒数第k个位置的节点的值 P38 21
typedef struct LNode
{
    int data,freq;
    LNode *next,*prior;
}LNode;
int Search(LNode *list,int k)
{
    LNode *p=list->next;
    LNode *pre=list->next;
    while(k)
    {
        p=p->next;
        if(p==NULL)
            return 0;
        k--;
    }
    while(p)
    {
        p=p->next;
        pre=pre->next;
    }
    return pre->data;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        p->prior=q;
        q=p;
        q->next=NULL;
    }
    int d=Search(t,3);
    cout<<d;
}

6
3 45 7 3 2 4
3
*/


/*
//找出两个链表共同后缀的起始位置  P38 22
typedef struct LNode
{
    int data,freq;
    LNode *next,*prior;
}LNode;
int strlen(LNode *t)
{
    int cnt=0;
    while(t->next)
    {
        cnt++;
        t=t->next;
    }
    return cnt;
}
LNode *Find(LNode *a,LNode *b)
{
    int len1=strlen(a);
    int len2=strlen(b);
    LNode *longlist,*shortlist;
    int min1,max2;
    if(len1<len2)
    {
        shortlist=a;
        longlist=b;
        min1=len1;
        max2=len2;
    }
    else
    {
        longlist=a;
        max2=len1;
        shortlist=b;
        min1=len2;
    }
    int t=max2-min1;
    while(t)
    {
        longlist=longlist->next;
        t--;   //注意循环控制条件！！！
    }
    while(longlist&&shortlist)
    {
        if(longlist->data==shortlist->data)
        {
            return longlist;
        }
        else
        {
            longlist=longlist->next;
            shortlist=shortlist->next;
        }
    }
    return NULL;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i<n2;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t3=(LNode*)malloc(sizeof(LNode));
    t3->next=NULL;
    int n3;
    cin>>n3;
    cin>>t0;
    t3->data=t0;
    LNode *q3=t3;
    for(int i=1;i<n3;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q3->next=p;
        q3=p;
        q3->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    q->next=t3;
    q2->next=t3;
    
    LNode *s=Find(t,t2);
    while(s)
    {
        cout<<s->data<<" ";
        s=s->next;
    }
}


3
2 4 5
2
6 8
4
2 6 4 3
2 6 4 3
*/


/*
//删除绝对值相同的元素 P38 23
typedef struct LNode
{
    int data,freq;
    LNode *next,*prior;
}LNode;
void Delete(LNode *t)
{
    int map[maxSize];
    LNode *p=t->next;
    LNode *pre=t;
    while(p)
    {
        if(map[abs(p->data)]==0)
        {
            map[abs(p->data)]++;
            p=p->next;
            pre=pre->next;
        }
        else if(map[abs(p->data)]==1)
        {
            pre->next=p->next;
            p=pre->next;
        }
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Delete(t);
    while(t->next)
    {
        cout<<t->next->data<<" ";
        t=t->next;
    }
}

5
21 -15 -15 -7 15
21 -15 -7
*/

 

努力努力再努力0.0
关注
专栏目录
王道22数据结构课后习题（第二章2.2.3）
艾
06-28 1134
2、设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)。 3、对长度为n的顺序表L，编写一个时间复杂度为O(n)、空间复杂度为O(1)的算法，删除线性表中所有值为x的数据元素。 4、从有序顺序表中删除其值在[s,t]之间的所有元素，若s或t不合理或顺序表为空，则显示出错误信息并退出运行。 5、从顺序表中删除其值在给定值s与t之间（要求 s < t）的所有元素，若s或t不合理或顺序表为空，则显示出错误信息并退出运行。 暴力方法 双指针方法 6、从有序顺序表中删除所有其值重复
数据结构王道课后习题
四块的博客
10-17 1289
第五章 树与二叉树 1.若某非空二叉树的先序序列和后序序列正好相反，则该二叉树的形态是什么？ 二叉树的先序序列为NLR（根左右），后序序列是LRN（左右根）。要使得NLR=LRN（后序序列反序）则成立。L或R应该为空，这样的二叉树每层只有一个节点，即二叉树的形态是其高度等于节点个数。例如： 2.若某非空二叉树的先序序列和后序序列正好相同，则该二叉树的形态是什么？ ...
考研王道数据结构课后题（代码应用题）
最新发布
Java程序员十六的博客
07-03 523
并由函数返回被删除元素，空出位置由最后一个元素填补，若顺序表为空，则显示错误信息并推出运行。包含s和t，要求s<t，若s或t不合理或顺序表为空时，显示错误。找到,与后继元素互换;找不到,插入表中并使表仍然有序。要求s<t，若s或t不合理或顺序表为空时，显示错误。如果有环，找出环的入口点并返回；要求时间复杂度为O(n)，空间复杂度为O(1)查找成功输出该节点值，并返回1，否则返回0。要求算法的时间复杂度为O(1)效率高，假设最小值节点唯一。链表为空时，删除表头节点。不使用数组作为辅助空间。
王道数据结构课后习题 | P37
益达的小作坊
08-03 1388
3、设L为带头节点的单链表，编写算法实现从尾到头反向输出每个节点的值。 我想到的是reverse一下/笑哭 想想这个就有点杀鸡用牛刀的感觉… 看了题解说是可以用递归…卧槽瞬间orzclass Solution{ public: //利用递归解决 void reverseOut(ListNode* head){ if(head->next!=NULL)
数据结构复习—王道课后习题（线性表）
m0_51769031的博客
05-14 2242
一、
【数据结构】王道课后习题（线性表）（一）（可直接运行）
treesorshining的博客
07-07 657
完整题目如下： 显然，只需要遍历找到最小值，并用最后一个元素覆盖即可。 具体实现如下： 1.2 完整代码 2.02 逆置 2.1算法实现 完整题目如下： 要求空间复杂度为O(1)，时间复杂度无要求，那么只需要循环换位即可实现。 代码如下： 2.2 完整代码 3.03 删除所有指定元素 3.1算法实现 完整题目如下： 分析题目，要求时间复杂度O(n)，那么就不能使用最简单的即找即删。可以设定一个变量k用于记录非x的个数，如果该元素不是x，那么就把它放到第k个，同时k+1，这样前k个即全部是非x，再将
18版考研数据结构天勤课后习题代码-线性表【完】
努力努力再努力0.0的博客
09-07 323
#include <iostream> using namespace std; #define maxSize 101 //顺序表插入元素 天勤P26 例2-1 /* typedef struct Sqlist { int data[maxSize]; int length; }; void insert(Sqlist &s,int x) { int cnt=...
2022王道考研数据结构笔记--第二章 线性表
weixin_41170125的博客
05-23 664
第二章 线性表 2.1 线性表的定义和基本操作 要点： 线性表的基本操作——创销、增删、改查 传入参数时，何时要用引用 & 2.2 线性表的顺序表示 2.2.1 顺序表的定义 顺序表的实现———静态分配 #include <stdio.h> #define MaxSize 10 //定义最大长度 typedef struct{ int data[MaxSize]; //用静态的“数组”存放数据元素 ElemType:int int Length;
19版考研数据结构王道课后习题代码-查找【完】
努力努力再努力0.0的博客
09-17 444
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> ...
王道数据结构考研课后习题（线性表）
2201_75825034的博客
08-26 238
int* data;int length;}SeqList;int pos;L.length--;return 0;
2018王道数据结构课后习题代码
10-26
2018年王道数据结构课后习题代码是一个针对该课程学习者的重要资源，它包含了对数据结构概念的深入理解和实际编程实践。这份资料的提供者已经通过了考研，这意味着这些代码经过了实际检验，具有一定的权威性和实用性...
阅读笔记：王道考研-数据结构考研复习指导读书笔记和课后习题的实现
02-13
阅读笔记 这是2021王道考研-数据结构考研复习指导的课后习题的实现，由于书中都是采用c语言或c ++实现的，在这里我们统一都是采用javascript进行实现，主要是为了系统地学习数据结构，同时使用js实现提高自己的编程能力。
王道数据结构课后选填汇总
02-19
数据结构复习使用，方便二刷数据结构选填使用
2018王道数据结构课后习题代码.rar
09-07
2018王道数据结构课后习题代码
王道数据结构2019考研视频讲解+视频讲义PPT+课后习题讲解
06-10
此资源是配套王道数据结构考研书籍的讲解视频，视频讲义PPT，课后习题讲解（习题讲解不是全部讲解，而是选取一部分题讲解），压缩文档里有视频的百度云链接）
【2025王道数据结构】王道数据结构课后代码题汇总答案C、C++代码实现完整版大全（可直接运行）
CSDN 精品推荐
04-25 1万+
下面内容是本人在复习王道数据结构的过程中, 对一些算法设计题目的全部实现（答案解析全部都是伪码或者函数的部分实现，不可调试运行），不一定是最优的, 但是都能保证端到端测试运行，本文会陆陆续续更新，个人水平有限，可能文章里面存在一些问题，还望各位多多指点。   加油，阿光！！！我看好你哦😋😋😋 以下摘自王道2023年数据结构考研复习指导题目 文章目录 😉第2章：线性表 ✌18页综合应用题 题号 题解链接 1 传送门 2 传送门 3 传送门 4 传送门 5 传送.
【专栏必读】王道考研408数据结构+计算机算法设计与分析万字笔记、题目题型总结、注意事项、目录导航和思维导图
热门推荐
快乐江湖的博客
11-23 4万+
各位老铁思维导图在我整理完笔记后会放上去的，我需要根据王道的思维导图重新再做一遍 文章目录一：有关注意事项二：关于专栏三：学习建议四：各专栏导航（各位老铁别催，质量优先）（1）第一章：绪论（2）第二章：线性表（3）第三章：栈和队列第四章：串第五章：二叉树第六章：图 首先感谢王道大大（手动比心），很用心在做了，大家可以看其中两节是否符合胃口 (王道408考研数据结构)第五章树-第三节1：二叉树遍历（先序、中序和后序） (王道408考研数据结构)第五章树-第四节2：平衡二叉树(AVL)及其旋转 一：有.
王道计算机考研 数据结构 课后编程习题代码（绪论、线性表）
m0_51448653的博客
10-07 509
2.2.3 1. 题意 ：从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删函数的值，空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。 思路 ：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补空出的原最小值元素的位置。 bool Del_Min(SqList &L, ElemType &value) { //删除顺序表L中最小值元素结点，并通过引用型参数value返回其值 //若删除成功，则返回true，否则返回fal
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值