数据结构实验报告——实验六
实验题目：排序算法学号：
日期：2014.12.4 班级：物联网工程姓名：
Email：
实验目的：堆和搜索树
任务要求：
一、实验目的
1、掌握堆和搜索树的基本概念，插入、删除方法。
二、实验内容
创建最大堆类。最大堆的存储结构使用链表。
提供操作:堆的插入、堆的删除。堆的初始化。Huffman树的构造。二叉搜索树的构造。
接收键盘录入的一系列整数，输出其对应的最大堆、Huffman编码以及二叉搜索树。
堆排序。
软件环境：
Win7 操作系统
开发工具：visual C++ 6.0
实验步骤：
#include
#include
#include
#include
using namespace std;
class BinaryTreeNode
{
public:
BinaryTreeNode(){ LeftChild=RightChild=0;}
BinaryTreeNode(const int & e)
{
data=e;
LeftChild=RightChild=0;
}
BinaryTreeNode(const int& e,BinaryTreeNode *l,BinaryTreeNode *r)
{
data=e;
LeftChild=l;
RightChild=r;
}
int data;
BinaryTreeNode *LeftChild,*RightChild;
};
void Travel(BinaryTreeNode* roots){
queue
while(roots){
cout<
if(roots->LeftChild)q.push(roots->LeftChild);
if(roots->RightChild)q.push(roots->RightChild);
try{
roots=q.front();
q.pop ();
}
catch(...)
{return;}
}
}
void PrOrder(BinaryTreeNode* roots){
if(roots){
cout<
PrOrder(roots->LeftChild);
PrOrder(roots->RightChild);}
}
void InOrder(BinaryTreeNode* roots){
if(roots){
InOrder(roots->LeftChild);
cout<
InOrder(roots->RightChild);}
}
class MaxHeap {
public:
MaxHeap() {
root = 0;
state = 0;
void MakeHeap(int element, MaxHeap& left, MaxHeap& right);
int Max() {
if (!root)
return 0;
return root->data;
}
MaxHeap& Insert(const int& x);
MaxHeap& DeleteMax(int& x);
MaxHeap& Initialize(int a[], int n);
void Deactivate(){heap=0;}
void HeapSort(int a[],int n);
BinaryTreeNode *root, *last,*p_last;
int state;
void ConditionOrder(BinaryTreeNode *u, int k, int i,BinaryTreeNode *temp);
void Adjust(BinaryTreeNode *u);
BinaryTreeNode* LocateLast(BinaryTreeNode *u,int k,int i);
private:
MaxHeap *heap;
};
void MaxHeap::MakeHeap(int element, MaxHeap& left, MaxHeap& right) {
root = new BinaryTreeNode(element, left.root, right.root);
left.root = right.root = 0;
last=p_last=root;
state++;
}
BinaryTreeNode* MaxHeap::LocateLast(BinaryTreeNode *u,int k,int i)
{
if(k<=1)
return u;
else
{
int n=(int)pow(2.0,k-1);
int s=n/2;
if(i<=s)
return LocateLast(u->LeftChild,k-1,i);
else
return LocateLast(u->RightChild,k-1,i-s);
}
}
void MaxHeap::ConditionOrder(BinaryTreeNode *u, int k, int i,BinaryTreeNode *temp) {
int half = (int) pow(2.0, k - 2);
if (u->data < temp->data)
{
swap(u->data, temp->data);
}
if (!u->LeftChild || !u->RightChild)
{
if (!u->LeftChild)
{
u->LeftChild = temp;
p_last=u;
state++;
}
else {
u->RightChild = temp;
p_last=u;
state++;
}
}
else
{
if (i <= half)
ConditionOrder(u->LeftChild, k - 1, i, temp);
else
ConditionOrder(u->RightChild, k - 1, i - half, temp);
}
}
MaxHeap& MaxHeap::Insert(const int& x) {
if(root){
int k = (int) (log((double)(state)) / log(2.0)) + 1;
int index = state - (int) (pow(2.0, k - 1) - 1);
int p_index = index / 2 + 1;
BinaryTreeNode *temp = new BinaryTreeNode (x);
last = temp;
if (index == (int) (pow(2.0, k - 1))) {
p_index = 1;
ConditionOrder(root, k, p_index, temp);
}
else
ConditionOrder(root, k - 1, p_index, temp);}
else{
root = new BinaryTreeNode(x);
last=p_last=root;
state++;}
return *this;
}
void MaxHeap::Adjust(BinaryTreeNode *u) {
if (!u->LeftChild && !u->RightChild)
return;
else if(u->LeftChild && u->RightChild){
if (u->LeftChild->data > u->RightChild->data) {
if (u->data < u->LeftChild->data)
{
swap(u->data, u->LeftChild->data);
Adjust(u->LeftChild);
}
}
else
{
if (u->data < u->RightChild->data)
{
swap(u->data, u->RightChild->data);
Adjust(u->RightChild);
}
}
}}
MaxHeap& MaxHeap::DeleteMax(int& x)
{
if (!root)
exit(1) ;
else if(!last)
{x=root->data;
state=0;root=0;}
else{
x = root->data;
root->data = last->data;
int k = (int)(log((double)(state))/log((double)(2)))+ 1; int index = state - (int)(pow(2.0, k - 1) - 1);
Adjust(root);
if(index%2)
p_last->LeftChild=0;
else
p_last->RightChild=0;
delete last;
state--;
k = (int)(log((double)(state-1))/log((double)(2)))+ 1;
index = state - 1 - (int)(pow(2.0, k - 1) - 1);
int p_index = index / 2 + 1;
if (index == (int) (pow(2.0, k - 1))){
p_index=1;
p_last=LocateLast(root,k,p_index);
}
else
p_last=LocateLast(root,k-1,p_index);
if(!p_last->RightChild)
last=p_last->LeftChild;
else
last=p_last->RightChild;}
return *this;
}
MaxHeap& MaxHeap::Initialize(int a[], int n)
{
MaxHeap LMaxHeap,RMaxHeap;
MakeHeap(a[0],LMaxHeap,RMaxHeap);
for(int i=1;i Insert(a[i]); return *this; } void MaxHeap::HeapSort(int * a,int n) { //创建一个最大堆 MaxHeap maxHeap; maxHeap.Initialize(a,n); //从最大堆中逐个抽取元素 int x; for(int i=n-1;i>=0;i--) { maxHeap.DeleteMax(x); // cout<<"i="< // Travel(root);cout< a[i]=x; } //在堆的析构函数中保存数组a //maxHeap.Deactivate(); } class HTNode { public: int weight;//权重 int parent,lchild,rchild; }; typedef HTNode * HuffmanTree; HuffmanTree HuffmanCoding(char** &HC,int w[],int a[],int n); void Select(HuffmanTree HT,int n,int&s1,int&s2); void HTEcode(char** &HC,int w[],int code[],int codeLen,int a[],int aLen ); void Select(HuffmanTree HT,int n,int&s1,int&s2) { int i=1,j; while(HT[i].parent!=0) i++; j=i+1; while(HT[j].parent!=0) j++; if(HT[i].weight>HT[j].weight) { s1=j;//s1为权重小的 s2=i; } else { s1=i; s2=j; } i=j+1; while(i<=n) { if(HT[i].parent!=0) i++; else if(HT[i].weight { s2=s1; s1=i; } else if(HT[i].weight s2=i; i++; } } HuffmanTree HuffmanCoding(char **& HC,int w[],int a[],int n) { int i,start,c,f; HTNode *p; char *cd; if(n<1)return NULL; int m=2*n-1; //定义一个有m+1个节点的霍夫曼树 HuffmanTree HT=new HTNode[m+1]; //初始化 for(p=HT+1,i=1;i<=n;i++,p++) { p->weight=w[i-1]; p->lchild=0; p->rchild=0; p->parent=0; } int s1,s2; for(;i<=m;++i) { Select(HT,i-1,s1,s2); HT[s1].parent=i; HT[s2].parent=i; HT[i].parent=0; HT[i].lchild=s1; HT[i].rchild=s2; HT[i].weight=HT[s1].weight+HT[s2].weight; } HC=new char* [n]; cd=new char[n]; cd[n-1]='\0'; for(i=1;i<=n;++i) { start=n-1; for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent) { if(HT[f].lchild==c) cd[--start]='0'; else cd[--start]='1'; } HC[i-1]=new char[n-start]; strcpy(HC[i-1],&cd[start]); } return HT; } void HTEcode(char** &HC,int w[],int code[],int codeLen,int a[],int aLen ) { int j; HuffmanTree HT=HuffmanCoding(HC,w,code,codeLen); //for(int f=1;f<=2*codeLen-1;f++) // cout<<"\n序号:"< for(int r=0;r { cout<<"\n"< } for(int i=0;i { bool find=false; for(j=0;j { if(a[i]==code[j]) { find=true; cout< } } // if(!find) // cout<<"空"; } } class DBSTree{ public : DBSTree(){root=0;}; BinaryTreeNode * root; DBSTree & BSInitialize(int a[],int len); DBSTree & BSInsert(const int& e); }; DBSTree & DBSTree::BSInsert(const int& e){ BinaryTreeNode *p=root,*pp=0; while(p){ pp=p; if(e p=p->LeftChild; else if(e>p->data) p=p->RightChild; } BinaryTreeNode * r=new BinaryTreeNode(e); if(root){ if(e pp->LeftChild=r; else pp->RightChild=r;} else root=r; return *this; } DBSTree & DBSTree::BSInitialize(int a[],int len){ for(int i=0;i BSInsert(a[i]); return *this; } void main() { MaxHeap maxHeap; DBSTree bstree; int s, n,sel,Alen; char **codeA; int* IntA,* w; cout<<"输入最大堆元素个数"; int len; cin>>len; int * a=new int[len]; for(int i=0;i cout<<"输入第"< cin>>a[i]; } maxHeap.Initialize(a,len); cout<<"最大堆操作:"< cout<<"0.堆排序"< maxHeap.HeapSort(a,len); for(int h=0;h cout < cout < cout<<"1.初始化层次遍历输出最大堆"< cout< cout<<"前序遍历输出最大堆\n"; PrOrder(maxHeap.root); cout< cout<<"2.插入整数元素"< cin>>s; maxHeap.Insert(s); cout<<"层次遍历输出最大堆\n"; Travel(maxHeap.root); cout< cout<<"前序遍历输出最大堆\n"; PrOrder(maxHeap.root); cout< cout<<"3.删除最大元素\n"; maxHeap.DeleteMax(s); cout<<"层次遍历输出最大堆\n"; Travel(maxHeap.root); cout< /////////////////////////////////////// cout<<"Huffman操作"; cout<<"输入元素个数"< cin>>Alen; IntA=new int[Alen]; w=new int[Alen]; for(n=0;n cout<<"\n输入第"< cin>>IntA[n]; cout<<"\n输入对应权值\n"; cin>>w[n]; } HuffmanCoding(codeA,w,IntA,len); HTEcode(codeA,w,IntA,Alen,a,len); cout< /////////////////////////////////////////// cout<<"二叉搜索树层次遍历"< cout<<"输入二叉搜索树元素个数"; int bslen; cin>>bslen; int * b=new int[bslen]; for(int j=0;j cout<<"输入第"< cin>>b[j]; } bstree.BSInitialize(b,bslen); cout<<"前序遍历输出二叉搜索树: "< cout< cout<<"中序遍历输出二叉搜索树: "< cout< cout<<"层次遍历输出二叉搜索树: "< Travel(bstree.root); cout< } 实验结果： 实验2 查找算法的实现和应用?实验目的 1. 熟练掌握静态查找表的查找方法； 2. 熟练掌握动态查找表的查找方法; 3. 掌握hash表的技术. ?实验内容 1.用二分查找法对查找表进行查找； 2.建立二叉排序树并对该树进行查找； 3.确定hash函数及冲突处理方法，建立一个hash表并实现查找。 程序代码 #include cout<<"Not present!"; } return 0; } 结果 二叉排序树 #include 山东大学数据库实验答案2—8 CREATE TABLE test2_01 AS SELECT SID, NAME FROM pub.STUDENT WHERE sid NOT IN ( SELECT sid FROM pub.STUDENT_COURSE ) CREATE TABLE test2_02 AS SELECT SID, NAME FROM PUB.STUDENT WHERE SID IN ( SELECT DISTINCT SID FROM PUB.STUDENT_COURSE WHERE CID IN ( SELECT CID FROM PUB.STUDENT_COURSE WHERE SID='200900130417' ) ) CREATE TABLE test2_03 AS select SID,NAME from PUB.STUDENT where SID in ( select distinct SID from PUB.STUDENT_COURSE where CID in (select CID from PUB.COURSE where FCID='300002') ) CREATE TABLE test2_04 AS select SID,NAME from PUB.STUDENT where SID in ( select distinct SID from PUB.STUDENT_COURSE where CID in (select CID from PUB.COURSE where NAME='操作系统') intersect select distinct SID from PUB.STUDENT_COURSE where CID in (select CID from PUB.COURSE where NAME='数据结构') ) create table test2_05 as with valid_stu(sid,name) as ( select SID,NAME from PUB.STUDENT where AGE=20 and SID in (select SID from PUB.STUDENT_COURSE) ) select sid,name as name,ROUND(avg(score)) as avg_score,sum(score) as sum_score from PUB.STUDENT_COURSE natural join valid_stu where SID in (select SID from valid_stu) group by SID,NAME create table test2_06 as 1.二分搜索一个14个数的数组，查找A[4]所经过的元素有____. 2.一个序列先入栈，再出栈，出栈元素加入队列，生成一个新的顺序（已给出），则栈结构最少需要能保存几个元素_______. 3.一个5000个元素的数据需要排序，在堆排序，基数排序，快速排序里，要求速度最快，选哪一个______. 4.n个结点的m序B树，有____个外部节点。一个5序B树有53个结点，该B树至少有___ 层。 5.已给出一个K=11的散列表已有三个元素，再插入两个元素，则这两个元素的位置是________. 6.已给出一个无序数组，选第一个元素作为基点，快排一趟之后的顺序为____________________. 7.一个图已给3条边，再添加一条边，使其有唯一的拓扑序列，添加的边是_______,拓扑序列为____________. 8已给出一个序列，初始化为最小堆____________________。 1.跳表和散列，分别搜索最小元素写出思想和时间复杂度。 2.已给出一个序列，写出建立A VL树的过程，及删除某一个元素后的结果。 3.已给出一个有向图，写出对应的邻接表，根据Dijkstra算法写出某个顶点到其余各顶点的最短路径。 4.已给出一颗公式化描述的二叉树，画出二叉树并写出前中后序列及转化成森林。 5.无向图用公式化描述，为简化，用数组M表示上三角矩阵。写出A[i,j]到M的映射关系，说明如何求任意顶点i的度。 6.6个有序的序列，20 30 40 60 70 100 通过5次两两合并，生成一个有序的序列，求最少次数的合并过程。 1.删除链表形式的二叉搜索树的最大元素，写出思想，算法实现，时间复杂度。 2.邻接链表表示的图写出算法判断是否存在V->U的路径，以及思想。 重庆文理学院软件工程学院实验报告册 专业：_____软件工程__ _ 班级：_____软件工程2班__ _ 学号：_____201258014054 ___ 姓名：_____周贵宇___________ 课程名称：___ 数据结构 _ 指导教师：_____胡章平__________ 2013年 06 月 25 日 实验序号 1 实验名称实验一线性表基本操作实验地点S-C1303 实验日期2013年04月22日 实验内容1.编程实现在顺序存储的有序表中插入一个元素（数据类型为整型）。 2.编程实现把顺序表中从i个元素开始的k个元素删除（数据类型为整型）。 3.编程序实现将单链表的数据逆置，即将原表的数据（a1,a2….an）变成 (an,…..a2,a1)。（单链表的数据域数据类型为一结构体，包括学生的部分信息：学号，姓名，年龄） 实验过程及步骤1. #include { ElemType elem[MAXSIZE]; /*线性表占用的数组空间*/ int last; /*记录线性表中最后一个元素在数组elem[ ]中的位置（下标值），空表置为-1*/ }SeqList; #include "common.h" #include "seqlist.h" void px(SeqList *A,int j); void main() { SeqList *l; int p,q,r; int i; l=(SeqList*)malloc(sizeof(SeqList)); printf("请输入线性表的长度:"); scanf("%d",&r); l->last = r-1; printf("请输入线性表的各元素值:\n"); for(i=0; i<=l->last; i++) { scanf("%d",&l->elem[i]); } px(l,i); printf("请输入要插入的值:\n"); 数据库实验（一） 熟悉环境、建立/删除表、插入数据 Drop table 表名 update dbtest set test=1 select * from dbscore 1．教师信息(教师编号、姓名、性别、年龄、院系名称) test1_teacher：tid char 6 not null、name varchar 10 not null、sex char 2、age int、dname varchar 10。 根据教师名称建立一个索引。 1、create table test1_teacher( tid char(6) primary key, name varchar(10) not null, sex char(2), age int, dname varchar(10) ) 2．学生信息（学生编号、姓名、性别、年龄、出生日期、院系名称、班级）test1_student：sid char 12 not null、name varchar 10 not null、sex char 2、age int、birthday date（oracle的date类型是包含时间信息的，时间信息全部为零）、dname varchar 10、class varchar(10)。 根据姓名建立一个索引。 2、create table test1_student( sid char(12) primary key, name varchar(10) not null, sex char(2), age int, birthday date, dname varchar(10), class varchar(10) ) 3．课程信息（课程编号、课程名称、先行课编号、学分） test1_course：cid char 6 not null、name varchar 10 not null、fcid char 6、credit numeric 2，1（其中2代表总长度，1代表小数点后面长度）。 根据课程名建立一个索引。 3、create table test1_course( cid char(6) primary key, name varchar(10) not null, fcid char(6), credit numeric(2,1) ) 4．学生选课信息（学号、课程号、成绩、教师编号） test1_student_course：sid char 12 not null、cid char 6 not null、 score numeric 5，1（其中5代表总长度，1代表小数点后面长度）、tid char 6。 4、 create table test1_student_course( sid char(12) , cid char(6) , score numeric(5,1), tid char(6), primary key(sid,cid), 《数据结构》模拟卷 一、选择题 1.在一个长度为n的顺序表的任一位置插入一个新元素的渐进时间复杂度为（A ）。 A. O(n) B. O(n/2) C. O(1) D. O(n2) 2.带头结点的单链表first为空的判定条件是：（B ）。 A. first == NULL; B. first->link == NULL; C. first->link == first; D. first != NULL; 3. 从逻辑上可以把数据结构分为（C ）两大类。 A．动态结构、静态结构B．顺序结构、链式结构 C．线性结构、非线性结构D．初等结构、构造型结构 4.在系统实现递归调用时需利用递归工作记录保存实际参数的值。在传值参数情形，需为 对应形式参数分配空间，以存放实际参数的副本；在引用参数情形，需保存实际参数的（ D ），在被调用程序中可直接操纵实际参数。 A. 空间 B. 副本 C. 返回地址 D. 地址 5. 以下数据结构中，哪一个是线性结构（D ）。 A．广义表 B. 二叉树 C. 稀疏矩阵 D. 串 6. 以下属于逻辑结构的是（C ）。 A．顺序表 B. 哈希表 C.有序表 D. 单链表 7.对于长度为9的有序顺序表，若采用折半搜索，在等概率情况下搜索成功的平均搜索长 度为（ C ）的值除以9。 A. 20 B. 18 C. 25 D. 22 8.在有向图中每个顶点的度等于该顶点的（ C ）。 A. 入度 B. 出度 C. 入度与出度之和 D. 入度与出度之差 9.在基于排序码比较的排序算法中，（ C ）算法的最坏情况下的时间复杂度不高于 O(nlog2n)。 A. 起泡排序 B. 希尔排序 C. 归并排序 D. 快速排序 10.当α的值较小时，散列存储通常比其他存储方式具有（ B ）的查找速度。 A. 较慢 B. 较快 C. 相同 D.不同 二、填空题 1.二维数组是一种非线性结构，其中的每一个数组元素最多有___2___个直接前驱（或直 接后继）。 2.将一个n阶三对角矩阵A的三条对角线上的元素按行压缩存放于一个一维数组B中， A[0][0]存放于B[0]中。对于任意给定数组元素B[K]，它应是A中第_「(K+1)／3」_行的元素。 3.链表对于数据元素的插入和删除不需移动结点，只需改变相关结点的_指针__域的值。 4.在一个链式栈中，若栈顶指针等于NULL则为__空栈__。 5.主程序第一次调用递归函数被称为外部调用，递归函数自己调用自己被称为内部调用， 它们都需要利用栈保存调用后的__返回___地址。 6.在一棵树中，_叶子_结点没有后继结点。 7.一棵树的广义表表示为a (b (c, d (e, f), g (h) ), i (j, k (x, y) ) )，结点f的层数为__3__。假定 根结点的层数为0。 8.在一棵AVL树（高度平衡的二叉搜索树）中，每个结点的左子树高度与右子树高度之差 的绝对值不超过__1____。 9.n (n﹥0) 个顶点的无向图最多有_n（n-1）/2__条边，最少有___0___条边。 10.在索引存储中，若一个索引项对应数据对象表中的一个表项（记录），则称此索引为_ 稠密_索引，若对应数据对象表中的若干个表项，则称此索引为__稀疏__索引。 三、判断题 1.数组是一种复杂的数据结构，数组元素之间的关系既不是线性的也不是树形的(对) 2.链式存储在插入和删除时需要保持物理存储空间的顺序分配，不需要保持数据元素之间 的逻辑顺序(错) 3.在用循环单链表表示的链式队列中，可以不设队头指针，仅在链尾设置队尾指针(对) 数据结构实验报告 一．题目要求 1）编程实现二叉排序树，包括生成、插入，删除； 2）对二叉排序树进行先根、中根、和后根非递归遍历； 3）每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。 4）分别用二叉排序树和数组去存储一个班(50人以上)的成员信息(至少包括学号、姓名、成绩3项),对比查找效率，并说明在什么情况下二叉排序树效率高,为什么? 二．解决方案 对于前三个题目要求，我们用一个程序实现代码如下 #include 实验报告 实验六图的应用及其实现 一、实验目的 1．进一步功固图常用的存储结构。 2．熟练掌握在图的邻接表实现图的基本操作。 3．理解掌握AOV网、AOE网在邻接表上的实现以及解决简单的应用问题。 二、实验内容 一>.基础题目：(本类题目属于验证性的，要求学生独立完成) [题目一]：从键盘上输入AOV网的顶点和有向边的信息,建立其邻接表存储结构,然后对该图拓扑排序,并输出拓扑序列. 试设计程序实现上述AOV网 的类型定义和基本操作,完成上述功能。 [题目二]：从键盘上输入AOE网的顶点和有向边的信息,建立其邻接表存储结构,输出其关键路径和关键路径长度。试设计程序实现上述AOE网类型定义和基本操作,完成上述功能。 测试数据：教材图7.29 【题目五】连通OR 不连通 描述：给定一个无向图，一共n个点，请编写一个程序实现两种操作： D x y 从原图中删除连接x，y节点的边。 Q x y 询问x，y节点是否连通 输入 第一行两个数n,m（5<=n<=40000,1<=m<=100000） 接下来m行，每行一对整数 x y （x,y<=n）,表示x,y之间有边相连。保证没有重复的边。 接下来一行一个整数 q（q<=100000） 以下q行每行一种操作，保证不会有非法删除。 输出 按询问次序输出所有Q操作的回答，连通的回答C，不连通的回答D 样例输入 3 3 1 2 1 3 2 3 5 Q 1 2 D 1 2 Q 1 2 D 3 2 Q 1 2 样例输出 C C D 【题目六】 Sort Problem An ascending sorted sequence of distinct values is one in which some form of a less-than operator is used to order the elements from smallest to largest. For example, the sorted sequence A, B, C, D implies that A < B, B < C and C < D. in this problem, we will give you a set of relations of the form A < B and ask you to determine whether a sorted order has been specified or not. 【Input】 Input consists of multiple problem instances. Each instance starts with a line containing two positive integers n and m. the first value indicated the number of objects to sort, where 2 <= n<= 26. The objects to be sorted will be the first n characters of the uppercase alphabet. The second value m indicates the number of relations of the form A < B which will be given in this problem instance. 1 <= m <= 100. Next will be m lines, each containing one such relation consisting of three characters: an uppercase letter, the character "<" and a second uppercase letter. No letter will be outside the range of the first n letters of the alphabet. Values of n = m = 0 indicate end of input. 【Output】 For each problem instance, output consists of one line. This line should be one of the following three: Sorted sequence determined: y y y… y. Sorted sequence cannot be determined. Inconsistency found. 山东大学操作系统实验报告4进程同步实验 计算机科学与技术学院实验报告 实验题目：实验四、进程同步实验学号： 日期：20120409 班级：计基地12 姓名： 实验目的： 加深对并发协作进程同步与互斥概念的理解，观察和体验并发进程同步与互斥 操作的效果，分析与研究经典进程同步与互斥问题的实际解决方案。了解 Linux 系统中 IPC 进程同步工具的用法，练习并发协作进程的同步与互斥操作的编程与调试技术。 实验内容： 抽烟者问题。假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个有纸，另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这一过程重复进行。请用以上介绍的 IPC 同步机制编程，实现该问题要求的功能。 硬件环境： 处理器：Intel? Core?i3-2350M CPU @ 2.30GHz ×4 图形：Intel? Sandybridge Mobile x86/MMX/SSE2 内存：4G 操作系统：32位 磁盘：20.1 GB 软件环境： ubuntu13.04 实验步骤： （1）新建定义了producer和consumer共用的IPC函数原型和变量的ipc.h文件。 （2）新建ipc.c文件，编写producer和consumer 共用的IPC的具体相应函数。 （3）新建Producer文件，首先定义producer 的一些行为，利用系统调用，建立共享内存区域，设定其长度并获取共享内存的首地址。然后设定生产者互斥与同步的信号灯，并为他们设置相应的初值。当有生产者进程在运行而其他生产者请求时，相应的信号灯就会阻止他，当共享内存区域已满时，信号等也会提示生产者不能再往共享内存中放入内容。 （4）新建Consumer文件，定义consumer的一些行为，利用系统调用来创建共享内存区域，并设定他的长度并获取共享内存的首地址。然后设定消费者互斥与同步的信号灯，并为他们设置相应的初值。当有消费进程在运行而其他消费者请求时，相应的信号灯就会阻止它，当共享内存区域已空时，信号等也会提示生产者不能再从共享内存中取出相应的内容。 运行的消费者应该与相应的生产者对应起来，只有这样运行结果才会正确。 姓名： 学号： 班级： 2010年12月15日 实验一线性表的应用 【实验目的】 1、熟练掌握线性表的基本操作在顺序存储和链式存储上的实现。、； 2、以线性表的各种操作（建立、插入、删除、遍历等）的实现为重点； 3、掌握线性表的动态分配顺序存储结构的定义和基本操作的实现； 4、通过本章实验帮助学生加深对C语言的使用（特别是函数的参数调用、指针类型的 应用和链表的建立等各种基本操作）。 【实验内容】 约瑟夫问题的实现：n只猴子要选猴王，所有的猴子按1,2，…，n编号围坐一圈，从第一号开始按1,2…，m报数，凡报到m号的猴子退出圈外，如此次循环报数，知道圈内剩下一只猴子时，这个猴子就是猴王。编写一个程序实现上述过程，n和m由键盘输入。【实验要求】 1、要求用顺序表和链表分别实现约瑟夫问题。 2、独立完成，严禁抄袭。 3、上的实验报告有如下部分组成： ①实验名称 ②实验目的 ③实验内容：问题描述：数据描述：算法描述：程序清单：测试数据 算法： #include 山大网络教育《数据结构》(-C-卷) 《数据结构》模拟卷 一、单项选择题 1．数据结构是（）。 A．一种数据类型 B．数据的存储结构 C．一组性质相同的数据元素的集合 D．相互之间存在一种或多种特定关系的数据元素的集合 2．算法分析的目的是（ B ）。 A．辨别数据结构的合理性 B．评价算法的效率 C．研究算法中输入与输出的关系 D．鉴别算法的可读性 3．在线性表的下列运算中，不．改变数据元素之间结构关系的运算是（ D ）。 A．插入B．删除 C．排序D．定位 4．若进栈序列为1，2，3，4，5，6，且进栈和出栈可以穿插进行，则可能出现的出栈序列为（ B ）。 A．3，2，6，1，4，5 B．3，4，2，1，6，5 C．1，2，5，3，4，6 D．5，6，4，2，3，1 5．设串sl=″Data Structures with Java″,s2=″it″，则子串定位函数index(s1,s2)的值为（ D ）。 A．15 B．16 C．17 D．18 6．二维数组A[8][9]按行优先顺序存储，若数组元素A[2][3]的存储地址为1087，A[4][7]的存储地址为1153，则数组元素A[6][7]的存储地址为（ A ）。 A．1207 B．1209 C．1211 D．1213 7．在按层次遍历二叉树的算法中，需要借助的辅助数据结构是（ A ）。 A．队列B．栈 C．线性表D．有序表 8．在任意一棵二叉树的前序序列和后序序列中，各叶子之间的相对次序关系（ B ）。A．不一定相同B．都相同 C．都不相同D．互为逆序 9．若采用孩子兄弟链表作为树的存储结构，则树的后序遍历应采用二叉树的（ C ）。 长春大学计算机学院网络工程专业 数据结构实验报告 实验名称：实验二栈和队列的操作与应用 班级：网络14406 姓名：李奎学号：041440624 实验地点：日期： 一、实验目的： 1．熟练掌握栈和队列的特点。 2．掌握栈的定义和基本操作，熟练掌握顺序栈的操作及应用。 3．掌握链队的入队和出队等基本操作。 4．加深对栈结构和队列结构的理解，逐步培养解决实际问题的编程能力。 二、实验内容、要求和环境： 注：将完成的实验报告重命名为：班级+学号+姓名+（实验二），（如：041340538张三（实验二）），发邮件到：ccujsjzl@https://www.doczj.com/doc/1f6097987.html,。提交时限：本次实验后24小时之内。 阅读程序，完成填空，并上机运行调试。 1、顺序栈，对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数 (1)文件SqStackDef. h 中实现了栈的顺序存储表示 #define STACK_INIT_SIZE 10 /* 存储空间初始分配量*/ #define STACKINCREMENT 2 /* 存储空间分配增量*/ typedef struct SqStack { SElemType *base; /* 在栈构造之前和销毁之后，base 的值为NULL */ SElemType *top; /* 栈顶指针*/ int stacksize; /* 当前已分配的存储空间，以元素为单位*/ }SqStack; /* 顺序栈*/ (2)文件SqStackAlgo.h 中实现顺序栈的基本操作（存储结构由SqStackDef.h 定义） Status InitStack(SqStack &S) { /* 构造一个空栈S */ S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType)); if(!S.base) exit(OVERFLOW); /* 存储分配失败*/ S.top=S.base; S.stacksize=STACK_INIT_SIZE; return OK; } int StackLength(SqStack S) { // 返回S 的元素个数，即栈的长度, 编写此函数 洛阳理工学院实验报告 附：源程序： #include { InsertBST(&((*bst)->lchild),key); return OK; } else if(key>(*bst)->key) { InsertBST(&((*bst)->rchild),key); return OK; } } void CreateBST(BSTree *bst) { int key; *bst=NULL; scanf("%d", &key); while (key!=ENDKEY) { InsertBST(bst, key); scanf("%d", &key); } } BSTree SearchBST(BSTree bst, int key) { if(!bst) return NULL; else if(bst->key==key) return bst; //查找成功 else if(bst->key>key) return SearchBST(bst->lchild,key); else return SearchBST(bst->rchild,key); 软件学院操作系统实验报告 实验题目： 实验二、线程和进程/线程管道通信实验 学号：201100300124 日期：2013年04月19日 班级：5班姓名：韩俊晓 Email：hanjunxiao188@https://www.doczj.com/doc/1f6097987.html, 实验目的： 通过Linux 系统中线程和管道通信机制的实验,加深对于线程控制和管道通信概念的理解,观察和体验并发进/线程间的通信和协作的效果,练习利用无名管道进行进/线程间通信的编程和调试技术。 实验要求： 设有二元函数f(x,y) = f(x) + f(y) 其中：f(x) = f(x-1) * x(x >1) f(x)=1(x=1) f(y) = f(y-1) + f(y-2)(y> 2) f(y)=1(y=1,2) 请编程建立3个并发协作进程（或线程），它们分别完成f(x,y)、f(x)、f(y) 其中由父进程（或主线程）完成：f(x,y) = f(x) + f(y) 由子进程1（或线程1）完成：f(x) = f(x-1) * x(x >1) f(x)=1(x=1) 由子进程2（或线程2）完成：f(y) = f(y-1) + f(y-2)(y> 2) f(y)=1(y=1,2) 硬件环境： 实验室计算机 软件环境： Ubuntu08.4－Linux操作系统 BASH_VERSION='3.2.33(1)-release gcc version 4.1.2 gedit 2.18.2 OpenOffice 2.3 实验步骤： 1.实验说明： 1）与线程创建、执行有关的系统调用说明 线程是在共享内存中并发执行的多道执行路径,它们共享一个进程的资源,如进程程序段、文件描述符和信号等,但有各自的执行路径和堆栈。线程的创建无需像进程那样重新申请系统资源,线程在上下文切换时也无需像进程那样更换内存映像。多线程的并发执行即避免了多进程并发的上下文切换的开销又可以提高并发处理的效率。 Linux 利用了特有的内核函数__clone 实现了一个叫phread 的线程库,__clone是fork 函数的替代函数,通过更多的控制父子进程共享哪些资源而实现了线程。Pthread 是一个标准化模型,用它可把一个程序分成一组能够并发执行的多个任务。phread 线程库是POSIX 线程标 实验六图的应用及其实现 一、实验目的 1．进一步功固图常用的存储结构。 2．熟练掌握在图的邻接表实现图的基本操作。 3．理解掌握AOE网在邻接表上的实现及解决简单的应用问题。 二、实验内容 [题目]：从键盘上输入AOE网的顶点和有向边的信息,建立其邻接表存储结构,输出其关键路径和关键路径长度。试设计程序实现上述AOE网类型定义和基本操作,完成上述功能。 三、实验步骤 （一）、数据结构与核心算法的设计描述 本实验题目是基于图的基本操作以及邻接表的存储结构之上，着重拓扑排序算法的应用，做好本实验的关键在于理解拓扑排序算法的实质及其代码的实现。 （二）、函数调用及主函数设计 以下是头文件中数据结构的设计和相关函数的声明： typedef struct ArcNode // 弧结点 { int adjvex; struct ArcNode *nextarc; InfoType info; }ArcNode; typedef struct VNode //表头结点 { VertexType vexdata; ArcNode *firstarc; }VNode,AdjList[MAX_VERTEX_NUM]; typedef struct //图的定义 { AdjList vertices; int vexnum,arcnum; int kind; }MGraph; typedef struct SqStack //栈的定义 { SElemType *base; SElemType *top; int stacksize; }SqStack; int CreateGraph(MGraph &G);//AOE网的创建 int CriticalPath(MGraph &G);//输出关键路径 （三）、程序调试及运行结果分析 （四）、实验总结 在做本实验的过程中，拓扑排具体代码的实现起着很重要的作用，反复的调试和测试占据着实验大量的时间，每次对错误的修改都加深了对实验和具体算法的理解，自己的查错能力以及其他各方面的能力也都得到了很好的提高。最终实验结果也符合实验的预期效果。 四、主要算法流程图及程序清单 1、主要算法流程图： 2、程序清单： 创建AOE网模块： int CreateGraph(MGraph &G) //创建有向网 { int i,j,k,Vi,Vj; ArcNode *p; cout<<"\n请输入顶点的数目、边的数目"< 第一章作业 第章作 试编个递归数来输个素的 5. 试编写一个递归函数，用来输出n 个元素的 所有子集。例如，三个元素{a, b, c} 的所有子集是：{ }（空集），{a}, {b}, {c}, {a, b}, {a, c}, {,}{,,} b, c} 和a, b, c。 基本思想： 用一个一维数组x[1:n]表示大小为n的数组的一个子集。 如果第j个元素包含在子集中，那么x[j]=1 ，否则x[j]=0； x[j]0 例如原数组为{a,b},那么他的子集为{0，0}，{0，1}，{1，0}，{1，1}。分别对应子集{?}，{}{}{} {b},{a},{a,b}． 函数实现： #include 山东大学操作系统实验 六 HEN system office room 【HEN16H-HENS2AHENS8Q8-HENH1688】 软件学院操作系统实验报告 实验题目： 实验六、死锁问题实验 学号：0124 日期：2013年05月23日 班级：5班姓名：韩俊晓 Email： 实验目的： 通过本实验观察死锁产生的现象，考虑解决死锁问题的方法。从而进一步加深对于死锁问题的理解。掌握解决死锁问题的几种算法的编程和调试技术。练习怎样构造管程和条件变量，利用管程机制来避免死锁和饥俄问题的发生。 实验要求： 在两个城市南北方向之间存在一条铁路，多列火车可以分别从两个城市的车站排队等待进入车道向对方城市行驶，该铁路在同一时间，只能允许在同一方向上行车，如果同时有相向的火车行驶将会撞车。请模拟实现两个方向行车，而不会出现撞车或长时间等待的情况。您能构造一个管程来解决这个问题吗？ 硬件环境： 实验室计算机 软件环境： －Linux操作系统 gcc version 实验步骤： 1.实验说明： 管程-Monitor 管程是一种高级抽象数据类型，它支持在它的函数中隐含互斥操作。结合条件变量和其他一些低级通信原语，管程可以解决许多仅用低级原语不能解决的同步问题。利用管程可以提供一个不会发生死锁或饥饿现象的对象;哲学家就餐问题和Java语言中的synchronized对象都是很好的管程的例子. 管程封装了并发进程或线程要互斥执行的函数。为了让这些并发进程或线程在管程内互斥的执行，进入管程的进/线程必须获取到管程锁或二值信号量 条件变量Condition Variables 条件变量提供了一种对管程内并发协作进程的同步机制。如果没有条件变量，管程就不会有很有用。多数同步问题要求在管程中说明条件变量。条件变量代表了管程中一些并发进程或线程可能要等待的条件。一个条件变量管理着管程内的一个等待队列。如果管程内某个进程或线程发现其执行条件为假，则该进程或线程就会被条件变量挂入管程内等待该条件的队列。如果管程内另外的进程或线程满足了这个条件，则它会通过条件变量再次唤醒等待该条件的进程或线程，从而避免了死锁的产生。所以，一个条件变量C应具有两种操作()和()。 当管程内同时出现唤醒者和被唤醒者时，由于要求管程内的进程或线程必须互斥执行，因此就出现了两种样式的条件变量： 2011~2012第一学期数据结构实验报告 班级：信管一班 学号：201051018 姓名：史孟晨 实验报告题目及要求 一、实验题目 设某班级有M（6）名学生，本学期共开设N（3）门课程，要求实现并修改如下程序（算法）。 1. 输入学生的学号、姓名和 N 门课程的成绩（输入提示和输出显示使用汉字系统）， 输出实验结果。（15分） 2. 计算每个学生本学期 N 门课程的总分，输出总分和N门课程成绩排在前 3 名学 生的学号、姓名和成绩。 3. 按学生总分和 N 门课程成绩关键字升序排列名次，总分相同者同名次。 二、实验要求 1．修改算法。将奇偶排序算法升序改为降序。（15分） 2．用选择排序、冒泡排序、插入排序分别替换奇偶排序算法,并将升序算法修改为降序算法；。（45分）） 3．编译、链接以上算法，按要求写出实验报告（25）。 4. 修改后算法的所有语句必须加下划线，没做修改语句保持按原样不动。 5．用A4纸打印输出实验报告。 三、实验报告说明 实验数据可自定义，每种排序算法数据要求均不重复。 (1) 实验题目：《N门课程学生成绩名次排序算法实现》； (2) 实验目的：掌握各种排序算法的基本思想、实验方法和验证算法的准确性； (3) 实验要求：对算法进行上机编译、链接、运行； (4) 实验环境（Windows XP-sp3,Visual c++)； (5) 实验算法（给出四种排序算法修改后的全部清单）； (6) 实验结果（四种排序算法模拟运行后的实验结果）； (7) 实验体会（文字说明本实验成功或不足之处）。 三、实验源程序（算法） Score.c #include "stdio.h" #include "string.h" #define M 6 #define N 3 struct student { char name[10]; int number; int score[N+1]; /*score[N]为总分,score[0]-score[2]为学科成绩*/ }stu[M]; void changesort(struct student a[],int n,int j) {int flag=1,i; struct student temp; while(flag) { flag=0; for(i=1;i数据结构实验
山东大学数据库实验答案2—8
山东大学软件学院2014-2015数据结构真题
数据结构实验答案1
山东大学《数据库系统》上机实验答案 详细整理 2013最新版
山东大学网络教育《数据结构》( A 卷)
数据结构实验报告
数据结构_实验六_报告
山东大学操作系统实验报告4进程同步实验
数据结构实验报告
山大网络教育《数据结构》(-C-卷)
数据结构实验
数据结构实验六
山东大学操作系统实验二
数据结构实验六 图的应用及其实现
山东大学数据结构第1-3章作业
山东大学操作系统实验六完整版
数据结构实验报告及心得体会
相关主题
文本预览