精华内容
下载资源
问答
  • 完全借鉴他人 数据结构上机测试二又树应用霍夫曼编码
  • 数据结构上机测试

    2012-12-06 14:31:54
    含有大量的数据结构上机练习题.C语言,数据结构
  • 数据结构上机测试1:顺序表的应用

     

    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #define LISTINCREASMENT 100
    #define LISTSIZE 10
    #define OVERFLOW -1
    #define OK 1
    typedef int ElemType;

    typedef struct
    {
     ElemType *elem;
     int length;
     int listsize;
    }Sqlist;

    int SqInitial(Sqlist &L)
    {
     L.elem=(ElemType *)malloc(LISTSIZE*sizeof(ElemType));
     if(!L.elem) exit(OVERFLOW);
     L.length=0;
     L.listsize=LISTSIZE;
     return OK;
    }
    int ListInsert(Sqlist &L,int i,ElemType e)
    {
     if(i<1||i>L.length+1) printf("ERROR");
     if(L.length>=L.listsize)
     {
      ElemType*newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREASMENT)*sizeof(ElemType));
      if(!newbase) return OVERFLOW;

       L.elem=newbase;
      L.listsize+=LISTINCREASMENT;
     }
     ElemType * q=&(L.elem[i-1]);
     ElemType * p;
     for(p=&(L.elem[L.length-1]);p>=q;--p)
      *(p+1)=*p;
     *q=e;
     ++L.length;
     return OK;
    }
    void purge(Sqlist &L)
    {
     int i,j,k;
     for(i=0;i<L.length-1;++i)
     {
      j=i+1;
      while(j<L.length)
       if(L.elem[j]!=L.elem[i])
        ++j;
       else
       {
        for(k=j+1;k<L.length;++k)
            L.elem[k-1]=L.elem[k];
        --L.length;
       }
     }
    }
    int main()
    {
     Sqlist L;
     int i,n,d;
     scanf("%d",&n);
     SqInitial(L);
     for(i=1;i<=n;i++)
     {
      scanf("%d",&d);
      ListInsert(L,i,d);
     }
     purge(L);
     printf("%d\n",L.length);
     for(i=1;i<=L.length;i++)
     {
      printf("%d%c",L.elem[i-1],(i==L.length)?'\n':' ');
     }
     return 0;
    }

    /**************************************
     Problem id : SDUT OJ A
     User name : wy150428臧志栋
     Result  : Accepted
     Take Memory : 284K
     Take Time : 0MS
     Submit Time : 2016-08-02 20:25:32 
    **************************************/

     

    三个函数

    SqInitial 用于创建与清空顺序表

    ListInsert 用于给已经创建好的顺序表添加数据,并且对于输入结果进行判断

    purge 逐一的浏览顺序表 若有重复 指针后移动

    该算法的算法的时间复杂度为: O(L.length3)

     

    展开全文
  • 数据结构上机测试2-1:单链表操作A Time Limit:1000MSMemory Limit:4096KB SubmitStatisticDiscuss Problem Description 输入n个整数,先按照数据输入的顺序建立一个带头结点的单链表,再输入一个数据m,...

    数据结构上机测试2-1:单链表操作A

    Time Limit: 1000MS Memory Limit: 4096KB

    Problem Description

    输入n个整数,先按照数据输入的顺序建立一个带头结点的单链表,再输入一个数据m,将单链表中的值为m的结点全部删除。分别输出建立的初始单链表和完成删除后的单链表。

    Input

    第一行输入数据个数n;
    第二行依次输入n个整数;
    第三行输入欲删除数据m。

    Output

    第一行输出原始单链表的长度;
    第二行依次输出原始单链表的数据;
    第三行输出完成删除后的单链表长度;
    第四行依次输出完成删除后的单链表数据。

    Example Input

    10
    56 25 12 33 66 54 7 12 33 12
    12

    Example Output

    10
    56 25 12 33 66 54 7 12 33 12
    7
    56 25 33 66 54 7 33

    #include<stdio.h>
    #include<malloc.h>
    struct LinkList{
        int data;
        struct LinkList *next;
    };
    LinkList * CreateList(LinkList *head,int n){
        LinkList *tail,*r;
        head->next=NULL;
    tail = head;
        for(int i=0;i<n;i++){
            r=(LinkList *)malloc(sizeof(LinkList));
            scanf("%d",&r->data);
            tail->next=r;
            tail=r;
        }
    tail->next = NULL;
        return head;
    }
    LinkList *DeleList(LinkList *&head,int &n,int key)
    {
        LinkList *p,*q,*tail,*temp2;
        p = head;  
        while(p->next)  
        {  
            if(p->next->data==key)  //p的下一个元素与key对比
            {  
                n--;                 
                tail = p->next;   //tail是与key相同的元素的指针地址
                p->next = tail->next;  //将tail的后继赋值给tail的后继
                free(tail);  //释放tail
            }  
            else  
                p = p->next;  
        }  
        printf("%d\n",n);
        return head;
    }
    void DispList(LinkList *head){
        LinkList *p=head->next;
        while(p->next!=NULL){
            printf("%d ",p->data);
            p=p->next;
        }
        printf("%d\n",p->data);
    }
    int main(){
        int n;
        scanf("%d",&n);
        LinkList *head;
        head=(LinkList *)malloc(sizeof(LinkList));
        CreateList(head,n);
    int key;
    scanf("%d",&key);
        printf("%d\n",n);
        DispList(head);
        DeleList(head,n,key);
        DispList(head);
        return 0;
    }

    转载于:https://www.cnblogs.com/CCCrunner/p/6444603.html

    展开全文
  • 数据结构上机测试2-2:单链表操作B Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Discuss Problem Description 按照数据输入的相反顺序(逆位序)...

    数据结构上机测试2-2:单链表操作B

    			Time Limit: 1000 ms
    			Memory Limit: 65536 KiB
    							
    			
    				Submit
    				Statistic
    				Discuss
    			
    			Problem Description
    			
    			按照数据输入的相反顺序(逆位序)建立一个单链表,并将单链表中重复的元素删除(值相同的元素只保留最后输入的一个)。				
    			Input
    			
    			第一行输入元素个数n;
    

    第二行输入n个整数。
    Output

    			第一行输出初始链表元素个数;
    

    第二行输出按照逆位序所建立的初始链表;

    第三行输出删除重复元素后的单链表元素个数;

    第四行输出删除重复元素后的单链表。
    Sample Input

    				10
    

    21 30 14 55 32 63 11 30 55 30

    			Sample Output
    			
    				10
    

    30 55 30 11 63 32 55 14 30 21
    7
    30 55 11 63 32 14 21

    #include <iostream>
    
    using namespace std;
    
    struct node
    {
        int data;
        struct node *next;
    };
    
    void output(node *h)//输出
    {
        node *p;
        for(p=h->next; p!=NULL; p=p->next)
        {
            if(p->next==NULL)
            {
                cout << p->data << endl;
            }
            else
            {
                cout << p->data << " ";
            }
        }
    }
    
    int creat(node *h,int m)//删除
    {
        node *p,*q,*t;
        p=h->next;
        while(p)
        {
            t=p->next;
            q=p;
            while(t)
            {
                if(p->data==t->data)
                {
                    q->next=t->next;
                    m--;
                    t=t->next;
                }
                else
                {
                    q=q->next;
                    t=t->next;
                }
            }
            p=p->next;
        }
        return m;
    }
    
    int main()
    {
        int a,i,x;
        node *h,*p;
        h=new node;
        h->next=NULL;
        cin >> a;
        for(i=1; i<=a; i++)//建表
        {
            p=new node;
            cin >> p->data;
            p->next=h->next;
            h->next=p;
        }
        cout << a << endl;
        output(h);
        x=creat(h,a);
        cout << x << endl;
        output(h);
        return 0;
    }
    
    
    展开全文
  • 数据结构上机测试4.1:二叉树的遍历与应用1 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 输入二叉树的先序遍历序列和中序遍历序列,输出该二叉树的后序遍历序列。 Input ...

    数据结构上机测试4.1:二叉树的遍历与应用1
    Time Limit: 1000MS Memory Limit: 65536KB
    Submit Statistic
    Problem Description

    输入二叉树的先序遍历序列和中序遍历序列,输出该二叉树的后序遍历序列。
    Input

    第一行输入二叉树的先序遍历序列;
    第二行输入二叉树的中序遍历序列。
    Output

    输出该二叉树的后序遍历序列。
    Example Input

    ABDCEF
    BDAECF
    Example Output

    DBEFCA

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    struct node
    {
        char data;
        struct node *l, *r;
    };
    char s1[2000], s2[2000];
    struct node *creat(int n, char *s1, char *s2)
    {
        int i;
        if(n == 0)
            return NULL;
        struct node *root;
        root = (struct node*) malloc (sizeof(struct node));
        root -> data = s1[0];
        for(i = 0; i < n; i++)
        {
            if(s2[i] == s1[0])
                break;
        }
        root -> l = creat(i, s1 + 1, s2);
        root -> r = creat(n - 1 - i, s1 + i + 1, s2 + i + 1);
        return root;
    }
    void houxv(struct node *root)
    {
        if(root)
        {
            houxv(root -> l);
            houxv(root -> r);
            printf("%c", root -> data);
        }
    }
    
    int main()
    {
        scanf("%s", s1);
        scanf("%s", s2);
        int n = strlen(s1);
        struct node *root;
        root = creat(n, s1, s2);
        houxv(root);
        return 0;
    }
    
    展开全文
  • 数据结构上机测试4.1:二叉树的遍历与应用1 Problem Description 输入二叉树的先序遍历序列和中序遍历序列,输出该二叉树的后序遍历序列。 Input 第一行输入二叉树的先序遍历序列; 第二行输入二叉树的中序遍历序列。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 659
精华内容 263
关键字:

数据结构上机测试

数据结构 订阅