精华内容
下载资源
问答
  • 数 据 结 构 实验报告 实验课程 数据结构 学 号 2016031124 学生姓名 郑世林 班 级 16软件 2017年 月 日 实验一 函数与结构体复习 一实验目的 巩固复习前期所学C语言的函数参数传递指针和结构体等知识点加强学习数据...
  • 数据结构实验课(全部题目+全部完整代码+全部实验报告)
  • 压缩包里面是2017级软件学院数据结构实验源代码,做实验时可以参考一下,即使题型有变,本质都差不太多。
  • #资源达人分享计划#
  • #资源达人分享计划#
  • 数据结构实验课2014年

    2015-12-26 10:25:25
    数据结构实验课2014年
  • 2017年大二下学习期数据结构期末考试各类算法及答案。涵盖了书中所有的算法。
  • #资源达人分享计划#
  • #资源达人分享计划#
  • #资源达人分享计划#
  • 重邮数据结构实验课全部代码目录

    千次阅读 多人点赞 2021-05-19 23:41:23
    CQUPT 数据结构实验课全部代码目录 实验一、顺序表的实现及应用 实验二、链表的实现及应用 实验三、栈的实现及应用 实验四、队列的实现及应用 实验五、二叉树操作及应用 实验六、图的遍历操作及应用 实验七、查找...

    CQUPT 数据结构实验课全部代码目录

    实验一、顺序表的实现及应用

    实验二、链表的实现及应用

    实验三、栈的实现及应用

    实验四、队列的实现及应用

    实验五、二叉树操作及应用

    实验六、图的遍历操作及应用

    实验七、查找算法的实现

    实验八、排序算法的实现

    链接

    实验一、顺序表的实现及应用

    实验二、链表的实现及应用

    实验三、栈的实现及应用

    实验四、队列的实现及应用

    实验五、二叉树操作及应用

    实验六、图的遍历操作及应用

    实验七、查找算法的实现

    实验八、排序算法的实现

    word版
    数据结构与算法实验指导书
    提取码2021

    链接:https://pan.baidu.com/s/1aOuB26a9E6U0pMMjoNeQ8g
    提取码:2021

    实验代码
    提取码2021

    链接:https://pan.baidu.com/s/1HjOLZTZ6namy3K0ED0QX5w
    提取码:2021

    展开全文
  • 冬M 冬M哪范学ft ANYANG NORMAL UNIVERSITY 908 课程名称 数据结构课程教学设计 院系部 计算机与信息工程学院基础教研室 主讲教师 刘国英 使用 教材数据结构C 语言版严蔚敏编著 授课内容 循环队歹V 团队 成员 刘运通...
  • 燕山大学 软件工程专业 大二上学期 数据结构课 实验报告单 PDF 包含重点代码以及截图
  • 数据结构实验课:实验三、栈的实现及应用

    千次阅读 多人点赞 2021-05-19 22:36:25
    一、实验目的 1.掌握栈的存储表示和实现 2.掌握栈的基本操作实现。 3.掌握栈在解决实际问题中的应用。 二、实验要求 问题描述:设计一个程序,演示用算符优先法对算术表达式求值的过程。利用算符优先关系,实现对...

    一、实验目的
    1.掌握栈的存储表示和实现
    2.掌握栈的基本操作实现。
    3.掌握栈在解决实际问题中的应用。
    二、实验要求
    问题描述:设计一个程序,演示用算符优先法对算术表达式求值的过程。利用算符优先关系,实现对算术四则混合运算表达式的求值。
    (1)输入的形式:表达式,例如2*(3+4)#
    包含的运算符只能有’+’ 、’-’ 、’’ 、’/’ 、’(’、 ‘)’,“#”代表输入结束符;
    (2)输出的形式:运算结果,例如2
    (3+4)=14;
    (3)程序所能达到的功能:对表达式求值并输出。
    三、解题参考思路
    为了实现用栈计算算数表达式的值,需设置两个工作栈:用于存储运算符的栈opter,以及用于存储操作数及中间结果的栈opnd。
    算法基本思想如下:
    (1)首先将操作数栈opnd设为空栈,而将’#‘作为运算符栈opter的栈底元素,这样的目的是判断表达式是否求值完毕。
    (2)依次读入表达式的每个字,表达式须以’#‘结,读入字符若是操作数则入栈opnd,读入字符若是运算符,则将此运算符c与opter的栈顶元素top比较优先级后执行相应的操作,具体操作如下:
    (i)若top的优先级小于c,即top<c,则将c直接入栈opter,并读入下一字符赋值给c;
    (ii)若top的优先级等于c,即top=c,则弹出opter的栈顶元素,并读入下一字符赋值给c,这一步目的是进行括号操作;
    (iii)若top优先级高于c,即top>c,则表明可以计算,此时弹出opnd的栈顶两个元素,并且弹出opter栈顶的的运算符,计算后将结果放入栈opnd中。直至opter的栈顶元素和当前读入的字符均为’#’,此时求值结束。
    算符间的优先关系如下表所示(表来源:严蔚敏《数据结构》):

    表中需要注意的是θ1为opter的栈顶元素,θ2为从表达式中读取的操作符,此优先级表可以用二维数组实现。
    图例:

    比较算符优先关系代码示例:
    int getIndex(char theta) //获取theta所对应的索引
    {
    int index = 0;
    switch (theta)
    {
    case ‘+’:
    index = 0;
    break;
    case ‘-’:
    index = 1;
    break;
    case ‘*’:
    index = 2;
    break;
    case ‘/’:
    index = 3;
    break;
    case ‘(’:
    index = 4;
    break;
    case ‘)’:
    index = 5;
    break;
    case ‘#’:
    index = 6;
    default:break;
    }
    return index;
    }

    char getPriority(char theta1, char theta2) //获取theta1与theta2之间的优先级
    {
    const char priority[][7] = //算符间的优先级关系
    {
    { ‘>’,’>’,’<’,’<’,’<’,’>’,’>’ },
    { ‘>’,’>’,’<’,’<’,’<’,’>’,’>’ },
    { ‘>’,’>’,’>’,’>’,’<’,’>’,’>’ },
    { ‘>’,’>’,’>’,’>’,’<’,’>’,’>’ },
    { ‘<’,’<’,’<’,’<’,’<’,’=’,‘0’ },
    { ‘>’,’>’,’>’,’>’,‘0’,’>’,’>’ },
    { ‘<’,’<’,’<’,’<’,’<’,‘0’,’=’ },
    };

    int index1 = getIndex(theta1);
    int index2 = getIndex(theta2);
    return priority[index1][index2];
    }
    四、实验任务
    认真阅读与理解实验内容的具体要求,参考教材相关章节,结合实验内容的要求,编写实验程序并上机调试与测试,完成实验报告的撰写。

    (已改)代码如下

    #include <stdio.h>
    #include <stdlib.h>
    #define OK 1
    #define ERROR 0
    #define MAXSIZE 100 // 存储空间初始分配量
    typedef int Status;
    typedef struct
    {
            int data[MAXSIZE];
            int top; // 用于栈顶指针
    }opndStack;
    
    typedef struct
    {
            char data[MAXSIZE];
            int top; // 用于栈顶指针
    }opterStack;
    
    //====================================================================
    int getIndex(char theta)   //获取theta所对应的索引
    {
        int index = 0;
        switch (theta)
        {
    	    case '+':
    	        index = 0;
    	        break;
    	    case '-':
    	        index = 1;
    	        break;
    	    case '*':
    	        index = 2;
    	        break;
    	    case '/':
    	        index = 3;
    	        break;
    	    case '(':
    	        index = 4;
    	        break;
    	    case ')':
    	        index = 5;
    	        break;
    	    case '#':
    	        index = 6;
    	    default:break;
        }
        return index;
    }
    
    //====================================================================
    
    char getPriority(char theta1, char theta2)   //获取theta1与theta2之间的优先级
    {
        const char priority[][7] =     //算符间的优先级关系
        {
            { '>','>','<','<','<','>','>' },
            { '>','>','<','<','<','>','>' },
            { '>','>','>','>','<','>','>' },
            { '>','>','>','>','<','>','>' },
            { '<','<','<','<','<','=','0' },
            { '>','>','>','>','0','>','>' },
            { '<','<','<','<','<','0','=' },
        };
    
        int index1 = getIndex(theta1);
        int index2 = getIndex(theta2);
        return priority[index1][index2];
    }
    
    //====================================================================
    
    Status InitopndStack(opndStack *S)//建立opnd空栈
    {
        S->top=-1;
        return OK;
    }
    
    Status InitopterStack(opterStack *S)//建立opter空栈
    {
        S->top=-1;
        return OK;
    }
    
    //====================================================================
    
    Status Pushnd(opndStack *S,int n)//入栈
    {
        if(S->top== MAXSIZE-1)
        {
            return ERROR;
        }
        S->top++;//
        S->data[S->top]=n;
        return OK;
    }
    
    Status Pushter(opterStack *S,char n)
    {
        if(S->top== MAXSIZE-1)
        {
            return ERROR;
        }
        S->top++;//
        S->data[S->top]=n;
        return OK;
    }
    
    //=========================================================
    
    Status Popnd(opndStack *S,int *n)//出栈 并返回到 n 中
    {
        if(S->top==-1)
            return ERROR;
        *n=S->data[S->top];
        (S->top)--;
        return OK;
    }
    
    Status Popter(opterStack *S,char *n)
    {
        if(S->top==-1)
            return ERROR;
        *n=S->data[S->top];
        S->top--;
        return OK;
    }
    
    //=======================================================
    
    signed int calculate(int x1,int x2,char c)
    {
        switch(c)
        {
        case '+':
            return (x1+x2);
        case '-':
            return (x1-x2);
        case '*':
            return (x1)*(x2);
        case '/':
            return (x1)/(x2);
        default:
            return 0;
        }
        return 0;
    }
    
    //======================================================
    
    int isdigit(char c)//判断是否为操作数
    {
        if(c<='9'&& c>='0')
            return 1;
        else
            return 0;
    }
    
    int ischar(char c)//判断是否为运算符
    {
        switch(c)
        {
        case '+':
        case '-':
        case '*':
        case '/':
        case '(':
        case ')':
        case '#':
            return 1;
        default:
            return 0;
        }
        return 0;
    
    }
    //=========================================================
    
    void input(char s[])  //输入表达式 存入s[]数组中。
    {
        char c;
        int i = 0;
        while(c!='#')
        {
            while((c=getchar())==' ');//跳过所有空格进行c的输入
            s[i++]=c;
        }
        return ;
    }
    
    //==========================================================
    
    int calculateall()
    {
        char c,s[100]={0},k;
        int x1,x2,i=0;
        int n=0;
        opndStack opnd;
        opterStack opter;
        InitopndStack(&opnd); //空栈
        InitopterStack(&opter);
        Pushter(&opter,'#');
    
        input(s);
    
        while(s[i]!='\0')
        {
            c=s[i];
                if(ischar(c))
                {
                     switch(getPriority(opter.data[opter.top],c))
                        {
                        case '<':
                            Pushter(&opter,c);
                            break;
                        case '=':
                            Popter(&opter,&k);//k没有用处 用来满足函数关系而已
                            break;
                        case '>':
                            while(getPriority(opter.data[opter.top],c)=='>')
                            {
                                Popnd(&opnd,&x1);
                                Popnd(&opnd,&x2);
                                Popter(&opter,&k);
                                x1=calculate(x2,x1,k);
                                Pushnd(&opnd,x1);
                            }
                            if(getPriority(opter.data[opter.top],c)=='<')
                                Pushter(&opter,c);
                            else
                                Popter(&opter,&k);
                            break;
                        default:
                            printf("INPUT ERROR");
                        }
                }
                else
                {
                    Pushnd(&opnd,c-'0');
                }
            ++i;
        }
        Popnd(&opnd,&k);
        return k;
    }
    
    //=========================================================
    int main()
    {
       int k;
       k=calculateall();
       printf("%d",k);
       return 0;
    }
    
    

    当时自己写的版本(c++)

    #include <iostream>
    using namespace std;
    #include <string>
    #define size2 10
    #define size1 100
    #define erro -1
    typedef int iii;
    typedef struct
    {
        char *base;
        char *top;
        int size;
    } stack2;
    typedef struct
    {
        iii * base;
        iii* top;
        int size;
    } stack;
    void InitStack(stack2 &s)//初始化栈
    {
        s.base=(char*)malloc (size1*sizeof(char));
        if(!s.base)
    
        {
            printf("超出界限\n");
            return;
    
        }
        else
    
        {
            s.top=s.base;
            s.size=size1;
    
        }
    }
    void InitStack(stack &s)//初始化栈
    {
        s.base=(iii *)malloc (size1*sizeof(iii));
        if(!s.base)
    
        {
            printf("超出界限\n");
            return;
    
        }
        else
    
        {
            s.top=s.base;
            s.size=size1;
    
        }
    }
    void Insert(stack2 &s,char a) //插入元素
    {
        if(s.top-s.base>=s.size)
    
        {
            s.base=(char *)realloc (s.base,(s.size+size1)*sizeof (char));
            if(!s.base)
            {
                printf("超出界限\n");
                return ;
    
            }
    
        }
        *s.top++=a;
    }
    void Insert2( stack &s,int a)
    {
        if(s.top-s.base>=s.size)
    
        {
            s.base=(iii *)realloc (s.base,(s.size+size1)*sizeof (iii));
            if(!s.base)
            {
                printf("超出界限\n");
                return ;
    
            }
    
        }
        *s.top++=a;
    }
    char Pop(stack2 &s )//删除栈顶元素,并返回栈顶元素
    {
        if(s.top==s.base)
    
        {
            printf("栈为空\n");
            return erro;
    
        }
        else
    
        {
            *--s.top;
            return * s.top;
    
        }
    }
    int Pop2(stack &s)
    {
        if(s.top==s.base)
    
        {
            printf("栈为空\n");
            return erro;//没意义
    
        }
        else
    
        {
            *--s.top;
            return * s.top;
    
        }
    }
    void View(stack &s)
    {
        for(int i=1; i<=(s.top-s.base); i++)
    
        {
            char k;
            k=*(s.top-i);
            cout<<k<<endl;
    
        }
    }
    char GetPop(stack2 &s)
    {
        if(s.top==s.base)
    
        {
            printf("栈为空\n");
            return-1;
    
        }
        else
            return *(s.top-1);
    }
    int GetPop2(stack &s)
    {
        if(s.top==s.base)
    
        {
            printf("栈为空\n");
            return-1;
    
        }
        else
            return *(s.top-1);
    }
    char Compare(char q,char r)//比较优先级
    {
        int j[2];
        char str[2];
        char table[7][7]=
        {
            {'>','>','<','<','<','>','>'},
            {'>','>','<','<','<','>','>'},
            {'>','>','>','>','<','>','>'},
            {'>','>','>','>','<','>','>'},
            {'<','<','<','<','<','=','e'},
            {'>','>','>','>','e','>','>'},
            {'<','<','<','<','<','e','='}
    
        };
        str[0]=q;
        str[1]=r;
        for(int i=0; i<2; i++)
    
        {
            switch(str[i])
            {
            case '+':
                j[i]=0;
                break;
            case '-':
                j[i]=1;
                break;
            case '*':
                j[i]=2;
                break;
            case '/':
                j[i]=3;
                break;
            case '(':
                j[i]=4;
                break;
            case ')':
                j[i]=5;
                break;
            case '#':
                j[i]=6;
                break;
    
            }
    
        }
        return table[j[0]][j[1]];
    }
    int Operate (int a,char b,int c)
    {
        switch(b)
    
        {
        case '+':
            return a+c;
        case '-':
            return a-c;
        case '*':
            return a*c;
        case '/':
            return a/c;
    
        }
    }
    bool Decide(char c)
    {
        if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='#')
            return true;
        else
            return false;
    }
    int main()
    {
        stack2 a;
        stack b;//a存储符号,b存储数字
        InitStack(a);
        Insert(a,'#');
        InitStack(b);
        char c;
        c=getchar();
        int temp=0;
        while (c!='#'||GetPop(a)!='#')
    
        {
            if(!Decide(c))
            {
                temp=(temp*10+c-'0');//可支持数位数字
                c=getchar();
    
            }
            else if(Decide(c))
            {
                if(temp!=0)
                {
                    Insert2(b,temp);
    
                }
                temp=0;
                switch(Compare(GetPop(a),c))
                {
                case '<':
    //栈顶元素优先权低
    //cout<<"<"<<endl;
                    Insert(a,c);
                    c=getchar();
                    break;
                case '=':
    //脱括号
                    Pop(a);
                    c=getchar();
                    break;
                case'>':
                    char f=Pop(a);
                    int g=Pop2(b);
                    int h=Pop2(b);
                    Insert2(b,Operate(h,f,g));
                    break;
    
                }
    
            }
    
        }
        cout<<"结果为"<<endl;
        cout<<GetPop2(b)<<endl;
        return 0;
    }
    
    
    展开全文
  • 用javafx瞎搞了一个界面,根据学院祖传作业的特色,你们可能会用到吧233,下载了别另外上传啊。
  • 这是大学开设的数据结构的所有实验,需要的大家顶一下。
  • 用C语言写的所有数据结构试验的程序. 包含的主要内容: 树,约瑟夫问题,迷宫,链表,运动会,杖
  • 实 验 报 告 书 程 名 数据结构 题 目 树形数据结构实验 1 班 级 学 号 姓 名 评语 成绩 指导教师 批阅时间 年 月 日 一目的与要求 1熟练掌握二叉树的二叉链表表示创建算法与实现 2 熟练掌握栈的前序中序和后序...
  • 实验七、查找算法的实现 一、实验目的 掌握顺序和二分查找算法的基本思想及其实现方法。 二、实验要求 问题描述:对给定的任意数组(设其长度为n),分别用顺序和二分查找方法在此数组中查找与给定值k相等的元素。 ...

    实验七、查找算法的实现

    一、实验目的
    掌握顺序和二分查找算法的基本思想及其实现方法。
    二、实验要求
    问题描述:对给定的任意数组(设其长度为n),分别用顺序和二分查找方法在此数组中查找与给定值k相等的元素。
    顺序查找基本思想:从查找表的一端开始,逐个将记录的关键字值和给定值进行比较,如果某个记录的关键字值和给定值相等,则称查找成功;否则,说明查找表中不存在关键字值为给定值的记录,则称查找失败。
    二分查找基本思想:先取查找表的中间位置的关键字值与给定关键字值作比较,若它们的值相等,则查找成功;如果给定值比该记录的关键字值大,说明要查找的记录一定在查找表的后半部分,则在查找表的后半部分继续使用折半查找;若给定值比该记录的关键字值小,说明要查找的记录一定在查找表的前半部分,则在查找表的前半部分继续使用折半查找。…直到查找成功,或者直到确定查找表中没有待查找的记录为止,即查找失败。
    两者比较:
    (1)顺序查找的查找效率很低;但是对于待查记录的存储结构没有任何要求,既适用于顺序存储,又适用于链式存储;当待查表中的记录个数较少时,采用顺序查找法较好。
    (2)二分查找的平均查找长度较小,查找速度快;但它只能用于顺序存储,不能用于链式存储;且要求表中的记录是有序的。对于不常变动的有序表,采用折半查找法是较为理想的。
    三、算法思想与算法描述
    1、顺序查找,在顺序表R[0…n-1]中查找关键字为k的记录,成功时返回找到的记录位置,失败时返回-1,具体的算法如下所示:
    int SeqSearch(SeqList R[],int n,KeyType k)
    {
    int i=0;
    while(i<n&&R[i].key!=k)
    {
    printf("%d",R[i].key);
    i++;
    }
    if(i>=n)
    return -1;
    else
    {
    printf("%d",R[i].key);
    return i;
    }
    }
    2、二分查找,在有序表R[0…n-1]中进行二分查找,成功时返回记录的位置,失败时返回-1,具体的算法如下:
    int BinSearch(SeqList R[],int n,KeyType k)
    {
    int low=0,high=n-1,mid,count=0;
    while(low<=high)
    {
    mid=(low+high)/2;
    printf("第%d次查找:在[ %d ,%d]中找到元素R[%d]:%d\n ",++count,low,high,mid,R[mid].key);
    if(R[mid].key==k)
    return mid;
    if(R[mid].key>k)
    high=mid-1;
    else
    low=mid+1;
    }
    return -1;
    }
    四、实验任务
    认真阅读与理解实验内容的具体要求,参考教材相关章节,编写实验程序并上机调试与测试,完成实验报告的撰写。
    1.已知含有10个整数的查找表如下:(9,13,15,7,45,32,56,89,60,36),从键盘上输入一个整数,用顺序查找的方法在查找表中查找该整数。若存在,输出该元素的下标值,否则,给出相应的信息。
    2.对有序数据表(5,7,9,12,15,18,20,22,25,30,100),编写程序按折半查找方法查找12和28。

    顺序查找:

    #include <stdio.h>
    #include <stdlib.h>
    
    int SeqSearch(int R[],int n,int k)
    {
        int i=0;
        while(i<n && R[i]!=k)
        {
            printf("%d",R[i]);
            i++;
        }
        if(i>=n)
            return -1;
        else
        {
            printf("%d",R[i]);
            return i;
        }
    
    }
    
    int main() {
      int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
      int k, loc;
      printf("Please input your number: \n");
      scanf("%d", &k);
      loc=SeqSearch(a, 10, k);
      printf("\n");
      printf("The number's location is %d\n ", loc);
      return 0;
    }
    
    

    二分查找:

    #include <stdio.h>
    #include <stdlib.h>
    
    int BinSearch(int R[], int n, int k)
    {
        int low=0,high=n-1,mid,count=0;
        while(low<=high)
        {
            mid=(low+high)/2;
            printf("第%d次查找:在[ %d ,%d]中找到元素R[%d]:%d\n ",++count,low,high,mid,R[mid]);
            if(R[mid]==k)
                return mid;
            if(R[mid]>k)
                high=mid-1;
            else
                low=mid+1;
        }
        return -1;
    }
    
    int main()
    {
        int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int k, loc;
        printf("Please input your number: \n");
        scanf("%d", &k);
        loc=BinSearch(a, 10, k);
        if(loc == -1)
            printf("not find!");
        return 0;
    }
    

    求赞!!!

    展开全文
  • #资源达人分享计划#
  • 本科数据结构与算法实验,题目与代码完整版。题目 写在PPT里,代码单独放在文件里,用C++编写,可以运行。
  • 数据结构实验课:实验二、链表的实现及应用

    千次阅读 多人点赞 2021-05-19 22:29:30
    一、实验目的 了解和掌握线性表的链式存储结构;掌握用C语言上机调试线性表的基本方法;掌握线性表的基本操作:插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算,以及对相应算法的性能...

    一、实验目的
    了解和掌握线性表的链式存储结构;掌握用C语言上机调试线性表的基本方法;掌握线性表的基本操作:插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算,以及对相应算法的性能分析。

    二、实验要求
    给定一段程序代码,程序代码所完成的功能为:(1)建立一个线性表;(2)依次输入数据元素1,2,3,4,5,6,7,8,9,10;(3)删除数据元素5;(4)依次显示当前线性表中的数据元素。假设该线性表的数据元素个数在最坏情况下不会超过100个,要求使用单链表。
    程序中有3处错误的地方,有标识,属于逻辑错误,对照书中的代码仔细分析后,要求同学们修改错误的代码,上机调试并得到正确的运行结果。

    三、程序代码:
    #include <stdio.h>/该文件包含printf()等函数/
    #include <stdlib.h>/该文件包含exit()等函数/
    #include <malloc.h>/该文件包含malloc()等函数/

    typedef int DataType;/定义DataType为int/

    typedef struct Node
    {
    DataType data;
    struct Node *next;
    } SLNode;

    void ListInitiate(SLNode **head)/初始化/
    {
    /如果有内存空间,申请头结点空间并使头指针head指向头结点/
    if((*head = (SLNode *)malloc(sizeof(SLNode))) == NULL) exit(1);
    (*head)->next = NULL;/*置链尾标记NULL */
    }

    int ListLength(SLNode head) / 单链表的长度*/
    {
    SLNode *p = head;/p指向首元结点/
    int size = 0;/size初始为0/

    while(p->next != NULL)/循环计数/
    {
    p = p->next;
    size ++;
    }
    return size;
    }

    int ListInsert(SLNode *head, int i, DataType x)
    /在带头结点的单链表head的数据元素ai(0 ≤ i ≤ size)结点前/
    /插入一个存放数据元素x的结点/
    {
    SLNode *p, *q;
    int j;

    p = head; /p指向首元结点/
    j = -1;/j初始为-1/
    while(p->next != NULL && j < i - 1)
    /最终让指针p指向数据元素ai-1结点/
    {
    p = p->next;
    j++;
    }

    if(j != i - 1)
    {
    printf(“插入位置参数错!”);
    return 0;
    }

    /生成新结点由指针q指示/
    if((q = (SLNode *)malloc(sizeof(SLNode))) == NULL) exit(1);
    q->data = x;

    //此段程序有一处错误
    p->next = q->next;/给指针q->next赋值/
    p->next = q;/给指针p->next重新赋值/
    return 1;
    }

    int ListDelete(SLNode *head, int i, DataType *x)
    /删除带头结点的单链表head的数据元素ai(0 ≤ i ≤ size - 1)结点/
    /删除结点的数据元素域值由x带回。删除成功时返回1;失败返回0/
    {
    SLNode *p, *s;
    int j;

    p = head; /p指向首元结点/
    j = -1;/j初始为-1/
    while(p->next != NULL && p->next->next!= NULL && j < i - 1)
    /最终让指针p指向数据元素ai-1结点/
    {
    p = p->next;
    j++;
    }

    if(j != i - 1)
    {
    printf(“删除位置参数错!”);
    return 0;
    }

    //此段程序有一处错误
    s->next = p; /指针s指向数据元素ai结点/
    *x = s->data;/把指针s所指结点的数据元素域值赋予x/
    p->next = s->next;/把数据元素ai结点从单链表中删除/
    free(s);/释放指针s所指结点的内存空间/
    return 1;
    }

    int ListGet(SLNode *head, int i, DataType *x)
    /取数据元素ai和删除函数类同,只是不删除数据元素ai结点/
    {
    SLNode *p;
    int j;

    p = head;
    j = -1;
    while(p->next != NULL && j < i)
    {
    p = p->next;j++;
    }

    if(j != i)
    {
    printf(“取元素位置参数错!”);
    return 0;
    }

    //此段程序有一处错误
    *x = p->next;
    return 1;
    }

    void Destroy(SLNode **head)
    {
    SLNode *p, *p1;

    p = *head;
    while(p != NULL)
    {
    p1 = p;
    p = p->next;
    free(p1);
    }
    *head = NULL;
    }

    void main(void)
    {
    SLNode *head;
    int i , x;
    ListInitiate(&head);/初始化/
    for(i = 0; i < 10; i++)
    {
    if(ListInsert(head, i, i+1) == 0) /插入10个数据元素/
    {
    printf(“错误! \n”);
    return;
    }
    }

    if(ListDelete(head, 4, &x) == 0) /删除数据元素5/
    {
    printf(“错误! \n”);
    return;
    }

    for(i = 0; i < ListLength(head); i++)
    {
    if(ListGet(head, i, &x) == 0) /取元素/
    {
    printf(“错误! \n”);
    return;
    }
    else printf("%d ", x);/显示数据元素/
    }

    Destroy(&head);
    }
    三、实验任务
    1.改正上述程序中的错误。
    2.编写合并函数,将两个有序的单链表合并成一个有序单链表。
    3.完成实验报告的撰写。

    代码如下

    #include <stdio.h>/*该文件包含pringtf()等函数*/
    #include <stdlib.h>/*该文件包含exit()等函数*/
    #include <malloc.h>/*该文件包含malloc()等函数*/
    
    typedef int DataType;/*定义DataType为int*/
    
    
    typedef struct Node
    {
        DataType data;
        struct Node *next;
    } SLNode;
    
    void ListInitiate(SLNode **head)/*初始化*/
    {
        /*如果有内存空间,申请头结点空间并使头指针head指向头结点*/
        if((*head = (SLNode *)malloc(sizeof(SLNode))) == NULL) exit(1);
        (*head)->next = NULL;/*置链尾标记NULL */
    }
    
    int ListLength(SLNode *head)               /* 单链表的长度*/
    {
        SLNode *p = head;/*p指向首元结点*/
        int size = 0;/*size初始为0*/
    
        while(p->next != NULL)/*循环计数*/
        {
            p = p->next;
            size ++;
        }
        return size;
    }
    
    int ListInsert(SLNode *head, int i, DataType x)
    /*在带头结点的单链表head的数据元素ai(0 ≤ i ≤ size)结点前*/
    /*插入一个存放数据元素x的结点*/
    {
        SLNode *p, *q;
        int j;
    
        p = head; /*p指向首元结点*/
        j = -1;/*j初始为-1*/
        while(p->next != NULL && j < i - 1)
            /*最终让指针p指向数据元素ai-1结点*/
        {
            p = p->next;
            j++;
        }
    
        if(j != i - 1)
        {
            printf("插入位置参数错!");
            return 0;
        }
    
        /*生成新结点由指针q指示*/
        if((q = (SLNode *)malloc(sizeof(SLNode))) == NULL) exit(1);
        q->data = x;
    
    //此段程序有一处错误
        q->next = p->next;/*给指针q->next赋值*/
        p->next = q;/*给指针p->next重新赋值*/
        return 1;
    }
    
    int ListDelete(SLNode *head, int i, DataType *x)
    /*删除带头结点的单链表head的数据元素ai(0 ≤ i ≤ size - 1)结点*/
    /*删除结点的数据元素域值由x带回。删除成功时返回1;失败返回0*/
    {
        SLNode *p, *s;
        int j;
    
        p = head; /*p指向首元结点*/
        j = -1;/*j初始为-1*/
        while(p->next != NULL && p->next->next!= NULL && j < i - 1)
            /*最终让指针p指向数据元素ai-1结点*/
        {
            p = p->next;
            j++;
        }
    
        if(j != i - 1)
        {
            printf("插入位置参数错!");
            return 0;
        }
    
    //此段程序有一处错误
        s = p->next; /*指针s指向数据元素ai结点*/
        *x = s->data;/*把指针s所指结点的数据元素域值赋予x*/
        p->next = s->next;/*把数据元素ai结点从单链表中删除指*/
        free(s);/*释放指针s所指结点的内存空间*/
        return 1;
    }
    
    int ListGet(SLNode *head, int i, DataType *x)
    /*取数据元素ai和删除函数类同,只是不删除数据元素ai结点*/
    {
        SLNode *p;
        int j;
    
        p = head;
        j = -1;
        while(p->next != NULL && j < i)
        {
            p = p->next;
            j++;
        }
    
        if(j != i)
        {
            printf("取元素位置参数错!");
            return 0;
        }
    
    //此段程序有一处错误
        *x = p->data;
        return 1;
    }
    
    void Destroy(SLNode **head)
    {
        SLNode *p, *p1;
    
        p = *head;
        while(p != NULL)
        {
            p1 = p;
            p = p->next;
            free(p1);
        }
        *head = NULL;
    }
    
    int main()
    {
        SLNode *head;
        int i, x;
        ListInitiate(&head);/*初始化*/
        for(i = 0; i < 10; i++)
        {
            if(ListInsert(head, i, i+1) == 0) /*插入10个数据元素*/
            {
                printf("错误! \n");
                return 0;
            }
        }
        if(ListDelete(head, 4, &x) == 0) /*删除数据元素5*/
        {
            printf("错误! \n");
            return 0;
        }
        for(i = 0; i < ListLength(head); i++)
        {
            if(ListGet(head, i, &x) == 0) /*取元素*/
            {
                printf("错误! \n");
                return 0;
            }
            else printf("%d    ", x);/*显示数据元素*/
        }
        Destroy(&head);
        return 0;
    }
    

    第二题

    #include <stdio.h>/*该文件包含pringtf()等函数*/
    #include <stdlib.h>/*该文件包含exit()等函数*/
    #include <malloc.h>/*该文件包含malloc()等函数*/
    /*=====================================*/
    typedef int DataType;/*定义DataType为int*/
    typedef struct Node
    {
        DataType data;
        struct Node *next;
    } SLNode;
    
    void ListInitiate(SLNode **head)/*初始化*/
    {
        /*如果有内存空间,申请头结点空间并使头指针head指向头结点*/
        if((*head = (SLNode *)malloc(sizeof(SLNode))) == NULL) exit(1);
        (*head)->next = NULL;/*置链尾标记NULL */
    }
    
    int ListLength(SLNode *head)               /* 单链表的长度*/
    {
        SLNode *p = head;/*p指向首元结点*/
        int size = 0;/*size初始为0*/
    
        while(p->next != NULL)/*循环计数*/
        {
            p = p->next;
            size ++;
        }
        return size;
    }
    
    int ListInsert(SLNode *head, int i, DataType x)
    /*在带头结点的单链表head的数据元素ai(0 ≤ i ≤ size)结点前*/
    /*插入一个存放数据元素x的结点*/
    {
        SLNode *p, *q;
        int j;
    
        p = head; /*p指向首元结点*/
        j = -1;/*j初始为-1*/
        while(p->next != NULL && j < i - 1)
            /*最终让指针p指向数据元素ai-1结点*/
        {
            p = p->next;
            j++;
        }
    
        if(j != i - 1)
        {
            printf("插入位置参数错!");
            return 0;
        }
    
        /*生成新结点由指针q指示*/
        if((q = (SLNode *)malloc(sizeof(SLNode))) == NULL) exit(1);
        q->data = x;
    
    //此段程序有一处错误 zjyigai
        q->next=p->next;/*给指针q->next赋值*/
        p->next = q;/*给指针p->next重新赋值*/
        return 1;
    }
    
    int ListGet(SLNode *head, int i, DataType *x)
    /*取数据元素ai和删除函数类同,只是不删除数据元素ai结点*/
    {
        SLNode *p;
        int j;
    
        p = head;
        j = -1;
        while(p->next != NULL && j < i)
        {
            p = p->next;
            j++;
        }
    
        if(j != i)
        {
            printf("取元素位置参数错!");
            return 0;
        }
    
    //此段程序有一处错误 zjyigai
        *x = p->data;
        return 1;
    }
    
    void Destroy(SLNode **head)
    {
        SLNode *p, *p1;
    
        p = *head;
        while(p != NULL)
        {
            p1 = p;
            p = p->next;
            free(p1);
        }
        *head = NULL;
    }
    
    void MergeList(SLNode *head1,SLNode *head2,SLNode **head3)
    {
        int i=0,j=0,k=0,ai,bj;
        int La_len=ListLength(head1),Lb_len=ListLength(head2);
        while(i<La_len && j<Lb_len)
        {
            ListGet(head1,i,&ai);
            ListGet(head2,j,&bj);
            if(ai<=bj)
            {
                ListInsert(*head3,k++,ai);
                i++;
            }
            else
            {
                ListInsert(*head3,k++,bj);
                j++;
            }
        }
        while(i<La_len)
        {
            ListGet(head1,i++,&ai);
            ListInsert(*head3,k++,ai);
        }
        while(j<Lb_len)
        {
            ListGet(head2,j++,&bj);
            ListInsert(*head3,k++,bj);
        }
    }
    int main(void)
    {
        SLNode *head1,*head2,*head3;
        int i , x;
        ListInitiate(&head1);/*初始化*/
        ListInitiate(&head2);
        ListInitiate(&head3);
        for(i = 0; i < 10; i++)
        {
            if(ListInsert(head1, i, i*2) == 0) /*插入10个数据元素*/
            {
                printf("错误! \n");
                return 1;
            }
            if(ListInsert(head2,i,i*2+1)==0)
            {
                printf("错误!\n");
                return 1;
            }
        }
        printf("head1:");
        for(i = 0; i < ListLength(head1); i++)
        {
            if(ListGet(head1, i, &x) == 0) /*取元素*/
            {
                printf("错误! \n");
                return 1;
            }
            else printf("%d ", x);/*显示数据元素*/
        }
        printf("\nhead2:");
        for(i = 0; i < ListLength(head2); i++)
        {
            if(ListGet(head2, i, &x) == 0) /*取元素*/
            {
                printf("错误! \n");
                return 1;
            }
            else printf("%d ", x);/*显示数据元素*/
        }
        MergeList(head1,head2,&head3);
        printf("\nhead3:");
        for(i = 0; i < ListLength(head3); i++)
        {
            if(ListGet(head3, i, &x) == 0) /*取元素*/
            {
                printf("错误! \n");
                return 1;
            }
            else printf("%d ", x);/*显示数据元素*/
        }
        Destroy(&head1);
        Destroy(&head2);
        Destroy(&head3);
    }
    
    

    求赞!!!

    展开全文
  • 吉林大学软件学院卓班数据结构上机和实验代码 共七次 第一次实例:单链表实现 class Node{ public: int data; }; class List{ Node *list; int size; public: List(){size=0;list=new Node[maxsize];} ~List...
  • 数据结构实验课_实验四 队列

    千次阅读 2020-12-28 22:37:32
    一、实验内容 1.采用顺序存储实现循环队列的初始化、入队、出队操作。 2.采用链式存储实现队列的初始化、入队、出队操作。 3.编写一个程序,使用两个链队q1和q2,用来分别存储由计算机随机产生的20个100以内的...
  • 东北大学数据结构实验,包括打印机以及欧洲旅游的java代码以及实验报告
  • 数据结构课实验,简单实验顺序表、单链表,终端显示 压缩包包含:两个cpp文件,一个顺序表,一个单链表,可直接编译运行
  • 数据结构C语言代码 实验程序
  • #资源达人分享计划#
  • 数据结构课实验,简单实现稀疏矩阵转置,终端显示 压缩包包含:xxjz.txt,一个cpp,可直接编译运行
  • 数据结构实验课:实验四、队列的实现及应用

    千次阅读 多人点赞 2021-05-19 22:55:54
    实验四、队列的实现及应用 一、实验目的 1.掌握队列的存储表示和实现。 2.掌握队列的基本操作实现。...假定模拟数据已按客户到达的先后顺序依次存于某个正文数据文件中,对应每位客户有两个数据:到达时间和需要办理业

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,033
精华内容 10,813
关键字:

数据结构实验课教案

数据结构 订阅