动态内存分配算法实验报告

动

态

内

存

分

配

算

法

实

验

报

告

院系:计算机与通信工程学院班级:计科08-1班

姓名:胡太祥

学号:200807010112

一．实验题目：动态内存分配算法

二、实验目的

深入了解动态分区存储管理方式内存分配与回收的实现

三、实验要求

熟悉存储管理中动态分区的管理方式及Windows环境下，VC++程序设计方法

四、实验内容

1，确定定内存空闲分配表和进程内存分配表

2，采用首次适应算法完成内存空间的分配

3，采用最佳适应算法完成内存空间的分配

4，采用最坏适应算法完成内存空间的分配

5，实现内存回收功能

五、实验结果

首次适应算法结果

最佳适应算法

最坏适应算法

六、实验总结

首次适应算法：从表头指针开始查找课利用空间表，将找到的第一个大小不小于“请求”的空闲块的一部分分配给用户。

最佳适应算法：将可利用空间表中一个大小不小于“请求”且最接近“请求”的空闲块的一部分分配给用户。

最坏适应算法：将可利用空间表中一个大小不小于“请求”且是链表中最大的空闲块的一部分分配给用户。

以上是动态内存分配的三种算法思想，算法采用数据结构中的双向链表实现。

附录（算法代码）：

#include

#include

#define Free 0 //空闲状态

#define Used 1 //已用状态

#define OK 1 //完成

#define ERROR 0 //出错

#define MAX_length 32767 //最大内存空间为32767KB

typedef int Status; //typedef将标识符Status定义成一个数据型标识符

int n = 0;

typedef struct freearea { //定义一个结构体freearea,并对这个空闲分区进行说明

int ID; //分区号

long size; //分区大小

long address; //分区地址

int state; //当前状态

} ElemType;

typedef struct DuLNode { //double linked list // 线性表的双向链表存储结构

ElemType data;

struct DuLNode *prior; //前趋指针

struct DuLNode *next; //后继指针} DuLNode, *DuLinkList;

DuLinkList free_list; //空闲链表DuLinkList alloc_list; //已分配链表Status alloc(int);//内存分配

void free_memory(int ID, int method); //内存回收

Status first_fit(int ID, int size); //首次适应算法

Status best_fit(int ID, int size); //最佳适应算法

Status worst_fit(int ID, int size); //最坏适应算法

void first_fit_insert(DuLNode *insert); //首次适应插入排序void best_fit_insert(DuLNode *insert); //最佳适应插入排序

void worst_fit_insert(DuLNode *insert); //最坏适应插入排序DuLNode *independent_node(DuLNode *node); //断开节点node与相邻节点的联系，使其孤立

//将节点node分割，返回分配的节点信息，node为剩余内存信息

//node为双指针形式，因为可能需要对node的值进行修改

DuLNode *slice_node(DuLNode **node, int ID, int size);

void show();//查看分配

Status Initblock();//开创空间表

Status Initblock()//开创带头节点的内存空间链表，头节点不用

{

alloc_list = (DuLinkList)malloc(sizeof(DuLNode));

free_list = (DuLinkList)malloc(sizeof(DuLNode));

//头节点不用

alloc_list->prior = alloc_list->next = NULL;

free_list->prior = free_list->next = NULL;

//空闲列表初始为整个内存大小，放到node节点中

DuLNode *node = (DuLNode*)malloc(sizeof(DuLNode));

node->data.address = 0;

node->data.size = MAX_length;

node->data.ID = 0;

node->data.state = Free;

//将node节点放到空闲链表中

node->prior = free_list;

node->next = NULL;

free_list->next = node;

return OK;

}

//将所插入节点按首址从小到大顺序插入到空闲链表中

void first_fit_insert(DuLNode *insert) //首次适应插入排序

{

DuLNode *p = free_list->next;

//空闲链表为空，则将节点放到头节点后

if (p == NULL) {

free_list->next = insert;

insert->prior = free_list;

return;

}

//按首址从小到大的顺序插入节点

while (p) {

//找到插入位置: p之前

if (insert->data.address <= p->data.address) {

insert->next = p;

insert->prior = p->prior;

p->prior->next = insert;

p->prior = insert;

break;

}

//插入位置为链表尾

if (p->next == NULL) {

p->next = insert;

insert->prior = p;

break; //还是提前退出循环的好，不然会再次进入循环

}

p = p->next; //搜索下一个节点

}

}

//最佳适应插入排序：

//将所插入节点按空间从小到大插入链表void best_fit_insert(DuLNode *insert)

{

DuLNode *p = free_list->next;

//空闲链表为空，则插入到头节点后

if (p == NULL) {

free_list->next = insert;

insert->prior = free_list;

return;

}

//按空间从小到大插入节点

while (p) {

//在p前插入

if (insert->data.size <= p->data.size) {

insert->next = p;

insert->prior = p->prior;

p->prior->next = insert;

p->prior = insert;

break;

}

//插入位置为链表尾

if (p->next == NULL) {

p->next = insert;

insert->prior = p;

break; //还是提前退出循环的好，不然会再次进入循环

}

p = p->next; //搜索下一个节点

}

}

//最坏适应插入排序：

//将所插入节点按空间从大到小插入链表

void worst_fit_insert(DuLNode *insert)

{

DuLNode *p = free_list->next;

//链表为空，则插入到头节点后

if (p == NULL) {

free_list->next = insert;

insert->prior = free_list;

return;

}

//按空间从大到小插入节点

while (p) {

//在p前插入节点

if (insert->data.size >= p->data.size) {

insert->next = p;

insert->prior = p->prior;

p->prior->next = insert;

p->prior = insert;

break;

}

//插入位置为链表尾

if (p->next == NULL) {

p->next = insert;

insert->prior = p;

break; //还是提前退出循环的好，不然会再次进入循环

}

p = p->next; //搜索下一个节点

}

}

//断开节点node与相邻节点间的联系，使其孤立

//返回孤立后的节点指针

DuLNode *independent_node(DuLNode *node)

{

if (node != NULL) {

if (node->prior != NULL) {

node->prior->next = node->next;

}

if (node->next != NULL) {

node->next->prior = node->prior;

}

node->prior = node->next = NULL;

}

return node;

}

//将节点node分片，其中一片allocnode 为为用户所分配的内存片，

//另一片为分配后原node节点所剩余的内存片，放到node中

//若node节点原来大小等于所要开辟的大小，则node赋值为NULL

//返回分配结果

DuLNode *slice_node(DuLNode **node, int ID, int size)

{

DuLNode *allocnode = NULL;

//node的大小正好等于所要分配的大小，

//则直接将该节点放到分配链表中，node赋值为NULL

if ((*node)->data.size == size) {

//将node从空闲链表中分出来

independent_node((*node));

//得到所分配的内存片

allocnode = (*node);

allocnode->data.ID = ID;

allocnode->data.state = Used;

//没有剩余空间,这个地方导致必须用双重指针

(*node) = NULL;

} else if ((*node)->data.size > size) {//node的大小大于所需的大小，故将node分为两片

//一片为所分配的内存片，分配地址和空间

allocnode =

(DuLNode*)malloc(sizeof(DuLNode));

allocnode->data.size = size;

allocnode->data.address = (*node)->data.address;

allocnode->data.ID = ID;

allocnode->data.state = Used;

allocnode->prior = allocnode->next = NULL;

//另一片为分配后剩下的内存片，修改内存地址和大小

(*node)->data.address += size;

(*node)->data.size -= size;

}

//返回分配结果

return allocnode;

}

//按不同的分配方法归还内存

void free_memory(int ID, int method) //内存回收

{

DuLNode *p, *prior, *next, *freenode;

p = prior = next = freenode = NULL;

//从已分配链表中找到所要归还的内存信息

p = alloc_list->next;

while (p) {

if (p->data.ID == ID) { //找到所要归还的内存信息

freenode = p;

freenode->data.state = Free;

freenode->data.ID = Free;

break;

}

p = p->next; //继续查找

}

//将freenode从已分配链表中分离出来

independent_node(freenode);

if (freenode == NULL) { //没有所要归还的内存

return;

}

//合并空闲内存片

p = free_list->next;

while (p) {

//找到先前合并内存节点prior

if (p->data.address + p->data.size == freenode->data.address) {

prior = p;

} else if (freenode->data.address + freenode->data.size == p->data.address) {

//找到向后合并内存节点next

next = p;

//在这儿，如果是首次适应算法可以直接中断循环了

}

p = p->next; //继续查找

}

//向前合并节点存在，则进行合并

if (prior != NULL) {

independent_node(prior); //将prior从空闲链表中分离出来

//freenode与prior合并

freenode->data.address = prior->data.address;

freenode->data.size += prior->data.size;

//释放prior节点

free(prior);

}

//向后合并节点存在，则进行合并

if (next != NULL) {

independent_node(next); //将next从空闲链表中分离出来

//freenode与next合并

freenode->data.size += next->data.size;

//释放next节点

free(next);

}

//按不同的分配方式，重新插入合并后的节点

if (method == 1) {

first_fit_insert(freenode);

} else if (method == 2) {

best_fit_insert(freenode);

} else if (method == 3) {

worst_fit_insert(freenode);

}

}

Status alloc(int ch) // 分配主存{

int ID, request;

cout << "请输入作业(分区号)：";

cin >> ID;

cout << "请输入需要分配的主存大小(单位:KB)：";

cin >> request;

if (request < 0 || request == 0) {

cout << "分配数据不合适，请重新输入!" << endl;

return ERROR;

}

if (ch == 1) {//首次适应算法

if (first_fit(ID, request) == OK) {

cout << "分配成功!" << endl;

} else {

cout << "内存不足，分配失败!" << endl;

}

return OK;

} else if (ch == 2) { //选择最佳适应算法

if (best_fit(ID, request) == OK) {

cout << "分配成功!" << endl;

} else {

cout << "内存不足，分配失败!" << endl;

}

return OK;

} else if (ch == 3) { //最坏适应算法

if (worst_fit(ID, request) == OK) {

cout << "分配成功!" << endl;

} else {

cout << "内存不足，分配失败!" << endl;

}

return OK;

}

return ERROR;

}

Status first_fit(int ID, int size) //传入作业名及申请量// 首次适应算法-

{

DuLNode *p = free_list->next;

DuLNode *allocnode = NULL;

while (p) {

//找到合适空闲内存节点

if (p->data.size >= size) {

break;

}

p = p->next;

}

if (p == NULL) { //内存空间不足

return ERROR;

}

//将p分片，返回所要分配的内存信息

//由于是按首址从小到大排列空闲内存节点

//故不需再重排剩余内存节点

allocnode = slice_node(&p, ID, size);

DuLNode *q = alloc_list->next;

//将所分配节点放到已分配链表头节点后

if (q != NULL) {

allocnode->next = q;

allocnode->prior = q->prior;

q->prior->next = allocnode;

q->prior = allocnode;

} else {

alloc_list->next = allocnode;

allocnode->prior = alloc_list;

}

return OK;

}

Status best_fit(int ID, int size) // 最佳适应算法

{

DuLNode *p = free_list->next;

DuLNode *allocnode = NULL, *leftnode = NULL;

while (p) {

//找到了合适的内存节点

if (p->data.size >= size) {

break;

}

p = p->next;

}

if (p == NULL) { //内存不足

return ERROR;

}

//分片，剩余内存片需重新排序

allocnode = slice_node(&p, ID, size);

leftnode = p;

DuLNode *q = alloc_list->next;

//将所分配节点放到已分配链表头节点后

if (q != NULL) {

allocnode->next = q;

allocnode->prior = alloc_list;

q->prior->next = allocnode;

q->prior = allocnode;

} else {

alloc_list->next = allocnode;

allocnode->prior = alloc_list;

}

//重新插入剩余内存片

if (leftnode != NULL) {

//分离剩余内存片

independent_node(leftnode);

//插入该片

best_fit_insert(leftnode);

}

return OK;

}

Status worst_fit(int ID, int size) //最坏适应算法,直接找第一个节点

{

DuLNode *p = free_list->next;

DuLNode *allocnode = NULL, *leftnode = NULL;

if (p == NULL || p->data.size < size) { //内存空间不足

return ERROR;

}

//分片，剩余内存片需重新排序

allocnode = slice_node(&p, ID, size);

leftnode = p;

DuLNode *q = alloc_list->next;

//将所分配节点放到已分配链表头节点后

if (q != NULL) {

allocnode->next = q;

allocnode->prior = alloc_list;

q->prior->next = allocnode;

q->prior = allocnode;

} else {

alloc_list->next = allocnode;

allocnode->prior = alloc_list;

}

//重新插入剩余内存片

if (leftnode != NULL) {

//分离剩余内存片

independent_node(leftnode);

//插入该片

worst_fit_insert(leftnode);

}

return OK;

}

void show()// 显示主存分配情况

{

cout << " 主存分配情况\n";

DuLNode *p = free_list->next;

cout << "\n 空闲分区\n\n";

while (p) {

cout << "分区号：Free" << endl;

cout << "起始地址：" << p->data.address << endl;

cout << "分区大小：" << p->data.size << " KB" << endl;

cout << "-----------------------" << endl;

p = p->next;

}

cout << "\n 已分配分区\n\n";

p = alloc_list->next;

while (p) {

cout << "分区号：" << p->data.ID << endl;

cout << "起始地址：" << p->data.address << endl;

cout << "分区大小：" << p->data.size << " KB" << endl;

cout << "-----------------------" << endl;

p = p->next;

}

}

void main()// 主函数

{

int ch, d = 0; //算法选择标记

cout << "你有以下算法可供选择：\n";

cout << "\n";

cout << "1.首次适应算法\n";

cout << "2.最佳适应算法\n";

cout << "3.最坏适应算法\n";

cout << "0.退出\n";

cout << "\n";

cout << "请输入你的选择：";

cin >> ch;

if (ch == 0 || ch == 1 || ch == 2 || ch == 3) {

d++;

}

while (d == 0) {

cout << "请选择正确的数字0 ,1, 2或3" << endl;

cin >> ch;

if (ch == 0 || ch == 1 || ch == 2 || ch == 3) {

d++;

}

}

if (ch == 0) {

exit(0);

}

if (n == 0) {

Initblock(); //开创空间表}

int choice; //操作选择标记

while (1) {

cout << " 1: 分配";

cout << " 2: 回收\n";

cout << " 3: 查看";

cout << " 0: 返回\n";

cout << "\n";

cout << "请选择：";

cin >> choice;

if (choice == 1) {

alloc(ch); // 分配内存

n++;

} else if (choice == 2) { // 内存回收

int ID;

cout << "请输入您要释放的分区号：";

cin >> ID;

free_memory(ID, ch);

n++;

} else if (choice == 3) {

show();//显示主存

n++;

} else if (choice == 0) {

main(); //退出

n++;

} else { //输入操作有误

cout << "输入有误，请重试!" << endl;

continue;

}

}

}

插入排序算法实验报告

算法设计与分析基础 实验报告 应用数学学院 二零一六年六月

实验一插入排序算法 一、实验性质设计 二、实验学时14学时 三、实验目的 1、掌握插入排序的方法和原理。 2、掌握java语言实现该算法的一般流程。 四、实验内容 1、数组的输入。 2、输入、输出的异常处理。 3、插入排序的算法流程。 4、运行结果的输出。 五、实验报告 Ⅰ、算法原理 从左到右扫描有序的子数组，直到遇到一个大于（或小于）等于A[n-1]的元素，然后就把A[n-1]插在该元素的前面（或后面）。 插入排序基于递归思想。 Ⅱ、书中源代码 算法InsertionSort（A[0..n-1]） //用插入排序对给定数组A[0..n-1]排序 //输入：n个可排序元素构成的一个数组A[0..n-1] //输出：非降序排列的数组A[0..n-1] for i ←1 to n-1 do v ← A[i] j ← i-1 while j ≥0and A[j] > v do A[j+1] ← A[j] j ← j-1 A[j+1] ← v

Ⅲ、Java算法代码： import java.util.*; public class Charu { public static void main(String[] args) { int n = 5; int a[] = new int[n]; int s = a.length; int i = 0, j = 0, v = 0; System.out.println("请输入若干个数字："); Scanner sc = new Scanner(System.in); try { while (i < s) { a[i] = sc.nextInt(); i++; } for (i = 1; i = 0 && a[j] > v) { a[j + 1] = a[j]; j--; } a[j + 1] = v; } System.out.println("插入排序结果显示："); for (i = 0; i < s; i++) { System.out.println(a[i]); } } catch (Exception es) { System.out.println(es); } } } Ⅳ、运行结果显示：

算法实验报告

华北电力大学 实验报告| | 实验名称算法设计与分析综合实验 课程名称算法设计与分析 | | 专业班级软件12 学生姓名： 学号：成绩： 指导教师：胡朝举实验日期：

实验一分治策略—归并排序 一、实验要求 （1）编写一个模板函数：template ，MergeSort(T *a, int n); 以及相应的一系列函数，采用分治策略，对任意具有:bool operator<(const T&x,const T&y);比较运算符的类型进行排序。 （2）与STL库中的函数std::sort(..)进行运行时间上的比较，给出比较结果,如：动态生成100万个随机生成的附点数序列的排序列问题, 给出所用的时间比较。 二、实验代码 #include <> #include <> #include <> #include <> #define MAX 50 typedef struct { int arr[MAX+1]; int length; }SortArr; SortArr *CreateSortArr() { int i = 0; char buf[4*MAX] = ""; char *ptr = NULL; SortArr *sortArr = (SortArr *)malloc(sizeof(SortArr)); memset(sortArr, 0, sizeof(SortArr)); printf("请输入待排序数据，以逗号分隔，以分号结束\n" "input:"); scanf("%s", buf); ptr = buf; sortArr->arr[i] = 0; i = 1; while(*ptr != ';') { sortArr->arr[i] = atoi(ptr); i++; ptr = strstr(ptr, ","); if(!ptr) { break; } ptr++; } sortArr->length = (i - 1); return sortArr; } int merge(int arr[], int p, int q, int r) { int i = 0; int j = 0; int k = 0; int n1 = 0; int n2 = 0; int *leftArr = NULL; int *rightArr = NULL; n1 = q - p + 1; n2 = r - q;

cad cam实验报告 贝齐尔(Bezier)曲线曲面的生成方法

CAD / CAM 技术实验报告

实验三贝齐尔（Bezier）曲线曲面的生成方法 实验类型：综合型 一、目的与任务 目的：通过学生上机，了解贝齐尔（Bezier）曲线德卡斯特里奥的递推算法和贝齐尔（Bezier）曲线的几何作图法。 任务：熟悉线框建模、表面建模的基本方法。 二、内容、要求与安排方式 1、实验内容与要求： 贝齐尔（Bezier）曲线曲面的德卡斯特里奥的递推算法P（t）=∑Bi,n(t)Q(i)和几何作图法； 要求用熟悉的编程语言编制、调试和运行程序，并打印程序清单和输出结果。 2、实验安排方式：课外编写好程序清单，按自然班统一安排上机。 三、实验步骤 1、熟悉贝齐尔（Bezier）的贝齐尔基函数和贝齐尔的性质 2、贝齐尔（Bezier）曲线的德卡斯特里奥的递推算法； 3、贝齐尔（Bezier）曲线的几何作图法； 4、贝齐尔（Bezier）曲线的德卡斯特里奥的递推算法； 5、贝齐尔（Bezier）曲线的几何作图法。 6、对几何作图法绘制出图，对德卡斯特里奥的递推算法编出程序。 四、实验要求 1．在规定的时间内完成上机任务。 2．必须实验前进行复习和预习实验内容。 3．在熟悉命令过程中，注意相似命令在操作中的区别。 4．指定图形完成后，需经指导教师认可后，方可关闭计算机。 5．完成实验报告一份。 五、试验具体内容 1，Bezier 曲线的描述 在空间给定n + 1 个点P0 ,P1 ,P2 , ?,Pn ,称下列参数曲线为n 次的Bezier 曲线。 P(t) = 6n

t = 0 PiJ i ,n (t) , 0 ≤t ≤1 其中J i ,n (t) 是Bernstein 基函数,即 B i ,n (t) = n !／i !(n - i) *t(1-t); i = 0 , ??,n 一般称折线P0P1P2 ?Pn 为曲线P(t) 的控制多边形;称点P0 ,P1 ,P2 , ?,Pn 为P(t) 的控制顶点。在空间曲线的情况下,曲线P(t) = (x(t) ,y(t) ,z (t) ) 和控制顶点Pi = (Xi ,Yi ,Zi) 的关系用分量写出即为: X(t) = 6n i = 0 XiJ i ,n (t) Y(t) = 6 n i = 0 YiJ i ,n (t) Z(t) = 6n i = 0 ZiJ i ,n (t) 当t 在区间[0 ,1 ] 上变动时,就产生了Bezier 曲线。若只考虑x和y ,就是平面上的Bezier 曲线。以三次Bezier 曲线为例,它可用矩阵形式表示如下: P(t) = [t3 t2 t 1] - 1 3 - 3 1 3 - 6 3 0 - 3 3 0 0 1 0 0 0 Q(0) Q(1) Q(2) Q(3) 0 ≤t ≤1 2, Bezier 曲线的性质 Bezier 曲线具有以下性质: 当t = 0 时,P(0) = P0 ,故P0 决定曲线的起点,当t = 1 时,P(1) = Pn ,故Pn 决定曲线的终点。Bezier 曲线的起点、终点与相应的特征多边形的起点、终点重合。Bezier 曲线P(t) 在P0 点与边P0P1 相切,在Pn点与边Pn- 1Pn 相切。Bezier 曲线P(t) 位于其控制顶点P0 ,P1 ,P2 ,?,Pn 的凸包之内。 Bezier 曲线P(t) 具有几何不变性。 Bezier 曲线P(t) 具有变差缩减性。 3, Bezier曲线的de Casteljau算法 Paul de Casteljau 发现了一个Bezier 曲线非常有趣的特性,任何的Bezier 曲线都能很容易地分成两个同样阶次的Bezier 曲线。

《数据结构》实验报告——排序.docx

《数据结构》实验报告排序实验题目： 输入十个数，从插入排序，快速排序，选择排序三类算法中各选一种编程实现。 实验所使用的数据结构内容及编程思路： 1. 插入排序：直接插入排序的基本操作是，将一个记录到已排好序的有序表中，从而得到一个新的，记录增一得有序表。 一般情况下，第i 趟直接插入排序的操作为：在含有i-1 个记录的有序子序列r[1..i-1 ]中插入一个记录r[i ]后，变成含有i 个记录的有序子序列r[1..i ]；并且，和顺序查找类似，为了在查找插入位置的过程中避免数组下标出界，在r [0]处设置哨兵。在自i-1 起往前搜索的过程中，可以同时后移记录。整个排序过程为进行n-1 趟插入，即：先将序列中的第一个记录看成是一个有序的子序列，然后从第2 个记录起逐个进行插入，直至整个序列变成按关键字非递减有序序列为止。 2. 快速排序：基本思想是，通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。 假设待排序的序列为{L.r[s] ,L.r[s+1],…L.r[t]}, 首先任意选取一个记录 （通常可选第一个记录L.r[s]）作为枢轴（或支点）（PiVOt ）,然后按下述原则重新排列其余记录：将所有关键字较它小的记录都安置在它的位置之前，将所有关键字较大的记录都安置在它的位置之后。由此可以该“枢轴”记录最后所罗的位置i 作为界线，将序列{L.r[s] ，… ，L.r[t]} 分割成两个子序列{L.r[i+1],L.[i+2], …,L.r[t]}。这个过程称为一趟快速排序，或一次划分。 一趟快速排序的具体做法是：附设两个指针lOw 和high ，他们的初值分别为lOw 和high ，设枢轴记录的关键字为PiVOtkey ，则首先从high 所指位置起向前搜索找到第一个关键字小于PiVOtkey 的记录和枢轴记录互相交换，然后从lOw 所指位置起向后搜索，找到第一个关键字大于PiVOtkey 的记录和枢轴记录互相 交换，重复这两不直至low=high 为止。 具体实现上述算法是，每交换一对记录需进行3 次记录移动(赋值)的操作。而实际上，

算法实验报告

贵州大学计算机科学与技术学院 计算机科学与技术系上机实验报告 课程名称：算法设计与分析班级：软件101 实验日期：2012-10-23 姓名：学号：指导教师： 实验序号：一实验成绩： 一、实验名称 分治算法实验- 棋盘覆盖问题 二、实验目的及要求 1、熟悉递归算法编写； 2、理解分治算法的特点； 3、掌握分治算法的基本结构。 三、实验环境 Visual C++ 四、实验内容 根据教材上分析的棋盘覆盖问题的求解思路，进行验证性实验； 要求完成棋盘覆盖问题的输入、分治求解、输出。有余力的同学尝试消去递归求解。 五、算法描述及实验步骤 分治算法原理： 分治算法将大的分解成形状结构相同的子问题，并且不断递归地分解，直到子问题规模小到可以直接求解。 棋盘覆盖问题描述： 在一个2k x 2k个方格组成的棋盘中恰有一个方格与其他的不同称为特殊方格，想要求利用四种L型骨牌（每个骨牌可覆盖三个方格）不相互重叠覆盖的将除了特殊方格外的其他方格覆盖。

实验步骤： 1、定义用于输入和输出的数据结构； 2、完成分治算法的编写； 3、测试记录结构； 4、有余力的同学尝试不改变输入输出结构，将递归消除，并说明能否不用栈，直接消除递归，为什么？ 六、调试过程及实验结果 详细记录程序在调试过程中出现的问题及解决方法。 记录程序执行的结果。

七、总结 对上机实践结果进行分析，问题回答，上机的心得体会及改进意见。 通过对本实验的学习，对分治算法有了进一步的认识，对棋盘覆盖问题和其他分治问题进行了对比。 八、附录 源程序（核心代码）清单或使用说明书，可另附纸 ① #include #include using namespace std; int board[100][100],tile=1; void chessboard(int tr,int tc,int dr,int dc,int size)//tr 棋盘左上角方格的行号，tc棋盘左上角方格的列号。dr特殊方格所在的行号。dc特殊方格所在的列号。size棋盘的大小2^k. { int s; if(size==1) return ; int t=tile++; s=size/2; //覆盖左上角棋盘 if(dr=tc+s) chessboard(tr,tc+s,dr,dc,s); else { board[tr+s-1][tc+s]=t; chessboard(tr,tc+s,tr+s-1,tc+s,s); } ② //覆盖左下角子棋盘 if(dr>=tr+s&&dc=tr+s&&dc>=tc+s) chessboard(tr+s,tc+s,dr,dc,s); else { board[tr+s][tc+s]=t; chessboard(tr+s,tc+s,tr+s,tc+s,s); } } int main() { int k,tr,tc,size,i,j; cin>>k>>tr>>tc; size=pow(2,k); chessboard(0,0,tr,tc,size); for(i=0;i

计算机图形学实验报告(原创)

实验报告 计算机图形学实验报告——C字曲线算法

计算机图形学实验报告——C字曲线算法 1）算法原理介绍 实验环境：Microsoft Visual C++ C字线算法原理：C曲线由控制多边形通过一系列割角变换生成，具有连续性。C 曲线容易在计算机上快速产生, 用于计算机图形的实时处理。实验中还应用了C 曲线的凸包性、保凸性、局部无依赖性等性质。本实验程中GetMaxX()函数得到屏幕上的X方向上的最大值；GetMaxY()数得到屏幕上的Y方向上的最大值； c(n,300,150,MaxX-300,150)函数画出C字样图形。 2）程序设计文档说明 一、课程设计目的 在掌握图形学的基本原理、算法和实现技术基础上，通过编程实践学会基本的图形软件开发技术。 1.了解Visual C++ 2005绘图的基本概念 2.了解Visual C++2005绘图环境 3.了解Visual C++2005绘图环境 4. 掌握用Visual C++ 2005绘图的基本命令 二、课程设计内容 仿照Windows的附件程序“画图”, 用C++语言编制一个具有交互式绘制和编辑多种图元功能的程序“C字曲线算法”，实现以下功能对应的设计内容： (1) 能够以交互方式在图形绘制区绘制直线（折线）； (2)设置C字曲线的迭代次数，分析不同迭代次数的变化情况；

（3）通过帮助文档了解和使用函数。 三、实验步骤 1．新建MFC应用程序 1.1新建工程。运行VC++6.0，新建一个MFC AppWizard[exe]工程，并命名，选择保存 路径，确定。

1.2选择应用程序的类型，选择“单文档”，则可以通过菜单打开对话框 2．建立单文档应用程序，在其中调用对话框 2.1 查看工程资源 在单击完成之后，即建立了一个工程，在工程的左侧资源视图可以看到MFC向导为该程序提供的一些资源。 分别如下所示：

算法排序问题实验报告

《排序问题求解》实验报告 一、算法的基本思想 1、直接插入排序算法思想 直接插入排序的基本思想是将一个记录插入到已排好序的序列中，从而得到一个新的，记录数增1 的有序序列。 直接插入排序算法的伪代码称为InsertionSort，它的参数是一个数组A[1..n]，包含了n 个待排序的数。用伪代码表示直接插入排序算法如下： InsertionSort (A) for i←2 to n do key←A[i] //key 表示待插入数 //Insert A[i] into the sorted sequence A[1..i-1] j←i-1 while j>0 and A[j]>key do A[j+1]←A[j] j←j-1 A[j+1]←key 2、快速排序算法思想 快速排序算法的基本思想是，通过一趟排序将待排序序列分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可对这两部分记录继续进行排序，以达到整个序列有序。 假设待排序序列为数组A[1..n]，首先选取第一个数A[0]，作为枢轴（pivot），然后按照下述原则重新排列其余数：将所有比A[0]大的数都排在它的位置之前，将所有比A[0] 小的数都排在它的位置之后，由此以A[0]最后所在的位置i 作为分界线，将数组A[1..n]分成两个子数组A[1..i-1]和A[i+1..n]。这个过程称作一趟快速排序。通过递归调用快速排序，对子数组A[1..i-1]和A[i+1..n]排序。 一趟快速排序算法的伪代码称为Partition,它的参数是一个数组A[1..n]和两个指针low、high,设枢轴为pivotkey，则首先从high 所指位置起向前搜索，找到第一个小于pivotkey 的数，并将其移到低端，然后从low 所指位置起向后搜索，找到第一个大于pivotkey 的数，并将其移到高端，重复这两步直至low=high。最后，将枢轴移到正确的位置上。用伪代码表示一趟快速排序算法如下： Partition ( A, low, high) A[0]←A[low] //用数组的第一个记录做枢轴记录 privotkey←A[low] //枢轴记录关键字 while low=privotkey do high←high-1 A[low]←A[high] //将比枢轴记录小的记录移到低端 while low

算法程序设计实验报告

程序设计》课程设计 姓名：王 学号：20100034 班级：软件工程00 班 指导教师：王会青 成绩： 2010年 6 月 实验一.构造可以使n 个城市连接的最小生成树 专业：__软件工程___ 班级：__软件姓名：_王___ 学号：_20100034 完成日期：_2010/6/26 ________ 一、【问题描述】给定一个地区的n 个城市间的距离网，用Prim 算法或Kruskal 算法建立最小生成树，并计算得到的最小生成树的代价。 1 城市间的道路网采用邻接矩阵表示，邻接矩阵的存储结构定义采用课本中给出的定义，若两个城市之间不存在道

路，则将相应边的权值设为自己定义的无穷大值。 2 显示出城市间道路网的邻接矩阵。 3 最小生成树中包括的边及其权值，并显示得到的最小生成树的总代价。 4 输入城市数、道路数→输入城市名→输入道路信息→执行Kruskal 算法→执行Prim 算法→输出最小生成树 二、【问题分析】 1. 抽象数据类型结构体数组的定义： #ifnd ef ADJACENCYMATRIXED// 防止该头文件被重复引用 #define ADJACENCYMATRIXED // 而引起的数据重复定义 #define INFINITY 32767 // 最大值∞ #define MAX_VERTEX_NUM 20 // 最大顶点个数 typedef int VRType; // 权值，即边的值 typedef char InfoType; // 附加信息的类型，后面使用时会定义成一个指针 typedef char VertexType[MAX_VERTEX_NUM]; // 顶点类型 typedef enum {DG=1, DN, UDG, UDN} GraphKind; //{ 有向图，有向网，无向图，无向网} typedef struct ArcCell { VRType adj; //VRType 是顶点关系类型。对无权图，用1 或0 表示相邻否；对带权图，则为权值类型。 InfoType*info; // 该弧关系信息的指针

Voronoi图生成算法的实现、对比及演示实验报告

Voronoi图生成算法的实现、 对比及演示实验报告 C组 张哲 2012212882 唐磊 2012212861 陈帅 2012212906 1. 实验内容 对Voronoi图的生成算法进行实现、对比及演示。 2. 数据结构 采用DCEL结构（下面所列代码去除了函数、只留下成员变量，具体见源码中basic_types.h 文件）： class Site { public: Point p; private: double x_, y_; //coordinates of this site Face* incFace_; //the face that this site belongs to }; class Vertex { public: Point p; private: double x_, y_; //coordinates of v

Halfedge* incEdge_; //pionter to any outgoing incident halfedge }; class Face { private: Site* site_; //the site of this face Halfedge* incEdge_; //any incident halfedge }; class Halfedge { public: bool hasDraw; private: Halfedge* twinEdge_; //pointer to twin halfedge Vertex* oriVertex_; //pointer to origin vertex Face* incFace_; //pointer to left incident face Halfedge* prevEdge_; //pointer to CCW previous halfedge Halfedge* nextEdge_; //pointer to CCW next halfedge Point* midPoint_; //the midpoint of the two sites of this halfedge Vector* direction_; //the direction of this halfedge }; 3. 算法描述 3.1 增量法 3.1.1 增量法概述 每次向voronoi图中增加一个点，寻找与这个点最近的site，从这个site开始计算新加入的点所统治的区域的边界，删除旧的边并更新DCEL结构，直到所有点都加入到图中为止。

各种排序实验报告

【一】需求分析 课程题目是排序算法的实现，课程设计一共要设计八种排序算法。这八种算法共包括：堆排序，归并排序，希尔排序，冒泡排序，快速排序，基数排序，折半插入排序，直接插入排序。 为了运行时的方便，将八种排序方法进行编号，其中1为堆排序，2为归并排序，3为希尔排序，4为冒泡排序，5为快速排序，6为基数排序，7为折半插入排序8为直接插入排序。 【二】概要设计 1.堆排序 ⑴算法思想：堆排序只需要一个记录大小的辅助空间，每个待排序的记录仅占有一个存储空间。将序列所存储的元素A[N]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的元素均不大于(或不小于)其左右孩子(若存在)结点的元素。算法的平均时间复杂度为O(N log N)。 ⑵程序实现及核心代码的注释： for(j=2*i+1; j<=m; j=j*2+1) { if(j=su[j]) break; su[i]=su[j]; i=j; } su[i]=temp; } void dpx() //堆排序 { int i,temp; cout<<"排序之前的数组为："<=0; i--) { head(i,N); } for(i=N-1; i>0; i--) {

temp=su[i]; su[i]=su[0]; su[0]=temp; head(0,i-1); } cout<<"排序之后的数组为："<

Romberg龙贝格算法实验报告.

Romberg龙贝格算法实验报告 2017-08-09 课程实验报告 课程名称： 专业班级： CS1306班学号： U201314967 姓名：段沛云指导教师：报 告日期： 计算机科学与技术学院 目录 1 实验目的 (1) 2 实验原理 (1) 3 算法设计与流程框图 (2) 4 源程序 (4) 5 程序运行 (7) 6 结果分析 (7) 7 实验体会 (7) 1 实验目的 掌握Romberg公式的用法，适用范围及精度，熟悉Romberg算法的流程，并能够设计算法计算积分 31 得到结果并输出。 1x 2 实验原理 2.1 取k=0,h=b-a,求T0= 数)。 2.2 求梯形值T0( b-a

),即按递推公式（4.1）计算T0。 k 2 h [f(a)+f(b)]，令1→k,(k记区间[a，b]的二分次2 2.3 求加速值，按公式(4.12)逐个求出T表的第k行其余各元素Tj(k-j) (j=1,2,….k)。 2.4 若|Tk+1-Tk| n-1 11T2n=[Tn+hn∑f(xi+)] 22i=0 1 Sn=T2n+(T2n-Tn) 31 Cn=S2n+(S2n-Sn) 151 Rn=C2n+(C2n-Cn) 63 3 算法设计与流程框图 算法设计：(先假定所求积分二分最大次数次数为20) 3.1 先求T[k][0] 3.2 再由公式T (k)m 4m(k+1)1)=mTm-1-mTm(k-1(k=1,2,) 求T[i][j] 4-14-1 3.3 在求出的同时比较T[k][k]与T[k-1][k-1]的大小，如果二者之差的绝对 值小于1e-5，就停止求T[k][k]；此时的k就是所求的二分次数，而此时的T[k][k]就是最终的结果 3.4 打印出所有的T[i][j]；程序流程图

算法排序问题实验报告

《排序问题求解》实验报告 一、算法得基本思想 1、直接插入排序算法思想 直接插入排序得基本思想就是将一个记录插入到已排好序得序列中,从而得到一个新得, 记录数增 1 得有序序列。 直接插入排序算法得伪代码称为InsertｉonＳorｔ，它得参数就是一个数组A[1、、n］,包含了n 个待排序得数。用伪代码表示直接插入排序算法如下: IｎsｅrtｉonＳｏｒt (Ａ) for i←2 tｏn ｄo ｋeｙ←Ａ[i］／/key 表示待插入数 //Ｉnsｅrt A［i] ｉnto ｔhｅsｏrteｄｓequence A［1、、i-１］ j←i-1 wｈｉｌe j＞0 ａnｄＡ[j]＞key do A[j＋１］←A［j］ j←j-1 Ａ[j+1］←keｙ 2、快速排序算法思想 快速排序算法得基本思想就是，通过一趟排序将待排序序列分割成独立得两部分，其中一 部分记录得关键字均比另一部分记录得关键字小,则可对这两部分记录继续进行排序,以达 到整个序列有序。 假设待排序序列为数组A[１、、n]，首先选取第一个数Ａ[0],作为枢轴(ｐｉvｏt)，然后按照下述原则重新排列其余数:将所有比Ａ[0]大得数都排在它得位置之前,将所有比 A[０]小得数都排在它得位置之后,由此以A[0]最后所在得位置i 作为分界线,将数组 A[1、、n]分成两个子数组Ａ［1、、i－1］与Ａ[ｉ+1、、n］。这个过程称作一趟快速排序。通过递归调用快速排序,对子数组A[1、、ｉ-1]与A[i＋1、、n]排序。 一趟快速排序算法得伪代码称为Paｒtｉtion，它得参数就是一个数组A[１、、n］与两个指针ｌoｗ、high,设枢轴为ｐｉvotｋeｙ，则首先从higｈ所指位置起向前搜索,找到第一个小于ｐivｏtｋey得数,并将其移到低端,然后从low 所指位置起向后搜索,找到第一个大于pivotkey 得数,并将其移到高端，重复这两步直至low=ｈigh。最后,将枢轴移到正确得位置上。用伪代码表示一趟快速排序算法如下: Partiｔｉｏn ( Ａ，low，higｈ) A[０］←A[low] ／／用数组得第一个记录做枢轴记录 priｖotkey←Ａ[low] //枢轴记录关键字 wｈile lｏw<ｈigh //从表得两端交替地向中间扫描 whｉle low＝pｒivotｋey do ｈｉｇh←higｈ-1 A［loｗ]←Ａ[high] //将比枢轴记录小得记录移到低端 ｗｈile low<ｈigh &＆A[ｌow］＜＝pivｏｔkｅｙ)dｏlow←lｏw+１ A[hｉｇｈ]←A[ｌoｗ] ／/将比枢轴记录大得记录移到高端

算法设计与分析实验报告

算法设计与分析课程实验项目目录 学生姓名：学号： *实验项目类型：演示性、验证性、综合性、设计性实验。 *此表由学生按顺序填写。 本科实验报告专用纸

课程名称算法设计与分析成绩评定 实验项目名称蛮力法指导教师 实验项目编号 201 实验项目类型设计实验地点机房 学生姓名学号 学院信息科学技术学院数学系信息与计算科学专业级 实验时间 2012年 3月 1 日～6月30日温度24℃ 1.实验目的和要求： 熟悉蛮力法的设计思想。 2.实验原理和主要内容： 实验原理：蛮力法常直接基于问题的描述和所涉及的概念解决问题。 实验内容：以下题目任选其一 1).为蛮力字符串匹配写一段可视化程序。 2).写一个程序，实现凸包问题的蛮力算法。 3).最著名的算式谜题是由大名鼎鼎的英国谜人给出的： S END +MORE MONEY . 这 里有两个前提假设：第一，字母和十进制数字之间一一对应，也就是每个字母只代表一个数字，而且不同的字母代表不同的数字；第二，数字0不出现在任何数的最左边。求解一个字母算术意味着找到每个字母代表的是哪个数字。请注意，解可能并不是唯一的，不同人的解可能并不相同。 3.实验结果及分析： （将程序和实验结果粘贴，程序能够注释清楚更好。） 本科实验报告专用纸(附页) 该算法程序代码如下：

#include "" #include "" int main(int argc, char* argv[]) { int x[100],y[100]; int a,b,c,i,j,k,l,m,n=0,p,t1[100],num; int xsat[100],ysat[100]; printf("请输入点的个数：\n"); scanf("%d",&num); getchar(); clock_t start,end; start=clock(); printf("请输入各点坐标:\n"); for(l=0;l

排序算法实验报告

实验课程：算法分析与设计 实验名称：几种排序算法的平均性能比较（验证型实验） 实验目标： （1）几种排序算法在平均情况下哪一个更快。 （2）加深对时间复杂度概念的理解。 实验任务： （1）实现几种排序算法（selectionsort, insertionsort,bottomupsort,quicksort, 堆排序）。对于快速分类，SPLIT中的划分元素采用三者A(low)，A(high)，A((low+high)/2)中其值居中者。（2）随机产生20组数据（比如n=5000i，1≤i≤20）。数据均属于范围（0，105）内的整数。对于同一组数据，运行以上几种排序算法，并记录各自的运行时间（以毫秒为单位）。（3）根据实验数据及其结果来比较这几种分类算法的平均时间和比较次数，并得出结论。 实验设备及环境： PC；C/C++等编程语言。 实验主要步骤： (1)明确实验目标和具体任务； (2)理解实验所涉及的几个分类算法； (3)编写程序实现上述分类算法； (4)设计实验数据并运行程序、记录运行的结果； (5)根据实验数据及其结果得出结论； (6)实验后的心得体会。 一:问题分析（包括问题描述、建模、算法的基本思想及程序实现的技巧等）：1:随机生成n个0到100000的随机数用来排序的算法如下. for(int n=1000;n<20000;n+=1000) { int a[]=new int[n]; for(int i=0;i

银行家算法_实验报告

课程设计报告课程设计名称共享资源分配与银行家算法 系（部） 专业班级 姓名 学号 指导教师 年月日

目录 一、课程设计目的和意义 (3) 二、方案设计及开发过程 (3) 1.课题设计背景 (3) 2.算法描述 (3) 3.数据结构 (4) 4.主要函数说明 (4) 5.算法流程图 (5) 三、调试记录与分析 四、运行结果及说明 (6) 1．执行结果 (6) 2．结果分析 (7) 五、课程设计总结 (8)

一、程设计目的和意义 计算机科学与技术专业学生学习完《计算机操作系统》课程后，进行的一次全面的综合训练，其目的在于加深催操作系统基础理论和基本知识的理解，加强学生的动手能力.银行家算法是避免死锁的一种重要方法。通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法 二、方案设计及开发过程 1.课题设计背景 银行家算法又称“资源分配拒绝”法，其基本思想是，系统中的所有进程放入进程集合，在安全状态下系统受到进程的请求后试探性的把资源分配给他，现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较，找出剩余资源能满足最大需求量的进程，从而保证进程运行完成后还回全部资源。这时系统将该进程从进程集合中将其清除。此时系统中的资源就更多了。反复执行上面的步骤，最后检查进程的集合为空时就表明本次申请可行，系统处于安全状态，可以实施本次分配，否则，只要进程集合非空，系统便处于不安全状态，本次不能分配给他。请进程等待 2.算法描述 1）如果Request[i] 是进程Pi的请求向量，如果Request[i，j]=K,表示进程Pi 需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查： 如果Requesti[j]<= Need[i,j]，便转向步骤2；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。 2）如果Requesti[j]<=Available[j],便转向步骤3，否则，表示尚无足够资源，进程Pi须等待。 3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值： Available[j]:=Available[j]-Requesti[j]; Allocation[i,j]:=Allocation[i,j]+Requesti[j]; Need[i,j]:=Need[i,j]-Requesti[j];

汽车设计实验报告

汽车设计实验报告

汽车整体布置方案测绘与设计 一、实验目的 通过测绘汽车整体结构，学会汽车整体布置方案设计方法。 二、试验内容 a 测绘汽车整体结构 1 整车布置基准线确定 （1）车架上平面线 纵梁上翼面较长的一段平面或承载式车身中部地板或边梁的上边缘在侧视图上的投影线，称为车架上平面线。它作为标注垂直尺寸的基准线，即Z坐标线，向上为“+”，向下为“-”，该标记线为Z/0。货车的车架上平面在满载静止位置时，通常与地面倾斜0.5°到1.5°，使车架成前低后高状，这样在汽车加速时，货箱可接近水平。为了画图方便，可将车架上平面线画成水平的，将地面线画成斜的。（2）前轮中心线 通过左右前轮中心，并垂直于车架平面线的平面，在侧视图和俯视图上的投影线，称为前轮中心线。它作为标注纵向尺寸的基准线，即X坐标线，向前为“-”、向后为“+”，该标记线记为X/0。 （3）汽车中心线 汽车纵向垂直对称平面在俯视图和前视图上的投影线，称为汽车中心线。用它作为标注横向尺寸的基准线，即Y坐标线，向左为“+”、向右为“-”，该标记线记为Y/0。

（4）地面线 地平面在侧视图和前视图上的投影线，称为地面线。此线是标注汽车高度、接近角离去角、离地间隙和货台高度等尺寸的基准线。 （5）前轮垂直线 通过左、右前轮中心，并垂直于地面的平面，在侧视图和俯视图上的投影线，称为前轮垂直线。此线用来作为标注汽车轴距和前悬的基准线。当车架与地面平行时，前轮垂直线与前轮中心线重合(如乘用车)。 b 发动机总成位置布置 I.发动机的布置 (1)发动机的上下位置发动机的上下位置对离地间隙和驾驶员视野有影响。乘用车前部因没有前轴，发动机油底壳至路面的距离，应保证满载状态下对最小离地间隙的要求。货车通常将发动机布置在前轴上方，考虑到悬架缓冲块脱落以后，前轴的最大向上跳动量能达到70-100mm，这就要求发动机有足够高的位置，以防止前轴碰坏发动机油底壳。油底壳通常设计成深浅不一的形状，使位于前轴上方的地方最浅，同时再将前梁中部锻成下凹形状〔注意前梁下部尺寸必须保证所要求的最小离地间隙)a所有这些措施将有利于降性发动机位置的高度，并使发动机罩随之降低，这能改善长头车的驾驶员视野，同时有利于降低汽车质心高度。除此之外，还要检查油底壳与横拉杆之间的间隙。发动机高度位置初定之后，用气缸体前端面与曲轴中心线交点K到地面高度尺寸b来标明其高度位置.如图所示。

概率论实验报告蒙特卡洛方法估计积分值

概率论实验报告 ——蒙特卡洛方法估计积分值 姓名： 学号： 班级： 实验内容：用蒙特卡洛方法估计积分值 1用蒙特卡洛方法估计积分 20sin x xdx π ?，2-0x e dx +∞?和 22221x y x y e dxdy ++≤??的值，并将估 计值与真值进行比较。 2用蒙特卡洛方法估计积分 21 0x e dx ? 和 22x y +≤??的值， 并对误差进行估计。 要求：（1）针对要估计的积分选择适当的概率分布设计蒙特卡洛方法； （2）利用计算机产生所选分布的随机数以估计积分值； （3）进行重复试验，通过计算样本均值以评价估计的无偏性；通过计算均方误差（针对第1类题）或样本方差（针对第2类题）以评价估计结果的精度。 目的：（1）能通过 MATLAB 或其他数学软件了解随机变量的概率密度、分布函数及其期望、方差、协方差等； （2） 熟练使用 MATLAB 对样本进行基本统计，从而获取数据的基本信息； （3） 能用 MATLAB 熟练进行样本的一元回归分析。 实验一、估计2 sin x xdx π ?的值，并将估计值与真值进行比较。 MATLAB 代码： s=0;m=0;f=0;r=0;n=50; h(1:10)=0; for j=1:10 for i=1:n a=unifrnd(0,pi/2,n,1); x=sort(a); y=pi/2*mean(x.*sin(x)); s=s+y; end b=s./n; fprintf('b=%.4f\n',b); h(j)=b;

s=0; m=m+b; end p=m./10 z=1 for j=1:10 r=(h(j)-z).^2; f=f+r; end f=f./10; fprintf('f=%.6f\n',f) 运行结果： b=1.0026 b=1.0061 b=1.0037 b=1.0135 b=0.9932 b=0.9988 b=1.0213 b=1.0310 b=0.9813 b=1.0041 p = 1.0056 z = 1 f=0.000207 >> （运行截图） 结果显示f=0.000207，表明估计结果与理论值非常接近。 实验二、估计 2-0x e dx +∞ ?的值，并将估计值与真值进行比较。 I=dx e x ?+∞-02=1/2*pi dx e pi e x x *2***2/1*2/2/22-+∞ ∞--? =)(x f x 2/2**2/1x e pi - g(x)=e pi x *2*2/2- )(x f x 为标准正态分布的概率密度.分别取10个估计值h(j)，求得估计值的均值p ，对照积分的真实值求得估计均方误差f 。