您的位置：360文档中心› 计算机软件基础(太原科技大学)实验五

计算机软件基础(太原科技大学)实验五

合集下载

计算机软件技术基础实验报告

计算机软件技术基础实验报告

学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：实验四二叉树的建立与遍历一、实验目的1.掌握二叉树的建立、显示、节点数目、树深度等操作的程序实现。

2.掌握二叉树的先序、中序、后序遍历操作的程序实现。

3.加深对树的基本概念,基本理论及相应遍历算法的掌握与理解。

二、实验用软件和工具实验软件 VC++ 6.0三、实验步骤建立一棵二叉树、设计二叉树的节点数目、树深度等操作实现算法、调试并输出一棵树及其节点数目、树深度；编写一个程序实现如下功能：二叉树的先序、中序、后序遍历操作的程序实现，调试并输出结果。

1.定义一个二叉树结构体。

2.建立并显示一棵二叉树。

3.求二叉树的节点数目、树深度。

4.计算度为2，度为1的结点。

5.二叉树的先序、中序、后序遍历。

四、实验程序与程序运行结果/*二叉树的基本操作*/#include <stdio.h>#include <malloc.h>#define MaxSize 100#define MaxWidth 40typedef char ElemType;typedef struct node{ElemType data;struct node *left,*right;} BTree;void creatree(BTree **BT,char *str){BTree *stack[MaxSize],*p;int top=-1,k,j=0;/*top为栈指针,k指定是左还是右孩子,j为str指针*/char ch;学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：*BT=NULL;ch=str[j];while (ch!='\0'){switch(ch){case '(':top++;stack[top]=p;k=1; /*为左结点*/break;case ')':top--;break;case ',':k=2; /*为右结点*/break;default: p=(BTree *)malloc(sizeof(BTree));p->data=ch;p->left=p->right=NULL;if (*BT==NULL) /*根结点*/*BT=p;else{switch(k){case 1:stack[top]->left=p;break;case 2:stack[top]->right=p;}}}j++;ch=str[j];}}void disptree(BTree *BT){BTree *stack[MaxSize],*p;int level[MaxSize][2],top,n,i,width=4;if (BT!=NULL){printf("\n凹入表示法:\n");top=1;stack[top]=BT; /*根结点入栈*/level[top][0]=width;while (top>0){p=stack[top]; /*退栈并凹入显示该结点值*/n=level[top][0];for (i=1;i<=n;i++) /*其中n为显示场宽,字符以右对齐显示*/printf(" ");printf("%c",p->data);for (i=n+1;i<=MaxWidth;i+=2)printf("━");printf("\n");学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：top--;if (p->right!=NULL){ /*将右子树根结点入栈*/top++;stack[top]=p->right;level[top][0]=n+width; /*显示场宽增width*/level[top][1]=2;}if (p->left!=NULL){ /*将左子树根结点入栈*/top++;stack[top]=p->left;level[top][0]=n+width; /*显示场宽增width*/level[top][1]=1;}}}}int BTreeDepth(BTree *BT){int leftdep,rightdep;if (BT==NULL)return(0);else{leftdep=BTreeDepth(BT->left);rightdep=BTreeDepth(BT->right);if (leftdep>rightdep)return(leftdep+1);elsereturn(rightdep+1);}}int nodecount(BTree *BT){if (BT==NULL)return(0);elsereturn(nodecount(BT->left)+nodecount(BT->right)+1);}int leafcount(BTree *BT){if (BT==NULL)return(0);else if (BT->left==NULL && BT->right==NULL)return(1);elsereturn(leafcount(BT->left)+leafcount(BT->right));}int notleafcount(BTree *BT){学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：if (BT==NULL)return(0);else if (BT->left==NULL && BT->right==NULL)return(0);elsereturn(notleafcount(BT->left)+notleafcount(BT->right)+1);}int onesoncount(BTree *BT){if (BT==NULL)return(0);else if ((BT->left==NULL && BT->right!=NULL) ||(BT->left!=NULL && BT->right==NULL))return(onesoncount(BT->left)+onesoncount(BT->right)+1);elsereturn(onesoncount(BT->left)+onesoncount(BT->right));}int twosoncount(BTree *BT){if (BT==NULL)return(0);else if (BT->left==NULL || BT->right==NULL)return(twosoncount(BT->left)+twosoncount(BT->right));else if (BT->left!=NULL && BT->right!=NULL)return(twosoncount(BT->left)+twosoncount(BT->right)+1);}void printree(BTree *BT){if (BT!=NULL){printf("%c",BT->data);if (BT->left!=NULL || BT->right!=NULL){printf("(");printree(BT->left);if (BT->right!=NULL)printf(",");printree(BT->right);printf(")");}}}main(){BTree *B;char *s="A(B(D,E(H,I)),C(G))";creatree(&B,s);disptree(B);printf("二叉树括号表示:");printree(B);printf("\n二叉树深度:%d\n",BTreeDepth(B));学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：printf("总结点个数:%d\n",nodecount(B));printf("叶子结点个数:%d\n",leafcount(B));printf("非叶子结点个数:%d\n",notleafcount(B));printf("具有双孩子结点个数:%d\n",twosoncount(B));printf("具有单孩子结点个数:%d\n",onesoncount(B));}/*二叉树遍历*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct node{ElemType data;struct node *left,*right;} BTree;void creatree(BTree **BT,char *str){BTree *stack[MaxSize],*p;int top=-1,k,j=0;/*top为栈指针,k指定是左还是右孩子,j为str指针*/char ch;*BT=NULL;ch=str[j];while (ch!='\0'){switch(ch){case '(':top++;stack[top]=p;k=1; /*为左结点*/break;case ')':top--;break;case ',':k=2; /*为右结点*/break;default: p=(BTree *)malloc(sizeof(BTree));p->data=ch;p->left=p->right=NULL;if (*BT==NULL) /*根结点*/*BT=p;else{switch(k){case 1:stack[top]->left=p;break;case 2:stack[top]->right=p;}}}j++;ch=str[j];}学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：}void preorder(BTree *BT){if (BT!=NULL){printf("%c",BT->data);preorder(BT->left);preorder(BT->right);}}void inorder(BTree *BT){if (BT!=NULL){inorder(BT->left);printf("%c",BT->data);inorder(BT->right);}}void postorder(BTree *BT){if (BT!=NULL){postorder(BT->left);postorder(BT->right);printf("%c",BT->data);}}main(){BTree *B;char *s="A(B(D,E(H,I)),C(G))";creatree(&B,s);printf("\n先序遍历:");preorder(B);printf("\n中序遍历:");inorder(B);printf("\n后序遍历:");postorder(B);}试验运行结果如图：学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：五、实验心得与体会通过本次上机实验，我掌握了二叉树的建立、显示、节点数目、树深度等操作的程序实现，以及二叉树的先序、中序、后序遍历操作的程序实现，对树与二叉树的遍历，尤其是广度优先遍历和深度优先遍历的理解进一步加深，收获很多啊。

计算机软件技术基础上机实验报告

计算机软件技术基础上机实验报告
h->next=null;/*创建头结点*/
return h;
}
pushls(slnode *h,int x)/*把数据元素插入栈中*/
{slnode *p;
p=(slnode *)malloc(sizeof(slnode));
p->data=x;
p->next=h->next;
h->next=p;
j++;}
if(j!=i-1)
{printf("i is invalid!");return 0;}
else
{if(p->next==null)
{ printf("i is invalid!");
return 0;}
else
{ s=p->next;
p->next=s->next;
free(s);
return h;}
{p=h->next;
h->next=p->next;
ch=p->data;
printf("%5d",ch);}
printf("\n");
}
三、队
3.1顺序队
实验内容：队的顺序存储结构的定义、创建、插入和删除，
将数据元素显示出来。
源程序
#include<stdio.h>
#define max 10
typedef struct
/*在第i个结点处插入数据元素x*/
{slnode *p,*s;
int j;p=h;j=0;
while(p->next!=null&&j<i-1)

计算机软件技术基础实验报告

计算机软件技术基础实验报告

学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：实验七SQL 简单查询、连接查询和子查询一、实验目的1.掌握在查询分析器中使用SELECT语句进行简单查询。

2.熟练掌握简单表的数据查询、数据排序和数据连接查询的操作方法。

3.熟练掌握数据查询中的分组、统计、计算和组合的操作方法。

4.观察查询结果, 体会SELECT语句实际应用二、实验用软件和工具1．计算机。

实验软件 VC++ 6.02．SQL Server2005软件。

三、实验步骤1 简单查询操作此部分查询包括投影、选择条件表达、数据排序、使用临时表等。

对EDUC（shiyan6）数据库实现以下查询：（1）求信电学院的学生学号和姓名；（2）求选修了课程的学生学号；（3）求选修C1 课程的学生学号和成绩，并要求对查询结果按成绩的降序排列，如果成绩相同则按学号的升序排列；（4）求选修课程C1 且成绩在80－90 之间的学生学号和成绩，并将成绩乘以系数0.75 输出；（5）求计算机系和数学系的姓张的学生的信息；（6）求缺少了成绩的学生的学号和课程号。

2 连接查询操作对EDUC（shiyan6）数据库实现以下查询：（1）查询每个学生的情况以及他（她）所选修的课程；（2）求学生的学号、姓名、选修的课程名及成绩；（3）求选修C1 课程且成绩在90 分以上的学生学号、姓名及成绩；（4）查询每一门课的间接先行课。

3．子查询操作，在数据库EDUC（shiyan6）中实现查询：学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：（1）求选修了高等数学的学生学号和姓名；（2）求C1 课程的成绩高于张三的学生学号和成绩；（3）求其他系中比计算机系某一学生年龄小的学生信息（即求其它系中年龄小于计算机系年龄最大者的学生）；（4）求其他系中比计算机系学生年龄都小的学生信息；（5）求选修了C2 课程的学生姓名；（6）求没有选修C2 课程的学生姓名；（7）查询选修了全部课程的学生的姓名；（8）求至少选修了学号为“S2”的学生所选修的全部课程的学生学号和姓名。

计算机软件基础实验报告(C语言)

计算机软件基础实验报告(C语言)

计算机软件基础实验报告一．实验目的1.熟悉C语言的使用，编辑算法实现特定要求。

2.熟悉Huffman树的编码程序和数组元素的比较程序等。

二．实验内容和要求1.实验内容1）试设计一算法，从包括n个元素的数组中，求最大和最小元素，并使得当n 个元素为有序排列时，元素之间的比较次数仅为n-1次。

2）在给出的Huffman编码源程序基础上，要求画出Huffman树，求出与等长编码相比时的压缩比。

2.实验要求1）根据实验内容编写算法，并用 C 语言进行程序设计。

2）将所编程序在计算机上调试通过，并全面测试。

3）整理完成实验报告，包括：姓名、学号、实验日期等。

三．程序清单1.#include<iostream.h>int main(){int n,max,min;cout<<"请输入数组大小"<<endl;cin>>n;int *a=new int [n];//输入数组for(int i=0;i<n;i++){cin>>a[i];}//比较排序for(int k=0;k<n-1;k++)for(int j=k+1;j<n;j++){if(a[k]>a[j]){int temp=0;temp=a[k];a[k]=a[j];a[j]=temp;}}//为最大值和最小值赋值max=a[n-1];min=a[0];//输出结果cout<<"排序后的序列"<<endl;for(int l=0;l<n;l++)cout<<" "<<a[l];cout<<endl;cout<<"max= "<<max<<" min= "<<min<<endl;return 0;}2.#include <dos.h>#include <conio.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <math.h>typedef struct{unsigned int weight; //结点权值unsigned int parent,lchild,rchild; //结点的父指针，左右孩子指针}HTNode,*HuffmanTree; //动态分配数组存储哈夫曼树typedef char **HuffmanCode; //动态分配数组存储哈夫曼编码表void CreateHuffmanTree(HuffmanTree &,unsigned int*,int ); //生成哈夫曼树void HuffmanCoding(HuffmanTree,HuffmanCode &,int,unsigned int* ); //对哈夫曼树进行编码void PrintHuffmanCode(HuffmanCode,unsigned int*,int,unsigned int*); //显示哈夫曼编码void Select(HuffmanTree,int,int&,int&); //在数组中寻找权值最小的两个结点void drawHT(int,unsigned int* ,unsigned int*);int powlen(int);void ptspace(int );int mstep(int);void main(){HuffmanTree HT; //哈夫曼树HTHuffmanCode HC; //哈夫曼编码表HCint n,i; //n是哈夫曼树叶子结点数unsigned int *w,*num; //w存放叶子结点权值char j='y';printf("演示构造哈夫曼树.\n");printf("输入需要进行编码的字符数目.\n例如:8\n");printf("然后输入每个字符出现的次数/权值.\n");printf("例如:5 29 7 8 14 23 3 11\n");printf("自动构造一棵哈夫曼树并显示哈夫曼编码.\n");printf(" 5---0110\n 29---10\n 7---1110\n 8---1111\n 14---110\n");printf(" 23---00\n 3---0111\n 11---010\n");while(j!='N'&&j!='n'){printf("请输入字符数目:");scanf("%d",&n); //输入字符数目if(n<=1) {printf("该数不合理!\n");continue;}w=(unsigned int*)malloc(2*n*sizeof(unsigned int)); //开辟空间存放权值num=(unsigned int*)malloc(2*n*sizeof(unsigned int));printf("请输入各字符出现的次数/权值:\n");for(i=0;i<n;i++) scanf("%d",&w[i]); //输入各字符出现的次数/权值CreateHuffmanTree(HT,w,n); //生成哈夫曼树HuffmanCoding(HT,HC,n,w); //进行哈夫曼编码PrintHuffmanCode(HC,w,n,num); //显示哈夫曼编码printf("\n");drawHT(n,w,num);printf("哈夫曼树构造完毕，还要继续吗?(Y/N)");free(w);free(num);scanf(" %c",&j);}}void CreateHuffmanTree(HuffmanTree &HT,unsigned int *w,int n){//w存放n个结点的权值，将构造一棵哈夫曼树HTint i,m;int s1,s2;HuffmanTree p;if(n<=1) return;m=2*n-1; //n个叶子结点的哈夫曼树，有2*n-1个结点HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode)); //开辟2*n各结点空间for(p=HT+1,i=1;i<=n;++i,++p,++w) //进行初始化{ p->weight=*w;p->parent=0;p->lchild=0;p->rchild=0;}for(;i<=m;++i,++p){p->weight=0;p->parent=0;p->lchild=0;p->rchild=0;}for(i=n+1;i<=m;++i) //建哈夫曼树{Select(HT,i-1,s1,s2);//从HT[1...i-1]中选择parent为0且weight最小的两个结点，其序号分别为s1和s2HT[s1].parent=i; HT[s2].parent=i; //修改s1和s2结点的父指针parentHT[i].lchild=s1; HT[i].rchild=s2; //修改i结点的左右孩子指针HT[i].weight=HT[s1].weight+HT[s2].weight; //修改权值}}void HuffmanCoding(HuffmanTree HT,HuffmanCode &HC,int n,unsigned int* w) {//将有n个叶子结点的哈夫曼树HT进行编码，所编的码存放在HC中//方法是从叶子到根逆向求每个叶子结点的哈夫曼编码int i,c,f,start;char *cd;HC=(HuffmanCode)malloc((n*2)*sizeof(char *)); //分配n个编码的头指针向量cd=(char *)malloc(n*sizeof(char)); //开辟一个求编码的工作空间cd[n-1]='\0'; //编码结束符for(i=1;i<2*n;++i) //逐个地求哈夫曼编码{start=n-1;//编码结束位置if(i>n)w[i-1]=HT[i].weight;for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent) //从叶子到根逆向求编码{if(HT[f].lchild==c)cd[--start]='0'; //若是左孩子编为'0'elsecd[--start]='1'; //若是右孩子编为'1' }HC[i]=(char *)malloc((n-start)*sizeof(char)); //为第i个编码分配空间strcpy(HC[i],&cd[start]); //将编码从cd复制到HC中}free(cd); //释放工作空间}void PrintHuffmanCode(HuffmanCode HC,unsigned int *w,int n,unsigned int *num) {//显示有n个叶子结点的哈夫曼树的编码表int i,j,temp,len,x,ly=0;float mux=0;j=powlen(n);printf("HuffmanCode is :\n");for(i=1;i<2*n;i++){temp=atoi(HC[i]);len=strlen(HC[i]);if(i<=n){printf(" %3d---",w[i-1]);puts(HC[i]);mux+=len*w[i-1];ly+=w[i-1];}x=(int)pow(2.0,len);num[i-1]=mstep(temp)+x-1;}mux/=ly;printf("\n");printf("压缩比是%f",j/mux);}void Select(HuffmanTree HT,int t,int&s1,int&s2){//在HT[1...t]中选择parent不为0且权值最小的两个结点，其序号分别为s1和s2 int i,m,n;m=n=10000;for(i=1;i<=t;i++){if(HT[i].parent==0&&(HT[i].weight<m||HT[i].weight<n))if(m<n){n=HT[i].weight;s2=i;}else{m=HT[i].weight;s1=i;}}if(s1>s2) //s1放较小的序号{i=s1;s1=s2;s2=i;}}int mstep(int a){int i=1,x=0,mod;if(a==0)return 0;while(a){mod=a%10;if(mod==1){x=x+i;}a=a/10;i=i*2;}return x;}void ptspace(int x){int i=0;for(i=0;i<x;i++)printf(" ");}void drawHT(int n,unsigned int *w,unsigned int*num){int i=0,j=1,k=1,m=2*n-1,xu=1,t=2;int x[500]={0};for(i=0;i<2*n-1;i++){x[num[i]]=w[i];}i=0;do{ptspace(64/t);for(xu=j;(xu<j*2);xu++){if(x[xu-1]!=0){printf("%d",x[xu-1]);i++;}elseprintf(" ");ptspace(2*64/t-1);}t*=2;j*=2;printf("\n");}while(i<2*n-1);}int powlen(int n){int i=2,j=1;float mux=0;while(n>i){i=i*2;j=j+1;}return j;}四．所输入的数据及运行结果1.2.五．实验心得通过此次实验，对于此次实验要求中的程序设计有了一定的认识。

计算机软件技术基础实验报告

计算机软件技术基础实验报告

学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：实验二栈和队列的基本操作一、实验目的1.掌握栈与队列的数据类型描述及特点；2.掌握栈和队列的存储；3.掌握栈的顺序和链式存储存表示与入栈、出栈操作的程序实现；4. 掌握队列的链式存储表示与入队、出队基本操作算法实现。

二、实验用软件和工具实验软件 VC++ 6.0三、实验步骤1.根据栈数据结构，分别建立一个顺序栈和链式栈并实现其上基本操作（出栈和入栈等）,定义一个顺序栈和链栈结构体（队列结构体）。

2.利用入栈功能保存数据。

3.利用出栈删除弹出栈内信息。

4.根据队列数据结构，分别建立链队列和循环队列，并完成其上的基本操作（出入队列等）,利用入队功能保存数据。

5.利用出队删除队列信息。

四、实验程序与程序运行结果顺序栈程序：sxz.h#include <iostream>using namespace std;template <class T>class sq_Stack{private:int mm;int top;T *s;public:sq_Stack(int);void prt_sq_Stack();void ins_sq_Stack(T x);T del_sq_Stack();T read_sq_Stack();学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：};template <class T>sq_Stack<T>::sq_Stack(int m){mm=m;s = new T[mm];top=0;return;}template <class T>void sq_Stack<T>::prt_sq_Stack(){int i;cout<<"top="<<top<<endl;for (i=top;i>0;i--) cout<<s[i-1]<<endl;return;}template <class T>void sq_Stack<T>::ins_sq_Stack(T x){if (top==mm){cout<<"overflow!"<<endl; return;}//存储空间已满，上溢错误top=top+1; //s[top-1]=x; //插入新元素return;}template<class T>T sq_Stack<T>::del_sq_Stack(){T y;if(top==0) //空，下溢错误{cout<<"underflow!"<<endl; return(0);}y=s[top-1]; //top=top-1; //长度减1return(y);}template<class T>T sq_Stack<T>::read_sq_Stack(){if(top==0) //空，下溢错误{cout<<"underflow!"<<endl; return(0);}return(s[top-1]);学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：}sxz.cpp#include "sq_Stack.h"int main(){sq_Stack<int> s(10);s.ins_sq_Stack(50);s.ins_sq_Stack(60);s.ins_sq_Stack(70);s.ins_sq_Stack(80);s.ins_sq_Stack(90);s.ins_sq_Stack(100);cout<<"第1次输出栈顶指针与栈中的元素:"<<endl;s.prt_sq_Stack();cout<<"输出栈顶元素:"<<s.read_sq_Stack()<<endl;cout<<"输出退栈的元素:"<<endl;cout<<s.del_sq_Stack()<<endl;cout<<s.del_sq_Stack()<<endl;cout<<s.del_sq_Stack()<<endl;cout<<"再输出栈顶指针与栈中的元素:"<<endl;s.prt_sq_Stack();return 0;}顺序队列程序：sq_Queue.h#include <iostream>using namespace std;template <class T>class sq_Queue{private:int mm;int front;int rear;int s;T *q;public:sq_Queue(int) ;void prt_sq_Queue();void ins_sq_Queue(T x);T del_sq_Queue();};template <class T>sq_Queue<T>::sq_Queue(int m){mm=m;q = new T[mm];front=mm;学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：rear=mm;s=0;return;}template <class T>void sq_Queue<T>::prt_sq_Queue(){int i;cout<<"front="<<front<<endl;cout<<"rear="<<rear<<endl;if ((s==0)&&(rear==front)){cout<<"队列空!"<<endl; return;}i=front;if (front>=mm)front=i%mm ;for (i=front; i<rear;i++){ cout<<q[i]<<endl;}return;}template <class T>void sq_Queue<T>::ins_sq_Queue(T x){if ((s==1)&&(rear==front)){cout<<"Queue_overflow!"<<endl; return;}//存储空间已满，上溢错误rear=rear+1; //if (rear==mm+1)rear=1;q[rear-1]=x; //插入新元素s=1;return;}template <class T>T sq_Queue<T>::del_sq_Queue(){T y;if (s=0){cout<<"Queue_underflow!"<<endl; return(0);}//存储空间已满，上溢错误front=front+1; //if (front==mm+1)front=1;y=q[front-1]; //插入新元素if (rear==front)s=0;return(y);}sq_Queue.cpp学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：#include "sq_Queue.h"int main(){sq_Queue<int> q(10);q.prt_sq_Queue();q.ins_sq_Queue(50);q.ins_sq_Queue(60);q.ins_sq_Queue(70);q.ins_sq_Queue(80);q.ins_sq_Queue(90);q.ins_sq_Queue(100);cout<<"输出队头与队尾指针及队列中的元素:"<<endl;q.prt_sq_Queue();cout<<"输出退队元素:"<<endl;cout<<q.del_sq_Queue()<<endl;cout<<q.del_sq_Queue()<<endl;cout<<q.del_sq_Queue()<<endl;cout<<"再输出队头与队尾指针及队列中的元素:"<<endl;q.prt_sq_Queue();return 0;}链栈：#include <iostream.h>#include <stdio.h>#include <stdlib.h>typedef char DateType;typedef struct node{DateType data;struct node* next;}LinkStack;LinkStack *top;void InitStack(){top=(LinkStack*)malloc(sizeof(LinkStack));top->next=NULL;top->data=0;cout<<"初始化链栈成功!";}void push(DateType x){LinkStack* s;s=(LinkStack*)malloc(sizeof(LinkStack));s->data=x;s->next=top;top=s;cout<<"入栈成功!";}学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：void pop(){LinkStack* s;s=top;if(s->next==NULL){cout<<"栈为空!";}else{top=s->next;free(s);cout<<"出栈成功";}}void readTop(){if(top==NULL){cout<<"栈为空!";}else{cout<<"栈顶元素为:"<<top->data;}}void showStack(){LinkStack* s;s=top;if(s->next==NULL){cout<<"栈为空!";}else{cout<<"链栈元素为:\n";cout<<"\t\t\t";while(s!=NULL){cout<<" "<<s->data;s=s->next;}}}void main(){int i,j;DateType x;while(j)学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：{cout<<"\n\n\n\n";cout<<"****************************************************************"<<endl; cout<<"*** 菜单：***"<<endl;cout<<"*** ①创建链栈②入栈③读栈顶元***"<<endl;cout<<"*** ④出栈⑤显示链栈元素⑥退出***"<<endl;cout<<"****************************************************************"<<endl; cout<<"请选择您所希望的操作：";cin>>i;if(i==1){InitStack();}else if(i==2){if(top==NULL){cout<<"请先初始化链表!";}else{cout<<"请输入要入栈的元素:";cin>>x;push(x);}}else if(i==3){pop();}else if(i==4){readTop();}else if(i==5){showStack();}else if(i==6){j=0;cout<<"程序结束\n";}}}链队列：#include <stdlib.h>#include<iostream.h>#define TRUE 1#define FALSE 0学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：typedef int QElemType;typedef struct LNode{QElemType data;struct LNode *next;}LNode , *LinkList;typedef struct{LinkList front;LinkList rear;}LinkQueue;//链式队列void InitQueue_L(LinkQueue &Q)//引用做参数，Q为结构体{//初始化队列Q.front=Q.rear=new LNode;if(!Q.front) {cout<<"存储分配失败！"<<endl; exit(1);}Q.front->next=NULL;}int IsEmpty(LinkQueue &Q){if(Q.front==Q.rear){return TRUE;}else{return FALSE;}}//创建队列，数据元素由键盘输入void CreateQueue_L(LinkQueue &Q){QElemType temp;LNode *p;cout<<"输入要插入的队列值（输入-1结束）"<<endl;cin>>temp;while(temp != -1){p=new LNode;p->data=temp;p->next=NULL;Q.rear->next=p;学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：Q.rear=p;cin>>temp;}cout<<"创建成功！"<<endl;}//入队操作int EnterQueue(LinkQueue &Q,QElemType x){//将数据元素x插入到队列Q中LNode *NewNode=new LNode;if(!NewNode) {cout<<"存储分配失败！"<<endl; exit(1);}if(NewNode!=NULL){NewNode->data=x;NewNode->next=NULL;Q.rear->next=NewNode;Q.rear=NewNode;cout<<"入队成功！"<<endl<<endl;return(TRUE);}else return(FALSE); //溢出}//出队操作int DeleteQueue(LinkQueue &Q,QElemType &x){//将队列Q的队头元素出队，并存放到x所指的存储空间中LNode *p;/*if(Q.front==Q.rear){cout<<"该队列为空！"<<endl;return(FALSE);}*/p=Q.front->next;x=p->data;Q.front->next=p->next; //队头元素p出队if(Q.rear==p) //如果队中只有一个元素p，则p出队后成为空队Q.rear=Q.front;free(p); //释放存储空间cout<<"出队成功！"<<endl<<endl;return(TRUE);}//队列长度int QueueLength_L(LinkQueue Q){int length=0;if(IsEmpty(Q)) cout<<"该队列为空！"<<endl;else学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：{LNode *p=new LNode;p=Q.front->next;while(p){length++;p=p->next;}}return length;}//输出队列元素void OutputQueue_L(LinkQueue Q){LNode *p=new LNode;if(!p) {cout<<"存储分配失败！"<<endl; exit(1);}if(Q.front==Q.rear) cout<<"该队列为空！"<<endl;else{p=Q.front->next;cout<<endl;cout<<"队列的元素依次为：";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl<<endl;}}QElemType SearchQueue(LinkQueue &Q,int &i){LNode *p=new LNode;if(!p) {cout<<"存储分配失败！"<<endl; exit(1);}//if(Q.front==Q.rear) cout<<"该队列为空！"<<endl;int j=1;p=Q.front->next;while(p&&j<i){j++;p=p->next;}return p->data;}学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：//销毁队列void DestroyQueue_L(LinkQueue &Q){while(Q.front){Q.rear=Q.front->next;delete Q.front;Q.front=Q.rear;}}void main(){int flag=1,select;LinkQueue Q;int x;while(flag){cout<<" ☆☆链式队列基本操作☆☆"<<endl;cout<<" ☆1.创建队列☆"<<endl;cout<<" ☆2.判断链队列是否为空☆"<<endl;cout<<" ☆3.队头元素出队☆"<<endl;cout<<" ☆4.新元素入队☆"<<endl;cout<<" ☆5.求队列长度☆"<<endl;cout<<" ☆6.输出队列元素☆"<<endl;cout<<" ☆7.查找第i个位置元素☆"<<endl;cout<<" ☆8.销毁队列☆"<<endl;cout<<" ☆9.其他键退出☆"<<endl;cout<<endl;cout<<"请选择操作：";cin>>select;switch(select){case 1:InitQueue_L(Q);CreateQueue_L(Q);OutputQueue_L(Q);break;case 2:if(IsEmpty(Q)) cout<<"该队列为空！"<<endl;else cout<<"该队列不为空！"<<endl;break;case 3:if(IsEmpty(Q)) {cout<<"队列为空！"<<endl; break;}学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：DeleteQueue(Q,x);OutputQueue_L(Q);break;case 4:if(IsEmpty(Q)) {cout<<"队列还未创建！"<<endl; break;}cout<<"输入要入队的元素x：";cin>>x;EnterQueue(Q,x);OutputQueue_L(Q);break;case 5:if(IsEmpty(Q)) {cout<<"队列还未创建！"<<endl; break;}cout<<"该链队列的长度为："<<QueueLength_L(Q)<<endl<<endl;break;case 8:if(IsEmpty(Q)) {cout<<"队列还未创建！"<<endl; break;}DestroyQueue_L(Q);cout<<"销毁成功!"<<endl<<endl;break;case 7:cout<<"请输入要查找的位置i：";cin>>x;if(x<1||x>QueueLength_L(Q)) {cout<<"i值不合法！"<<endl; break;}cout<<"该元素为："<<SearchQueue(Q,x)<<endl<<endl;break;case 6:OutputQueue_L(Q);break;default:flag=0;break;}}}试验运行结果如图：栈：学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：队列：链栈：学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：链队列：学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月25日成绩：五、实验心得与体会通过本次上机实验，我掌握了栈的顺序和链式存储存表示与入栈、出栈操作的程序实现，以及队列的链式存储表示与入队、出队基本操作算法实现。

计算机软件技术基础实验报告

计算机软件技术基础实验报告

学院：信电学院班级姓名：学号：课程：计算机软件技术基础实验日期：2013年11月24日成绩：实验九建立结构图和程序流程图一、实验目的1、掌握Microsoft visio环境。

2、掌握4种类型的模块；3、掌握建立系统结构图；4、掌握程序流程图的建立。

二、实验用软件和工具1．计算机。

2．VISIO软件。

三、实验步骤1 Microsoft OfficeVisio 环境和使用。

(1)模板:通过打开一个模板来开始创建Microsoft Office Visio图表。

模板在绘图页的左侧打开一个或多个模具。

模具包含创建图表所需的形状。

模板还包括创建特定的图表类型所需的所有样式、设置和工具。

(2)模具和形状:打开模板后，从模具中将形状拖到绘图页上来创建您的图表。

模具上的形状专门用于特定的绘图类型，并且其中的许多形状是“智能”的 - 它们具有感知绘图环境的内置行为。

(3)绘图环境:打开模板后，您将看到 Microsoft Office Visio 绘图环境，它包括菜单、工具栏、包含形状的模具、绘图页和位于绘图页右侧的任务窗格。

您在绘图页上创建绘图，所创学院：信电学院班级姓名：学号：课程：计算机软件技术基础实验日期：2013年11月24日成绩：建的绘图表示打印页面，并包含帮助调整形状位置的网格。

Visio 菜单和工具栏与其他Microsoft Office 系统程序中的菜单和工具栏类似，因此您可以用熟悉的方法打开、打印和保存图表。

（4）开始创建图表：1）打开模板：在“文件”菜单上，指向“新建”，然后单击“选择绘图类型”。

在“选择绘图类型”窗口的“类别”下，单击“软件”。

在“模板”下，单击“数据流模型图”。

2）添加形状：通过将“形状”窗口中模具上的形状拖到绘图页上，可以将形状添加到图表中。

把进程，接口，数据存储和数据流拖动到绘图页上。

3）删除形状：删除形状很容易。

只需单击绘图页上形状，然后按 DELETE 键。

单击图表中的最后一个“进程”形状，然后按 DELETE 键。

计算机软件基础实验报告

计算机软件基础实验报告

《计算机软件基础》实验报告姓名：***学号：**********班级：11电气1班专业：电气工程及其自动化学院：电气与信息工程学院2013年12月实验一线性表的插入和删除一、实验目的1.熟悉C++上机环境；2.掌握线性表的基本操作：查找、插入、删除等运算在链接存储结构上的运算。

二、实验内容【任务一】阅读理解阅读后面的程序，并将其输入到计算机中，调试成功，运算出结果。

这个程序中我们创建了一个整数类型的升序单，演示了单链表的创建、输出和删除操作。

【任务二】完善功能构造函数node *insert (node *head,int num)，实现把一个节点插入链表，仍保持链表上各节点的升序关系，并在主函数中完成对你所添加函数的测试。

三、算法描述建立含有若干个元素的升序单链表，对其进行插入、删除等操作，并将结果在屏幕上输出。

// 实验一线性表#include "stdafx.h"const int SIZE0=2;const int STEP=1;struct List{int *A,len,size;List(){A=(int *)malloc(SIZE0*sizeof(int));if(!A)exit(1);len=0;size=SIZE0;}~List(){delete[size]A;}int GetLen();void Output();int Insert(int loc,int x);int Delete(int loc,int &y);int Geti(int loc,int &y);List(int *p,int n);void StraightInsertSort();void BinaryInsertSort();void BubbleSort();int Patation(int low,int up);void QuickSort(int low,int high);void SelectSort();void Shift_down(int heapsize,int index);void DeleteNodeofHeap(int heapsize,int index);void createHeap();void HeapSort();void ShellInsert(int dk);void ShellSort(int *delta,int t);};List::List(int *p,int n){A=new int[n];for(int i=0;i<n;i++)A[i]=p[i];len=size=n;};//简单选择排序void List::SelectSort(){int i,j,temp,max;for(i=len-1;i>0;i--){max=0;for(j=1;j<=i;j++)if(A[j]>A[max])max=j;temp=A[i];A[i]=A[max];A[max]=temp;cout<<"第"<<len-i<<"趟的结果为...\n";this->Output();cout<<endl;}}//将当前A[0]~A[heapsize-1]构成的完全二叉树中下标为index的结点A[index] //在其子树T中进行下移，使T成为大头堆O(log2(heapsize))void List::Shift_down(int heapsize,int index)//大头堆{int max,temp,i=index,j=2*i+1;while(j<heapsize){max=j;if(j+1<heapsize && A[j+1]>A[j]) max=j+1; //左右子树均存在if(A[i]<A[max]){temp=A[i];A[i]=A[max];A[max]=temp;i=max;j=2*i+1;}else break;}}//删除当前A[0]~A[heapsize-1]构成的大头堆中下标为index的结点A[index]，//将其与A[heapsize-1]交换，并将A[0]~A[heapsize-2]调整为大头堆void List::DeleteNodeofHeap(int heapsize,int index){int temp=A[index];A[index]=A[heapsize-1];A[heapsize-1]=temp;Shift_down(heapsize-1,index);//cout<<"delete...\n";//this->Output();cout<<endl;};void List::createHeap() //生成大头堆O(len){int i,j,max,temp;for(i=len/2-1;i>=0;i--){max=j=2*i+1;if(j+1<len && A[j]<A[j+1])max=j+1;if(A[i]<A[max]){ temp=A[i];A[i]=A[max];A[max]=temp;} }//cout<<"createHeap()...\n";//this->Output();cout<<endl;};//堆排序O(len*log2(len))void List::HeapSort(){int i;createHeap();for(i=len;i>1;i--)DeleteNodeofHeap(i,0);};void List::ShellInsert(int dk)//升序{int i,j,temp;for(i=dk;i<len;i++){temp=A[i];for(j=i-dk;j>=0;j=j-dk){if(A[j]>temp)A[j+dk]=A[j];else break;};A[j+dk]=temp;};// this->Output();// cout<<endl;};void List::ShellSort(int *delta,int t){int k;for(k=0;k<t;k++)ShellInsert(delta[k]);};int List::Patation(int low,int up)//划分，升序{int pivot,mid,temp;//先选择枢轴if(up-low>1){mid=(low+up)/2;if(A[mid]<A[up] && A[mid]>A[low] || A[mid]<A[low] && A[mid]>A[up]) {pivot=A[low];A[low]=A[mid];A[mid]=pivot;}elseif(A[up]<A[mid] && A[up]>A[low] || A[up]<A[low] && A[up]>A[mid]) {pivot=A[low];A[low]=A[up];A[up]=pivot;}};//==========temp=A[low];//cout<<"temp="<<temp<<endl;while(up>low){while(up>low){if(A[up]>=temp) up--;else {A[low]=A[up];break;}};while(up>low){if(A[low]<=temp)low++;else {A[up]=A[low];break;}};};//cout<<"up="<<up<<"low="<<low<<endl;A[up]=temp;//this->Output();return(up);}void List::QuickSort(int low,int high){int pivot;if(low<high){pivot=Patation(low,high);QuickSort(low,pivot-1);QuickSort(pivot+1,high);};};void List::StraightInsertSort()//直接插入排序,升序{int i,j,temp;for(i=1;i<len;i++)//共len-1趟for(j=i;j>0;j--)if(A[j]<A[j-1]){temp=A[j];A[j]=A[j-1];A[j-1]=temp;}else break;};void List::BinaryInsertSort()//折半插入排序，升序{int i,j,low,up,mid,temp;for(i=1;i<len;i++){low=0;up=i-1;temp=A[i];while(up>=low){mid=(low+up)/2;if(temp<A[mid])up=mid-1;else low=mid+1;};for(j=i-1;j>=up+1;j--)A[j+1]=A[j];A[up+1]=temp;};};void List::BubbleSort()//冒泡排序，升序{int i,j,temp,tag;for(i=len-1;i>0;i--)//共len-1趟{tag=1;//逆序标志for(j=0;j<i;j++)if(A[j]>A[j+1]){temp=A[j];A[j]=A[j+1];A[j+1]=temp;tag=0;} if(tag)break;//本趟无逆序}};int List::GetLen(){return(len);}void List::Output(){for(int i=0;i<len;i++){ cout<<"A["<<i<<"]="<<A[i]<<'\x20';if((i+1)%5==0)cout<<endl;};cout<<endl;}int List::Geti(int loc,int &y){if(len==0)return(-1);if(loc<0||loc>=len)return(0);y=A[loc];return(1);}int List::Insert(int loc,int x){int *p,i;if(loc<0||loc>len)return(0);if(len==0){A[0]=x;len=len+1;return(1);};if(len==size){p=(int *)malloc((size+STEP)*sizeof(int));if(!p)return(-1);for(i=0;i<size;i++)p[i]=A[i];delete[len]A;A=p;size=size+STEP;};for(i=len;i>loc;i--)A[i]=A[i-1];A[loc]=x;len=len+1;return(1);}int List::Delete(int loc,int &y){int i;if(len==0)return(-1);if(loc<0||loc>=len)return(0);y=A[loc];for(i=loc+1;i<len;i++)A[i-1]=A[i];len=len-1;return(1);}void main(int argc, char* argv[]){int loc,value,ok,sel;char ch='N';List L1;int B[]={8,5,6,4,2,7,3,1};int delta[]={3,2,1};List L10(B,8);do{cout<<"线性表抽象数据类型及其实现\n";cout<<"1--输出线性表\n";cout<<"2--插入一元素\n";cout<<"3--删除一结点\n";cout<<"4--求表的长度\n";cout<<"5--取某位序元素\n";cout<<"6--排序\n";cout<<"66--排序(新插入的元素)\n";cout<<"7--退出\n";cout<<"请选择相应的功能（1~7）\n";cin>>sel;switch(sel){case 1:L1.Output();break;case 2:cout<<"插入一元素合法位序为：0 ~ "<<L1.GetLen()<<endl;cout<<"请输入位序和元素的值：\n";cin>>loc>>value;ok=L1.Insert(loc,value);if(ok==1)cout<<"插入成功！\n";else if(ok==0)cout<<"插入位序非法！\n";else cout<<"表满！\n";break;case 3:cout<<"删除一元素合法位序为：0~"<<L1.GetLen()-1<<endl;cout<<"请输入位序：\n";cin>>loc;ok=L1.Delete(loc,value);if(ok==1)cout<<"删除成功！删除结点的值="<<value<<endl;else if(ok==0)cout<<"删除位序非法！\n";else cout<<"表空！\n";break;case 4:cout<<"表的长度="<<L1.GetLen()<<endl;break;case 5:cout<<"取某一元素\n";cout<<"请输入位序：\n";cin>>loc;ok=L1.Geti(loc,value);if(ok==1)cout<<"第"<<loc<<"位序的值="<<value<<endl;else if(ok==0)cout<<"取值位序非法！\n";else cout<<"表空！\n";break;case 6:L10.StraightInsertSort();L10.Output();break;case 66:L1.StraightInsertSort();L1.Output();break;case 7:ch='Y';};}while(ch!='Y');}四、实验数据及截图图1在0位置插入10图2插入位序非法图3继续插入元素图4输出线性表图5删除一元素后输出图6求表的长度图7取某一元素图8排序（原程序）图9 输出和排序新插入的元素（程序修改后）图10退出实验二栈抽象数据及实现一、实验目的1．掌握栈的数据类型描述、站的特点及栈的存储结构；2．掌握栈的基本运算及应用。

计算机软件技术基础实验报告

计算机软件技术基础实验报告

学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：实验五图的存储与遍历一、实验目的1.熟悉图的逻辑结构定义、深度优先搜索和广度优先搜索算法。

2.掌握图的深度优先搜索和广度优先搜索程序实现。

二、实验用软件和工具实验软件 VC++ 6.0三、实验步骤建立一个图，用C语言实现，调试并输出结果；实现图的深度优先搜索和广度优先搜索，用C语言实现，调试并输出结果。

1.建立并显示一个图。

2.图的深度优先搜索。

3.图的广度优先搜索。

四、实验程序与程序运行结果有向网的邻接矩阵#include "stdio.h"#define M 50#define N 4void init(int b[][N]) /*初始化图*/{ int i,j,k;for(i=0;i<N;i++) /*弧的尾结点*/for(j=0;j<N;j++)/*弧的头结点*/{ printf("%d,%d(%d)",i+1,j+1,M);scanf("%d",&b[i][j]);/*输入权值*/}}void fz(int b[][N],int d[][N])/*复制一个图*/{ int i,j;for(i=0;i<N;i++)for(j=0;j<N;j++)d[i][j]=b[j][i];}void sc(int b[][N])/*显示图*/{ int i,j;学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：for(i=0;i<N;i++)/*显示图或最小生成树的数组*/{for(j=0;j<N;j++)printf("%d ",b[i][j]);printf("\n");}}main(){ int a[N][N],c[N][N];printf("\nshuruhu:\n\n");init(a);/*初始化图*/printf("\nxianshitu\n\n");sc(a);/*显示图*/fz(a,c);/*图转置*/printf("\nxianshizhuanzhitu\n\n");sc(c);/*显示图*/}遍历#include <iostream>//#include <malloc.h>#define INFINITY 32767#define MAX_VEX 20 //最大顶点个数#define QUEUE_SIZE (MAX_VEX+1) //队列长度using namespace std;bool *visited; //访问标志数组//图的邻接矩阵存储结构typedef struct{char *vexs; //顶点向量int arcs[MAX_VEX][MAX_VEX]; //邻接矩阵int vexnum,arcnum; //图的当前顶点数和弧数}Graph;//队列类class Queue{public:void InitQueue(){base=(int *)malloc(QUEUE_SIZE*sizeof(int));front=rear=0;}void EnQueue(int e){base[rear]=e;rear=(rear+1)%QUEUE_SIZE;}void DeQueue(int &e){e=base[front];front=(front+1)%QUEUE_SIZE;}public:int *base;int front;学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：int rear;};//图G中查找元素c的位置int Locate(Graph G,char c){for(int i=0;i<G.vexnum;i++)if(G.vexs[i]==c) return i;return -1;}//创建无向网void CreateUDN(Graph &G){int i,j,w,s1,s2;char a,b,temp;printf("输入顶点数和弧数:");scanf("%d%d",&G.vexnum,&G.arcnum);temp=getchar(); //接收回车G.vexs=(char *)malloc(G.vexnum*sizeof(char)); //分配顶点数目printf("输入%d个顶点.\n",G.vexnum);for(i=0;i<G.vexnum;i++){ //初始化顶点printf("输入顶点%d:",i);scanf("%c",&G.vexs[i]);temp=getchar(); //接收回车}for(i=0;i<G.vexnum;i++) //初始化邻接矩阵for(j=0;j<G.vexnum;j++)G.arcs[i][j]=INFINITY;printf("输入%d条弧.\n",G.arcnum);for(i=0;i<G.arcnum;i++){ //初始化弧printf("输入弧%d:",i);scanf("%c %c %d",&a,&b,&w); //输入一条边依附的顶点和权值temp=getchar(); //接收回车s1=Locate(G,a);s2=Locate(G,b);G.arcs[s1][s2]=G.arcs[s2][s1]=w;}}//图G中顶点k的第一个邻接顶点int FirstVex(Graph G,int k){if(k>=0 && k<G.vexnum){ //k合理for(int i=0;i<G.vexnum;i++)if(G.arcs[k][i]!=INFINITY) return i;}return -1;}//图G中顶点i的第j个邻接顶点的下一个邻接顶点int NextVex(Graph G,int i,int j){if(i>=0 && i<G.vexnum && j>=0 && j<G.vexnum){ //i,j合理for(int k=j+1;k<G.vexnum;k++)if(G.arcs[i][k]!=INFINITY) return k;}学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：return -1;}//深度优先遍历void DFS(Graph G,int k){int i;if(k==-1){ //第一次执行DFS时,k为-1for(i=0;i<G.vexnum;i++)if(!visited[i]) DFS(G,i); //对尚未访问的顶点调用DFS}else{visited[k]=true;printf("%c ",G.vexs[k]); //访问第k个顶点for(i=FirstVex(G,k);i>=0;i=NextVex(G,k,i))if(!visited[i]) DFS(G,i); //对k的尚未访问的邻接顶点i递归调用DFS}}//广度优先遍历void BFS(Graph G){int k;Queue Q; //辅助队列QQ.InitQueue();for(int i=0;i<G.vexnum;i++)if(!visited[i]){ //i尚未访问visited[i]=true;printf("%c ",G.vexs[i]);Q.EnQueue(i); //i入列while(Q.front!=Q.rear){Q.DeQueue(k); //队头元素出列并置为kfor(int w=FirstVex(G,k);w>=0;w=NextV ex(G,k,w))if(!visited[w]){ //w为k的尚未访问的邻接顶点visited[w]=true;printf("%c ",G.vexs[w]);Q.EnQueue(w);}}}}//主函数void main(){int i;Graph G;CreateUDN(G);visited=(bool *)malloc(G.vexnum*sizeof(bool));printf("\n广度优先遍历: ");for(i=0;i<G.vexnum;i++)visited[i]=false;DFS(G,-1);printf("\n深度优先遍历: ");for(i=0;i<G.vexnum;i++)学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：visited[i]=false;BFS(G);printf("\n程序结束.\n");}试验运行结果如图：学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：五、实验心得与体会通过本次实验，我掌握了图的深度优先搜索和广度优先搜索程序实现对树与二叉树的遍历，尤其是广度优先遍历和深度优先遍历的理解进一步加深。

计算机基础-实训五

计算机基础-实训五

实训五
实训日期：2013年11月18日
实训名称：幻灯片的基本设置
所用设备或系统：PowerPoint软件
实训地点：网络实训
教师姓名：刘俊
实训目的：
1、创建PowerPoint的方法
实训内容及步骤：
1）实训内容
进入PowerPoint，采用两种不同方法创建演示文稿：
1、创建最少三张新幻灯片并选择相应版式，输入样文中的文字，设置标题和文
字字体、字号、字形，保存为实训12-1.ppt；
如：第一张幻灯片“标题”幻灯片，主标题为“第一章计算机应用基础”，主标题文字设置：隶书、54磅、加粗；
副标题为“1.1 计算机概述
1.2 计算机系统的基本组成
1.3 微型机的结构
1.4 微型机常用外设的使用”；
副标题文字设置成：宋体、40磅、倾斜；
2）实训步骤：自行完成
实训分析：
本实训所用的操作：幻灯片的创建方法三种：1）文件菜单-
新建；2）CTRL+N；3）常用工具栏新建
实训小结：
幻灯片PowerPoint是一种制作和播放演示文稿的应用程序，岗位培训、商业计划、项目管理、产品介绍等，都可以通过幻灯片进行展示。

计算机软件基础实验指导书

计算机软件基础实验指导书

计算机软件技术基础实验指导书实验报告要求：1.手写报告2.统一封皮（封皮填写相应内容）3.包括内容1）实验题目2）实验内容和要求3）源程序（必要的注释）4）调试过程5）运行结果6）实验心得实验一多项式的链表表示及运算一、实验目的掌握多项式的链表表示及运算方法。

二、实验内容设有多项式A(x)=7+3x+9x8+3x15B(x)=5x+6x7-9x8(1)用单链表给出A(x)的存储表示；(2)用单链表给出B(x)的存储表示；(3)以上述两个单链表为基础，通过插入和删除等运算给出A(x)+B(x)的存储表示，使其存储空间覆盖A(x)和B(x)的存储空间。

三、实验要求上述A(x)，B(x)的每项系数和指数均须从键盘输入， A(x)+B(x)每项系数和指数输出到屏幕。

实验二二叉树的生成与遍历一、实验目的熟悉二叉树的二叉链表表示法，掌握使用递归方法实现二叉树的三种遍历的算法。

二、实验内容图a生成如图a所示二叉树的二叉链表，并以前序、中序、后序遍历输出。

实验三 图的表示及其遍历一、 实验目的掌握图的两种存储方式，会编程实现二叉图的两种遍历算法。

二、 实验内容1．生成所示图的邻接表2．对其进行深度优先搜索 和广度优先搜索。

实验四 查找方法比较 一、 实验目的熟悉并掌握顺序，折半，二叉排序树查找的原理及其算法。

二、 实验内容题目1 顺序与折半查找分别采用顺序查找和折半查找的算法在顺序表 (11，21，31…，91，101) 中查找元素b 。

若查找成功，输出success ！及该元素的序号；若查找失败，输出fail!。

要求：1）元素b 从键盘输入；2）输出查找的过程及比较次数，比较两种查找算法的效率。

题目2 二叉排序树查找按元素在表中的顺序生成序列（45，24，53，13，30，85）的二叉排序树，并查找元素b 。

如果查找成功，输出success ！；否则，输出fail!。

要求：1）元素b 从键盘输入； 2）中序遍历该二叉树。

软件基础实验报告

软件基础实验报告

软件基础实验报告软件基础实验报告导言软件基础作为计算机科学与技术专业的一门基础课程，对于学生的专业素养和实践能力培养具有重要意义。

本次实验旨在通过实践操作，加深学生对软件基础知识的理解和应用能力的提升。

本报告将详细记录实验过程和结果，并对实验中遇到的问题进行分析和解决。

实验一：编写简单的计算器程序本实验要求我们使用Python语言编写一个简单的计算器程序。

我们首先进行了Python环境的搭建和相关库的导入，然后按照要求设计了用户界面，包括输入框、按钮和输出框等。

接着，我们编写了计算器逻辑代码，实现了加减乘除等基本运算功能。

最后，我们进行了测试，确保程序的正确性和稳定性。

实验结果显示，我们的计算器程序能够正确地进行基本运算，并且在用户输入非法字符时会给出相应的提示。

通过这个实验，我们不仅熟悉了Python语言的基本语法和库的使用，还提高了问题解决能力和编程思维。

实验二：设计一个学生信息管理系统本实验要求我们使用C语言设计一个学生信息管理系统。

我们首先进行了C语言环境的搭建和相关库的导入，然后按照要求设计了系统的功能模块，包括学生信息的录入、查询、修改和删除等。

接着，我们编写了相应的代码，并进行了测试。

实验结果显示，我们的学生信息管理系统能够正确地进行学生信息的录入、查询、修改和删除等操作，并且在用户输入非法信息时会给出相应的提示。

通过这个实验，我们不仅熟悉了C语言的基本语法和库的使用，还提高了系统设计和数据结构的能力。

实验三：实现一个简单的图像处理程序本实验要求我们使用Java语言实现一个简单的图像处理程序。

我们首先进行了Java环境的搭建和相关库的导入，然后按照要求设计了程序的功能模块，包括图像的读取、灰度化、二值化和边缘检测等。

接着，我们编写了相应的代码，并进行了测试。

实验结果显示，我们的图像处理程序能够正确地进行图像的读取、灰度化、二值化和边缘检测等操作，并且在用户输入非法图像时会给出相应的提示。

计算机软件技术基础实验报告

计算机软件技术基础实验报告

学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：实验六SQL Server 2005 的安装和数据库的创建和修改一、实验目的1.掌握SQL Server 2005的安装方法，了解SQL Server 2005 的环境。

2.掌握使用向导创建数据库的方法。

3.掌握使用向导和SQL语句创建表。

4.掌握使用SQL语句修改表。

二、实验用软件和工具1．实验软件 VC++ 6.0 。

2．SQL Server2005软件。

三、实验步骤1.安装SQL Server 2005。

2.使用向导创建学籍管理系统数据库EDUC。

3.使用向导和SQL语句创建学籍管理系统数据库中的表。

4.使用SQL语句修改学籍管理系统数据库中的表。

四、实验程序与程序运行结果1.安装SQL Server 2005。

(1)根据安装机器软硬件的要求，选择一个合适的版本，以下以开发版为例(2)将 SQL Server 2005 DVD 插入 DVD 驱动器。

如果DVD驱动器的自动运行功能无法启动安装程序无法启动安装程序，请导航到 DVD 的根目录然后启动splash.hta。

(3)在自动运行的对话框中，单击“运行 SQL Server 安装向导”。

(4)在“最终用户许可协议”页上，阅读许可协议，再选中相应的复选框以接受许可条款和条件。

接受许可协议后即可激活“下一步”按钮。

若要继续，请单击“下一步”若要结束安装程序，请单击“取消”。

如下图：学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年11月22日成绩：(5)在“SQL Server 组件更新”页上，安装程序将安装 SQL Server 2005 的必需软件。

有关组件要求的详细信息，请单击该页底部的“帮助”按钮。

若要开始执行组件更新，请单击“安装”。

更新完成之后若要继续，请单击“完成”。

(6)在 SQL Server 安装向导的“欢迎”页上，单击“下一步”以继续安装。

计算机软件基础实验指导书(内容)

计算机软件基础实验指导书(内容)

实验一线性表及其应用一、实验目的1.熟悉C语言的上机环境，进一步掌握C语言的结构特点。

2.掌握线性表的顺序存储结构——顺序表的定义及C语言实现。

3.掌握线性表在顺序存储结构——顺序表中的各种基本操作。

4.掌握线性表的链式存储结构——单链表的定义及C语言实现。

5.掌握线性表在链式存储结构——单链表中的各种基本操作。

二、实验原理在数据处理中，大量数据均以表格形式出现，称为线性表，它是一种最简单也是最常见的数据结构。

线性表是数据元素的有限序列。

线性表的结构特点是：数据元素之间是线性关系，线性表中存在唯一的“第一个元素”（表头），必存在一个唯一的“最后一个元素”（表尾）。

除第一个元素外，每个元素有且只有一个前趋元素，除最后一个元素外，每个元素有且只有一个后续元素。

三、实验内容1.顺序线性表的建立、插入及删除。

2.链式线性表的建立、插入及删除。

四、实验步骤1.建立一个顺序表存储序列{21，23，14，5，56，17，31}，然后在第i个位置插入元素68。

2.写出打印算法在屏幕上显示该顺序表中各元素的值及顺序表的长度。

3.建立一个带头结点的单链表存储序列{21，23，14，5，56，17，31}。

4. 写出打印算法在屏幕上显示该单链表中各元素的值及单链表的长度。

五、实现提示1.由于C语言的数组类型也有随机存取的特点，一维数组的机内表示就是顺序结构。

因此，可用C语言的一维数组实现线性表的顺序存储。

在此，我们利用C语言的结构体类型定义顺序表：#define MAXSIZE 100struct sequenlist{ int elem[MAXSIZE];int last; /* 顺序表的长度 */} sequenlist;typedef struct sequenlist sequentable;将此结构定义放在一个头文件sqlist.h里，可避免在后面的参考程序中代码重复书写，另外在该头文件里给出顺序表的建立及常量的定义。

《计算机软件技术基础》实验

《计算机软件技术基础》实验

（二）实验内容实验一顺序表1．实验目的(1)掌握顺序表的概念。

(2)熟练掌握线性表的顺序存储结构。

(3)熟练掌握线性表在顺序存储结构上的运算。

(4)了解测试的思想。

2．实验内容(1)编写算法实现顺序表中元素的逆置。

要求按用户输入的数据建立一个顺序表。

在逆置的过程中使用最少的辅助存储单元。

测试数据为：10， 9， 8， 7， 6， 5， 4， 3， 2， 1(2)己知顺序表中的元素非递减有序排列，编写算法删除顺序表中值相同的多余的元素。

(3)有两个顺序表A(有m个元素)和B(有n个元素)，其元素均按从小到大的升序排列。

编写算法，将这两个顺序表合并成一个顺序表C，要求C也是按从小到大的升序排列。

(4)编写算法，在非递减有序的顺序表中，插入一个给定的元素，插入后该顺序表仍然递增有序。

有序表中的数据为：12，16，24，33，45，66，68，89需要进行测试的插入数据分别是：9，13，25，33，88，91实验二线性链表1．实验目的(1)掌握线性链表的概念。

(2)熟练掌握线性表的链式存储结构。

(3)熟练掌握线性表在链式存储结构上的运算。

2．实验内容(1)编写算法，根据用户输入的字符数据用尾插法创建一个带头结点的单链表，‘#’作为输入数据的结束符。

测试数据共有四组，分别是：①“#”②“a#”③“ab#”④“abcd#”(2)编写算法，在带有头结点的单链表中查找序号为f的结点并输出。

假设单链表中包含6个数据元素，测试数据是：①查找第0个②查找第1个③查找第2个④查找第6个⑤查找第7个(3)已知单链表中的数据元素递增有序，编写算法，删除表中的最大值。

实验三查找1．实验目的(1)掌握顺序查找的算法。

(2)掌握二分查找的算法。

2．实验内容编写算法，利用顺序查找的算法、二分查找的算法对数据序列进行查找（大于10000个数，可用随机函数产生数据），给出查找成功与不成功的相关信息。

实验四排序1．实验目的(1)掌握直接插入排序的算法。

计算机软件基础(太原科技大学)实验五

计算机软件基础(太原科技大学)实验五

《软件开发技术基础》实验报告学院：电子信息工程学院__班级：电子131502____学号：姓名：实验五 Windows操作系统并发多线程的应用(2学时）班级电子131502 学号 201315020232 姓名许鹏第 15 周星期五第3 、4节成绩 ______实验类型：验证性实验要求：必修实验学时： 2学时一、实验目的：加深对Windows线程概念及线程同步管理各部门内容的理解；熟悉Windows线程管理API的使用。

二、实验要求：1、通过上网查阅资料，了解Windows线程同步函数，写出常用的API函数的定义；2、阅读案例程序，给出程序的详细注解；3、运行程序，分析程序结果；4、改写程序实现要求见（四）。

三、实验内容：以下程序实现多线程同步，其关系如下：父亲、儿子、女儿三人和一个盘子，当盘子空时，父亲往盘中随机放苹果或香蕉，儿子只从盘中拿桔子，女儿只从盘中拿苹果。

四、要求：1）改写程序，要求为：母亲往盘中随机放苹果或桔子，儿子只从盘中拿苹果，女儿只从盘中拿桔子2）写出完整的程序并能调试通过即可五、实验原理：调用Win32 API中的CreateThread函数创建线程。

CreateThread(NULL,0,&TEventWindow::ThreadFunc,this,0,&hThread Id);第一个参数设定线程的安全属性，因其仅用于Windows NT，故不设定。

第二个参数为0指定线程使用缺省的堆栈大小。

第三个参数指定线程函数，线程即从该函数的入口处开始运行，函数返回时就意味着线程终止运行。

第四个参数为线程函数的参数，可以是指向任意数据类型的指针。

第五个参数设定线程的生成标志。

hThreadId存放线程的标识号。

线程函数如下定义，上述的this参数是指向线程所属窗口的句柄指针，通过thrdWin参数传送过来，利用这个指针再调用相应的LoopFunc函数，线程的具体事务都在这个函数中执行。

计算机软件基础上机实验报告

计算机软件基础上机实验报告

计算机软件基础上机实验报告实验目的：通过本次实验，掌握计算机软件的基本操作、基本编程概念以及实现方法，并能对实验结果进行分析和总结。

实验设备：计算机硬件平台和软件平台。

实验内容：1.学习使用计算机软件的基本操作。

2.学习使用计算机软件进行编程。

3.编写一个简单的计算机软件，并进行测试。

实验步骤：1.打开计算机软件，并学习基本的操作方法。

包括如何创建、保存和打开文件，如何设置字体、颜色和格式等。

2.学习基本的编程概念和语法，包括变量、函数、条件语句和循环语句等。

3.编写一个简单的计算机软件，并进行测试。

假设我们要编写一个求解一元二次方程的软件。

首先，定义一个函数来计算方程的根。

然后，在主函数中输入方程的系数，并调用函数进行计算。

最后，输出结果。

实验结果分析：通过本次实验，我学会了如何使用计算机软件进行操作和编程。

在编写一元二次方程求解软件的过程中，我遇到了一些问题，如如何处理方程无解和有多个解的情况等。

为了解决这些问题，我添加了对方程判别式的计算和判断逻辑，从而得到了正确的结果。

实验总结：本次实验让我更加深入地了解了计算机软件的基本操作和编程概念。

通过编写一个简单的计算机软件，我不仅巩固了所学的知识，还锻炼了分析和解决问题的能力。

在今后的学习和工作中，我将继续深入学习和应用计算机软件，为实现更多的功能和创造更大的价值做出贡献。

此外，我还意识到在软件开发过程中应注重错误处理和逻辑判断，确保软件的稳定性和可靠性。

以上是本次计算机软件基础上机实验的报告，通过本次实验，我对计算机软件的基本操作和编程有了更深入的了解，并在实践中掌握了一些基本的编程技巧和方法。

这将为我今后的学习和工作奠定坚实的基础。

计算机软件基础实验报告 xxx

计算机软件基础实验报告 xxx

计算机软件基础实验报告 xxx
实验名称：计算机软件基础实验
实验报告
实验目的：
1. 了解计算机软件的基本概念和分类；
2. 熟悉计算机软件的开发过程；
3. 掌握常用的计算机软件开发工具和方法。

实验内容：
1. 计算机软件的基本概念和分类
1.1 计算机软件的定义和特点
1.2 计算机软件的分类：系统软件、应用软件和工程软件
2. 计算机软件的开发过程
2.1 需求分析
2.2 设计
2.3 编码
2.4 测试
2.5 发布和维护
3. 计算机软件开发工具和方法
3.1 集成开发环境（IDE）：使用Visual Studio进行软件开发 3.2 版本控制系统：使用Git进行版本控制
3.3 软件开发方法：使用敏捷开发方法进行软件开发
实验步骤：
1. 学习计算机软件的基本概念和分类；
2. 学习计算机软件的开发过程；
3. 学习计算机软件开发工具和方法；
4. 在实验环境中安装和配置所需的开发工具；
5. 通过实例学习和实践，完成一个简单的软件开发任务。

实验结果：
经过实验，我对计算机软件的基本概念和分类有了更深入的了解。

我熟悉了计算机软件的开发过程，并掌握了常用的计算机软件开发工具和方法。

在实验环境中成功安装和配置了开发工具，并完成了一个简单的软件开发任务。

实验总结：
通过本次实验，我进一步巩固了计算机软件的基础知识，并熟悉了计算机软件的开发过程。

我掌握了常用的计算机软件开发工具和方法，对计算机软件开发有了更深入的认识。

在以后的学习和工作中，我将继续努力，不断提升自己的计算机软件开发能力。

计算机软件技术基础实验报告

计算机软件技术基础实验报告

计算机软件实验报告姓名：班级：学号：指导教师：实验一线性表的基本操作一、实验目的与基本要求1．掌握数据结构中的一些基本概念。

数据、数据项、数据元素、数据类型和数据结构，以及它们之间的关系。

2．了解数据的逻辑结构和数据的存储结构之间的区别与联系；数据的运算与数据的逻辑结构的关系。

3．掌握线性表的基本操作：插入、删除、查找以及线性表的合并等运算。

4．掌握运用C语言上机调试线性表的基本方法。

二、实验条件1．硬件：一台微机2．软件：操作系统和C语言系统三、实验方法确定存储结构后，上机调试实现线性表的基本运算。

四、实验内容1．试编写在无头结点的单链表上实现线性表基本运算LOCATE（L，X），INSERT （L，X，1）和DELETE（L，1）的算法。

2．假设有两个按数据元素值递增有序排列的线性表A和B，均以单链表作为存储结构。

编写算法将A表和B表归并成一个按元素值递减有序（即非递增有序，允许值相同）排列的线性表C，并要求利用原表（即A表和B表）结点空间存放表C。

3．将一个线性表中的值就地逆置。

4．在线性表的顺序存储结构的第一个位置上插入一个元素。

（注意区分链表和顺序表）实验代码：#include"stdlib.h"#include"stdio.h"struct node //定义结构体{int d;struct node *next;};struct node *head1,*head2,*p,*q;void pre(struct node *head) //打印数据{printf("链表中的数据为：\n");p=head;while(p!=NULL){printf("%5d",p->d);q=p;p=p->next;}printf("\n");}struct node *creat() //建立链表{struct node *head;int x;printf("输入你要储存的数据：\n");head=NULL;q=NULL;scanf("%d",&x);while(x>0){p=(struct node *)malloc(sizeof(struct node));p->d=x;p->next=NULL;if(head==NULL) head=p;else q->next=p;q=p;scanf("%d",&x);getchar();}pre(head);return (head);}void locate(struct node *head,int x) //查找链表中的数据{int u=1;p=head;while (p->next!= NULL){if (p->d==x)break;else{ p=p->next;u++;}}if(p->d!= x)printf("无此结点");printf("在链表中的位置为：");printf("%d",u);}void insert(struct node *head,int x, int i) //插入数据{ p = head;int j=1;q=(struct node *)malloc(sizeof(struct node));q->d=x;if(i==1){ q->next=head;head=q;}else{while((j<i-1)&&(p->next !=NULL)){j++;p=p->next;}q->next=p->next;p->next=q;}}void delet(struct node *head,int i) //删除数据{ p=head;int j=1;if(i<0) printf("无此位置");if(i==1){q=head; head=head->next; free(q);}else{while((j<i-1) && (p->next != NULL)){ p=p->next;j++;}q=p->next;p->next=q->next;free(q);}}void hebing(struct node *x,struct node *y) //合并两个链表{p=x;q=y;while(p->next!=NULL)p=p->next;p->next=q;pre(x);}void paixu(struct node *head) //对链表中的数据进行排序{int m,n,i=1,t;p=head;while(p->next!=NULL){p=p->next;i++;}p=head;for(n=i;n>1;n--){p=head;for(m=1;m<n;m++){q=p->next;if(p->d<q->d){t=p->d;p->d=q->d;q->d=t;}p=p->next;}}}void caozuo(struct node *head) //操作界面{int m,n;char t;printf("输入你要的操作：，查找 2，插入 3，删除\n");scanf("%c",&t);switch(t){case'1':{printf("输入你要查找的元素的值：\n");scanf("%d",&m);locate(head,m);}break;case'2':{printf("输入你要插入的元素的值和位置：\n");scanf("%d",&m);scanf("%d",&n);insert(head,m,n);pre(head);}break;case'3':{printf("输入你要删除的元素的位置：\n");scanf("%d",&m);delet(head,m);pre(head);}break;default:printf("error\n");}}void main() //主函数{char frag='y',n=NULL;printf("输入你要建立的第A链表中的元素：\n");head1=creat();printf("输入你要建立的第B链表中的元素：\n");head2=creat();do{printf("选择你要操作的链表A/B或者合并排序操作C：\n"); //选择操作scanf("%c",&n);getchar();switch(n){case'A':{caozuo(head1);}break;case'B':{caozuo(head2);}break;case'C':{hebing(head1,head2);paixu(head1);pre(head1);}break;default:printf("error\n");}printf("\n是否继续y/n：\n");scanf("%c",&frag);getchar();}while(frag=='y');}实验2 栈和队列的基本操作一、实验目的与基本要求1．掌握栈和队列的顺序存储和链式存储结构2．掌握栈和队列的特点。

计算机软件技术基础实验报告

计算机软件技术基础实验报告

学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月18日成绩：实验一顺序表的基本操作及学生信息管理实现一、实验目的1.掌握顺序表结构的实现方式。

2.掌握顺序表常用算法初始化、插入、删除等操作的程序实现。

2.熟悉利用顺序表解决问题的一般思路。

3.学习体会顺序表结构的优点与不足。

二、实验用软件和工具实验软件 VC++ 6.0三、实验步骤利用顺序表实现学生信息管理。

学生的信息包括学号、姓名、性别、班级和联系电话，功能要求：信息浏览：显示所有学生信息列表；插入信息：在线性表的头部插入一个学生信息；删除信息：按照学号删除某个学生的信息；修改信息：实现按照学号修改某个学生信息；退出程序。

编写程序调试并输出结果。

（1）建立一个顺序表、设计顺序表表的基本操作实现算法、调试并输出结果。

（2）参考顺序表的算法描述和算法的实现，在本程序中修改顺序表的插入、删除、修改等算法的实现函数。

①信息的浏览②利用插入功能插入学生信息。

③利用删除功能删除学生信息。

④利用修改功能修改学生信息。

（3）编写主函数，可通过在while循环结构中嵌入switch分支结构实现操作选择功能。

（4）可以增加学生的课程成绩，实现成绩的统计分析功能。

四、实验程序与程序运行结果#include <stdio.h>#include <string.h>struct data{int number;char name[10];char sex[5];char classes[5];int tel;};int insert(struct data st[5],int n); /*申明插入函数*/void scanning(struct data st[5],int n); /*申明浏览函数*/学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月18日成绩：int del(struct data st[5],int n); /*申明删除函数*/void fix(struct data st[5],int n); /*申明修改函数*/int main(){struct data st[5];int chioce,flag=1;int n;n=0;while(flag){printf("请选择功能:\n 1—信息浏览\n 2—插入信息\n 3—删除信息\n 4-修改信息\n 0—退出程序\n");scanf("%d",&chioce);switch(chioce){case 1:scanning(st,n);break;case 2:n=insert(st,n);break;case 3:n=del(st,n);break;case 4:fix(st,n);break;case 0:flag=0;break;}}printf("\n");printf("谢谢使用！\n");return 0;}void scanning(struct data st[5],int n) /*定义浏览函数*/{int i;if(n==0) /*无元素*/{printf("请选择功能键，先插入名单！\n");printf("\n");printf("\n");}else{学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月18日成绩：for(i=1;i<=n;i++){printf(" 学号：%d\n ",st[i].number);printf(" 姓名：%s\n",st[i].name);printf(" 性别：%s\n",st[i].sex);printf(" 班级：%s\n",st[i].classes);printf("联系方式：%d\n",st[i].tel);printf("\n");}}}int insert(struct data st[5],int n) /*定义插入函数*/{int i,p;struct data t;if(n>=5){printf("内存已满！\n");printf("\n");}else{printf("请输入学号：\n");scanf("%d",&t.number);printf("请输入姓名：\n");scanf("%s",);printf("请输入性别：\n");scanf("%s",t.sex);printf("请输入班级：\n");scanf("%s",t.classes);printf("请输入号码：\n");scanf("%d",&t.tel);}for(i=n;i>0;i--) /*所有元素后移*/{st[i+1].number=st[n].number;strcpy(st[i+1].classes,st[i].classes);strcpy(st[i+1].name,st[i].name);strcpy(st[i+1].sex,st[i].sex);st[i+1].tel=st[i].tel;}st[1].number=t.number;strcpy(st[1].classes,t.classes);strcpy(st[1].name,);strcpy(st[1].sex,t.sex);学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月18日成绩：st[1].tel=t.tel;p=n+1;return p;}int del(struct data st[5],int n) /*定义删除函数*/{int m,i,q,t;printf("请输入你要删除的同学的学号：\n");scanf("%d",&m);for(i=1;i<=n;i++){if(st[i].number==m){t=i;break;}}for(i=t;i<n;i++) /*删除结点后的所有元素后移*/{st[i].number=st[i+1].number;st[i].tel=st[i+1].tel;strcpy(st[i].classes,st[i+1].classes);strcpy(st[i].name,st[i+1].name);strcpy(st[i].sex,st[i+1].sex);}q=n-1;return q;}void fix(struct data st[5],int n) /*定义修改函数*/{int i,m,p,t=1;struct data s;printf("请输入你要修改的学生的学号：\n");scanf("%d",&m);for(i=1;i<=n;i++){if(st[i].number==m){while(t){printf("你想要修改哪项数据？\n 1代表学号\n 2代表姓名\n 3代表性别\n 4代表班级\n 5代表联系方式\n (注意：修改完毕请输入)\n");scanf("%d",&p);switch(p)学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月18日成绩：{case 1:printf("请输入修改后的学号！\n");scanf("%d",&s.number);st[i].number=s.number;break;case 2:printf("请输入修改后的姓名！\n");scanf("%s",);strcpy(st[i].name,);break;case 3:printf("请输入修改的性别！\n");scanf("%s",s.sex);strcpy(st[i].sex,s.sex);break;case 4:printf("请输入修改的班级！\n");scanf("%s",s.classes);strcpy(st[i].classes,s.classes);break;case 5:printf("请输入修改后的联系方式！\n");scanf("%d",&s.tel);st[i].tel=s.tel;break;case 0:t=0;break;}}}}}试验运行结果如图：学院：信电学院班级：姓名：学号：课程：计算机软件技术基础实验日期：2013年10月18日成绩：五、实验心得与体会掌握了顺序表的创建与数据的添加、删除、修改等操作；在设计功能性程序的过程中，对顺序表中的数据进行写入、查询实在很方便，正是其优点所在。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

《软件开发技术基础》实验报告学院：电子信息工程学院__班级：电子131502____学号：姓名：实验五 Windows操作系统并发多线程的应用(2学时）班级电子131502 学号 201315020232 姓名许鹏第 15 周星期五第3 、4节成绩 ______实验类型：验证性实验要求：必修实验学时： 2学时一、实验目的：加深对Windows线程概念及线程同步管理各部门内容的理解；熟悉Windows线程管理API的使用。

二、实验要求：1、通过上网查阅资料，了解Windows线程同步函数，写出常用的API函数的定义；2、阅读案例程序，给出程序的详细注解；3、运行程序，分析程序结果；4、改写程序实现要求见（四）。

三、实验内容：以下程序实现多线程同步，其关系如下：父亲、儿子、女儿三人和一个盘子，当盘子空时，父亲往盘中随机放苹果或香蕉，儿子只从盘中拿桔子，女儿只从盘中拿苹果。

四、要求：1）改写程序，要求为：母亲往盘中随机放苹果或桔子，儿子只从盘中拿苹果，女儿只从盘中拿桔子2）写出完整的程序并能调试通过即可五、实验原理：调用Win32 API中的CreateThread函数创建线程。

CreateThread(NULL,0,&TEventWindow::ThreadFunc,this,0,&hThread Id);第一个参数设定线程的安全属性，因其仅用于Windows NT，故不设定。

第二个参数为0指定线程使用缺省的堆栈大小。

第三个参数指定线程函数，线程即从该函数的入口处开始运行，函数返回时就意味着线程终止运行。

第四个参数为线程函数的参数，可以是指向任意数据类型的指针。

第五个参数设定线程的生成标志。

hThreadId存放线程的标识号。

线程函数如下定义，上述的this参数是指向线程所属窗口的句柄指针，通过thrdWin参数传送过来，利用这个指针再调用相应的LoopFunc函数，线程的具体事务都在这个函数中执行。

WaitForSingleObject(hThread, 2000) windows里面的线程同步的api 就是让你这个线程或者说程序停在那里，等别的程序通知你或者说发一个信号量等，然后这个程序在继续运行下去。

CloseHandle函数为关闭一个内核对象。

其中包括文件、文件映射、进程、线程、安全和同步对象等。

在CreateThread成功之后会返回一个hThread的handle，且内核对象的计数加1，CloseHandle之后，引用计数减1，当变为0时，系统删除内核对象。

ReleaseSemaphore函数用于对指定的信号量增加指定的值；sleep函数可计算执行挂起的时间；rand函数在产生随机数srand(time(NULL))，可以为rand函数提供不同的种子值，进而产生不同的随机数序列。

六、程序代码：（1）苹果香蕉问题：#include<iostream>using namespace std;#include<windows.h>#include<time.h>int k;HANDLE Apple_;CRITICAL_SECTION mmutex;HANDLE Banana_;DWORD WINAPI Son(LPVOID n){//HANDLE Apple_;CRITICAL_SECTION mmutex;int i=1;//::OpenSemaphore(MUTEX_ALL_ACCESS,false,"Apple_");while(1){::WaitForSingleObject(Apple_,INFINITE);//等苹果cout<<"Son eats"<<i<<"apples"<<endl;LeaveCriticalSection(&mmutex);i++;}::CloseHandle(Apple_);return 0;}DWORD WINAPI Daughter(LPVOID n){int i=1;//HANDLE Banana_;CRITICAL_SECTION mmutex;//OpenSemaphore(MUTEX_ALL_ACCESS,false,"Banana_");while(1){::WaitForSingleObject(Banana_,INFINITE);//等香蕉cout<<"Daughter eats"<<i<<"bananas"<<endl;LeaveCriticalSection(&mmutex);i++;}::CloseHandle(Banana_);return 0;}DWORD WINAPI Father(LPVOID n){UINT fruit;//CRITICAL_SECTION mmutex; EnterCriticalSection(&mmutex);srand(GetTickCount());fruit=rand()%2;if(fruit==0){//盘中放入苹果cout<<k+1<<"father produce an apple"<<endl;k=k+1;::ReleaseSemaphore(Apple_,1,NULL);}else{//盘中放香蕉cout<<k+1<<"father produce a banana"<<endl;k=k+1;::ReleaseSemaphore(Banana_,1,NULL);}return 0;}int main(){int j;k=0;HANDLE Father_[20];Apple_=::CreateSemaphore(NULL,0,1,"apple");Banana_=::CreateSemaphore(NULL,0,1,"banana");InitializeCriticalSection(&mmutex);for(j=0;j<20;j++){Father_[j]=::CreateThread(NULL,0,Father,NULL,0,0);}::CreateThread(NULL,0,Son,NULL,0,0);::CreateThread(NULL,0,Daughter,NULL,0,0);Sleep(1000);WaitForMultipleObjects(20,Father_,TRUE,INFINITE);return 0;}（2）苹果桔子问题：#include <iostream>using namespace std;#include <windows.h>#include <time.h>int k;HANDLE Apple_;HANDLE Orange_;CRITICAL_SECTION mmutex;DWORD WINAPI Son(LPVOID n){//HANDLE Orange_;CRITICAL_SECTION mmutex;int i = 1;OpenSemaphore(MUTEX_ALL_ACCESS,false,"Orange_"); while (1){::WaitForSingleObject(Orange_,INFINITE);//等桔子cout<<"Son eats "<<i<<" oranges"<<endl; LeaveCriticalSection(&mmutex);i++;}::CloseHandle(Apple_);return 0;}DWORD WINAPI Daughter(LPVOID n){int i = 1;//HANDLE Apple_;CRITICAL_SECTION mmutex; OpenSemaphore(MUTEX_ALL_ACCESS,false,"Apple_"); while (1){::WaitForSingleObject(Apple_,INFINITE);//等苹果cout<<"Daughter eats "<<i<<" apples"<<endl; LeaveCriticalSection(&mmutex);i++;}::CloseHandle(Apple_);return 0;}DWORD WINAPI Mather(LPVOID n){UINT fruit;//CRITICAL_SECTION mmutex; EnterCriticalSection(&mmutex);srand(GetTickCount());fruit = rand()%2;if (fruit == 0){//盘中放入苹果cout<<k+1<<" mather produce an apple"<<endl;k=k+1;::ReleaseSemaphore(Apple_,1,NULL);}else {//盘中放入桔子cout<<k+1<<" mather produce an orange"<<endl; k=k+1;::ReleaseSemaphore(Orange_,1,NULL);}return 0;}int main(){int j;k=0;HANDLE Mather_[20];Apple_ = ::CreateSemaphore(NULL,0,1,"apple"); Orange_ =::CreateSemaphore(NULL,0,1,"orange"); InitializeCriticalSection(&mmutex);for (j= 0 ; j < 20; j++){Mather_[j]=::CreateThread(NULL,0,Mather,NULL,0,0); }::CreateThread(NULL,0,Son,NULL,0,0);::CreateThread(NULL,0,Daughter,NULL,0,0);Sleep(1000);WaitForMultipleObjects(20,Mather_,TRUE,INFINITE); return 0;}七、实验结果。

相关文档
最新文档