精华内容
下载资源
问答
  • 数据结构实践报告

    2015-04-03 23:30:25
    数据结构实践报告设计一个通讯录管理系统!
  • 数据结构实践报告2018

    2020-12-24 17:15:16
    数据结构实践报告2018
  • 数据结构实践报告分析 1 程序所实现的功能 2 程序的输入包含输入的数据格式和说明 3 程序的输出程序输出的形式 4 测试数据如果程序输入的数据虽比较大需要给 出测试数据 5 合作人及其分工 1 主要的数据结构设计说明 ...
  • 数据结构实践报告 学 号 150906112 姓 名 武锦蓉 班 级 NET2 班 指导老师 田喜平 时 间 2016-12-21 项目名称 一 项目构思 程序由三个模块组成 1输入模块无提示语句直接输入总人数n 和报数次数 m 中间用逗 号隔开 2 ...
  • 学习参考 学习参考 河南财经政法大学 实 践 ... 五调试分析 9 六 测试分析 10 七 心得体会 11 八 附录源代码 12 设计目的 1通过课程设计了解并掌握数据结构的设计方法具备初步的独 立分析和设计能力 2通过课程设计初步
  • 河 南 财 经 政 法 大 学 集 中 实 践 报 告 院系 班级 指导老师 小组 小组成员 目 录 一设计目的 3 二问题描述 3 三概要设计 4 四详细设计 8 五调试分析 9 六测试分析 10 七心得体会 11 八附录
  • 数据结构实验报告实验名称: 实验七 图 dijkstra算法学号:***姓名:gnosed实验日期:2017.12.23 一、实验目的掌握求最短路径的Dijkstra算法 二、实验具体内容1、实验题目1:(1)题目编写程序,用Dijkstra算法求...

    数据结构实验报告

    实验名称: 实验七 图 dijkstra算法

    学号:***

    姓名:gnosed

    实验日期:2017.12.23

     

    一、实验目的

    掌握求最短路径的Dijkstra算法

     

    二、实验具体内容

    1、实验题目1:

    (1)题目

    编写程序,用Dijkstra算法求图的最短路径

    (2)分析

    存储结构:

    1. 图以邻接矩阵表示,关系矩阵对角线初值取为0。
    2. 数组dist[]:dist[i]最终储存Vo到Vi的最短路径及最短路径上Vi的前驱顶点(计算过程为距离值,可能会被调整)。

    说明:

    1. dist可分为集合U和V两部分,U指从Vo到一个顶点最短路径的所有顶点,V指未确定最短路径的顶点集合。
    2. 初始化dist时,集合U只有Vo,其对应的距离值为0;集合V中Vi的距离值为边(Vo,Vi)的权,若Vo和Vi之间无直接边,则Vi的距离值为无穷大(这里定为1000)。

    算法过程:

    1)从集合V中选择距离值最小的顶点Vmin加入到集合U(可通过修改对角线元素值为1来表示)

    2)因为上面选出的Vmin放到U时,如果Vmin可能是Vo到其它顶点V[i]最短路径上的一个顶点,这使得dist[i]的距离值减小,所以这时,需要根据min值,对集合V中各顶点的距离值进行调整:如果Vo到Vi的距离值比原来的距离值小,则修改Vi的距离值dist[i].length,否则不修改。

    3)重复1)2),直到从Vo可以到达的所有顶点都被放入集合U为止。

    (3)实验代码

    源代码:

    #include <iostream>
    #include <stack>
    #define Vextype int
    #define Adjtype int
    #define VN 6
    #define MAX 1000
    using namespace std;
    
    struct GraphMatrix
    {
        Vextype vex[VN][VN];
        Adjtype arc[VN][VN];
    };
    typedef struct{
        Adjtype length;//shortest path
        int prevex;//Vi的前驱顶点
    }Path;
    Path dist[VN];
    void init(GraphMatrix *pgraph,Path *dist)
    {
        dist[0].length=dist[0].prevex=0;
        pgraph->arc[0][0]=1;//用矩阵对角线元素表示U,为1表示在U中
        for(int i=1;i<VN;++i){//初始化U-V中顶点的距离值
            dist[i].length=pgraph->arc[0][i];
            if(dist[i].length!=MAX) dist[i].prevex=0;
            else dist[i].prevex=-1;
        }
    }
    void dijkstra(GraphMatrix *pgraph,Path *dist)
    {
        init(pgraph,dist);//初始化,U中只有Vo
        Adjtype minw;
        int mv;
        for(int i=1;i<VN;++i){
            minw=MAX; mv=0;
            for(int j=1;j<VN;++j)//在V-U中选出距离Vo最近的顶点
                if(pgraph->arc[j][j]!=1 && minw>dist[j].length){
                    minw=dist[j].length; mv=j;
                }
            if(mv==0)    break;//Vo与V-U的顶点不连通,结束
            pgraph->arc[mv][mv]=1;//顶点mv加入U
            for(int i=1;i<VN;++i){//调整V-U顶点的已知最短路径
                if(pgraph->arc[i][i]!=1&&
                   dist[i].length>dist[mv].length+pgraph->arc[mv][i]){
                       dist[i].prevex=mv;
                        dist[i].length=dist[mv].length+pgraph->arc[mv][i];
                   }
            }
        }
    }
    
    int main()
    {
        GraphMatrix *G=new struct GraphMatrix;
        for(int i=0;i<VN;i++)
            for(int j=0;j<VN;j++)
                cin>>G->arc[i][j];
        dijkstra(G,dist);
        cout<<"起点是0,请输入终点:";
        int en,k;
        cin>>en;
        k=en;
        cout<<"最短路径长度:"<<dist[k].length<<"\n路径:";
        stack<int> Path;
        while(1){
            Path.push(dist[k].prevex);
            k=dist[k].prevex;
            if(!k) break;
        }
        while(!Path.empty()){
            cout<<Path.top()<<"->";
            Path.pop();
        }
        cout<<en;
        return 0;
    }
    


    Input

    0 50 101000 45 1000
    1000 0 15 1000 5 1000
    20 1000 0 15 1000 1000
    1000 20 1000 0 35 1000
    1000 1000 1000 30 0 1000
    1000 1000 1000 3 1000 0

    Output:

    起点是0,请输入终点:3
    最短路径长度:25
    路径:0->2->3

    展开全文
  • 数据结构实验报告实验名称:实验五 二叉堆排序树的建立和检索学号:***姓名:gnosed实验日期:2017.11.10 一、实验目的1、掌握以堆为序列的二叉堆排序树的建立2、对二叉排序树进行数据检索 二、实验具体内容1、...

     数据结构实验报告

    实验名称:实验五 二叉堆排序树的建立和检索

    学号:***

    姓名:gnosed

    实验日期:2017.11.10

     

    一、实验目的

    1、掌握以堆为序列的二叉堆排序树的建立

    2、对二叉排序树进行数据检索

     

    二、实验具体内容

    1、实验题目1:

    (1)题目

    构造一棵二叉排序树,并进行遍历,检索数据

    要求:

    1、输入数据构造二叉排序树

    2、对构造好的二叉排序树进行中根序遍历

    提示:

    对二叉排序树进行中根序遍历的时候,获得的是排序序列

     

    (2)分析

    构造(以小根堆为例):

    1)查找:

    按二叉排序树的性质,查找并返回元素要插入的位置——父亲(叶)节点地址;

    2)插入:对于给定序列的每个元素(无重复),

    如果二叉排序树为空,创建根节点;

    否则,执行1),将元素与返回的叶节点进行比较,若前者小则将其插入到后者的左子树,否则插入到右子树。

    重复2),直到序列末尾。

    验证:

    对构造好的二叉排序树进行中序遍历,验证构造是否正确。

    (3)实验代码

    源代码:

    #include<iostream>
    #include<string.h>
    #defineELEMTYPE int
     
    using namespace std;
     
    typedef struct node* Pnode;
    typedef struct node* Ptree;
    struct node{
        ELEMTYPE x;
        Pnode llink,rlink;
    };
    int MAXN;
    //1)
    Pnode searchPnode(Ptree t,ELEMTYPE i){
       if(t->llink==NULL&&t->rlink==NULL)
            return t;
        Pnode pre;//flag previous node
        while(t){
            pre=t;
            if(i<t->x)
                t=t->llink;
            else
                t=t->rlink;
        }
        return pre;
    }
    //2)
    Ptreecreate(ELEMTYPE seq[]){
        Pnode root=new struct node;
        root->x=seq[0];
        root->llink=root->rlink=NULL;
        for(int i=1;i<MAXN;i++){
            Pnode t=new struct node;
            t->x=seq[i];
            t->llink=t->rlink=NULL;
     
            Pnode pre=searchPnode(root,seq[i]);
            if(seq[i]<pre->x)//linking
                pre->llink=t;
            else
                pre->rlink=t;
        }
        return root;
    }
    //recursionin order traversing
    void in_order(Ptree root){
        if(!root)
            return;
        in_order(root->llink);
        cout<<root->x<<"";
        in_order(root->rlink);
    }
    int main()
    {
        cin>>MAXN;//input number of nodes
        ELEMTYPE seq[MAXN];
        for(int i=0;i<MAXN;i++)
            cin>>seq[i];
        cout<<"In order search of the tree: ";
        in_order(create(seq));
        return 0;
    }


    测试结果:

    10
    53 7 10 1 4 8 -40 -5 0
    Inorder search of the tree: -40 -5 0 1 3 4 5 7 8 10
     
    14
    55-88 45 32 1 56 44 30 23 -23 2 3 100 -101
    Inorder search of the tree: -101 -88 -23 1 2 3 23 30 32 44 45 55 56 100


    三、实验小结

    1.        二叉排序树的插入时间复杂度为O(n^2)

    2.        检索二叉排序树最坏时间复杂度为O(n)

    展开全文
  • 个人收集整理 仅供参考学习 数据结构实践报告 学号150906112 姓名武锦蓉 班级NET2?班 指导老师田喜平 时 间2016-12-21 1?/?8 个人收集整理 仅供参考学习 项目名称 一?项目构思 程序由三个模块组成 1输入模块无提示...
  • 数据结构实践设计报告,数据结构实验,适用于数据结构这门课程的报告
  • 数据结构实践报告:文件目录管理与显示的代码及报告样本
  • 自考本科,数据结构实践报告。包含了实践原理,实践内容,实践结果,实践分析以及实践心得。
  • 实 验 报 告 课程名称 数据结构实验 实验项目 二叉树的建立及遍历 姓 名 专 业 班 级 学 号 计算机科学与技术学院 实验教学中心 2017 年 11 月 17 日 哈尔滨理工大学计算机科学与技术学院实验教学中心 实验报告 ...
  • 陕西省 西安电子科技大学 计算机应用实践报告 数据结构 doc
  • 数据结构实践》设计报告—迷宫求解 因为学校要求答辩结课,给了很多题目都不太会,决定把感兴趣的都做一做,在这存档备用。 课程设计题目:迷宫求解 课程设计主要内容和要求: 一.设计目的: 1.掌握栈的特点及其...

    《数据结构实践》设计报告—迷宫求解

    因为学校要求答辩结课,给了很多题目都不太会,决定把感兴趣的都做一做,在这存档备用。

    课程设计题目:迷宫求解

    课程设计主要内容和要求:

    一.设计目的:
    1.掌握栈的特点及其描述方法
    2.掌握链栈的各种基本操作

    二.设计内容和要求:
    由0和1构成的m*n维矩阵表示一个迷宫,其中0表示通路,1表示墙壁。迷宫入口为(1,0),出口为(m-1,n)。迷宫随机产生。试编一算法求出从入口到出口的一条通路,或显示没有通路。要求实现如下功能:
    1.从键盘输入m和n,随机产生迷宫。
    2.找到一条通路即可,若没有显示“No path!”。

    --------------------------------------------------------------------

    一、题目描述

    以一个m×n的长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍,设计一个程序,对任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。

    在这里插入图片描述

    二、解题思路

    建立一个迷宫:
    1、先建立一个数组假设数组存储的全为墙(wall),假设迷宫只有一条正确的道路。
    2、确定迷宫的起点(route),以起点为根节点向下搜索,搜索到墙(wall),将墙变为路(route)。
    3、我们挖的道路就像树结构,树上有很多的分支,分支也有子分支,每个子分支都不能相交,相交就说明墙被推倒了,那么此时的迷宫就可能存在多条正确道路,那么基于唯一道路的原则,我们向某个方向搜索一块新的区域时,要先判断新区域是否有形成回路的可能,如果可能要立即停止并换个方向搜索。
    4、因为采用了递归的方式,所以给迷宫外层围上墙之后,再在墙外围上一条路。避免程序永久执行下去。

    寻找迷宫路径:
    1、 将迷宫起点压栈,标记已走过道路。
    2、 向四个方向遍历,寻找是路的邻接点。
    3、 确认邻接点可行将邻接点压栈,标记邻接点为可行路径。如果邻接点不可行,则将邻接点弹栈。
    4、 重复,遍历到出口节点,输出路径。
    5、 如栈空,输出No path!

    三、主要数据结构

    1、使用数组存储迷宫,方便好看。使用静态二维数组作为参数传递比较麻烦,一般需要指明第二维的长度,但在本题情况中,第二维长度未知。所以使用malloc内存动态分配数组,既保证数组连续性,又方便传递参数。

    int **Maze = (int**)malloc(M * sizeof(int *));
    	for(i=0;i<M;i++){
            Maze[i]=(int*)malloc(N * sizeof(int));
    	}
    

    2、使用栈存储迷宫路径,因为栈的原则是先进后出,符合迷宫走错路就退一步的特点。栈使用链式存储方式,用于存放遍历的点和下一个点运动的方向。

    struct MG{
        int i;
        int j;
        int di;     ///记录方向
    }Stack[MaxSize];///栈:存放路径
    

    四、相关算法介绍

    深度优先搜索:目的是要达到被搜索结构的叶结点。即在搜索其余的结果之前必须先完整地搜索单独的一条链。深度优先搜索沿着结点走到不能再深入为止,然后返回到某一个结点,再继续选择其他结点搜索。当不再有其他结点可选择时,说明搜索已经结束。

    使用图的深度遍历:
    (1)从迷宫起点节点V开始访问
    (2)访问这个节点V,标记为可行的路径;
    (3)从v的未被访问的非"墙"邻接点中选取一个顶点w,重复第二步。如果v没有未访问的非"墙"邻接点,把这个节点的可行路径标记移除,回溯至上一节点;
    (4)重复上述第(2)、(3)步,直至遍历到迷宫的出口节点。

    五、源程序

    #include<stdio.h>
    #include<time.h>
    #include<math.h>
    #include <stdlib.h>
    ///墙和路径的标识
    #define wall  0
    #define route 1
    #define path  3
    #define MaxSize 100///规定栈空间最大是100
    
    struct MG{
        int i;
        int j;
        int di;     ///记录方向
    }Stack[MaxSize];///栈:存放路径
    int top=-1;
    
    ///声明函数
    void CreateMaze(int **maze, int x, int y);
    void mgpath(int **maze,int M, int N);
    
    int main() {
        srand((unsigned)time(NULL));/***生成随机数***/
    
        int M,N;
        printf("请输入迷宫长度M,宽度N(长宽差2,空格间隔)\n");
        scanf("%d %d/n",&M,&N);
        M=M+2;N=N+2;///加上外侧包围墙体,最外侧包围路径。
    
    	int i,j;
    	int **Maze = (int**)malloc(M * sizeof(int *));
    	for(i=0;i<M;i++){
            Maze[i]=(int*)malloc(N * sizeof(int));
    	}/***int *a=(int*)malloc(n*sizeof(int));
            表示定义一个int类型的指针变量a,
            并申请n*sizeof(int)个字节(即4*n个字节)的存储空间。***/
    
    ///防止搜索路时超出边界,把最外围层设为路径。
    	for (i=0; i<M; i++){
            Maze[i][0]=route;
    		Maze[i][N-1]=route;
    	}
    	for (i=0; i<N; i++){
    	    Maze[M-1][i]=route;
    		Maze[0][i]=route;
        }
    	///创造迷宫,(2,2)为起点
    	CreateMaze(Maze, 2, 2);
    
    	///画迷宫的入口
    	Maze[2][1] = route;
    
    	///算法随机性,出口不一定在(M-3,N-2)处,需要寻找出口。
    	for (i=M-3; i>=0; i--) {
    		if (Maze[i][M-3]==route) {
    			Maze[i][N-2] = route;
    			break;
    		}
    	}
    
    	///打印迷宫。
    	for (i=0; i<M; i++) {
    		for (j=0; j<N; j++) {
    			if (Maze[i][j]==route) {
    				printf(" 0 ");
    			}
    			else {
    				printf(" 1 "); ///█墙壁,测试用。
    			}
    		}
    		printf("\n");
    	}
    	printf("迷宫路径如下:\n");
        mgpath(Maze,M,N);
    
    	for(i=0;i<M;i++)
            free((int *)Maze[i]);
        free((int *)Maze);
    
    	return 0;
    }
    
    void CreateMaze(int **maze, int x, int y) {
    	maze[x][y] = route;
    	///确保四个方向随机
    	int direction[4][2] = { {-1,0},{1,0},{0,-1},{0,1} };///向上,下,左,右移动
    	int i,j,k;
    	for (i=0; i<4; i++) {
    		int r = rand() % 4;
    		int t = direction[0][0];
    		direction[0][0] = direction[r][0];
    		direction[r][0] = t;
    		t = direction[0][1];
    		direction[0][1] = direction[r][1];
    		direction[r][1] = t;
    	}
    
    	///决定下一步去往那个方向
    	for (i=0; i<4; i++) {
    		int dx=x;
    		int dy=y;
    
    		int range = 1;
    		while (range>0) {
    			dx += direction[i][0];
    			dy += direction[i][1];
    
    			///排除掉回头路
    			if (maze[dx][dy] == route) {
    				break;
    			}
    
    			///判断是否挖穿路径
    			int count = 0;
    			for (j=dx-1;j<dx+2;j++) {
    				for (k=dy-1;k<dy+2;k++) {
    		///abs(j-dx) + abs(k-dy) == 1 确保只判断九宫格的四个特定位置
    		///abs 绝对值函数
    					if (abs(j-dx)+abs(k-dy)==1 && maze[j][k]==route){
    						count++;
    					}
    				}
    			}
    
    			if (count > 1) {
    				break;
    			}
    
    			///确保不会挖穿时,前进
    			--range;
    			maze[dx][dy] = route;
    		}
    
    		///没有挖穿危险,以此为节点递归
    		if (range <= 0) {
    			CreateMaze(maze, dx, dy);
    		}
    	}
    }
    
    void mgpath(int **Maze,int M, int N){
        int i,j,di;/// i,j表示当前位置,di为方向
        int find,k;/// find为是否找到了可走点,找到为1,k用于读取
        top++;
        Stack[top].i=2;      ///初始位置(2,2)
        Stack[top].j=1;
        Stack[top].di=-1;
        Maze[2][1]= path;
    
        while(top>-1){       ///只要栈Stack不为空就继续走
            i=Stack[top].i;
            j=Stack[top].j;
            di=Stack[top].di;
            if(i==M-3&&j==N-2)         ///找到了出口,输出路径
            {
                for(k=0; k<=top; k++)
                {
                    printf("(%d,%d) ",Stack[k].i,Stack[k].j);
                }
                break;
           }
            find=0;
            ///di:0上1右2下3左四个方向,找可走点
    
            while(di<4 && find==0){    ///在4个方向内,寻找可走点
                di++;
                switch(di)
                {
                case 0:i=Stack[top].i-1;
                       j=Stack[top].j;
                       break;   ///上面
                case 1:i=Stack[top].i;
                       j=Stack[top].j+1;
                       break;   ///右边
                case 2:i=Stack[top].i+1;
                       j=Stack[top].j;
                       break;   ///下面
                case 3:i=Stack[top].i;
                       j=Stack[top].j-1;
                       break;  ///左边
                }
                if(Maze[i][j]==route){///找到可走点
                    find=1;
                }
            }
    
            if(find == 1)           ///找到了下一个可走结点
            {
                Stack[top].di=di;   ///修改原栈顶元素的di值
                top++;              ///下一个可走结点进栈
                Stack[top].i=i;
                Stack[top].j=j;
                Stack[top].di=-1;
                Maze[i][j]=path;        ///避免重复走到该结点
            }else                   ///没找到
            {
                Maze[Stack[top].i][Stack[top].j]=route;   ///让该位置变为其他路径的可走结点
                top--;
            }
        }
        if(top==-1){
                printf("No path!");
           }
    }
    
    
    

    六、时空分析(这个是真的不会,凑合弄的,凑合看吧。)

    建立一个迷宫:
    寻找迷宫路径:
    因为算法不稳定,其时空复杂度不仅和m,n有关,还和Maze[ ][ ]的具体数值有关。
    最坏情况下:每个点都试探过才走到终点。此时时间复杂度为:(m×n-1) ×4,(其中4为4个方向),空间复杂度m×n+100=m×n,(其中m×n为存储迷宫图空间,100为栈空间);
    再好情况下:一次试探过就走到终点。此时时间复杂度为:(min(m,n)-1),空间复杂度m×n;
    该算法时间复杂度为:[(m×n-1) ×4+(min(m,n)-1)]/2,约为2×m×n
    空间复杂度为3×m×n/2

    七、运行结果及分析

    在这里插入图片描述
    1、尝试使用在全为墙的数组中使墙随机生成路径,因为不确定性太大,每个wall都有50%的可能成为路,生成回路或者没有路径的可能性太大,决定使用深度搜索算法,缺点是只有一条路径。
    2、从键盘中输入行数与列数,调用CreateMaze函数随机生成一个迷宫,缺陷在于行数和列数的差值固定,只能为二。
    3、迷宫生成后调用mgpath函数寻找迷宫路径,因为算法问题只能生成一条且必有一条函数,所以只能输出一条路径,如有多条路径的算法可以定义length,再新建一个栈,使用length和top做比较,可以输出多条路径和最短路径。

    //例如
    if(top+1<minlen)           //比较是否是最短路径
       {
          for(k=0;k<=top;k++)     //是最短,保存路径
             Path[k]=Stack[k];
             minlen=top+1;
       }
    

    八、问题

    其实测试的时候出了很多问题,
    比如M和N的差值只能是二,其他的就会报错,

    ///算法随机性,出口不一定在(M-3,N-2)处,需要寻找出口。
    	for (i=M-3; i>=0; i--) {
    		if (Maze[i][M-3]==route) {
    			Maze[i][N-2] = route;
    			break;
    		}
    	}
    

    还有这个,如果挖到最后一行或最后一列,感觉应该用两个for循环,如果一个挖到出口列,把挖到的路到出口中间那一列的墙打通;一个挖到出口行,把挖到的路到出口中间那一行的墙打通。这么写也能运行,那我就凑合了。
    具体是为什么,我也没搞明白。

    九、参考。

    关于怎样生成一个迷宫:
    https://blog.csdn.net/jjwwwww/article/details/82872922
    关于怎样寻找迷宫路径:
    https://blog.csdn.net/zhouchenghao123/article/details/83626222

    展开全文
  • 数据结构作业,做一个小型图书管理系统,本内容为课程实践报告 包含源码(c++版本)
  • 关于图的基本操作,主要有图的建立,输入,输入,遍历和界面设计等操作,
  • 二、实验内容 1.根据给出的字符以及这些字符的使用频率构建哈夫曼树。 2.根据哈夫曼树对字符进行哈夫曼编码,并保存这些编码。...1. 建立哈夫曼树的存储结构和哈夫曼编码的存储结构。 2. 建立哈夫曼树的...

     

    二、实验内容

    1.根据给出的字符以及这些字符的使用频率构建哈夫曼树。

    2.根据哈夫曼树对字符进行哈夫曼编码,并保存这些编码。

    三、实验原理、方法和手段

        试构造出问题模型,并编程实现这一问题的求解。根据实验内容编程,上机调试、得出正确的运行程序;编译运行程序,观察运行情况和输出结果。

    六、实验步骤

    1. 建立哈夫曼树的存储结构和哈夫曼编码的存储结构。

    2. 建立哈夫曼树的函数;

    3. 哈夫曼编码的函数;

    4.哈夫曼编码的解码函数

    5. 设计测试用例进行测试。

    七、实验报告

    记录数据结构与算法设计的过程及实验步骤、上机过程中遇到的困难及解决办法、遗留的问题、意见和建议等。格式见实验报告模板。测试数据及测试结果请在上交的资料中写明。

    #include <stdio.h>
    #include <string.h>
    #define N 50
    #define M 2*N-1	
    const int INF=1e9+7;
    typedef struct//哈夫曼树的存储结构 
    {
    	char data[6];
    	double weight;	
    	int parent;	
    	int lchild;		
    	int rchild;		
    } HTNode;
    typedef struct//存放哈夫曼码存储结构 
    {
    	char cd[N];		
    	int start;
    } HCode;
    void CreateHT(HTNode ht[],int n0)	//建立哈夫曼树的函数 
    {	
    	int i,k,lnode,rnode;
    	double min1,min2;
    	for (i=0;i<2*n0-1;i++)		
    		ht[i].parent=ht[i].lchild=ht[i].rchild=-1;
    	for (i=n0;i<=2*n0-2;i++)		
    	{	
    		min1=min2=INF;//min1存最小的权值,min2存次小权值		
    		lnode=rnode=-1;
    		for (k=0;k<i;k++)//寻找ht里面未使用的最小的两个数 
    			if (ht[k].parent==-1) 
    			{	
    				if(ht[k].weight<min1)
    				{	
    					min2=min1;//保证min1<=min2 
    					rnode=lnode;
    					min1=ht[k].weight;
    					lnode=k;
    				}
    				else if(ht[k].weight<min2)
    				{	
    					min2=ht[k].weight;
    					rnode=k; 
    				}
    			}
    		ht[i].weight=ht[lnode].weight+ht[rnode].weight;
    		ht[i].lchild=lnode;
    		ht[i].rchild=rnode;
    		ht[lnode].parent=i;
    		ht[rnode].parent=i;
    	}
    }
    
    void CreateHCode(HTNode ht[],HCode hcd[],int n0)	//构造哈夫曼树编码
    {	
    	int i,f,c;
    	HCode hc;
    	for (i=0;i<n0;i++)			
    	{	
    		hc.start=n0;c=i;
    		f=ht[i].parent;
    		while (f!=-1)				
    		{	
    			if (ht[f].lchild==c)
    				hc.cd[hc.start--]='0';
    			else				
    				hc.cd[hc.start--]='1';
    			c=f;
    			f=ht[f].parent;	
    		}
    		hc.start++;			
    		hcd[i]=hc;
    	}
    }
    
    void DispHCode(HTNode ht[],HCode hcd[],int n0) 
    {
    	int i,k,temp=0;
    	double sum=0;
    	int j;
    	printf("  输出");
    	for(i=0;i<8;i++)
    		printf("%s",ht[i].data);
    	printf("的哈夫曼编码:\n");
    	for (i=0;i<n0;i++)
    	{
    		printf("    %s:\t\t",ht[i].data);
    		for (k=hcd[i].start;k<=n0;k++)
    			printf("%c",hcd[i].cd[k]);
    		printf("\n"); 
    	}	
    }
    
    void Decode(HTNode ht[],char code[]) //解码 
    {
    	printf("\n\n  对“%s”解码:\n",code);
    	int p=ht[0].parent;
    	int m;//根 
    	while(p!=-1)//找到根 
    	{
    		m=p;
    		p=ht[m].parent;	
    	}
    	int t;
    	int a1=0,a2=0;
    	for(int i=0;i<strlen(code);)
    	{
    		a1=a2;
    		t=m;
    		while(ht[t].lchild!=-1&&ht[t].rchild!=-1&&i<strlen(code)) 
    		{
    			if(code[i]== '0')                
    				t=ht[t].lchild;           
    			else  if(code[i]== '1')             
    				t=ht[t].rchild;
    			i++;			    
    		}
    		a2=i;
    		if(t==-1||ht[t].lchild!=-1&&ht[t].rchild!=-1)
    		{
    			int j=i-1;
    			printf("   ");
    			for(int j=a1;j<a2;j++)
    				printf("%c",code[j]);
    			printf(":\t错误\n");
    		} 	
    		else
    		{
    			printf("   ");
    			for(int j=a1;j<a2;j++)
    				printf("%c",code[j]);
    			printf(":%6s\n",ht[t].data);
    		}			
    	} 
    	printf("\n");
    }
    int main()
    {
    	int n=8,i;		//n表示初始字符串的个数
    	char str[][2]={"a","b","c","d","e","f","g","h"};
    	double fnum[]={0.07,0.19,0.02,0.06,0.32,0.03,0.21,0.1};
    	char code[40];
    	HTNode ht[M];//存哈夫曼树 
    	HCode hcd[N];//存哈夫曼编码 
    	for (i=0;i<n;i++) 
    	{
    		strcpy(ht[i].data,str[i]);
    		ht[i].weight=fnum[i];
    	}
    	CreateHT(ht,n);
    	CreateHCode(ht,hcd,n);
    	DispHCode(ht,hcd,n);
    	printf("\n");
    	printf("  请输入编码:"); 
    	scanf("%s",code);
    	Decode(ht,code);
    	return 1;
    }
     
    

     

    展开全文
  • 算法与数据结构快速排序排序流程四.编程语言五.开发平台总结 一、需求分析 学生成绩档案管理系统的主要实现有以下几点: 1.学生信息录入。 2.对学生信息的浏览、增加、删除和修改。 3.按照学生成绩确定名次并输出...
  • 记录数据结构与算法设计的过程及实验步骤、上机过程中遇到的困难及解决办法、遗留的问题、意见和建议等。格式见实验报告模板。 测试数据及测试结果请在上交的资料中写明。 #include #include #include #define ...
  • 文章目录一、实验内容二、实验任务三、算法A*算法四、解题思路总结 一、实验内容 3x3九宫棋盘,放置数码为1~8的8个棋子,棋盘中留有一个空格,空格周围的棋子可以移动到空格中,从而改变棋盘的布局。...
  • 南昌大学科学技术学院实验报告,《数据结构》课程设计是为训练学生的数据组织能力和提高程序设计能力而设置的增强实践能力的课程。目的:学习数据结构课程,旨在使学生学会分析研究数据对象的特性,学会数据的组织...
  • 目录一、实验任务与要求。二、实现方法a1.大致思路2....2.设计数据量大的文本,进行子串的查询处理,分析算法运行的时间效率,对所有输出的匹配位置结果进行验证,以证明算法设计和实现的正确性。用朴素模.
  • 20172328《程序设计与数据结构》实验三 敏捷开发与XP实践报告 课程:《程序设计与数据结构》 班级: 1723 姓名: 李馨雨 学号:20172328 实验教师:王志强 实验日期:2018年4月18日 必修选修: 必修 一、实验内容 ...

空空如也

空空如也

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

数据结构实践报告

数据结构 订阅