以下是的一些我们精选的数据结构实训报告
范文一：数据结构实训报告
专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站
一、 实训目的《数据结构》实训是信息管理与信息系统专业集中实践性环节之一，其目的就是要达到理论与实际应用相结合，使能够根据数据对象的特性，学会数据组织的方法，能把现实世界中的实际问题在计算机内部表示出来，并培养良好的程序设计技能。题目一:链表操作
一、线性链表的存储结构及算法设计
1、设计目的
(1)掌握线性表的在顺序结构和链式结构实现。
(2)掌握线性表在顺序结构和链式结构上的基本操作。
2、设计内容和要求利用顺序表链表的插入运算建立线性链表，然后实现链表的查找、插入、删除、计数、输出、排序、逆置等运算(查找、插入、删除、查找、计数、输出、排序、逆置要单独写成函数)，并能在屏幕上输出操作前后的结果。
3、算法设计a、线性表的建立LinkList CreateList_L( ){//逆位序输入n个元素的值，建立带表头结点的单链线性表LLNode *p;LinkList L;int i,n;L=(LinkList)malloc(sizeof(LNode));L->next=NULL; //先建立一个带头结点的单链表printf("输入要建立链表的元素个数: n");scanf("%d",&n);printf("输入链表元素值:n");for(i=n;i>0;i--)
{专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站p=(LinkList)malloc(sizeof(LNode)); //生成新结点scanf("%d",&p->data); //输入元素值p->next=L->next;L->next=p; //插入表头}printf("输入的链表元素为:n");Output(L);return L;}//CreateList_L
b、线性链表的查找Status GetElem_L(LinkList L){//L为带头节点的单链表的头指针//当第i个元素存在时。其赋值给e并返回OK，否则返回ERRORint i,j,e;LNode *p;printf("所有的链表元素为:n");Output(L);printf("n输入要查找的元素位置:n");scanf("%d",&i);p=L->next;j=1;while(p&&j{//顺指针向后查找，直到p指向第i个元素或p为空
p=p->next;j++;}if(!p||j>i){return ERROR;//第i个元素不存在printf("查找的元素不存在n");}e=p->data; //取第i个元素printf("查找的元素为:n %d",e);return OK;}//GetElem_Lc、线性链表的插入Status ListInsert_L(LinkList &L){专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站
//在带头结点的单链线性表L中第i个位置之前插入元素eLNode *p,*s;int i,j,e;printf("插入之前的链表元素为:n");Output(L);p=L->next;j=1;printf("n输入要插入元素的位置:n");scanf("%d",&i);printf("输入要插入的元素 e:n");scanf("%d",&e);printf("插入的元素为 e: n %dn",e);while(p&&j {p=p->next;
++j;} //寻找第i-1个结点if(!p||j>i-1)return ERROR; //i小于1或者大于表长+1s=(LinkList)malloc(sizeof(LNode)); //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;printf("插入之后的元素为:n");Output(L);return OK;}//LinkInsert_Ld、线性链表的删除Status ListDelete_L(LinkList&L){//在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
int i,j,e;LNode *p,*q;printf("输出删除之前的元素:n");Output(L);printf("n输入要删除的元素位置:n");scanf("%d",&i);p=L;j=0;while(p->next&&j {//寻找第i个结点，并由p指向其前驱p=p->next;++j;专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站
}if(!(p->next)||j>i-1){return ERROR; //删除位置不合理q=p->nextprintf("删除位置不合理或输入错误");}q=p->next;p->next=q->next; //删除并释放结点e=q->data;free(q);printf("删除之后的元素为:n");Output(L);return OK;}//ListDelete_Le、线性链表的逆置void InvertList_L(LinkList L){//链表的逆置
LNode *p,*q,*s;printf("逆置前的链表元素为:n");Output(L);p=L->next;q=p->next;p->next=NULL;while(q->next!=NULL){s=q->next;q->next=p;p=q;q=s;}q->next=p;L->next=q;printf("n逆置后的链表元素为:n");Output(L);}f、线性链表的输出void Output(LinkList L) {LNode *p;int j;p=L->next;专业好文档为您整理~谢谢使用~请双击清除页眉页脚
专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站while(p){printf("%d ",p->data);p=p->next;++j;}}g、线性链表的排序void SortList_L(LinkList L){//链表排序int t;LNode *p,*q;printf("排序前的链表元素为:n");Output(L);p=L->next;q=p->next;while(q){while(q){if(p->data>=q->data)
{t=p->data;p->data=q->data;q->data=t;}q=q->next;}p=p->next;q=p->next;}printf("n由小到大排序后的链表元素为:n");Output(L);}//SortList_L
4、源代码#include #include #define ERROR 0 //出错 #define OK 1 //正确 typedef int Status; typedef int ElemType; typedef struct LNode专业好文档为您整理~谢谢使用~请双击清除页眉页脚
专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站{ElemType data;struct LNode *next; }LNode,*LinkList;LinkList L;void Output(LinkList L) {LNode *p;int j;p=L->next;while(p){printf("%d ",p->data);p=p->next;++j;}}LinkList CreateList_L() {//逆位序输入n个元素的值，建立带表头结点的单链线性表L
LNode *p;LinkList L;int i,n;L=(LinkList)malloc(sizeof(LNode));L->next=NULL; //先建立一个带头结点的单链表printf("输入要建立链表的元素个数: n");scanf("%d",&n);printf("输入链表元素值:n");for(i=n;i>0;i--){p=(LinkList)malloc(sizeof(LNode)); //生成新结点scanf("%d",&p->data); //输入元素值p->next=L->next;
L->next=p; //插入表头}printf("输入的链表元素为:n");Output(L);return L;}//CreateList_LStatus GetElem_L(LinkList L)专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站{//L为带头节点的单链表的头指针//当第i个元素存在时。其赋值给e并返回OK，否则返回ERROR
int i,j,e;LNode *p;printf("所有的链表元素为:n");Output(L);printf("n输入要查找的元素位置:n");scanf("%d",&i);p=L->next;j=1;while(p&&j{//顺指针向后查找，直到p指向第i个元素或p为空p=p->next;j++;}if(!p||j>i){return ERROR;//第i个元素不存在printf("查找的元素不存在n");}e=p->data; //取第i个元素
printf("查找的元素为:n %d",e);return OK;}//GetElem_LStatus ListInsert_L(LinkList &L){//在带头结点的单链线性表L中第i个位置之前插入元素eLNode *p,*s;int i,j,e;printf("插入之前的链表元素为:n");Output(L);p=L->next;j=1;printf("n输入要插入元素的位置:n");scanf("%d",&i);printf("输入要插入的元素 e:n");
scanf("%d",&e);printf("插入的元素为 e: n %dn",e);while(p&&j {专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站p=p->next;++j;} //寻找第i-1个结点if(!p||j>i-1)return ERROR; //i小于1或者大于表长+1s=(LinkList)malloc(sizeof(LNode)); //生成新结点
s->data=e;s->next=p->next; //插入L中p->next=s;printf("插入之后的元素为:n");Output(L);return OK;}//LinkInsert_LStatus ListDelete_L(LinkList&L){//在带头结点的单链线性表L中，删除第i个元素，并由e返回其值int i,j,e;LNode *p,*q;printf("输出删除之前的元素:n");Output(L);printf("n输入要删除的元素位置:n");
scanf("%d",&i);p=L;j=0;while(p->next&&j {//寻找第i个结点，并由p指向其前驱p=p->next;++j;}if(!(p->next)||j>i-1){return ERROR; //删除位置不合理q=p->nextprintf("删除位置不合理或输入错误");}q=p->next;p->next=q->next; //删除并释放结点e=q->data;free(q);printf("删除之后的元素为:n");
Output(L);return OK;}//ListDelete_L专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站Status CountList_L(LinkList L){//计数LNode *p;int i;i=0;p=L->next;while(p){p=p->next;i++;}printf("链表元素个数为:%d",i);return i;}void InvertList_L(LinkList L)
{//链表的逆置LNode *p,*q,*s;printf("逆置前的链表元素为:n");Output(L);p=L->next;q=p->next;p->next=NULL;while(q->next!=NULL){s=q->next;q->next=p;p=q;q=s;}q->next=p;L->next=q;printf("n逆置后的链表元素为:n");Output(L);}void SortList_L(LinkList L){//链表排序int t;LNode *p,*q;printf("排序前的链表元素为:n");
Output(L);p=L->next;专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站q=p->next;while(q){while(q){if(p->data>=q->data){t=p->data;p->data=q->data;q->data=t;}q=q->next;}p=p->next;q=p->next;}printf("n由小到大排序后的链表元素为:n");
Output(L);}//SortList_Lvoid main(){int i;printf("n?
?
?
?
?
?
?
?
?
?
?
?
?
【请建立链表】?
?
?
?
?
?
?
?
?
?
?
?
?
n");L=CreateList_L();Loop:printf("n?
?
?
?
?
?
?
?
?
【功能菜单】?
?
?
?
?
?
?
?
?
n");printf("?
?
n");printf("?
1. 建立链表 ?
n");printf("?
2. 插入元素 ?
n");printf("?
3. 查找链表元素 ?
n");printf("?
4. 删除链表元素 ?
n");printf("?
5. 逆置链表元素 ?
n");
printf("?
6. 链表元素排序 ?
n");printf("?
7. 输出链表元素 ?
n");printf("?
8. 计算元素个数 ?
n");printf("?
0. 退出 ?
n");printf("?
?
n");printf("?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
n");printf("【选择功能】:");scanf("%d",&i);switch(i){专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站
case 0: break;case 1: CreateList_L();goto Loop;case 2: ListInsert_L(L);goto Loop;case 3: GetElem_L(L);goto Loop;case 4: ListDelete_L(L);goto Loop;case 5: InvertList_L(L);goto Loop;case 6: SortList_L(L);goto Loop;case 7: Output(L);goto Loop;case 8: CountList_L(L); goto Loop;default: printf("n输入错误，请重新输入n");goto Loop;
}}题目二:二叉树的基本操作
一、二叉链表存储结构及算法设计
1、设计目的
(1)掌握二叉树的概念和性质;
(2)掌握任意二叉树存储结构;
(3)掌握任意二叉树的基本操作。
2、设计内容和要求对任意给定的二叉树(顶点数自定)建立它的二叉链表存储结构，并利用栈的五种基本运算(置空栈、进栈、出栈、取栈顶元素、判栈空)实现二叉树的先序、中序、后序三种遍历，输出三种遍历的结果。
3、算法设计a、二叉树先序遍历Status PreOrderTrerse(BiTree T){//先序遍历二叉树if(T){printf("%c ",T->data);PreOrderTrerse(T->Lchild);PreOrderTrerse(T->Rchild);专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站}return OK;}//PreOrderTrerse
b、二叉树中序遍历Status InOrderTrerse(BiTree T) {//中序遍历二叉树if(T){InOrderTrerse(T->Lchild);printf("%c ",T->data);InOrderTrerse(T->Rchild);}return OK;}c、二叉树后序遍历Status PostOrderTrese(BiTree T) {//后序遍历二叉树if(T!=NULL){PostOrderTrese(T->Lchild);PostOrderTrese(T->Rchild);printf("%c ",T->data);
}return OK;}d、二叉树深度Status BiTreeDepth(BiTree T) { //二叉树深度int depth=0,depthLeft=0,depthRight=0;if ( !T)depth = 0;专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站else{depthLeft = BiTreeDepth(T->Lchild );depthRight= BiTreeDepth(T->Rchild );
depth =1+(depthLeft > depthRight ?
depthLeft : depthRight);}return depth;}e、计算叶子数Status CountLeaf(BiTree T) {//计算叶子数int num1,num2,num;num1=0;num2=0;num=0;if(!T)return ERROR;else{if(!(T->Lchild)&&!(T->Rchild))return OK;num1=CountLeaf(T->Lchild);num2=CountLeaf(T->Rchild);
}num=num1+num2;return num;}f、度为1的二叉树结点Status OneNode(BiTree T){ //度为1的二叉树结点int i=0;if(T!=NULL){OneNode(T->Lchild);OneNode(T->Rchild);if((T->Lchild==NULL&&T->Rchild!=NULL)||(T->Lchild!=NULL&&T->Rchild==NULL))i++;return i+1;}return OK;}专业好文档为您整理~谢谢使用~请双击清除页眉页脚
专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站g、二叉树总结点数Status CountNumNode(BiTree T) {int num=0;if(!T){return ERROR;}if (T){CountNumNode(T->Lchild);CountNumNode(T->Rchild);}num=CountNumNode(T->Lchild)+CountNumNode(T->Rchild)+1;return num;}
3.源代码#include#include
#define ERROR 0 //出错#define OK 1 //正确#define OVERFLOW 2 //溢出typedef char TElemType; typedef int Status;typedef struct BiTNode{TElemType data;struct BiTNode *Lchild,*Rchild; //左右孩子指针; }BiTNode,*BiTree;BiTree T;//***********建立二叉树***************// Status CreateBiTree(BiTree &T) {//按先序次序输入二叉树中结点的值(一个字符)，空格字符表示空树， //构造二叉链表表示的二叉树T
char ch;scanf("%c",&ch);if(ch==" ")T=NULL;专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站 else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))exit(OVERFLOW);T->data=ch; //生成根结点CreateBiTree(T->Lchild); //构造左子树CreateBiTree(T->Rchild); //构造右子树
}return OK;}//CreateBiTree//**************先序遍历二叉树***************// Status PreOrderTrerse(BiTree T) {//先序遍历二叉树if(T){printf("%c ",T->data);PreOrderTrerse(T->Lchild);PreOrderTrerse(T->Rchild);}return OK;}//PreOrderTrerse//****************中序遍历二叉树********************// Status InOrderTrerse(BiTree T) {//中序遍历二叉树
if(T){InOrderTrerse(T->Lchild);printf("%c ",T->data);InOrderTrerse(T->Rchild);}return OK;}//**********后序遍历二叉树*****************// Status PostOrderTrese(BiTree T) {//后序遍历二叉树if(T!=NULL){PostOrderTrese(T->Lchild);PostOrderTrese(T->Rchild);printf("%c ",T->data);}return OK;专业好文档为您整理~谢谢使用~请双击清除页眉页脚
专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站 }//******************计算二叉树的深度*****************// Status BiTreeDepth(BiTree T) { //二叉树深度int depth=0,depthLeft=0,depthRight=0;if ( !T)depth = 0;else{depthLeft = BiTreeDepth(T->Lchild );depthRight= BiTreeDepth(T->Rchild );
depth =1+(depthLeft > depthRight ?
depthLeft : depthRight);}return depth;}//***************计算叶子数**************// Status CountLeaf(BiTree T){//计算叶子数int num1,num2,num;num1=0;num2=0;num=0;if(!T)return ERROR;else{if(!(T->Lchild)&&!(T->Rchild))return OK;num1=CountLeaf(T->Lchild);
num2=CountLeaf(T->Rchild);}num=num1+num2;return num;}//*************度为1 的二叉树结点****************// Status OneNode(BiTree T){ //度为1的二叉树结点int i=0;if(T!=NULL){OneNode(T->Lchild);OneNode(T->Rchild);专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站 if((T->Lchild==NULL&&T->Rchild!=NULL)||(T->Lchild!=NULL&&T->Rchil
d==NULL))i++;return i+1;}return OK;}//*****************计算总结点数***************// Status CountNumNode(BiTree T) {int num=0;if(!T){return ERROR;}if (T){CountNumNode(T->Lchild);CountNumNode(T->Rchild);}num=CountNumNode(T->Lchild)+CountNumNode(T->Rchild)+1;return num;}
数据结构实训报告
//*****************主函数********************// void main(){int i;printf("n??
?
?
?
?
?
?
?
?
?
?
?
?
?
?
【请建立二叉树】?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
n");printf("请输入要建立的结点n");CreateBiTree(T);Loop:printf("n?
?
?
?
?
?
?
?
?
【功能菜单】?
?
?
?
?
?
?
?
?
n");printf("?
?
n");printf("?
1. 建立二叉树 ?
n");
printf("?
2. 先序遍历二叉树 ?
n");printf("?
3. 中序遍历二叉树 ?
n");printf("?
4. 后序遍历二叉树 ?
n");printf("?
5. 二叉树深度 ?
n");printf("?
6. 二叉树结点数 ?
n");printf("?
7. 二叉树叶子数 ?
n");printf("?
8. 二叉树度为1的结点 ?
n");专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站
printf("?
0. 退出 ?
n");printf("?
?
n");printf("?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
n");printf("【选择功能】:");scanf("%d",&i);switch(i){case 0: break;case 1: CreateBiTree(T);goto Loop;case 2: PreOrderTrerse(T);goto Loop;case 3: InOrderTrerse(T);goto Loop;case 4: PostOrderTrese(T);goto Loop;case 5: printf("二叉树深度为:n %d",BiTreeDepth(T));goto Loop;
case 6: printf("二叉树总结点数为:n %d",CountNumNode(T));goto Loop;case 7: printf("二叉树叶子数为:n %d",CountLeaf(T));goto Loop;case 8: printf("二叉树度为1的结点数为:n %d",OneNode(T)); goto Loop;default: printf("n输入错误，请重新输入:n");goto Loop;}}实习总结紧张的两周数据结构实训很快就过去了，通过这两周的实践学习，不仅使我们巩固了以前的知识并在此基础上还对数据结构的特点和算法有了更深的了解，使我们在这门课程的实际应用上也有了一个提高。
首先这两周的学习，使我们在巩固了原有的理论知识上，又培养了灵活运用和组合集成所学过知识及技能来分析、解决实际问题的能力，使我们体会到自身知识和能力在实际中的应用和发挥。其次，它激发了我们创新意识，开发创造的能力和培养沟通能力。其次，让我们进一步熟悉了数据结构的设计应用。每一处编码都是在反复的熟悉数据结构的结构特性，及其语法、函数和程序设计思想的过程，对我们数据结构的学习和提高很有益处，并且使我们明白了程序设计过程，如解决一些实际问题，从解决实际问题的角度，第一要了解这个问题的基本要求，即输入、输出、完成从输入到输出的要求是什么;第二，从问题的要害入手，从前到后的解决问题的每个方面，即从输入开始入手，着重考虑如何从输入导出输出，在这个过程
专业好文档为您整理~谢谢使用~请双击清除页眉页脚专业好文档为您整理~谢谢使用~请双击清除页眉页脚~ 更多精彩内容请关注本站 中，可确定所需的数据结构的基本类型——线性表、栈、队列、串、数组、广义表、树和二叉树以及图等，然后确定处理过程——算法，通过在编译环境中的编译与调试，可到最终的程序。最后，在这次的实训过程中，我们深刻的认识到了自己在学习方面的不足之处，我知道我还有太多的基本的思想没有真正的理解，当然我们不会灰心，我们会在以后的日子里努力弥补我们的不足。
从最初的查阅资料到最后的程序的成功运行，两个星期的时间让我们经历了很多，也收获了很多。经过这次课程设计，我们不仅学到了很多知识和技能，更重要的是我们学会了如何运用所学知识去解决实际问题。总之，两个星期的课程设计让我们受益匪浅。我们深深认识到，数据结构是计算机程序设计的重要理论技术基础，它是计算机科学的核心课程。要学好一门学科，没有刻苦钻研的精神是不行的，只有在不断的尝试中，经历失败，从失败中总结经验，然后再不断的尝试，才能获得成功。
参考文献
1.《C++程序设计》,清华大学出版社,
2.《数据结构,C语言版,》,清华大学出版社,
3.《数据结构,C语言版,》,中国铁道出版社,专业好文档为您整理~谢谢使用~请双击清除页眉页脚
范文二：《数据结构》实训报告
实验一 线性表
1. 实验要求
1.1 掌握数据结构中线性表的基本概念。
1.2 熟练掌握线性表的基本操作：创建、插入、删除、查找、输出、求长度及合并并运算在顺序存储结构上的实验。
1.3 熟练掌握链表的各种操作和应用。
2. 实验内容
2.1 编写一个函数，从一个给定的顺序表A 中删除元素值在x 到y 之间的所有元素，要求以较高效率来实现。
2.2 试写一个算法，在无头结点的动态单链表上实现线性表插入操作
2.3 设计一个统计选票的算法，输出每个候选人的得票结果。
3. 实验代码
2.1代码：#includetypedef int elemtype;#define maxsize 10int del(int A[],int n,elemtype x,elemtype y){int i=0,k=0;while(i{if(A[i]>=x&&A[i]k++;elseA[i-k]=A[i];i++;}return(n-k);
}void main(){int i,j;int a[maxsize];printf("输入%d个数:n",maxsize);for(i=0;iscanf("%d,",&a[i]);j=del(a,maxsize,1,3);printf("输出删除后剩下的数:n");for(i=0;iprintf("%d "n,a[i]);}
2.2代码：INSERT(L,i,b)。void Insert(Linklist &L,int i,elemtype x){if(!L){L=(Linklist)malloc(sizeof(Lnode));(*L).data=x;(*L).next=NULL;
}else{if(i==1){s=(Linklist)malloc(sizeof(Lnode));s->data=x;s->next=L;L=s;}else{p=L;j=1;while(p&&j{j++;p=p->next;}if(p||j>i-1)return error;s=(Linklist)malloc(sizeof(Lnode));s->data=x;s->next=p->next;p->next=s;}}}
2.3代码：typedef int elemtypetypedef struct linknode{elemtype data;
struct linknode *next;}nodetype;nodetype *create(){elemtype d;nodetype h=NULL,*s,*t;int i=1;printf("建立单链表:n");while
(1){printf("输入第%d个结点数据域",i);scanf("%d",&d);if(d==0)break;if(i==1){h=(nodetype *)malloc(sizeof(nodetype));h->data=d;h->next=NULL;t=h;}else{s=(nodetype *)malloc(sizeof(nodetype));
s->data=d;s->next=NULL;t->next=s;t=s;}i++;}return h;}void sat(nodetype *h,int a[]){nodetype *p=h;while(p!=NULL){a[p->data]++;p=p->next;}}void main(){int a[N+1],i;for(i=0;ia[i]=0;nodetype *head;head=create();sat(head,a);}printf("候选人:"); for(i=1;i
4. 实验小结线性表是最简单的、最常用的一种数据结构，是实现其他数据结构的基础。
实验二 栈与队列
1. 实验要求
1.1 了解栈和队列的特性，以便灵活运用。
1.2 熟练掌握栈和有关队列的各种操作和应用。
2. 实验内容
2.1 设一个算术表达式包括圆括号，方括号和花括号三种括号，编写一个算法判断其中的括号是否匹配。
3. 实验代码
2.1代码：#include#include#include#define NULL 0typedef struct list{char str;struct list *next;
}list;void push(char,list *);int pop(char.list *);void deal(char *str);main(void){char str[20];printf("n请输入一个算式:n");gets(str);deal(str);printf("正确!");getchar();return 0;}void deal(char *str){list *L;L=(list *)malloc(sizeof(list));if(!L){printf("错误!");exit(-2);}L->next=NULL;while(*str){if(*str=="("||*str=="["||*str=="{")
push(*str,L);elseif(*str==")"||*str=="]"||*str=="}")if(pop(*str,L)){puts("错误, 请检查!");puts("按回车键退出");getchar();exit(-2);}str++;}if(L->next){puts("错误, 请检查!");puts("按任意键退出");getchar();exit(-2);}}void push(char c,list *L){list *p;p=(list *)malloc(sizeof(list));if(!p){printf("错误!");
exit(-2);}p->str=c;p->next=L->next;L->next=p;}#define check(s) if(L->next->str==s){p=l->next;L->next=p->next;free(p);return
(0);} int pop(char c,list *L){list *p;if(L->next==NULL)return 1;switch(c){case")":check("(") break;case"]":check("[") break;case"}":check("{") break;
}return 1;
4. 实验小结栈和队列是最基础的一种数据结构之一，为实现其他数据结构的奠定基石。实验三 树
1. 实验要求
1.1 掌握二叉树，二叉树排序数的概念和存储方法。
1.2 掌握二叉树的遍历算法。
1.3 熟练掌握编写实现树的各种运算的算法。
2. 实验内容
2.1 编写程序，求二叉树的结点数和叶子数。
2.2 编写递归算法，求二叉树中以元素值为X 的结点为根的子数的深度。
2.3 编写程序，实现二叉树的先序，中序，后序遍历，并求其深度。
3. 实验代码
2.1代码：#include#includestruct node{char data;struct node *lchild,*rchild;}bnode;typedef struct node *blink;blink creat(){blink bt;char ch;ch=getchar();if(ch==" ") return(NULL);else{bt=(struct node *)malloc(sizeof(bnode));bt->data=ch;
bt->lchild=creat();bt->rchild=creat();}return bt;}int n=0,n1=0;void preorder(blink bt){if (bt){n++;if(bt->lchild==NULL&&bt->rchild==NULL)n1++;preorder(bt->lchild);preorder(bt->rchild);}}void main(){blink root;root=creat();preorder(root);printf("此二叉数的接点数有:%dn",n);printf("此二叉数的叶子数有:%dn",n1);}
2.2代码：int get_deep(bitree T,int x){if(T->data==x){printf("%dn",get_deep(T));exit 1;}else{if(T->lchild)get_deep(T->lchild,x);if(T->rchild)get_deep(T->rchild,x);}int get_depth(bitree T){if(!T)return 0;else{m=get_depth(T->lchild);n=get_depth(T->rchild);return(m>n?
m:n)+1;}}
2.3代码：
#include#includestruct node{char data;struct node *lchild,*rchild;}bnode;typedef struct node *blink;blink creat(){blink bt;char ch;ch=getchar();if(ch==" ") return(NULL);else{bt=(struct node *)malloc(sizeof(bnode));bt->data=ch;bt->lchild=creat();bt->rchild=creat();}return bt;}void preorder(blink bt)
{if (bt){printf("%c",bt->data);preorder(bt->lchild);preorder(bt->rchild);}}void inorder(blink bt){if(bt){inorder(bt->lchild);printf("%c",bt->data);inorder(bt->rchild);}}void postorder(blink bt){if(bt){postorder(bt->lchild);postorder(bt->rchild);printf("%c",bt->data);}}int max(int x,int y)
{if(x>y)return x;elsereturn y;}int depth(blink bt){if (bt)return 1+max(depth(bt->lchild),depth(bt->rchild));else}{ return 0; void main()blink root;root=creat(); printf("n"); printf("按先序排列:");preorder(root);printf("n");printf("按中序排列:");inorder(root);printf("n");printf("按后序排列:");
postorder(root);printf("n");} printf("此二叉数的深度是:"); printf("depth=%dn",depth(root));
4. 实验小结通过本章学习实验，对树有了初步的认识。树就是一种非线性的数据结构，描述了客观世界中事物之间的层次关系。这种结构有着广泛的应用，一切具有层次关系的问题都可以用树来表示。实验四 图
1. 实验要求
1.1 熟悉图的各种存储方法。
1.2 掌握遍历图的递归和非递归的算法。
1.3 理解图的有关算法。
2. 实验内容
2.1 写出将一个无向图的邻接矩阵转换成邻接表的算法。
2.2 以邻接表作存储结构，给出拓扑排序算法的实现。
3. 实验代码
2.1代码：void mattolist(int a[][],adjlist b[],int n) /*n为图的结点个数*/{for(i=0;ifor(i=0;i}
2.2代码：typedef struct vexnode
{VertexType vertex; int in;/*增加一个入度域*/ ArecNodeTp * fristarc; for(j=n-1;j>=0;j--) if(a[i][j]!=0) {p=(arcnodetp *)malloc(sizeof(arcnodetp));/*产生邻接点*/ p->adjvex=j; p->nextare=b[i].firstare; b[i].firstarc=p; }}AdjList[vnum];typedef struct graph{AdjList adjlist; int vexnum,arcnum;}GraphTp;
Top_Sort(GraphTp g){LstackTp *p;/*建立入度为0的顶点栈S*/int m,i,v;initStack(S);} for(i=0;iv printf("%d",v);/*输出v*/ m++; p=g.adjlist[i].fristarc;/*p=图g 中顶点v 的第一个邻接点*/ while(p!=NULL){//p存在 } (g.adjlist[p->adjvex].in)--;/*p的入度--*/ if(g.adjlist[p->adjvex].in==0)/*if(p的入度==0)*/ Push(S,p->adjvex);/*p入S 栈*/ p=p->nextarc;/*p=图g 中的顶点v 的下一个邻接点*/
4. 实验小结通过本章学习实验，对图有了具体的认识。图也是一种非线性的数据结构，这种结构有着广泛的应用，一切具有关系的问题都可以用图来表示。实验五 查找
1. 实验要求
1.1 掌握顺序查找、二分法查找、分块查找和哈希表查找的算法。
1.2 能运用线性表的查找方法解决实际问题。
2. 实验内容
2.1 编写一个算法，利用二分查找算法在一个有序表中插入一个元素
X ，并保持表的有序性。
2.2 根据给定的数据表，先建立索引表，然后进行分块查找。
3. 实验代码
2.1代码：#include#include#define MAXNUM 20int input(int *);/*输入数据*/int search(int *,int,int);/*查找插入位置*/void plug(int *,int,int);/*插入数据*/void main(void){int data[MAXNUM],m; int insert=1; m=input(data); printf("Input the insert num:"); scanf("%d",data); insert=search(data,1,m);/*返回插入位置*/
plug(data,insert,m);for(insert=1;insertprintf("%3d",*(data+insert));getch();}int input(int *data){int i,m;printf("nInput the max num:");scanf("%d",&m);printf("input datan");for(i=1;iscanf("%d",data+i);return m;}int search(int *data,int low,int high)/*递归查找插入位置*/{int mid;if(low>high) return low;/*没有找到插入数据，返回low*/
else{}search(data,low,high);}void plug(int *data,int insert,int m){int i;for(i=m;i>insert;i--)*(data+i+1)=*(data+i); mid=(low+high)/2; if(*(data+mid)==*data) retun mid;/*找到插入数据，返回mid*/ else if(*(data+mid)*data)*(data+insert)=*data}
2.2代码：#include#include#include#definr N 18 /*元素个数*/
#definr Blocknum 3 /*分块数*/typedef struct indexterm{int key;/*最大关键字*/int addr;/*块的起始地址*/}index; /*索引表数据类型*/index * CreateList(int data[],int n)/*建索引表*/{index *p;int m,j,k;m=n/BlockNum;/*分为BlockNum 块，每块有m 个元素*/p=(index *)malloc(BlockNum *sizeof(index));for(k=0;k}return p;
}int BlockSearch(index *list,int rectab[],int n,int m,int k)/*分块查找*/ {int low=0,high=m-1,mid,i;(p+k)->key=dat a[m*k]; (p+k)->addr=m*k; for(j=m*k;j(p+k)->key) (p+k)->key=data[j];/*块的最大关键字*/int b=n/m;/*每块有b 个元素*/while(low}if(lowfor(i=(list+low)->addr;iadder+b-1&&rectab[i]!=k;i++);
}return -1;}void main(){int record[N]={22,12,13,8,9,20,33,42,44,38,24,48,60,58,74,49,86,53}; int key;index *list;printf("please input key:n");scanf("%d",&key);list=CreateList(record,N);printf("data postion id %dn",BlockSearch(list,record,N,BlockNum,key)); } if(iaddr+b-1) return i; mid=(low+high)/2; if((list+mid)->key>=k) high=mid+1; else low=mid+1; else return -1;
4. 实验小结通过本章的学习，对排序有较高层次的理解与认识，从平时的练习中可以看出排序是数据处理中经常用到的重要运算。有序的顺序表可以采用查找效率较高的折半查找法，而无序的顺序表只能用效率较低的顺序查找法。
范文三：数据结构实训报告
山东科技大学泰山科技学院课程实训说明书课程： 数据结构系部名称： 信息工程系 专业班级：姓名： 徐志宏 ＿＿＿学 号：指 导 教 师： 学 校: 2015年7月22日目录第一章 课程设计性质与目的..................................4第二章 设计内容及基本要求............................5第三章 详细设计说明......................................... 11
3.1 项目
一.............................................................
73.2 项目
二............................................................ 1
63.3 项目
三.......................................................... 26第四章 实训总结.................................................. .37附录 （参考文献、核心代码）
第一章 课程设计性质与目的《数据结构》实训是信息管理与信息系统专业集中实践性环节之一，其目的就是要达到理论与实际应用相结合，使能够根据数据对象的特性，学会数据组织的方法，能把现实世界中的实际问题在计算机内部表示出来，并培养良好的程序设计技能。链表和顺序表操作的设计目的： 1．掌握线性表的在顺序结构和链式结构实现。 2．掌握线性表在顺序结构和链式结构上的基本操作。
二叉树操作的设计目的： 1．掌握二叉树的概念和性。
2. 掌握任意二叉树存储结构。 3．掌握任意二叉树的基本操作。第二章 设计内容及基本要求
一、实验实训的基本要求是：本实训面向应用，以解决实际问题为主。题目以选用相对比较熟悉的为宜，要求通过本实训，理解有关数据结构的基本概念、不同数据类型的存储和基本操作的算法实现，理解数据类型的逻辑结构及物理存储结构， 通过自己设计，编程、调试、测试、能够基本掌握在不同存储结构下的算法实现及算法优化，树立并培养系统规范开发的理念。实训中要将相关课程中学到的知识、思想和理念尽量应用在实训中。结束后要按规定提交代码和各种文档。
实训基本步骤：
1. 选题设计的课题尽量结合教学、科研的实际课题，规模、大小适当，具有一定复杂度。应根据题目大小、难度确定是否分组，组内成员人数。
2. 数据结构及算法设计根据需求分析，选择合理的数据结构及设计相应的算法。
3. 编码根据已设计的数据结构和算法，编写代码。
4. 测试按照系统测试的原则、方法和步骤，对系统进行测试。测试中应形成测试报告。
5. 编写实训报告实训说明书，内容及要求如下：
（1） 封面
（2） 成绩评定
（3） 目录
（4） 说明书正文，主要内容包括：
一、 设计题目
二、 运行环境（软、硬件环境）
三、 数据结构及算法设计的思想
四、 数据结构及算法设计
五、 源代码
六、 运行结果分析
七、 实习总结（收获及体会）参考资料：附录（核心代码）。
二、设计内容 项目一：顺序表操作
1、设计目的
（1）掌握线性表的在顺序结构上的实现。
（2）掌握线性表在顺序结构上的基本操作
2、设计内容和要求利用顺序表的插入运算建立顺序表，然后实现顺序表的查找、插入、删除、计数、输出、排序、逆置等运算（查找、插入、删除、查找、计数、输出、排序、逆置要单独写成函数），并能在屏幕上输出操作前后的结果。项目二：链表操作
1、设计目的
（1）掌握线性表的在链式结构上的实现。
（2）掌握线性表在链式结构上的基本操作
2、设计内容和要求利用链表的插入运算建立链表，然后实现链表的查找、插入、删除、计数、输出、排序、逆置等运算（查找、插入、删除、查找、计数、输出、排序、逆置要单独写成函数），并能在屏幕上输出操作前后的结果。项目三：二叉树的基本操作
1、设计目的
（1）掌握二叉树的概念和性质
（2）掌握任意二叉树存储结构。
（3）掌握任意二叉树的基本操作。
2、设计内容和要求
（1）对任意给定的二叉树（顶点数自定）建立它的二叉链表存储结构，并利用栈的五种基本运算（置空栈、进栈、出栈、取栈顶元素、判栈空）实现二叉树的先序、中序、后序三种遍历，输出三种遍历的结果。
（2） 求二叉树高度、结点数、度为1的结点数和叶子结点数。
第三章 详细设计说明项目一：顺序表操作：考查知识点：
（1）利用顺序表的插入运算建立顺序表；
（2）实现顺序表的查找、插入、删除、计数、输出、排序、逆置等运算（查找、插入、删除、查找、计数、输出、排序、逆置要单独写成函数）；
（3）能够在屏幕上输出操作前后的结果。
一、算法
1. 创建：#define LIST_INIT_SIZE 100#define LISTINCREMENT 20
typedf struct{Elem Type *elem;int length;int listsize;}SqList;Status InitList.Sq(SqList&L){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType)); if(!L.elem)exit(OVERFLOW);L.lengh=0;L.listsize=LIST_INIT_SIZE;return Ok;}//InitList_Sq
2. 插入:Status ListInsert_Sq(SqList&L,int i,ElemType e){//插入
if(iL.length+1)return ERROR;if(L.length>=L.listsize){newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType)); if(!newbase)exit(OVERFLOW); L.elem=newbase; L.listsize+=LISTINCREMENT; } q=&(L.elem[i-1]);//q指示插入位置for(p=&(L.elem[L.length-1);p>=q;--p)*(p+1)=*p;*q=e
++L.length；return OK;}//ListInsert_Sq
3. 删除：Status ListDelete_Sq(SqList &L，nt i,ElemType&e){if((iL.length))return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;//表尾元素的位置for(++p;p--L.length;//表长减1return OK;}//ListDelete_Sq
4. 查找：Int LocateElem_Sq(SqList L，ElemType e，
数据结构实训报告
Status （*compare）（ElemType ，ElemType ））{i=1；p=L.elem;while(iif(ielse return 0;}//LocateElem_Sq二、源代码#include#include#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;
typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 20typedef struct { //查找}SqList; int length; int listsize;int InitList_Sq(SqList &L) {L.list = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType)); if (!L.list) exit (OVERFLOW); // 存储分配失败int i,y;L.length = 0;L.listsize = LIST_INIT_SIZE;
printf("请输入元素个数:");scanf("%d",&y); printf("请输入元素:n"); for(i=0;ireturn OK;} // InitList_Sq//*****************输出函数******************void output_Sq(SqList &L){}//*****************插入*********************Status ListInsert_Sq(SqList &L){ printf("输出顺序表n"); for(int i=0;iint i,e; printf("请输入插入位置i:"); scanf(" %d",&i); if(i L.length + 1) return ERROR; if(L.length >= L.listsize){ newbase = (ElemType *)realloc(L.list, (L.listsize + LISTINCREMENT) * sizeof(ElemType)); if(!newbase)exit(OVERFLOW); L.list = newbase; L.listsize += LISTINCREMENT; } q = &(L.list[i-1]); // q指示插入位置 for (p = & (L.list[L.length-1]); p >= q; --p)*(p+1) = *p; // 插入位置及之后的元素右移
printf("输入插入数值e: "); scanf("%d",&e); *q = e; ++L.length; printf("输出插入之后的顺序表:"); for( i=0;i} // ListInsert_Sq//*****************删除*********************int ListDelete_Sq(SqList &L){ElemType *p,*q; int i,e;printf("请输入你要删除的元素位序："); scanf("%d",&i); if ((i L.length)) return ERROR; p = & (L.list[i-1]); e = *p; q = L.list + L.length - 1; // 表尾元素的位置
printf("删除的元素值为: %dn",e);for (++p; p*(p-1) = *p;--L.length;for( i=0;iprintf("%d ",L.list[i]);printf("n");return OK;} // ListDelete_Sq//******************查找********************Status LocateElem_Sq(SqList L){int e,i;printf("请输入你要查找元素的数值:scanf("%d",&e);printf("你要查找元素的位序为: ");
for(i=0;i{if(e==L.list[i])printf("%d ",i+1);}printf("n");return 0;} ");//************排序（由小到大）*************void Print_Sq(SqList &L){int t;}//*****************计数********************void ListLength_Sq(SqList L){}//*****************逆置********************void inverse_Sq(SqList &L){int t,i; for(i=0;iL.list[i+1]) {t=L.list[i];L.list[i]=L.list[i+1];L.list[i+1]=t;} printf("输出排序（由小到大）表n"); for(int i=0;i} //*****************退出*********************
int Quit_Sq(SqList L){}//****************主函数********************void main(){SqList L; int i; printf("
1. 构造 n"); printf("
2. 插入 n"); printf("
3. 删除 n"); printf("
4. 排序 n"); printf("
5. 计数 n"); printf("
6. 查找 n"); printf("
7. 逆置 n"); printf("
8. 输出 n"); printf("
9. 退出 n"); for(;;) { printf("Please choose 1 to 9 :n"); scanf("%d",&i); switch(i) { case 1:InitList_Sq(L);break; case 2:ListInsert_Sq(L); break; exit
(0); return 0;
} case 4:Print_Sq(L); break; case 5:ListLength_Sq(L); break; case 6:LocateElem_Sq(L);break; case 7:inverse_Sq(L);break; case 8:output_Sq(L);break; case 9: Quit_Sq(L);break; default:printf("输入有误"); } }
三、操作结果项目二：链表操作考查知识点：
（1）利用链表的插入运算建立链表；
（2）实现链表的查找、插入、删除、计数、输出、排序、逆置等运
算（查找、插入、删除、查找、计数、输出、排序、逆置要单独写成函数）；
（3）能够在屏幕上输出操作前后的结果。
一、算法
1. 创建：void CreateList_L(LinkList &L){ //逆序输入n 个元素的值，建立带头结点的单链线性表L 。L=(LinkList)malloc(sizeof(LNode));//生成新的结点L->next=NULL;//先建立一个带头结点的单链表
for(i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));scanf(&p->data);p->next = L->next;L->next = p; //插入到表头}}//CreateList L
2. 插入：Status ListInsert_L(LinkList &L,int i ,ElemType e){ //插入 p=L;j=0;while(p&&j{p=p->next;++j;}if(!p||j>i)return ERROR；s=(LinkList)malloc(sizeof(LNode));
s->data=e;s->next=p->next;p->next=s;return OK;}
3. 删除：Status ListDelete_L(LinkList &L,int &e){ //删除j=0;p=L;while(p->next && jp=p->next;++j;}if(!(p->next)||j>i-1)return ERROR;q=p->next;p->next=q->next;e=q->data;free(q);return OK;}//ListDelete_L
4. 查找:
Status GetElem_L(LinkList L,int i , ElemType &e) //查找 {p=L->next;j=1;while(p && j{p=p->next;j++;}if(!p||j>1)retun ERRORe=p->data;retun OK;}//GetElem.L
二、源代码#include#include#define OK 1#define ERROR 0typedef struct LNode{int data;struct LNode * next;}LNode, * LinkList;//逆序输入n 个元素的值，建立带头结点的单链线性表L 。 void CreateList_L(LinkList &L){
int i,x;LNode *p=NULL;L=(LinkList)malloc(sizeof(LNode));//生成新的结点L->next=NULL; //先建立一个带头结点的单链表 printf("请输入结点个数:");scanf("%d",&x);printf("请输入各结点元素的值为:");for(i=x;i>0;--i) //逆序输入x 个元素的值{p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next = L->next;L->next = p; //插入到表头
}p=L->next; //将p 指向头结点//输出已创建的链表printf("逆序输出链表为:n");while(p){printf("%d ",p->data);p=p->next;}}//*****************插入*******************int ListInsert_L(LinkList &L){LNode *p,*s;int j=0,e,i;p=L;printf("请输入所要插入的位置:");scanf("%d",&i);printf("请输入所要插入的数:");
scanf("%d",&e);while(p&&j{p=p->next;++j;}if(!p||j>i-1)printf("输入数据有误, 请输入数值在1 -- x+1之间输入"); s=(LinkList)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;p=L ->next;while(p){printf("%5d",p->data);p=p->next;}printf("n");return OK;}//*****************删除********************
int ListDelete_L(LinkList &L,int &e){LNode *p,*q;int i,j=0;p=L;printf("请输入要删除的第几个结点:");scanf("%d",&i);while(p->next && jp=p->next;++j;}if(!(p->next)||j>i-1)printf("输入的数值错误或删除位置不合理");q=p->next;p->next=q->next;e=q->data;free(q);//释放被删除结点
printf("被删除结点的数值为: %dn",e);p=L ->next;while(p){printf("%5d",p->data);p=p->next;}printf("n");return OK;}//******************计数********************void CountList_L(LinkList &L){int i=0;LNode *p=L->next;while(p){i++;p=p->next;}printf("结点个数为:%dn",i);}//*****************查找*******************
int LocateElem_L(LinkList L){LinkList p=L;int i,j=0;printf("请输入要查找的数的序号:");scanf("%d",&i);while(p && j{p=p->next;j++;}if(j!=i||!p){printf("参数i 错或单链表不存在");return(NULL);}printf("你查找的第 %d 个结点的数值为 %dn",i,p->data); return OK;}//*******************排序******************* void SortList_L(LinkList L)
{int i,j,t,k = 0;LNode *p = L->next,*q;while(p){k++;p=p->next;}p=L->next; q=p->next; //初始化for(i=0;i{p = L->next;for(j=0,p;jnext){q = p->next;if(p->data > q->data) //升序{t=p->data;p->data=q->data;q->data=t;}}}p=L->next;printf("输出升序的链表为:n");while(p)
{printf("%5d",p->data);p=p->next;}printf("n");}//*******************输出***************void OutputList_L(LinkList L){LNode *p;p=L->next;while(p){printf("%5d",p->data);p=p->next;}printf("n");}//*******************逆置****************int ReverseList_L(LinkList &L){LNode *p ,*q;p=L->next;
q=p->next;L->next=NULL;while(p->next){p->next=L->next;L->next=p;p=q;q=q->next;}p->next=L->next;L->next=p;printf("逆置后的链表结果为:");for(p=L->next;p;p=p->next)printf("%d ",p->data);printf("n");return 0;}//***************主函数**************int main(){LinkList L=NULL;
int i,e;printf("逆序输入创建一个链表并实现下列功能n");printf("
1. 创建 n");printf("
2. 插入 n");printf("
3. 删除 n");printf("
4. 计数 n");printf("
5. 查找 n");printf("
6. 排序 n");printf("
7. 输出 n");printf("
8. 逆置 n");for(;;){printf("请在1-8功能中选择一个: ");scanf("%d",&i);//************函数调用*************
switch(i){case 1:CreateList_L(L); break;case 2:ListInsert_L(L); break;case 3:ListDelete_L(L,e); break;case 4:CountList_L(L); break;case 5:LocateElem_L(L); break;case 6:SortList_L(L); break;case 7:OutputList_L(L); break;case 8:ReverseList_L(L); break;default:printf("输入错误");}}printf("n");return 0;}
三、操作结果项目三：二叉树的操作：
一、考查知识点：
1. 对任意给定的二叉树（顶点数自定）建立它的二叉链表存储结构；
2. 利用栈的五种基本运算（置空栈、进栈、出栈、取栈顶元素、判栈空）实现二叉树的先序、中序、后序三种遍历，输出三种遍历的结果。
3. 求二叉树高度、结点数、度为1的结点数和叶子结点数。
二、算法：
1. 创建二叉树：
Status Createbitree(bitree &t) //功能1：构建二叉树的二叉链表{ scanf(& ch); //按先序遍历建立二叉树 if(ch==’’)T=NULL;else{if(!(T=(BiTNde)malloc(sizeof(BiTNode))))exit(OVERFLOW); }T->data=ch;Createbitree(t->lchild);Createbitree(t->rchild);}Return OK;}//CreatBiTree
2. 先序遍历： Status PreOrderTrerse(Bitree T,Status（* visit）（TElemType) ）
{//采用二叉链表存储结构，Visit 是对数据元素操作的应用函数if(T){ if(Visist(T->data))if (PreOrderTrerse(p->lchild,Visit));if PreOrderTrerse(p->rchild,Visit));}return OK;return ERROR;}elese returnOK;}// PreOrderTrerse
3. 中序遍历：Status InOrderTrerse(Bitree T,Status（* Visit）（TElemType) ）{ InitStack(s);Push (S,T);
While(!StackEmpty(s){While(GetTop(s,p)&&p)Push(S,p->lchild);Pop(S,p);If(!StackEmpty(s)){Pop(s,p);if (!Visit(p->data))retu ERROR;Push(S,p->rchild);}//if}//WhileRetun OK;}// InOrderTrerse
二、源代码#include#include#include#define true 1#define false 0#define ok 1#define error 0#define overflow -2
typedef void status;typedef char BTtype;typedef char Stype;typedef struct BTnode {//定义二叉树存储结构BTtype data;struct BTnode *lc,*rc;}BTnode,*BTtree;typedef struct{//定义栈的存储结构Stype *base;Stype *top;int stacksize;} Sqstack;int max(int a,int b){return a>b?
a:b;}char Creat(BTtree &t){//创建
char ch;//printf("按顺序输入二叉树各节点的值：");scanf("%c",&ch);if(ch==" ") t=NULL;else {if(!(t=(BTtree )malloc(sizeof(BTnode)))){printf("创建失败。。");exit(overflow);}t->data=ch;Creat(t->lc);Creat(t->rc);}return ok;}char orderx(BTtree &t){//先序BTtree p=t;if(p){printf("%c",p->data);
orderx(p->lc);orderx(p->rc);}return 0;}char orderz(BTtree &t){//中序BTtree p=t;if(p){orderz(p->lc);printf("%c",p->data);orderz(p->rc);}return 0;}char orderh(BTtree &t){//后序BTtree p=t;if(p){orderh(p->lc);orderh(p->rc);printf("%c",p->data);}return 0;}int Depth(BTtree t){//求深度
int d,dl,dr;if(!t) d=0;else{dl=Depth(t->lc);dr=Depth(t->rc);d=max(dl,dr)+1;}return d;}int Nodes(BTtree &t){//结点数int num1,num2;if(t==NULL)return 0;else{num1=Nodes(t->lc);num2=Nodes(t->rc);return (num1+num2+1);}}void Degree(BTtree t,int &n){//度为1的结点个数//int n=0;if(t){if((t->lc && !t->rc) || (!t->lc && t->rc))
n++;Degree(t->lc,n);Degree(t->rc,n);}}void Lees(BTtree &t,int &yz){//叶子数//int yz=0;if(t){if((!t->lc) && (!t->rc))yz++;Lees(t->lc,yz);Lees(t->rc,yz);}//return yz;}void Quit(){//退出exit
(0);}int main(){BTtree t;int yz=0;int n=0;int x;//用于case 或ifprintf("需先按顺序输入二叉树各节点的值：");
if(Creat(t)) printf("创建成功！n");printf("
1、先序n
2、中序n
3、后序n
4、求深度n
5、求结点数n
6、求度为一的结点数n
7、求叶子数n
8、退出n");/*for(;;){printf("请选择1-9：");scanf("%d",&x);switch(x){case 1:printf("按顺序输入二叉树各节点的值："); Creat(t);printf("创建成功！n"); break;case 2:printf("先序遍历二叉树：");
orderx(t);printf("n");break;case 3:printf("中序遍历二叉树：");orderz(t);printf("n");break;case 4:printf("后序遍历二叉树：");orderh(t);printf("n");break;case 5:printf("二叉树的深度为：%dn",Depth(t));break; case 6:printf("二叉树的节点数为：%dn",Nodes(t));break;case 7:Lees(t,yz);printf("叶子数为：%dn",yz);break;
case 8:Degree(t,n);printf("度为1的节点个数为：%dn",n);break; case 9:Quit(); break;default:printf("输入错误");}}*/for(;;){printf("请选择1-8：");scanf("%d",&x);/*if(x=1){printf("按顺序输入二叉树各节点的值：");Creat(t); printf("创建成功！n");}else*/if(x==1){printf("先序遍历二叉树：");orderx(t);printf("n");
}else if(x==2){printf("中序遍历二叉树：");orderz(t);printf("n");}else if(x==3){printf("后序遍历二叉树：");orderh(t);printf("n");}else if(x==4){printf("二叉树的深度为：%dn",Depth(t)); }else if(x==5){printf("二叉树的节点数为：%dn",Nodes(t)); }else if(x==6){Degree(t,n);printf("度为1的节点个数为：%dn",n); }else if(x==7){
Lees(t,yz);printf("叶子数为：%dn",yz);}else if(x==8){Quit();}else printf("输入有误。。n");}/*printf("按顺序输入二叉树各节点的值：");if(Creat(t)) printf("创建成功！n");printf("先序遍历二叉树：");orderx(t);printf("n");printf("中序遍历二叉树：");orderz(t);printf("n");printf("后序遍历二叉树：");orderh(t);
printf("n");printf("二叉树的深度为：%dn",Depth(t));printf("二叉树的节点数为：%dn",Nodes(t));Degree(t,n);printf("度为1的节点个数为：%dn",n);Lees(t,yz);printf("叶子数为：%dn",yz);*/return 0;}
三、操作结果第四章 实训总结 通过这次实训，我把在课本上所学到的理论知识，运用到了实际的编程当中，也让我受益颇深。在这个为期两周的实训中, 我发觉到了自己的弱项和不足项, 也经过努力去克服了它们.
最深刻的总结成一个公式:学了学会了会用了，有些东西自己利用所学的地只是远远不能用算法很好的表达出来, 只能借助于书本, 互联网查找资料, 甚至以前老师所给做的笔记才能勉强完成. 有些不足还是.在开始的时候困难是很大的, 于是乎我并没有急于开工, 我先翻阅书本查找了有关知识点进行温习熟悉, 然后翻阅有关笔记, 上网查找资料. 之后我才开始编写算法, 实现目标这个过程中不免与同学进行交流合作. 这个铺桥的工作完成了. 下面的’’路’’也就好修了.
附录参考文献：
（1）《C 程序设计（第二版）》，谭浩强编，清华大学出版社，1999年1月。
（2）《C 语言程序设计题解与上机指导》，谭浩强编，清华大学出版社，2000年11月。
（3）数据结构C 语言版，严蔚敏，吴伟民编著，清华大学出版社，1997年4月。
范文四：数据结构实训报告
山东科技大学泰山科技学院课程实训说明书课程：数据结构（C题目：单链表、二叉树院 系： 信 息 工 程 系2015年 12月 18 日专业班级： 计算机科学与技术 学 号： 姓名： 指导教师：语言版）目录
一、设计题目············································1 课程设计题一：链表操作
1、设计目的
2、设计内容和要求
课程设计题二：二叉树的基本操作
1、设计目的
2、设计内容和要求
二、运行环境（软、硬件环境）····························1
1、软件环境
2、硬件环境
三、数据结构及算法设计的思想 ··························2 课程设计题一：链表操作课程设计题二：二叉树的基本操作
四、数据结构及算法设计·································4 课程设计题一：链表操作 课程设计题二：二叉树的基本操作
五、源代码 ············································6 课程设计题一：链表操作 课程设计题二：二叉树的基本操作
六、运行结果分析 ······································16 课程设计题一：链表操作
1、利用链表的插入运算建立线性链表（头插法）
2、链表的查找
3、链表的插入
4、链表删除
5、链表的计数
6、链表的输出
7、链表的排序
8、链表的逆置课程设计题二：二叉树的基本操作
1、建立二叉树（先序）
2、二叉树的先序遍历
3、二叉树的中序遍历
4、二叉树的后序遍历
5、求二叉树的高度
6、求二叉树的结点数
7、求二叉树的度为1的结点数
8、求二叉树的叶子结点数
七、实习总结（收获及体会）································22
一、设计目的课程设计题一：链表操作
数据结构实训报告
1、设计目的
（1）掌握线性表的在顺序结构和链式结构实现。
（2）掌握线性表在顺序结构和链式结构上的基本操作。
2、设计内容和要求
（1）利用链表的插入运算建立线性链表，然后实现链表的查找、插入、删除、计数、输出、排序、逆置等运算（查找、插入、删除、计数、输出、排序、逆置要单独写成函数），并能在屏幕上输出操作前后的结果。
课程设计题二：二叉树的基本操作
1、 设计目的
（1）掌握二叉树的概念和性质
（2）掌握任意二叉树存储结构。
（3）掌握任意二叉树的基本操作。
2、设计内容和要求
（1）对任意给定的二叉树（顶点数自定）建立它的二叉链表存储结构，并利用栈的五种基本运算（置空栈、进栈、出栈、取栈顶元素、判栈空）实现二叉树的先序、中序、后序三种遍历，输出三种遍历的结果。
（2）求二叉树高度、结点数、度为1的结点数和叶子结点数。
二、 运行环境（软、硬件环境）
1、软件环境Microsoft Visual C++
6.0
2、硬件环境 计算机一台处理器：Intel(R) Core(TM) i3-4010U CPU @
1.70GHz
1.70GHz
三、 数据结构及算法设计的思想课程设计题一：链表操作
（1）定义一个创建链表的函数，通过该函数可以创建一个链表，并为下面的函数应用做好准备。（ 因为每个新生成的结点的插入位置在表尾，则算法中必须维持一个始终指向已建立的链表表尾的指针。）
（2）定义一个遍历查找（按序号差值）的算法，通过此算法可以查找到链表中的每一个结点是否存在。 （单链表是一种顺序存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。因此，查找第 i 个数据元素的基本操作为：移动指针，比较 j 和 i 。令指针 p 始终指向线性表中第 j 个数据元素。设单链表的长度为 n ，要查找表中第 i 个结点，仅当 1≤i ≤n 时，i 的值是合法的。）
（3）定义插入结点的算法，通过定义这个算法，并结合这查找前驱和后继的算法便可以在连链表的任意位置进行插入一个新结点。（在链表中插入结点只需要修改指针。但同时，若要在第 i 个结点之前插入元素，修改的是第 i-1 个结点的指针。因此，在单链表中第 i 个结点之前进行插入的基本操作为:找到线性表中第i-1个结点，然后修改其指向后继的指针。）
（4）定义删除结点的操作，这个算法用于对链表中某个指定位置的结点的删除工作。（在单链表中删除第 i 个结点的基本操作为:找到线性表中第i-1个结点，修改其指向后继的指针。）
（5）定义一个计数的算法，通过此算法可以统计链表中结点的个数。
（6）定义输出链表的算法，通过对第一步已经定义好的创建链表函数的调用，在这一步通过调用输出链表的函数算法来实现对链表的输出操作。
（7）定义一个排序（冒泡排序）的算法，通过此算法对表中元素按照一定顺序进行排列。
（8）定义一个逆置单链表的操作，通过定义此算法，可以逆置输出单链表。（将原链表中的头结点和第一个元素结点断开（令其指针域为空），先构成一个新的空表，然后将原链表中各结点，从第一个结点起，依次插入这个新表的头部（即令每个插入的结点成为新的第一个元素结点））
课程设计题二：二叉树的基本操作
（1）定义二叉树链表：二叉树的链式存储方式下每个结点包含3个域，分别记录该结点的属性值及左右子树的位置。其左右子树的位置是通过指针方式体现，其中Ichild 是指向该结点左子树的指针，rchild 为指向该结点右子数的指针。结点结构：
（2）二叉树的创建：根据先序遍历结果建立二叉树，将第一个输入的结点作为二叉树的根结点，后继输入的结点序列是二叉树左右子树先序遍历的结果，由它们生成二叉树的左子数；再接下来输入的结点序列为二叉树右子树先序遍历的结果，应该由它们生成二叉树的右子树。而由二叉树左子树先序遍历的结果生成二叉树的左子树和由二叉树右子树先序遍历的结果生成二叉树的右子树的过程均与由整棵二叉树的先序遍历结果生成该二叉树的过程完全相同，只是所处理的对象范围不同，所以可以用递归方式实
现之。使用CreatBitree 建立一颗二叉树时，必须按其先序遍历的顺序输入结点的值，遍历过程中遇到空子树时，必须使用“#”代替。 例如：ABC##DE#G##F###
（3）二叉树的先序遍历：首先访问根结点；然后按照先序遍历的方式访问根结点的左子树；再按照先序遍历的方式访问根结点的右子数。
（4）二叉树的中序遍历：首先按照中序遍历的方式访问根结点的左子树；然后访问根结点；最后按照中序遍历的方式访问根结点的右子树。
（5）二叉树的后序遍历：首先按照后序遍历的方式访问根结点的左子树；然后按照后序遍历的方式访问根结点的右子树；最后访问根结点。
（6）求二叉树的高度：二叉树T ，如果T 为空，则高度为0；否则，其高度为其左子树的高度和右子树的高度的最大值再加1。
（7）求二叉树的结点数：二叉树T ，若T 为空，则T 中所含结点的个数为0；否则，T 中所含结点个数等于左子树中所含结点个数加上右子树中所含结点的个数再加1。
（8）求二叉树度为1的结点数：二叉树T ，若T 为空，则T 中度为1的结点数为0；否则，T 所含度为1的结点数等于左子树不为空右子树为空和左子树为空右子树不为空的结点个数之和。
（9）求二叉树的叶子结点数：求二叉树中叶子结点的个数，即求二叉树的所有结点中左、右子数均为空的结点个数之和。
四、 数据结构及算法设计课程设计题一：链表操作typedef struct LNode//线性表的单链表存储结构void CreatList_L(LinkList &L,int n);//头插法建表 （逆序建表）void GetElem_L(LinkList &L);//按序号查值
Status ListInsert_L(LinkList &L,int i,ElemType e);//插入 Status ListDelete_L(LinkList &L,int i,ElemType &e);//删除 void ListLength(LinkList &L);//计数 void PrintList(LinkList &L);//输出 void ListSort(LinkList &L);//冒泡排序 void OpposeList(LinkList &L);//逆置课程设计题二：二叉树的基本操作
typedef struct BiTNode//------二叉树的二叉链表存储结构---------Status CreateBiTree(BiTree &T)//建立二叉树的存储结构 —— 二叉链表（先序）。Status PreOrderTrerse (BiTree &T,Status (*Visit)(ElemType e))//先序遍历二叉树基本操作的递归算法在二叉链表上的实现Status InOrderTrerse (BiTree &T,Status (*Visit)(ElemType e))//中序遍历二叉树基本操作的递归算法在二叉链表上的实现
Status PostOrderTrerse (BiTree &T,Status (*Visit)(ElemType e))//后序遍历二叉树基本操作的递归算法在二叉链表上的实现 Status Visit(ElemType e)// 对二叉树中的数据元素访问 int BiTreeDepth(BiTree &T)//求二叉树的高度 int CountNode(BiTree &T)//二叉树的结点数 int NodeOne(BiTree &T)//二叉树中度为1的结点数 int CountLeaf (BiTree &T) //统计二叉树叶子结点
五、 源代码课程设计题一：链表操作#include #include #define OK 1 #define ERROR 0 typedef int Status; typedef int ElemType;typedef struct LNode{ ElemType data;struct LNode *next;}LNode,*LinkList; int i,j,k; LinkList L,p,q,s,r,head;void CreatList_L(LinkList&L,int n);//头插法建表 （逆序建表）void GetElem_L(LinkList
&L);//按序号查值Status ListInsert_L(LinkList&L,int i,ElemType e);//插入Status ListDelete_L(LinkList&L,int i,ElemType &e);//删除void ListLength(LinkList&L);//计数void PrintList(LinkList &L);//输出void ListSort(LinkList &L);//冒泡排序void OpposeList(LinkList&L);//逆置void CreatList_L(LinkList &L,int n){//逆位序输入n 个元素的值，建立带表头结点的单链线性表L 。
L=(LinkList)malloc(sizeof(LNode));L->next=NULL;//先建立一个带头结点的单链表 for(i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));//生成新结点scanf("%d",&p->data); //输入元素值p->next=L->next; //插到表头L->next=p;}}//头插法建表 （逆序建表）void GetElem_L(LinkList &L){//L为带头接点的单链表的头指针。当第i 个元素存在时，其赋值给e 并返回ERROR int i,e; p=L->next;
j=1; //初始化，p 指向第一个结点，j 为计时器printf("请输入查找位置:n");scanf("%d",&i);while(p&&j后查找，直到p 指向第i 个元素或p 为空 p=p->next; ++j; }if(!p||j>i)printf("第%d个元素不存在!",i); //第i 个元素不存在e=p->data;//取第i 个元素printf("查找结果为:%dn",e);}//按序号查值Status ListInsert_L(LinkList &L,int i,ElemType e){//在带头接点的单链线性表L 中第i 个位置之前插入元素e p=L; j=0;
printf("请输入插入位置:n");scanf("%d",&i); while(p&&jnext;++j;} //寻找第i-1个结点 if(!p||j>i-1)return ERROR; //i小于1或者大于表长加1s=(LinkList)malloc(sizeof(LNode)); //生成新结点printf("请输入插入元while(p->next&&j素:n");scanf("%d",&e);//寻找第i 个结点，并命令p 指向其前趋
s->data=e; p=p->next;//插入L 中 s->next=p->next; p->next=s;printf("插入后的链表为：n"); PrintList(L);return OK; }//插入Status ListDelete_L(LinkList &L,int i,ElemType &e){//在带头接点的单链线性表L 中，删除第i 个元素，并由e 返回其值 p=L; j=0;printf("请输入删除元素位置:n");scanf("%d",&i);
++j; }if(!(p->next)||j>i-1)return ERROR; //删除位置不合理 q=p->next;p->next=q->next; //删除并释放结点 e=q->data; free(q);printf("删除后的链表为：n"); PrintList(L);return OK; }//删除void ListLength(LinkList &L){ p=L;int j=0;//线性链表最后一个结点的指针为空 while((p->next)!=NULL) { j++; p=p->next;
}printf("单链表总共有%d个元素n",j); printf("n"); }//计数void PrintList(LinkList &L) { p=L->next; if(p==NULL)printf("n 链表为空!"); else while(p){printf("%d ",p->data); p=p->next; }printf("n");}//输出void ListSort(LinkList &L)//排序 { int t; int count=0; p=L->next; while(p) {count++; p=p->next; }
for(i=0;ip=L->next;for(j=0;jp->next) {if(p->data >p->next->data) { t=p->data;p->data=p->next->data;p->next->data=t;} } }printf("排序后的链表为：n"); p = L->next; while(p){printf("%d ",p->data); p=p->next; }printf("n");}//冒泡排序(升序)void OpposeList(LinkList &L){ p=L; p=p->next; L->next=NULL; while(p){ q=p; p=p->next; q->next=L->next; L->next=q;
}printf("逆置后的链表为：n"); PrintList(L); }//逆置int main() {int a,n,e;printf("************【请先建立单链表】************n");printf("请输入元素个数值:n"); scanf("%d",&n);printf("请输入%d个元素:n",n); CreatList_L(L,n);for(;;) {printf("--------------请选择如下操作码------------n"); printf("n");printf("*****-----------【1】查找------------*****n");
printf("*****-----------【2】插入------------*****n");printf("*****-----------【3】删除------------*****n");printf("*****-----------【4】计break; break; break; break; break;case 3: ListDelete_L(L,i,e);数------------*****n");printf("*****-----------【5】输case 4: ListLength(L);出------------*****n");printf("*****-----------【6】排
case 5: PrintList(L);序------------*****n");printf("*****-----------【7】逆case 6: ListSort(L);置------------*****n");printf("******************************************n"); scanf("%d",&a); switch(a) { break; break;case 7: OpposeList(L);default:printf("选择错误!n");} } return 0;case 1: GetElem_L(L);
}case 2: ListInsert_L(L,i,e);课程设计题二：二叉树的基本操作#include #include #define OK 1 #define ERROR 0#define OVERFLOW 0 typedef char ElemType; typedef int Status; typedef int TElemType;//------二叉树的二叉链表存储结构---------typedef struct BiTNode{ TElemType data;struct BiTNode*lchild,*rchild; }BiTNode,*BiTree; char ch;
//建立二叉树的存储结构 —— 二叉链表（先序）。 Status CreateBiTree(BiTree &T){ //按先序次序输入二叉树结点的值（一个字符），空格字符表示空树，构造二叉树链表表示的二叉树T 。 scanf("%c",&ch); if(ch=="#") T=NULL; else{if(!(T=(BiTNode*)malloc(sizeof(BiTNode)))) exit(OVERFLOW);T->data=ch;//生成根结点
CreateBiTree(T->lchild);//构造左子树CreateBiTree(T->rchild);//构造右子树 } return 0;}//先序遍历二叉树基本操作的递归算法在二叉链表上的实现 Status PreOrderTrerse (BiTree &T,Status (*Visit)(ElemType e)) {if(T){ if(!Visit(T->data)) return ERROR;PreOrderTrerse(T->lchild,Visit); PreOrderTrerse(T->rchild,Visit); }
return OK; }//中序遍历二叉树基本操作的递归算法在二叉链表上的实现Status InOrderTrerse (BiTree &T,Status (*Visit)(ElemType e)) {if(T){}Status Visit(ElemType e){InOrderTrerse(T->lchild,Visit); // 对二叉树中的数据元素访问 if(e==" "){ if(!Visit(T->data)) return ERROR;InOrderTrerse(T->rchild,Visit); }
return OK; }//后序遍历二叉树基本操作的递归算法在二叉链表上的实现 Status PostOrderTrerse (BiTree &T,Status (*Visit)(ElemType e)) {if(T){PostOrderTrerse(T->lchild,Visit);PostOrderTrerse(T->rchild,Visit); if(!Visit(T->data)) return ERROR;; }return OK;return ERROR; }else{printf("%c",e); }return OK; }
//求二叉树的高度int BiTreeDepth(BiTree &T){ int Depthall,Depthl,Depthr; if (T==NULL) Depthall=0;else {Depthl=BiTreeDepth(T->lchild);Depthr=BiTreeDepth(T->rchild);Depthall=(Depthl>Depthr?
Depthl:Depthr)+1;}return Depthall;}//二叉树的结点数 int CountNode(BiTree &T){ if(T==NULL) return 0; else
return(CountNode(T->lchild)+CountNode(T->rchild)+1); }//二叉树中度为1的结点数 int NodeOne(BiTree &T){ if(T==NULL) return 0;else{if((T->lchild==NULL&&T->rchild!=NULL)||(T->lchild!=NULL&&T->rchild==NULL))return 1;elsereturn(NodeOne(T->lchild)+NodeOne(T->rchild)); }
}//统计二叉树叶子结点 int CountLeaf (BiTree &T) { if ( T==NULL ) return 0; else{if ((!T->lchild) && (!T->rchild)) // 无左、右子树 return 1; elsereturn(CountLeaf( T->lchild)+CountLeaf ( T->rchild)); }}int main() {BiTree T;Status(*visit)(ElemType e)=Visit; int a;printf("************【请先建立二叉树】************n");
printf("请输入二叉树的元素(空节点以#号表示):n"); CreateBiTree(T);for(;;) {printf("--------------请选择如下操作码------------n"); printf("n");printf("*****-----------【1】先序遍历------------*****n");printf("*****-----------【2】中序遍历------------*****n");printf("*****-----------【3】后序遍历------------*****n");
printf("*****-----------【4】求二叉树的高度------*****n");printf("*****-----------【5】二叉树的结点数 -----*****n");printf("*****-----------【6】二叉树中度为1的结点数-***n");printf("*****-----------【7】统计二叉树叶子结点--*****n");printf("**********************************************n"); scanf("%d",&a); switch(a) {
case 1:PreOrderTrerse(T,visit); printf("n"); break;case 2: InOrderTrerse(T,visit); printf("n"); break;case 3:PostOrderTrerse (T,visit); printf("n"); break; case 4: printf("二叉树的高度为：%dn",BiTreeDepth(T)); break;case 5: printf("二叉树的结点数为：%dn",CountNode(T)); break;case 6: printf("度为1的default:printf("选择错
结点数为：%dn",NodeOne(T)); 误 !n"); break;case 7: printf("二叉树的}} } return 0;叶子结点数为：%dn",CountLeaf(T)); break;
六、 运行结果分析课程设计题一：链表操作
1、利用链表的插入运算建立线性链表（头插法）
2、链表的查找
3、链表的插入
4、链表删除
5、链表的计数
6、链表的输出
7、链表的排序
8、链表的逆置课程设计题二：二叉树的基本操作
1、建立二叉树（先序）
2、二叉树的先序遍历
3、二叉树的中序遍历
4、二叉树的后序遍历
5、求二叉树的高度
6、求二叉树的结点数
7、求二叉树的度为1的结点数
8、求二叉树的叶子结点数
七、 实习总结（收获及体会）通过这次实训，我获益匪浅：巩固和加深了对数据结构的理解，提高综合运用本课程所学知识的能力。刚开学的时候有很多地方不理解，每次上课都留有很多疑问，但又不能及时的解决，所以遗留的问题越来越多，但是通过本次的上机操作实训，解决了我遗留的问题，在这段时间里，我不断的思考，不断的查找资料，不断的在电脑上调试运行查找错误，利用互联网查找一般会出现的错误，并分析原因，以防自己犯同样的错误。就这样，一步一步地走完这一星期，最终达到了个人目的。
本次实训是关于单链表和二叉树的相关操作，单链表的建立、查找、插入、删除、计数、输出、排序、逆置等运算；二叉树的建立、先序遍历、中序遍历、后序遍历以及求二叉树高度、结点数、度为1的结点数和叶子结点数。这些操作几乎涵盖了单链表和二叉树的全部知识点，可以说这些会了，其他的也就不成问题了。关键就在于决绝这些问题。
通过这一次的实训，不仅加深了对数据结构知识的了解，更复习了以前学习过的C 语言，重新复习了排序等经典算法，而且对于以前不懂得地方，例如主函数与子函数之间的实参，形参之间的传递，并且在二叉树的遍历部分复习了递归算法的使用。编程时要认真仔细，出现错误要及时找出并改正，遇到问题要去查相关的资料。反复的调试程序，最好是多找几个同学来对你的程序进行调试并听其对你的程序的建议。要形成自己的编写程序与调试程序的风格，从每个细节出发，不放过每个知识点，注意与理论的联系和理论与实践的差别。另外，要注意符号的使用，注意对字符处理，特别是对指针的使用很容易出错且调试过程是不会报错的，那么我们要始终注意指针的初始化不管它怎么用以免不必要麻烦。
通过这次实训，让我对一个程序的数据结构有更全面更进一步的认识，但是遗憾的是由于实训时间短，在二叉树这块，全都是用的递归算法，递归算法虽然容易理解，但是它的时间复杂度很糟糕。然而非递归算法虽然不容易理解但是它有它的优点。实训虽小，但是它带给我的却很多。这次实训出现的问题很多但是都被一一解决，遇到困难一定不要畏缩或者放弃，一定要努力寻找办法去解决，即使希望很渺茫也要尝试，万一要成功了呢！一分耕耘一分收获，这句话永远不会过时。平时多积累，多注意，多听多写多看，只有有足够的知识储备，才能源源不断的释放自己的能量。
附录：参考资料：《数据结构》（C 语言版） 清华大学出版社 《数据结构题集》（C 语言版） 清华大学出版社 《数据结构》（C 语言）（第3版） 人民邮电出版社
范文五：数据结构实训报告
实训报告实训名称: 数据结构实训(全国交通咨询模拟)指导教师:姓名:学号:班级:日期: 2011 年1月10 日~2011年1月21 日
一、实训项目项目名称:全国交通咨询模拟
二、实训的目的
1.熟悉图数据结构;
2.掌握图的顺序存储结构—邻接表;
3.掌握最短路径算法
4.上机调试程序,掌握查错、排错使程序能正确运行。 三(实训要求
1.每个人独立完成实训项目，相互之间可以交流，不能抄袭
2.实训的成果包括程序代码和报告
3.程序代码要有注释和说明
三、实验的环境:
1.硬件环境: PC机
2.软件环环境:Windows2000 +Visual C++6
四、算法描述:建立图的数据结构，采用邻接矩阵作为其存储结构。存储以上的全国主要城市的交通信息。通过软件模拟的方法实现:给定出发点和终点，求出它们之间的最短路径，并给出最短路径的线路。
五、源程序清单:#include#include
#define VEX_NUM 26#define MAXINT 1000000typedef struct graph{char city[VEX_NUM][10];int arcs[VEX_NUM][VEX_NUM]; }Mgraph;void CreatGraph(Mgraph *G,int e); void Dijkstra(Mgraph *Gn, int v0,int path[],int dist[]);void PutPath(Mgraph *g,int v0,int v1,int p[],int d[]);int index(char s[],Mgraph *g); void main()
{Mgraph *g;int i;int e;int v0,v1;char sr[10],dt[10];int dist[VEX_NUM];int path[VEX_NUM];g=new Mgraph;CreatGraph(g,30);printf("输入出发城市和终点城市n");getchar();gets(sr);v0=index(sr,g);gets(dt);v1=index(dt,g);Dijkstra(g,v0,path,dist);PutPath(g,v0,v1,path,dist); }void CreatGraph(Mgraph *G,int e){int i,j,k,cost;
printf("输入城市名称n");for(i=0;i scanf("%s",G->city[i]);for(i=0;i for(j=0;j G->arcs[i][j]=MAXINT;printf("输入城市之间的距离n");for(k=0;k {scanf("%d,%d,%d",&i,&j,&cost);G->arcs[i][j]=cost;G->arcs[j][i]=cost;}}void Dijkstra(Mgraph *Gn, int v0,int path[],int dist[]){int s[VEX_NUM];
int v;int w;int i,j,k;int min;for(v=0; v {s[v]=0;dist[v]=Gn->arcs[v0][v];if(dist[v] path[v]=v0;else path[v]=-1;}dist[v0]=0;s[v0]=1;for(i=1;i {min=MAXINT;for(w=0;w if(!s[w] && dist[w] {v=w;min=dist[w];}s[v]=1;for(j=0;j if(!s[j] && (min+Gn->arcs[v][j] {dist[j]=min+Gn->arcs[v][j];
path[j]=v;}}}void PutPath(Mgraph *g,int v0,int v1,int p[],int d[]){int k;int next;int top=0;int st[20];if(d[v1] {st[top++]=v1;next=p[v1];while(next!=v0){st[top++]=next;next=p[next];}}elseif(v1!=v0){printf("%s->%s:没有路径n",g->city[v0],g->city[v1]);return;}st[top++]=v0;while(top){next=st[--top];
if(top!=0)printf("%s->",g->city[next]);elseprintf("%sn",g->city[next]);}printf("两个城市之间的最短距离为:%dn",d[v1]);}int index(char s[],Mgraph *g) {int i;for(i=0;i if(strcmp(s,g->city[i])==0)return i;}
六、运行结果:
七、实验运行情况分析(包括算法、运行结果、运行环境等问题的讨论)。最新数据结构实训报告可以看看这篇名叫2018最新会计实训报告的文章，可能你会获得更多数据结构实训报告
以下是的一些我们精选的2018最新会计实训报告我们毕业前夕总是想着自己的实训的地方是一个大平台很有前途，但是作为会计这个职业可能对于大平台的实训 要求得不差分毫，所以小编今天给大家准备一份《会计实训报告》10篇范文的分享。会计实训报告会计实训报告
（一）：会计实习报告范文
一、公司介绍华为是全球领先的信息与通信解决方案供应商。我们围绕客户的需求持续创新，与合作伙伴开放合作，在电信网络、终端和云计算等领域构筑了端到端的解决方案优势。我们致力于为电信运营商、企业和消费者等带给有竞争力的综合解决方案和服务，持续提升客户体验，为客户创造最大价值。目前，华为的产品和解决方案已经应用于140多个国家，服务全球1/3的人口。
我们以丰富人们的沟通和生活为愿景，运用信息与通信领域专业经验，消除数字鸿沟，让人人享有宽带。为应对全球气候变化挑战，华为透过领先的绿色解决方案，帮忙客户及其他行业降低能源消耗和二氧化碳排放，创造最佳的社会、经济和环境效益。
二、具体状况首先，在第一周时间里，我对公司业务流程的资料有了必须的了解。其次，在第二周的时间里，我认真、仔细学习了日常财务操作的全过程。跟出纳人员学会了如何开支票等票据、如何根据原始凭证编制记帐凭证、登记现金、银行日记帐、每月月底如何根据银行对帐单与帐户进行核对，及时编制调节表，向主管计学习财务报表的编制和财务分析。
最后，在第三周的时间里，我学习和了解了公司的有关财务制度，对财务人员的岗位主要职责有了具体认识。
三、公司在财会方面成功的主要经验财会人员是企业效益的创造者之一随着市场经济的发展，社会的进步，个性是经济效益观念的日益强化和“企业管理以财务管理为中心”的提出，对企业财会人员的工作要求越来越高，财会工作不再局限于简单的记帐、算帐和报帐，而是充分利用掌握的专业知识和政策法规，用心参与企业生产经营管理和资本运营等方方面面工作，直接或间接为企业效益最大化发挥着越来越重要的作用。与会的17位大型集团公司财务老总以不争的事实，论证了财会人员是企业不可或缺的，具有特殊身份的管理者之一，在创造企业效益中处于极其重要的核心地位，真正发挥着“内当家”的作用，在对企业效益的创造过程和结果进行全面核算与督的同时为企业直接或间接的创造效益。
财会人员为企业创造效益的几个方面
（一）、会计人员基础工作。会计核算是会计最基本的职能之一，透过记帐、算帐和报帐，及时带给正确、有用的会计信息，客观的反映经营成果，为公司领导的决策带给可靠的依据，既是会计人员劳动价值的体现，也进而成为企业效益间接的创造者。如何做好会计核算是会计人员最基本的工作，也是对会计人员最基本的要求，会计核算不做好，谈何进行会计督与参与管理。以信息化（erp）为手段，结合财务软件的使用，加强审核与对会计人员的考核督，来规范我们的核算，提高核算的效率，降低核算的成本，从而间接的为企业创造效益。
（二）、资金管理。资金是企业的血液，资金流贯穿企业生产经营的每一个环节，资金既是企业正常生产经营的保障，也是企业创造效益的最终体现。透过融资和投资，如何提高资金的使用率，降低资金的使用成本，为企业创造效益，是资金管理的根本。
1、融资筹划。合理确定筹资规模，用心寻求多渠道融资，充分利用企业信誉及内部相互担保的方式进行融资，降低融资成本，为企业的生产经营带给资金保障。
2、采用有利的支付方式。
（1）用心使用银行承兑汇票付款，付款与融资相结合，减轻付款压力，也降低融资费用。
（2）采用资金集中时间支付，如对日常费用报销规定每周一次，对材料款及大宗设备款规定每月两次等，有利于增强集团对资金的调控潜力，提高现金流的质量，提高集团帐户银行存款的日均存量，从而提高企业在银行的信誉；同时也能提高资金审批人员、支付人员的工作效率。
3、资本经营。
（1）根据企业特定的生产经营周期，资金有时也会出现剩余，财会人员透过股票、基金或国债申购，充分利用闲置资金，提高资金使用率，同时为企业创造资金效益。
（2）透过股权收购或股权投资，成立子公司，实现低成本扩张和企业快速发展。
4、资金收支一级管理，倡导“现金为王”的观念，用心利用银行电子商务，开展网上业务，尽可能地加速资金周转，减少资金成本，规避财务风险，提高企业经济效益。资金收支一级管理有利于增加现金流和结算存量，提高企业在银行的信誉，有利于各分、子公司资金的统一调配，提高使用效率，有利于加强对分、子公司的督管理，控制风险。资金管理实行内部模拟市场，即在企业内部实行资金有偿使用，财务部门即是资金调剂中心，也成为企业的创效部门。
（三）、税收筹划。我国是世界上税赋最重的国家之一，税赋在企业的成本中占有必须的比重，如何进行税收筹划，合法避税，是会计人员为企业节约成本，创造效益的重要方面。
1、充分运用国家财税新政策，如国产设备投资抵免政策，以国产设备投资抵免所得税；
2、用心向财税部门申请实施企业所得税合并纳税，使各分公司盈亏在所得税前合并调节，到达节税的目的；
3、关联企业销售改为委托加工。关联企业内部销售实质上增加了企业的税赋，透过税收筹划，改为委托加工的形式，大大降低了企业税赋。
（四）、参与管理。会计人员透过成本核算，进行实时跟踪比较，加强成本的日常控，对企业成本的降低起到很大作用；透过对财务数据分析，以及对专业知识和政策法规的掌握，为企业的发展提出有效的推荐；透过制订全面预算，明确企业总体目标，并在此基础上分解各部门预算，健全职责制考核体系，调动子、分公司用心性，促进企业快速发展。
四、对财会人员创造效益的几点认识
（一）、提高财会人员自身素质。既然财会人员是企业效益的创造者之一，在企业经营管理中起到极其重要的作用，我们要有职责感和使命感，提高自身素质，更好的服务于企业，更多的为企业创造效益。
1、专业知识。不断为自我充电，加强专业知识学习，努力提高职称水平，同时要在实践工作中不断的总结，透过实践积累来提升自身业务水平；
2、团队精神。一个人的力量是有限的，只有提高和发扬团队精神，整体提高财会人员的素质，工作有分工又有牵制，大家同心协力，才能把财务工作做得更好；
3、沟通与协调。财务工作涉及企业的每个部门，需要沟通与协调，这就要求财会人员还要提高沟通、协调潜力，将财务制度、财务管理理念贯彻到每个部门，并得到理解和支持，从而使财会人员创造效益的潜力得到充分的发挥。
（二）、公司领导的重视与支持。现代企业管理要以财务管理为中心，只有公司领导的高度重视与支持，财会人员才能更好的发挥自身的潜力，财务管理工作才能得以强化与落实，取得实效。从另一层面，公司领导对财务工作的重视，也体现出公司领导有正确的理财观念，能充分理解和支持财务工作。
（三）、制度与文化建设。财务管理是个系统性的工程，不但要求财会人员有良好的素质，以及得到公司领导的重视与支持，还要有制度的保障。首先要建立完善的财务管理制度和业务操作程序，并随着企业的发展不断制度创新；再次要组织和加强企业全体员工的制度学习，推进企业文化建设，让全员都有理财观念，大家都来开源节流，为企业创造效益而努力！
五、公司在财务会计方面存在的主要问题目前我认为该公司在财务会计方面存在以下几方面的问题：
1、帐务处理不准确。
2、会计凭证不规范。
3、会计档案整理不规范
六、实践的收获和体会以前，我总以为自我的会计理论知识扎实较强，正如所有工作一样，掌握了规律，照芦葫画瓢准没错，那么，当一名出色的会计人员，就应没问题了。此刻才发现，会计其实更讲究的是它的实际操作性和实践性。离开操作和实践，其它一切都为零！会计就是做账。
其次，就是会计的连通性、逻辑性和规范性。每一笔业务的发生，都要根据其原始凭证，一一登记入记账凭证、明细账、日记账、三栏式账、多栏式账、总账等等可能连通起来的账户。这为其一。会计的每一笔账务都有依有据，而且是逐一按时间顺序登记下来的，极具逻辑性，这为其二。在会计的实践中，漏账、错账的更正，都不允许随意添改，不容弄虚作假。每一个程序、步骤都得以会计制度为前提、为基础。体现了会计的规范性，这为其三。
登账的方法：首先要根据业务的发生，取得原始凭证，将其登记记帐凭证。然后，根据记帐凭证，登记其明细账。期末，填写科目汇总表以及试算平衡表，最后才把它登记入总账。结转其成本后，根据总账合计，填制资产负债表、利润表、损益表等等年度报表。这就是会计操作的一般顺序和基本流程。会计本来就是烦琐的工作。在实习期间，我曾觉得整天要对着那枯燥无味的账目和数字而心生烦闷、厌倦，以致于登账登得错漏百出。愈错愈烦，愈烦愈错，这只会导致“雪上加霜”。反之，只要你用心地做，反而会左右逢源。越做越觉乐趣，越做越起劲。梁启超说过：凡职业都具搞笑味的，只要你肯干下去，趣味自然会发生。因此，做账切忌：粗心大意，马虎了事，心浮气躁。做任何事都一样，需要有恒心、细心和毅力，那才会到达成功的彼岸！
会计实训报告
（二）：会计实训报告年级专业班级：学号：姓名：提交日期：
一、实训基本状况
（一）实训时间：年月日——月日
（二）实训单位：光华机床有限职责公司
（三）实训目的：
1、透过对企业会计模拟实训，这样能够系统地掌握企业会计核算的全过程，从而加强我们对学会计理论和知识的理解与认识，完成从理论到实践的认知过
2、实训的资料涵盖了会计操作的全部基本技能——从建账、填制和审核原始凭证、记账凭证到登记账簿；从日常会计核算、成本计算到编制会计报告、年终结账
3、全部实训突出综合性、完整性、超前性、和系统性。以一个模拟企业的特定会计期间为范围，将经济业务的来龙去脉与企业的生产经营有机地结合起来，将企业经济业务发生的前瞻性与市场经济的变化相配套，开阔视野，增进我们对社会、企业的了解和认识，为即将进入社会的我们从事财会工作打下很好的基础。
（四）实训完成状况：透过老师的指导，以光华机床有限职责公司为实训企业，经过一个月的实训，我基本上能够灵活的把所学的会计知识运用到会计实训当中。能够熟练的对会计核算的各步骤进行系统操作实验，包括账薄建立和月初余额的填制、原始凭证、记账凭证的审核和填制，各种账薄的登记、对账、结账、编制报表等。能够按计划完成指定工作。
（五）实训形式：手工会计
二、实训过程及资料：
1、建账。根据资料的期初余额建账
2、审核填制记账凭证。基本要求有：记帐凭证各项资料务必完整，记帐凭证就应连续编号，记帐凭证的书写应清楚、规范，记帐凭证能够根据每一张原始凭证填制，除结帐和更正错误的记帐凭证能够不附原始凭证外，其他记帐凭证务必附有原始凭证，填制记帐凭证时若发生错误，就应重新填制，记帐凭证填制完经济业务事项后，如有空行应当自金额栏最后一笔金额数字下的空行处至合计数上的空行处划线注销。
3、登明细帐。其中具体包括：三栏式明细帐、数量金额式、多栏式。
4、运用“T”形账户编制科目会总表。这是为登总账所做的准备，它能反应这期间业务发生进有哪几个会计科目，并且能清楚的看到其借贷所发生的余额以及最后余额。5利用科目汇总表登记总帐，。按照科目汇总表中各科目依次登帐。6，期末结账。
7、编制资产负债表、利润表的编制、现金流量表等
三、实训总结、体会及推荐
（一）总结和体会
1、在会计实训的一个月的学习中，让我对其有了更深的认识和见解。为期一个月的模拟实训结束了，透过本次实训，让我对会计整个流程的操作有了较好的认识，我学会了会计中各个环节的操作，以及更加懂得了细心、谨慎和职责对于一个会计来说是那么的重要。在这些会计模拟实训中，对于在课堂上老师讲授的透过这一次实训让我们系统地进行了一番实践。透过这次的模拟实验使我加强了对基础会计各方面知识的记忆也让我发现了自我在哪些方面的不足，发现问题及时补救是这一次实训一大收获。在实验我学习到了许多在书本上不能学到的知识。这次是透过自我对企业发生的业务审核并亲自填写记账凭证，登记明细账、编制科目汇总表、登总账等一系统的操作。在实训的过程中遇到问题除了问老师自我也意识到只有把书本上学到的会计理论知识应用于实际的会计实务操作中去，才能够真正掌握这门知识，我想这也是这次实训的真正目的吧。
2、在这一次的实训中我除了对会计工作有了进一步的认识，在取得实效的同时在实习过程中发现了自身的一些不足。比如自我不够细心，经常抄错数字或借贷写反，导致核算结果出错，引起不必要的麻烦；在编制分录方面还不够熟练，今后还得加强练习，熟悉课本知识。总而言之，这次的会计实训让我学到了许多在课堂上所学不到的经验，在实践中巩固了知识，也为我们以后走向社会奠定了坚实的基础。还有，基础的知识十分的重要，其实这一次实训我清楚的了解到自我还有很多基础知识不牢固个性是一些计算问题，基础、中级财务会计的知识模糊不清楚。在实际操作的过程中，在发现有很多问题自我不知如何下手，没有办法解决问题。只有透过学习和实训功过了，在课堂上认真的学习理论知识，在实践的过程中把学到的理论知识应用到实践中，才能够更好更快地解决问题。
3、在记帐过程中，由于种种原因遇到了很多问题，但是透过对症下，采用错帐更正方法，一般有划线更正法、补充登记法、红字更正法三种，而不是填补、挖改。这是我在作帐时要注意的一点。在实训中我也学会了原始凭证与证帐凭证、各明细帐与总帐核对等。这是十分繁琐，也是十分重要的，否则会功亏一篑，徒劳无功。在实训中最能体会的是累、烦！但是最终我还是坚持下来了，我为自我感到骄傲，我想这也是我负责、用心表现吧！Yjbys
（二）推荐但是作为一名即将走进社会的，能够很好的掌握书本上的知识并且灵活运用是十分实在和重要的，但是作为今后的一位会计人员职业道德也务必培养诚信，一个人如果没有良好的诚信品德，就不可能有坚定的的信念。因此要想做一个好的会计员，要想做一个对国家有用的人，就必须要以诚信为本。证据，在此刻的法制社会，无论做什么都要讲究证据，我们都明白作为会计人员在进行填制记账凭证和登记账簿时，都以证据进行操作，没有合法的凭证做依据来证明业务是否发生，则不能够进行账务处理。所以在会计中，讲证据是最重要的。敬业精神，经过两年多的学习我们都明白会计行业中更需要敬业精神，我们整天与数字打交道如果不敬业、不谨慎的对待工作，那将产生很大的损失。所以敬业不仅仅是对企业负责更是使对自我的负责。要学会不做假账，这是作为一个会计人员最起码的道德准则，也是一个会计人员最难遵守的原则。其中的矛盾实在难说，作为新一代会计人员，就就应坚守这一基本会计准则，为国家做出自我的一点牺牲，奉献自我的一点力量。做为一名会计人员必然要与金钱打交道，每一天要接触许多钱，这就要我们每一位会计人员做到无私。是自我就应拿的工资或奖金就一分不少的拿到，不是自我的钱即使是一分也不拿，要做
到严以律己、谨慎对事的良好的职业道德。灵活要求我们做会计的就应学会善于交际，与领导之间、与同事之间、与同行之间以及与业务往来客户打好人际关系，在不违背做人原则和会计原则、法规的基础上处理好人际关系，这对我们的工作有很好的帮忙。会计实训报告
（三）：
一、实习目的会计模拟实训的目的是培养的实践操作潜力。能够使系统，全面地掌握企业会计核算的基本程序和方法，加强对会计基本理论的理解，将会计知识理论和会计实务工作有机的结合在一齐。
二、实习时间
三、实习地点
四、实习资料《初级财务会计》实践教学是以一个中型工业企业——长春市万隆股份有限职责公司12月份的经济业务为例，透过设置账户、填制会计凭证、登记账簿和编制财务会计报告等工作环节，全面地、系统地、连续地完成企业基本业务处理。
(一)实习操作过程1经济业务发生后，首先要审核原始凭证，根据原始凭证或原始凭证汇总表填制各种记账凭证;
2根据收款凭证和付款凭证逐笔登记现金日记账和银行存款日记账;3根据各种记账凭证并且参考原始凭证或原始凭证汇总表，逐笔登记各种明细分类账;4根据各种汇总记账凭证汇总登记总分类账;5月末，将日记账明细分类账的余额与总分类账中相应账户的余额进行核对;6月末，根据总分类账和明细分类账的记录编制会计报表。
(二)操作要领1。期初建账：
(1)建总账时，1设置账簿的的封面与封底：2填写账簿启用以及经管人员一览表;3填写账户目录;4填写账页，将上一年或上一本的期末余额作为本次的期初余额，进行账目登记。
(2)建明细账时，将上个月或者是上一年总账中，所涉及到的相应的明细账的余额，分别填制到新账簿的分户账中，并标明科目，账户名，及余额和余额方向
(3)建日记账时，
建立现金存款日记账时，将上一年或上一个月的库存现金总账中的余额，填到新建的库存现金日记账中的余额栏中;银行存款日记账，将上一次的银行存款总账的余额，填到新建账中的相应的银行存款日记账中的余额栏上;2。审核或填制原始凭证1填制原始凭证的时候，要记录真实(记载的经济业务务必与实际状况相符)，手续完备(务必贴合内部牵制原则的要求)，资料齐全(基本资料和补充资料要详尽的填写齐全)，书写规范，还要及时填制(不拖延，不积压);
2审核：要审核其原始凭证反映的经济业务的合法，合规，合理，审核其填制要贴合规定的要求3。编制记账凭证修改记账凭证的摘要简明，科目运用准确，编号连续，附件齐全。4。登记日记账，对于库存现金日记账，根据审核无误的库存现金日记账的记账凭证，将每日发生的库存现金，逐笔登记到相应的库存现金日记账中，并标明金额及余额方向，同时还要对库存现金日记账进行日结;
银行存款日记账，也是根据审核无误的银行存款日记账的记账凭证，将发生的银行存款逐笔登记到银行存款日记账中，并标明金额及余额方向，对银行存款日记账进行月结。5。登记有关明细账。对发生的经济业务，根据审核无误的原始凭证，将其借贷方登记到三栏式，多栏式或数量金额式的有关明细账上(只限于有二级科目的;无二级科目的，到月底登记到总账上)。
6。编制科目汇总表根据必须会计期间编制的全部记账凭证，按照相同的会计科目进行归类，定期分别汇总每一个账户的借贷方的发生额，病填制在科目汇总表的相应栏内。7。登记总账根据科目汇总表登记的总分类账，将其表中汇总起来的歌科目的本期借。贷方发生额的合计数，分次或月末一次计入总分类账户的借方或贷方。8。对账1账证核对：各种账簿记录与会计凭证进行核对;
2账账核对：总分类账的歌账户的借方期末余额合计与贷方的合计数相符，明细账的各账户的余额合计与总账的余额相符，日记账的余额与总分类账的余额相等，各部门财产物资明细账的期末余额与保管或使用部门的明细账的期末数相等;3账实核对：账面数字与实际的屋子，款项进行核对;4账表核对:记账记录与各种会计报表相互核对。9。结账
1检查结账日止以前所发生的全部经济业务是否都已经登记入账;2编制结账分录;3计算发生额和余额。10。编制财务会计报告所编制的信息要真实，是确，并且要及时编制。在编制前，应当全面清查资产，适宜债务;还要做好结账和对账准备，根据规定的格式和要求编制报告，资料要完整，数字真实，计算准确，不得漏报和随意取舍。11。整理归档
对所填制的凭证，账簿，报表进行整理，并装订成册。
五、实习体会实习是每一个毕业生务必拥有的一段经历，它使我们在实践中了解社会、在实践中巩固知识;实习又是对每一位毕业生专业知识的一种检验，它让我们学到了很多在课堂上根本就学不到的知识，既开阔了视野，又增长了见识，为我们以后进一步走向社会打下坚实的基础，也是我们走向工作岗位的第一步。
以前，我以为会计业就是记记账管管钱，遵纪守法，是一件很容易而且很简单的事情，况且此刻都实现了电算化。认为自我的理论知识学的优秀点，正如所有工作一样，掌握了规律，照芦葫画瓢，那么，当一名出色的会计人员，就应没问题了。此刻才发现，会计其实更讲究的是它的实际操作性和实践性。离开了操作和实践，其实一切将会归于零!
透过这两周的基础会计的实习，我体会到，作为会计，在做账的时候应注意的细节和方法十分的严谨。首先要根据上月的余额及利润表，我们开始建账，将余额分别填到总分类账户中，有明细账的要登记到相应的分户账上，余额要准确，并且根据账户的种类写好余额的借，贷方向。接下来就是开始做记账凭证了，首先审核所附的原始凭证是否正确，根据所发生的经济业务的发生编写会计分录，根据会计分录将发生的经济业务登记到记账凭证上，在记账凭证上要填上年月日，凭证编号。对于业务资料这一栏，要简明扼要。还要填写你所附原始凭证的张数，在金额栏里，对于没有填写金额的空白处要用斜线划掉。对于原始凭证，要将其整齐的贴到记账凭证的背面，要与记账凭证左上对齐。记账凭证最好做一张扯一张，并保存好，便于最后装订的时候方便且整洁这一次我们涉及的经济业务资料比较少，但是越到最后经济业务也越复杂，一张记账凭证写不下来，所以要用分页记账法进行登帐。做记账凭证的时候必须要保证记账凭证的正确性，以免在以后做报表的时候发生借贷方不平。
然后根据审核无误的记账凭证进行登记明细账，要做完一张凭证要及时登帐。库存现金要及时逐笔登记，并进行日结，到月底年底还要进行月结年节，而银行存款日记账则不需日结(除非一天当中银行存款发生的业务量十分大)，一般是月结和年结。我们只做凭证就做了将近一周的时间，然后核对，去登明细账，然后将明细账进行月结，结出每笔明细账的余额，前几项做起来还比较简单。下方就开始编科目汇总表了，科目汇总表是很麻烦的，我们是半个月一编，要保证科目汇总表的贷方合计数等于借方合计数。
开始编的时候个性费劲，每一科目都要去查明细账。将金额登记完之后怎样算都是不平的，之后又算了四五遍还是没有进展，之后又从凭证上开始找还是没有找到错误的原因。最后找老师去核对才发现，原先在登记的时候由于粗心将金额少记了一笔，最后才将表的借贷方的合计数算平。所以编表的时候必须要专心，细心，将金额写正确。根据科目汇总表我们便开始登记总账，并进行对明细账和总账的月结。结完账之后就要开始编最麻烦的利润表和资产负债表了，它们要根据总账余额和明细账及其余额进行编制。
务必让资产负债表的资产类合计与负债所有者权益合计相等，但是我一次次的算，每次都是不一样的结果，我都差一点厌倦了，最后和同学以前才把这个表彻底的完成了。感觉就这两个表都让我头痛好一阵了此刻会计实施结束了，回想起来其实会计本来就是烦琐的工作。在实习期间，我曾觉得整天要对着那枯燥无味的账目和数字而心生烦闷、厌倦，以致于登账登得错漏百出。愈错愈烦，愈烦愈错，这只会导致“雪上加霜”。反之，只要你用心地做，反而会左右逢源。越做越觉乐趣，越做越起劲。梁启超说过：凡职业都具搞笑味的，只要你肯干下去，趣味自然会发生。因此，做账切忌：粗心大意，马虎了事，心浮气躁。做任何事都一样，需要有恒心、细心和毅力，那才会到达成功的彼岸!这次会计实习中，我可谓受益非浅。
经过这次的手工模拟实习，发现了自我还存在许多的问题：第一：书本上的知识掌握的不够扎实，以致不能够很熟练地运用到实践当中去;第二，没有足够的耐心，做事情也不够认真仔细，以致经常出现一些低级错误，比如写错数字，记错方向。虽然实习的时间并不是很长，但是却让我学到了很多在书本上学不到的知识，真正地把从书上学到的理论运用到实践当中，接触到了以后当一名会计要做的许多事情。虽然实习这段时间每一天都很辛苦，但是我认为值得，也让我体会到了作为一名会计有多辛苦，相信每一个岗位只要你用心、认真地去做了，都会很累，但是你却能够从中收获到很多，正所谓有得必有失。我相信我能够改正自我的缺点，在以后的实际工作中努力地做好自我的本分工作，严格地要求自我，做一名好会计。
难忘的一次实习，它记载了我这些天来付出的点点滴滴，记载了我流下的那些汗水，我想它会成为我以后快速进入会计领域的一笔宝贵财富。会计实训报告
（四）：会计电算化实习报告
一、实践目的：会计是指对具体事物进行计算、记录、收集他们的有关数据资料，透过加工处理转换为用户决策有用的财务信息。会计作为一门应用性的学科、一项重要的经济管理工作，是加强经济管理，提高经济效益的重要手段，经济管理离不开会计，经济越发展会计工作就显得越重要。会计工作在提高经济在企业的经营管理中起着重要的作用，其发展动力来自两个方面：一是社会经济环境的变化；二是会计信息使用者信息需求的变化。前者是更根本的动力，它决定了对会计信息的数量和质量的需求。本世纪中叶以来，以计算机技术为代表的信息技术革命对人类社会的发展产生了深远的影响，信息时代已经成为我们所处的时代的恰当写照。在这个与时俱进的时代里，无论是社会经济环境，还是信息使用者的信息需要，都在发生着深刻变化。会计上经历着前所未有的变化，这种变化主要体此刻两个方面：一是会计技术手段与方法不断更新，会计电算化已经或正在代替手工记账，而且在企业建立内部网状况下，实时报告成为可能。二是会计的应用范围不断拓展，会计的变化源于企业制造环境的变化以及管理理论与方法的创新，而后两者又起因于外部环境的变化。学习好会计工作不仅仅要学好书本里的各种会计知识，而且也要认真用心的参与各种会计实习的机会，
让理论和实践有机务实的结合在一齐，只有这样才能成为一名高质量的会计专业人才。
二、实践资料：会计学是一门实践性很强的学科，经过一学期的专业学习考取了会计从业资格证后，在坚信实践是检验真理的唯一标准下，认为只有把书上学到的理论知识应用于实际的会计操作中去，才能真正掌握这门知识。从而加强自我对所学专业知识的理解，培养实际操作的动手潜力将理论与实践有机地结合起来提高运用会计财务管理的技能水平，为今后的会计工作做铺垫。
实践期间，我主要是了解公司正在使用的财务软件系统的使用和会计处理的流程，并做一些简单的会计凭证。在这学期的在校学习与参与会计从业资格证的备考过程中，我已经初步了解了手工账务处理程序和会计电算化。为了更好的了解实际工作中的会计电算化的全面流程，我充分利用为期一周的社会实践去体验理论与实践的差异。公司采用的是金蝶财务软件，从编制记账凭证到记账、编制会计报表、结帐都是透过财务软件完成。我认真学习了正规而标准的公司会计流程，真正从课本中走到了现实中，细致地了解了公司会计工作的全部过程，掌握了金蝶财务软件的操作。实践期间我努力将自我在学校所学的理论知识向实践方面转化，尽量做到理论与实践相结合。在实践期间我遵守了工作纪律，不迟到、不早退，认真完成领导交办的记账工作。在这次实习中不仅仅让我深刻的感受到手工记账到会计电算化的使用对会计工作的重大好处还让我明白了会计电算化的必要性。以下是我的实践望老师予以指正错误之处。
三、实习体会：⒈会计电算化的定义及其特点会计电算化是现代经济管理活动的一个重要组成部分，是会计发展的一个历史性的飞跃，是以计算机替代人工记账、算账、报账以及对会计信息进行分析和利用的过程。它是管理现代化和会计自身改革以及发展的需要。近些年，会计电算化的推广与普及，大大减轻了财务人员的工作强度，提高了会计的工作效率与工作质量，但不容忽视的是它对传统的会计形式产生了巨大的影响。
⒉会计电算化的好处由于会计电算化是以计算机以及数据传输和通讯设备作为数据处理系统的核心，完成从原始数据的搜集，以及经由记录、验证、分类、登记、计算、汇总、报告等一系列会计工作，因此，在此过程中，会计人员只进行一些辅助性的操作，即只需把会计数据以规定的要求输入处理系统，计算机即可按照事先编制好的程序，自动完成会计数据处理，并将最终结果——-财务报告打印出来。会计电算化是把系统工程、电子计算机技术等科学与会计理论和方法融为一体，透过货币计量信息和其他有关信息的输入、存储、运算和输出，以现代机器工作代替手工操作，实现会计工作方式的变革和人的解放，带给计划和控制经济过程需要的会计信息。
会计电算化系统使得会计人员从财务账册中解放出来，但并未从根本上提高财务信息质量另外，系统的信息处理一般都是对手工会计职能的自动化，系统的结构是面向任务和职能的，这对满足会计核算的要求来说已经足够，但在业务流程的控和与其他系统的集成性上还需要加以完善。当企业发生危机时，它又总是首先反映在财务危机上，不是缺少现金，就是缺乏持续经营所需的资本。在这种状况下，产生于上个世纪90年代的ERP系统成了企业的一个新选取。
五、实践总结：透过本次实践，我深刻体会到会计电算化是会计史上崭新的一页。电子计算机的应用，首先带来数据处理工具的改变，也带来了信息载体的变化，会计电算化后对传统会计方法、会计理论都将发生巨大的影响，从而引起会计制度、会计工作管理制度的变革。会计电算化促进着会计信息的规范化、标准化、通用化，促进着管理的现代化。在本次的实践过程中，不仅仅培养了我实际的动手潜力，增加了实际的财务工作的过程有了一个新的认识。而且充分认识到了自我的不足。会计本来就是一项十分烦琐的工作，所以在实际操作过程中需百倍用心、细心。切忌：粗心大意、心浮气躁。本次实践已到达了预期目的，超多的会计专业知识与社会知识相结合，既巩固了专业知识，又学到了社会知识，对我今后的就业有极大的帮忙。透过这次暑期社会实践我对记账的会计岗位有了一个深层次的认识。我找到了专业知识的漏洞，对好多基础性知识还不是很肯定，需要重新回顾学习。对会计岗位人员要求的细致、耐心有了切实的体会，明确自我需要努力的方向。在会计实务的操作过程中企业的财会人员均认真执行《会计法》进一步加强财务基础工作的指导，规范记帐凭证的编制，严格对原始凭证的合理性、合法性进行审核，强化会计档案的保管工作。社会实践是挑
战也是机遇，只有很好的把握才能体现它的好处。这次会计实践工作中，我可谓受益匪浅，它为我步入社会奠定了基础，为我以后的就业找工作指明了方向。卡耐基说：“成功毫无技巧可言，我一向只对工作尽力而为而已。巨大的成功也不会一蹴而就，我们需要一步一步地进步。”诚然，短暂而又充实的暑期社会实践就这样结束了，其中汗水很多，知识技能很多，感慨充实的回忆也很多。
会计实训报告
（五）：
一、实习的目的和要求暑期社会实践是对会计专业进行认识社会的实践环节。利用假期对社会进行调查，接近社会、了解社会、利用所学的会计专业知识服务于社会，要求深入到企业和事业单位进行认真仔细地调查，对调查的资料和结果进行认真的分析和研究并得出相应的结论。对于以后毕业将要工作的本专业能够更好地适应工作岗位，更能适应社会要求。
二、实践状况这次暑假，我来到了我们当地的一家纺织厂，透过熟人的介绍，进入了该厂的财务部门实习，财务部门只有几个人，其中有一名经验丰富的中级会计师，发挥实际作用的是这位中级会计师。开始单位没有让我干什么，观察我是否有耐性全身心的投入本行业。然后是大批量的工作，数量和难度都很大但是要求不高，这是考察我的潜力，也让我找到自我的位置。单位里完全按潜力来分配待遇，而不是学历。社会的准则就是不能劳动的人就是废物，即便你是大、文化高、素质高、说话有水平、气质高、斯文做作等等。山外有山，人外有人，虚心向他人学习有真材实学才是当务之急。
作为学习了这么长时间会计的我们，能够说对会计基本上能耳目能熟了。有关会计的专业基础知识、基本理论、基本方法和结构体系，我们都基本掌握。透过实践了解到，这些似乎只是纸上谈兵。倘若将这些理论性极强的东西搬上实际上应用，那我们也会是无从下手，一窍不通。下方就是我透过这次会计实习中领悟到的很多书本上所不能学到的会计的特点和积累，以及题外的很多道理。
会计实践中最实际的就是做账，做账看起来很简单，但是实践起来，很繁琐。会计做账的每一个步骤会计制度都是有严格的要求的，例如写错数字就要用红笔划横线，再盖上职责人的章，才能作废。对于数字书写也有严格要求，字迹必须要清晰，按格填写。并且记账时要清楚每一明细分录及总账名称，不能乱写，要做到谨慎处理。每一笔业务的发生，都要根据其原始凭证，一一登记入账凭证，记明细账、日记账、总账等。漏账、错账的更正都不允许随意添改，不容弄虚作假。
该厂每一天每月都有结账，每一账页要结一次，每个月也要结一次，还有许多税务方面的账要记，计算时总是会出现许多大大小小的问题，还好会计总是能耐心的教我，从他那学到了不少知识。登账的方法：首先要根据业务的发生，取得原始凭证，将其登记记账凭证。然后，根据记账凭证，登记其明细账。期末，填写科目汇总表以及试算平衡表，
最后才把它登记入总账。结转其成本后，根据总账合计，填制资产负债表、利润表、损益表等年度报表。这是会计操作的一般顺序和基本流程，在工作中要安格按照要求去做，不能有任何投机取巧的想法。在实践中我也发现，会计具有很强的连通性、逻辑性和规范性。其一，每一笔业务的发生，都要根据其原始凭证，登记入记账凭证、明细账、日记账、三栏式账、多栏式账、总账等等可能连通起来的账户。其二，会计的每一笔账务都有依有据，而且是逐一按时间顺序登记下来的，极具逻辑性。其三，在会计的实践中，漏账、错账的更正，都不允许随意添改，不容弄虚作假。每一个程序、步骤都得以会计制度为前提、为基础。体现了会计的规范性。
透过一年多的会计知识的学习，积累了一些有关会计的专业基础知识，基本理论，基本方法，但是在实践中，尤其是刚开始实习的时候，并不能把课本的知识和实践结合起来，总是在出错，出错之后总是在改，有时候需要改好几遍才能做对账，使得我不得不带着课本去工作，时刻检查自我的工作有没有按照要求来做。下方是我总结的几个在会计实际操作中就应认真履行的原则及注意事项。
(一)：期初建账及余额的录入会计是对一个会计主体在一段会计期间的经济业务的反应，督、预策、决策等。首先我们得从建账开始，建账就是要根据公司有可能发生的经济资料做一个初步的规划，除了企业务必有的科目之外，还就应从实际的经济业务中来开设相应的会计科目。因为会计科目是反应企业经济业务记录核算的基础，根据企业的起初账务状况，建好总账和明细账，然后就是期初余额的录入，如实地将企业前期余额反映在所建的总账和明细账上。
(二)：填制会计凭证，并对凭证进行审核在设置好会计科目和建好总账明细账的状况下，就是要按照时间顺序对公司所发生的每一笔经济业务，依据原始凭证进行填制记账凭证，在填制记账凭证的时候要认真审核原始凭证是否贴合要求，依据审核后的原始凭证真实地填制记账凭证。在实训的过程中，我们用的是双金额式的记账凭证，有时候不留意就会将金额的方向填错，在记账凭证上还要如实的记录原始凭证的张数，在记账凭证的背面还要粘贴好原始凭证，真实的反映企业的每一笔经济业务的资料，做好记账凭证以后交给会计前辈审核一下，之后就能够登记总账和明细账了。
(三)：会计帐簿的登记与结帐记账凭证透过审核后就能够进行登记账簿工作，登记总账就是把已经签字了的记账凭证做为依据，逐笔将经济业务记录在总帐和明细账中，以便期末对经济业务的汇总核算，如实的反映企业在一个会计期间内所发生的经济业务。在会计期末时依据总账和明细账进行成本的核算和利润的分配，登记总帐和明细账必须要细心，不能出现金额的错误，或者方向的错误，因为记录错误的总帐和明细账是不能如实的反映企业经济业务的，会导致期末科目汇总时的数据不真实，试算不平衡等等多方面的问题，从而不能结帐，而且在反查账务的时候工作复杂力度加大了。给会计工作的时间上造成了推移，不能及时的反映经济状况，所以，早登记总帐和明细账的过程中我们主要把握好谨慎性原则，才能如实的不记账凭证完整的登记入账。
最新2018最新会计实训报告可以看看这篇名叫印象中的中秋的文章，可能你会获得更多2018最新会计实训报告 说真的，我对中秋没啥印象，早年生活在乡下时，像中秋这样的节日过得并不多，唯一有印象的是有一年家里打糍粑，味道怎样是忘了，只记得二姨父打糍粑的动作让我很想一试。后来在上高中时有一次班里组织中秋晚会，我和文艺委员当主持人，还表演了一个唱歌节目，但现在想来很搞笑。
再后来就是我刚从大学毕业工作那一年，刚好国家开始将中秋节纳入国家法定节假日里，并且那一年是中秋连着国庆放了8天，我了个去，太爽了，我直接躺沙发上看了三天的电影，那年中秋，是过得最让人回忆的，因为那一年，我从学校出来，通过自己的努力找了一份好工作，让我毫无负担地躺在沙发上享受生活。那几天秋阳暖照，夹带着桂花香的微风穿堂而过，还有一只小猫来家里作了几天客，当时我以为它准备定居，结果当我和陈江为它准备好一个猫碗时，就再也没有看到过它。
年龄越大，对我们小时候翘首以待的节日越没有感觉，无论是中秋，还是春节，总感觉少了一味兴奋剂一样。我想也许是我们现在更愿意享受生活中的宁静，驱车远离都市去看一片山一片海，或者坐在窗前看人群熙熙攘攘，听鸟语花香，不知道这是不是老了的象征。 别的不说了，祝不不博客读者2015中秋愉快，合家欢乐。 明月千里寄相思，分享给大家。
数据结构实训报告