数据结构 上机测试题 汇总

这篇博客汇总了多项数据结构上机测试题目,涉及链表的合并、逆置、差集操作,双链表插入,括号匹配,二叉树的各种遍历,字符串匹配和删除,以及多种排序算法的实现。
摘要由CSDN通过智能技术生成

1、 编写算法,将二个升序链表在原表空间内归并成一个升序链表。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <queue>
#include <math.h>
#include <stdlib.h>
using namespace std;

typedef struct linklist
{
    int data;
    struct linklist *next;
}linklist;

linklist *creat()
{
    linklist *head;
    head=(linklist*)malloc(sizeof(linklist));
    linklist *p,*q=head;
    int temp;
    while(1)
    {
        scanf("%d",&temp);
        if(temp!=-9999)
        {
            p=(linklist*)malloc(sizeof(linklist));
            p->data=temp;
            q->next=p;
            q=p;
        }
        else
        {
            q->next=NULL;
            break;
        }
    }
    return head;
}

linklist* unionlist(linklist* &a,linklist* b)
{
    linklist *pa=a->next,*pb=b->next,*s,*r=a;
    while(pa!=NULL&&pb!=NULL)
    {
        if(pa->data<pb->data)
        {
            r=pa;
            pa=pa->next;
        }
        else
        {
            s=(linklist*)malloc(sizeof(linklist));
            s->data=pb->data;
            s->next=pa;
            r->next=s;
            r=s;
            pb=pb->next;
        }
    }
    if(pb!=NULL)
    {
        r->next=pb;
    }
    return a;
}



int main()
{
    linklist *a,*b,*p;
    printf("input first linklist:");
    a=creat();
    printf("input second linklist:");
    b=creat();
    unionlist(a,b);
    p=a->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    return 0;
}

2、 编写算法,将二个升序链表在原表空间内归并成一个降序链表。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;

typedef struct linklist
{
    int data;
    struct linklist *next;
}linklist;

linklist *creat()
{
    linklist *head;
    head=(linklist*)malloc(sizeof(linklist));
    linklist *p,*q=head;
    int temp;
    while(1)
    {
        scanf("%d",&temp);
        if(temp!=-9999)
        {
            p=(linklist*)malloc(sizeof(linklist));
            p->data=temp;
            q->next=p;
            q=p;
        }
        else
        {
            q->next=NULL;
            break;
        }
    }
    return head;
}

linklist* unionlist(linklist* &a,linklist* b)
{
    linklist *pa=a->next,*pb=b->next,*r=a,*s;
    while(pa!=NULL&&pb!=NULL)
    {
        if(pa->data<pb->data)
        {
            r=pa;
            pa=pa->next;
        }
        else
        {
            s=(linklist*)malloc(sizeof(linklist));
            s->data=pb->data;
            s->next=pa;
            r->next=s;
            r=s;
            pb=pb->next;

        }
    }
    if(pb!=NULL)
    {
        r->next=pb;
    }
    return a;
}

void reverse_link(linklist* &a)
{
    linklist *p=a->next,*q;
    a->next=NULL;
    while(p)
    {
        q=p->next;
        p->next=a->next;
        a->next=p;
        p=q;
    }

}


int main()
{
    linklist *a,*b,*p;
    printf("input first linklist:");
    a=creat();
    printf("input second linklist:");
    b=creat();
    unionlist(a,b);
    reverse_link(a);
    p=a->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    return 0;
}

3、 编写算法,用顺序存储结构实现二个升序集合的A=A-B运算。
(事实上是求集合的差集,即只在A出现,不在B出现的A的元素)

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;
#define maxsize 20

typedef struct sqlist
{
    int data[maxsize];
    int length;
}sqlist,*lnode;

void create(lnode &l,int a[],int n)
{
    l=(sqlist*)malloc(sizeof(sqlist));
    for(int i=0;i<n;i++)
    {
        l->data[i]=a[i];
    }
    l->length=n;
}

void del(lnode &l,int n)
{
    int i;
    for(i=n;i<l->length-1;i++)
    {
        l->data[i]=l->data[i+1];
    }
    l->length--;
}

void listminus(lnode &a,lnode b)
{
    int m=a->length,n=b->length;
    int i,j,k=0;
    for(i=0;i<m;i++)
    {
        for(j=k;j<=n;j++)
        {
            if(a->data[i]==b->data[j])
            {
                del(a,i);
                k=j+1;
            }
        }
    }
}

void show(lnode l)
{
    int i;
    for(i=0;i<l->length;i++)
        printf("%d ",l->data[i]);
}



int main()
{
    lnode A,B;
    int a[10],b[10];
    printf("the five number :");
    for(int i=0;i<5;i++)
    {
        scanf("%d",&a[i]);
    }
    printf("the five number :");
    for(int i=0;i<5;i++)
    {
        scanf("%d",&b[i]);
    }
    create(A,a,5);
    create(B,b,5);
    listminus(A,B);
    show(A);
    return 0;
}

4、 编写算法,用单链表实现二个升序集合A和B的差集存放在集合C,即C=A-B运算,要求C中元素递减有序。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;

typedef struct node
{
    int data;
    struct node *next;
}node,*linklist;

void create(linklist l)
{
    int e;
    linklist p,q;
    p=l;
    printf("input the list:");
    scanf("%d",&e);
    while(e!=-9999)
    {
        q=(node*)malloc(sizeof(node));
        q->data=e;
        p->next=q;
        q->next=NULL;
        p=q;
        scanf("%d",&e);
    }
}

linklist linkminus(linklist &a,linklist b)
{
    linklist p=a->next,q=b->next,pre=a,r;
    while(p && q)
    {
        if(p->data<q->data)
        {
            pre=p;
            p=p->next;
        }
        else if(p->data>q->data)
        {
            q=q->next;
        }
        else
        {
            pre->next=p->next;
            r=p;
            p=p->next;
            free(r);
        }
    }
    return a;
}

void putdata(linklist l)
{
    linklist p=l->next;
    printf("\n");
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }

}

void reverse_link(linklist &a)
{
    linklist p=a->next,q;
    a->next=NULL;
    while(p)
    {
        q=p->next;
        p->next=a->next;
        a->next=p;
        p=q;
    }
}

int main()
{
    linklist A,B,C;
    A=(node*)malloc(sizeof(node));
    A->next=NULL;
    B=(node*)malloc(sizeof(node));
    B->next=NULL;
    create(A);
    create(B);
    C=linkminus(A,B);
    reverse_link(C);
    putdata(C);
    return 0;
}

5、 编写算法,将一单链表就地逆置。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;

typedef struct linklist
{
    int data;
    struct linklist *next;
}linklist;

linklist* creat()
{
    linklist* head;
    head=(linklist*)malloc(sizeof(linklist));
    linklist *p,*q=head;
    int temp;
    while(1)
    {
        scanf("%d",&temp);
        if(temp!=-9999)
        {
            p=(linklist*)malloc(sizeof(linklist));
            p->data=temp;
            q->next=p;
            q=p;
            p=p->next;
        }
        else
        {
            q->next=NULL;
            break;
        }
    }
    return head;
}

void reverse_link(linklist* &a)
{
    linklist *p=a->next,*q;
    a->next=NULL;
    while(p)
    {
        q=p->next;
        p->next=a->next;
        a->next=p;
        p=q;
    }
}

int main()
{
    linklist *a,*p;
    printf("input first linklist:");
    a=creat();
    p=a->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
    reverse_link(a);
    p=a->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;

    }
    return 0;
}

6、 编写算法,在一个双链表的第i个元素前插入一个元素。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;

typedef struct lnode
{
    int data;
    struct lnode *llink,*rlink;
}lnode,*linknode;

typedef struct
{
    linknode head,rear;
    int len;
}linklist;

void init(linklist &l)
{
    l.head=l.rear=(lnode*)malloc(sizeof(lnode));
    l.len=0;
    l.head->llink=l.head->rlink=l.head;
}

void create(linklist &l)
{
    linknode p;
    int e;
    init(l);
    scanf("%d",&e);
    while(e!=-9999)
    {
        p=(lnode*)malloc(sizeof(lnode));
        p->data=e;
        p->rlink=l.head->rlink;
        l.head->rlink=p;
        p->llink=l.head;
        p->rlink->llink=p;
        if(l.head==l.rear)
        {
            l.rear=p;
        }
        l.len++;
        scanf("%d",&e);
    }
}

int ins(linklist &l,int k,int e)
{
    int j;
    linknode p,q;
    if(k<1||k>l.len)return 0;
    p=l.head;
    j=0;
    while(j<k-1)
    {
        p=p->rlink;
        j++;
    }
    q=(lnode*)malloc(sizeof(lnode));
    q->data=e;
    q->llink=p;
    q->rlink=p->rlink;
    p->rlink=q;
    if(k == ++l.len)
    {
        l.rear=q;
    }
    return 1;
}

void putdata(linklist l)
{
    linknode p = l.head->rlink;
    printf("\n");
    while (p != l.head)
    {
        printf("%d,", p->data);
        p = p->rlink;
    }
}

int main()
{
    linklist l;
    int e;
    printf("\ninput to l:");
    create(l);
    putdata(l);
    ins(l,3,100);
    putdata(l);
    return 0;
}

7、 编写算法,删除一升序单链表中所有值相同的多余元素,释放被删结点空间。

#include <stdio.h
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值