实验3-方法和数组
利用指针排序实验报告(3篇)

第1篇一、实验目的1. 理解指针在排序算法中的应用。
2. 掌握几种常见的排序算法(如冒泡排序、选择排序、插入排序等)的指针实现方式。
3. 比较不同排序算法的效率,分析其优缺点。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验内容本次实验主要实现了以下排序算法:1. 冒泡排序2. 选择排序3. 插入排序以下是对每种排序算法的具体实现和性能分析。
1. 冒泡排序(1)算法原理冒泡排序是一种简单的排序算法。
它重复地遍历待排序的序列,比较每对相邻的元素,如果它们的顺序错误就把它们交换过来。
遍历序列的工作是重复地进行,直到没有再需要交换的元素为止。
(2)指针实现```cppvoid bubbleSort(int arr, int len) {for (int i = 0; i < len - 1; i++) {for (int j = 0; j < len - 1 - i; j++) {if ((arr + j) > (arr + j + 1)) {int temp = (arr + j);(arr + j) = (arr + j + 1);(arr + j + 1) = temp;}}}}```(3)性能分析冒泡排序的时间复杂度为O(n^2),空间复杂度为O(1)。
当待排序序列基本有序时,冒泡排序的性能较好。
2. 选择排序(1)算法原理选择排序是一种简单直观的排序算法。
它的工作原理是:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
以此类推,直到所有元素均排序完毕。
(2)指针实现```cppvoid selectionSort(int arr, int len) {for (int i = 0; i < len - 1; i++) {int minIndex = i;for (int j = i + 1; j < len; j++) {if ((arr + j) < (arr + minIndex)) {minIndex = j;}}int temp = (arr + i);(arr + i) = (arr + minIndex);(arr + minIndex) = temp;}}```(3)性能分析选择排序的时间复杂度为O(n^2),空间复杂度为O(1)。
C语言实验五实验报告——数组

C语言实验五实验报告——数组一、实验目的:1.了解数组的概念和基本使用方法;2.掌握一维数组和二维数组的定义、初始化、赋值及基本运算实现;二、实验内容与方法1.理论部分数组是一些具有相同类型的数据元素按一定顺序排列组合而成的集合,在程序设计中它是一个变量列表,由若干相同数据类型的元素组成。
通常用一个名字和一个下标来表示,下标可理解为数组元素在数组中的位置编号。
数组的特点:数组是根据顺序排列的元素的集合;所有的元素必须是相同类型。
数组的定义方法:1. 定义数组,数组元素类型 + 数组名[元素的个数];2. 元素的个数必须是整型常量或变量,定义时必须明确、指定元素的个数;3. 声明一个数组时,除了要指定数组的类型外,还要指定数组的名称;4. 数组定义完后,需要对其中的每个元素进行初始化。
可以在定义数组时赋初值,也可以通过赋值符号,对数组元素逐个进行赋值。
数组的初始化:1. 元素个数之间用逗号分开,最后1个元素后无逗号;2. 支持部分元素初始化;3. 定义和初始化可以一步完成。
二维数组数组可分为一维和多维数组。
一维数组可以看作是包含多个元素的向量,而二维数组可以看做是包含了多个一维数组的矩阵。
二维数组有行号和列号,因此,它同样需要两个下标。
数组元素类型数组名[行数][列数];数组元素类型数组名[ ][ ] = { {元素1, 元素2, ……}, {元素1, 元素2, ……}, ……{元素1, 元素2, ……}}2.实验代码**问题1:**定义一个一维数组a,包含有5个元素,分别为1,2,3,4,5;**问题2:**定义一个一维数组a,接收用户从键盘输入的5个数值,分别打印存储的各个元素。
三、实验结果与分析结果分析:定义了一个5个元素的一维数组a,并初始化了各个元素的值,其元素分别为1,2,3,4,5.循环遍历一遍数组a,并打印数组元素。
程序执行正常。
3.针对问题3:定义一个二维数组a,由4行3列组成,每个元素初始化为0,打印存储的各个元素;程序运行结果如下:四、实验总结:该实验主要是通过对C语言数组的理论知识和基本操作进行练习,加深了对数组的了解和掌握。
实验3 — 排序方法比较

实验3 —排序方法比较一.实验目的:掌握顺序表的常用排序方法,掌握一种计时方法,测试算法的稳定性。
二.实验内容:1) 分别编写函数实现冒泡排序、快速排序和简单插入排序算法;2) 2路归并排序;3) 编制一个应用程序,它将随机产生的N个0~65535之间的整数插入到一个顺序表中,然后分别用上述排序算法对这个顺序表进行排序;记录并显示各种方法的运行时间;三.源代码:#include"stdio.h"#include"math.h"#include"time.h"#include"stdlib.h"#define SIZE 5000 //每组元素的个数#define SIZE2 12 //每组元素的个数(测试稳定性)struct ele //为了检验算法的稳定性,每个元素设为结构体。
里面有内容和初始顺序。
{int data;int no;};typedef struct ele ELE;void creat(ELE a[],int n);//生成函数void creat2(ELE a[],int n);//生成函数void display(ELE a[],int n);//显示函数void bubble(ELE a[],int n);//冒泡排序函数void insert(ELE a[],int n);//插入排序函数void quick(ELE a[],int low,int high);//快速排序函数int qpass(ELE a[],int low,int high);void merge(ELE a[],ELE b[],int l, int m,int n);void mergepass(ELE a[],ELE b[],int L,int n);void mergesort(ELE a[],ELE b[],int n);//归并排序函数int main(int argc, char* argv[]){ELE a[SIZE];ELE ca[SIZE];//归并排序时使用的缓存结构体数组int i;int start[4],end[4];//记录时间double duration[4];creat(a,SIZE);start[0]=clock();bubble(a,SIZE);end[0]=clock();creat(a,SIZE);start[1]=clock();insert(a,SIZE);end[1]=clock();creat(a,SIZE);start[2]=clock();quick(a,0,SIZE-1);end[2]=clock();creat(a,SIZE);start[3]=clock();mergesort(a,ca,SIZE);end[3]=clock();printf("bubble,insert,quick sort,merge sort\n");for(i=0;i<4;i++){duration[i]=(double)(end[i]-start[i]);printf("持续时间%f\n",duration[i]);}creat2(a,SIZE2);bubble(a,SIZE2);printf("bubble:\n");display(a,SIZE2);creat2(a,SIZE2);insert(a,SIZE2);printf("insert:\n");display(a,SIZE2);creat2(a,SIZE2);quick(a,0,SIZE2-1);printf("quick sort:\n");display(a,SIZE2);creat2(a,SIZE2);mergesort(a,ca,SIZE2);printf("merge sort:\n");display(a,SIZE2);return 0;}void creat(ELE a[],int n){int i;for(i=0;i<n;i++){a[i].data=rand();a[i].no=i;}}void creat2(ELE a[],int n){int i;for(i=0;i<n;i++){a[i].data=rand();if((i%3==1)||(i%3==2))a[i].data=a[i-1].data;a[i].no=i;}}void display(ELE a[],int n){int i;for(i=0;i<n;i++){printf("%d\tInitial NO.%d\n",a[i].data,a[i].no);}printf("\n");}void bubble(ELE a[],int n){int i,j;ELE temp;for(i=0;i<n-1;i++){for(j=0;j<n-1-i;j++){if(a[j+1].data<a[j].data){temp=a[j+1];a[j+1]=a[j];a[j]=temp;}}}}void insert(ELE a[],int n){int i,j;ELE temp;for(i=1;i<n;i++){temp=a[i];j=i-1;while(temp.data<a[j].data){a[j+1]=a[j];j--;}a[j+1]=temp;}}int qpass(ELE a[],int low,int high){int i,j,k;ELE x;i=low;j=high;x=a[low];k=a[low].data;while(i<j){while((i<j)&&(a[j].data>=k))j--;a[i]=a[j];while((i<j)&&(a[i].data<=k))i++;a[j]=a[i];}a[i]=x;return i;}void quick(ELE a[],int low,int high){int i;if(low<high){i=qpass(a,low,high);quick(a,low,i-1);quick(a,i+1,high);}}void merge(ELE a[],ELE b[],int l, int m,int n) {int i,j,k;i=l;j=m+1;k=l;while((i<=m)&&(j<=n)){if(a[i].data<=a[j].data){b[k]=a[i];i++;}else{b[k]=a[j];j++;}k++;}if(i>m)for(;j<=n;j++,k++)b[k]=a[j];elsefor(;i<=m;i++,k++)b[k]=a[i];}void mergepass(ELE a[],ELE b[],int L,int n) {int i,j;i=0;while(i+2*L-1<n){merge(a,b,i,i+L-1,i+2*L-1);i=i+2*L;}if(i+L-1<n)merge(a,b,i,i+L-1,n);elsefor(j=i;j<n;j++)b[j]=a[j];}void mergesort(ELE a[],ELE b[],int n) {int L,i;n-=1;L=1;while(L<n){mergepass(a,b,L,n);L=2*L;if(L<n){mergepass(b,a,L,n);L=2*L;}elsefor(i=0;i<=n;i++)a[i]=b[i];}}四.截图:五.总结:通过实验使我对四种排序方法有了更好的认识,加深了对c语言的认识。
c语言实验报告实验

c语言实验报告实验C 语言实验报告实验一、实验目的本次 C 语言实验的主要目的是通过实际操作和编程实践,加深对 C 语言基本语法、数据类型、控制结构、数组、指针等重要概念的理解和掌握,提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程环境为 Visual Studio 2019,操作系统为Windows 10。
三、实验内容1、基本数据类型和运算符的使用定义不同类型的变量,如整数型(int)、浮点型(float、double)、字符型(char)等,并进行赋值和运算操作。
熟悉各种运算符的优先级和结合性,包括算术运算符(+、、、/、%)、关系运算符(>、<、>=、<=、==、!=)、逻辑运算符(&&、||、!)、位运算符(&、|、^、~、<<、>>)等。
2、控制结构的应用使用ifelse 语句实现条件判断,根据不同的条件执行相应的代码块。
运用 switch 语句进行多分支选择,处理不同的情况。
利用 for 循环、while 循环和 dowhile 循环实现重复执行的操作,例如计算数列的和、打印特定的图案等。
3、数组和字符串的操作定义和使用一维数组、二维数组,进行数组元素的访问、赋值和遍历。
掌握字符串的存储和处理方式,使用字符数组和字符串函数(如strlen、strcpy、strcmp 等)进行字符串的操作。
4、指针的应用理解指针的概念和指针变量的定义,通过指针访问变量和数组元素。
实现指针与数组、指针与函数的结合使用,体会指针在程序中的灵活运用。
5、函数的定义和调用编写自定义函数,实现特定的功能,如计算阶乘、判断素数等。
掌握函数的参数传递方式(值传递和地址传递),理解函数的返回值。
6、结构体和共用体的使用定义结构体类型,创建结构体变量,访问结构体成员。
了解共用体的概念和使用场景,比较结构体和共用体的区别。
四、实验步骤1、实验准备打开 Visual Studio 2019 开发环境,创建一个新的 C 语言项目。
实验三 高斯消去法和三角分解法1

实验报告实验三 高斯消去法与矩阵的三角分解一、实验目的1、掌握列主元素消去法,并且能够用MATLAB 编写相关程序,实现高斯消去法的求解。
2、能够用矩阵理论理解与研究高斯消去法,通过对矩阵的初等变换实现高斯消去法。
3、学会矩阵的三角分解,并且能够用MATLAB 编写相关程序,实现矩阵的三角分解,解方程组。
二、上机内容⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡=⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡2822171310871234567112345611123451111234111112311111121111111764321x x x x x x1、用列主元素高斯消去法求解方程组。
2、用列主元消去法求解方程组(实现PA=LU) 要求输出: (1)计算解X;(2)L,U;(3)正整型数组IP(i),(i=1,···,n) (记录主行信息)。
三、实验原理1、列主元素消去法用高斯消去法求解方程组时,为了减小误差,在消去的过程中要避免用绝对值较小的主元素。
因此在高斯消去法的每一步应该在系数矩阵货消去后的低阶矩阵中选取绝对值较大的元素作为主元素,保持|m ik |<=1,以减小计算过程中的舍入误差对计算解的影响。
此方法为完全主元素消去法。
完全主元素消去法在选主元素时花费一定的计算机时间,因此实际计算中常用列主元消去法。
列主元消去法在每次选主元时,仅依次按列选取绝对值最大的元素作为主元素,且仅交换两行,再进行消元计算。
装订 线第k步计算如下:对于k=1,2,…,n-1(1)按列选主元:即确定t使(2)如果t≠k,则交换[A,b]第t行与第k行元素。
(3)消元计算(4)回代求解计算流程图回代求解 b=b/a (当a nn ≠0)b ←(b -∑a x )/adet=a nn *det输出计算解及行列式及detk=1,2,…,n-1输入n ,A,b,εdet=1按列主元|a i(k),k |=max|a ik |C 0=a i(k),k换行 a ik a i(k)j(j=k,…n ) b k b j(k), 消元计算 (i=k+1,…,n ) a ik=a ik -a kk *m ik a ij=a ij -a kj *m ik (j=k+1,…,n )|C 0|<εi k =kdet=a kk det否否是是k<=n-1输出det(A)=0停机停机2. 矩阵的三角分解法 (1)定理设 n n R A ⨯∈ 。
顺序循环队列实验报告

一、实验目的1. 理解顺序循环队列的概念和原理。
2. 掌握顺序循环队列的初始化、入队、出队等基本操作。
3. 通过编程实现顺序循环队列,并验证其功能。
二、实验原理顺序循环队列是一种利用一维数组实现队列的存储结构。
它将一维数组看作是首尾相连的循环结构,队列的头部和尾部在数组的两端。
顺序循环队列的特点是:队列满时,头指针和尾指针相差一个数组的长度;队列空时,头指针和尾指针相等。
顺序循环队列的基本操作如下:1. 初始化:创建一个顺序循环队列,并设置头指针和尾指针。
2. 入队:将元素插入队列尾部。
3. 出队:从队列头部删除元素。
4. 判断队列是否为空或满。
三、实验内容1. 创建顺序循环队列类。
2. 实现顺序循环队列的初始化、入队、出队等基本操作。
3. 编写测试代码,验证顺序循环队列的功能。
四、实验步骤1. 创建顺序循环队列类,定义队列长度、头指针、尾指针等属性。
2. 实现顺序循环队列的初始化方法,初始化头指针和尾指针。
3. 实现顺序循环队列的入队方法,判断队列是否已满,如果未满,将元素插入队列尾部,并更新尾指针;如果已满,则提示队列已满。
4. 实现顺序循环队列的出队方法,判断队列是否为空,如果为空,则提示队列已空;如果未空,则从队列头部删除元素,并更新头指针。
5. 编写测试代码,创建顺序循环队列实例,执行入队和出队操作,验证顺序循环队列的功能。
五、实验结果与分析1. 初始化顺序循环队列```pythonclass CircularQueue:def __init__(self, size):self.queue = [None] sizeself.head = 0self.tail = 0self.count = 0self.maxsize = size```2. 入队操作```pythondef enqueue(self, item):if self.count == self.maxsize:print("Queue is full")else:self.queue[self.tail] = itemself.tail = (self.tail + 1) % self.maxsizeself.count += 1```3. 出队操作```pythondef dequeue(self):if self.count == 0:print("Queue is empty")else:item = self.queue[self.head]self.queue[self.head] = Noneself.head = (self.head + 1) % self.maxsize self.count -= 1return item```4. 测试代码```pythondef test_circular_queue():queue = CircularQueue(5)print("Enqueue 1 to 5:")for i in range(1, 6):queue.enqueue(i)print(queue.queue)print("Dequeue 1 to 5:")for _ in range(5):print(queue.dequeue())print(queue.queue)test_circular_queue()```实验结果分析:通过测试代码,我们可以看到顺序循环队列在初始化、入队和出队操作时都能正确执行。
算法冒泡排序实验报告(3篇)

第1篇一、实验目的本次实验旨在通过实现冒泡排序算法,加深对排序算法原理的理解,掌握冒泡排序的基本操作,并分析其性能特点。
二、实验内容1. 冒泡排序原理冒泡排序是一种简单的排序算法,它重复地遍历要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。
遍历数列的工作是重复地进行,直到没有再需要交换,也就是说该数列已经排序完成。
2. 实验步骤(1)设计一个冒泡排序函数,输入为待排序的数组,输出为排序后的数组。
(2)编写一个主函数,用于测试冒泡排序函数的正确性和性能。
(3)通过不同的数据规模和初始顺序,分析冒泡排序的性能特点。
3. 实验环境(1)编程语言:C语言(2)开发环境:Visual Studio Code(3)测试数据:随机生成的数组、有序数组、逆序数组三、实验过程1. 冒泡排序函数设计```cvoid bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}```2. 主函数设计```cinclude <stdio.h>include <stdlib.h>include <time.h>int main() {int n;printf("请输入数组长度:");scanf("%d", &n);int arr = (int )malloc(n sizeof(int)); if (arr == NULL) {printf("内存分配失败\n");return 1;}// 生成随机数组srand((unsigned)time(NULL));for (int i = 0; i < n; i++) {arr[i] = rand() % 100;}// 冒泡排序bubbleSort(arr, n);// 打印排序结果printf("排序结果:\n");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}printf("\n");// 释放内存free(arr);return 0;}```3. 性能分析(1)对于随机生成的数组,冒泡排序的平均性能较好,时间复杂度为O(n^2)。
C语言上机实验

实验一(第1章实验)实验目的:1.掌握运行C语言程序的全过程。
2.熟悉编译环境。
3.初步熟悉C语言程序的语法规定。
4.了解简单函数的使用方法。
实验内容:1.编程且上机运行:求3个整数的和。
2.编程且上机运行:求2个数的和、差、积和商。
3.编程且上机运行:输入3个数,求最大值。
4.编程且上机运行:输入圆的半径,求圆的面积和周长。
5.在屏幕上输出:“hello world!”实验结果:实验二(第3章实验)1.实验目的:理解C语言的类型系统。
实验内容:写程序测试数据-2在类型char,int,unsigned int,long int,unsigned long int 中存储情况。
实验过程:实验结果:参见各种类型的存储实现描述。
2.实验目的:了解混合类型计算中类型的转换规则。
实验内容:写程序测试多种类型数据一起运算时类型的转换及表达式结果的类型。
注意unsigned int和int数据运算时类型转换的方向。
实验过程:/** 类型转换问题* 试问下面两个表达式等价吗?*/#include <stdio.h>#include <stdlib.h>int main() {unsigned int ui,uj;ui = 1;uj = 2;if (ui < uj)printf("\n%u < %u is true !\n", ui, uj);elseprintf("\n%u < %u is false !\n", ui, uj);if (ui - uj < 0)printf("\n%u - %u <0 is true !\n", ui, uj);elseprintf("\n%u - %u <0 is false !\n", ui, uj);system("pause");return 0;}实验结果:参见类型转换规则。
R语言实验三

实验三数组的运算、求解方程(组)和函数极值、数值积分【实验类型】验证性【实验学时】2 学时【实验目的】1、掌握向量的四则运算和内积运算、矩阵的行列式和逆等相关运算;2、掌握线性和非线性方程(组)的求解方法,函数极值的求解方法;3、了解 R 中数值积分的求解方法。
【实验内容】1、向量与矩阵的常见运算;2、求解线性和非线性方程(组);3、求函数的极值,计算函数的积分。
【实验方法或步骤】第一部分、课件例题:1.向量的运算x<-c(-1,0,2)y<-c(3,8,2)v<-2*x+y+1vx*yx/yy^xexp(x)sqrt(y)x1<-c(100,200); x2<-1:6; x1+x22.x<-1:5y<-2*1:5x%*%ycrossprod(x,y)x%o%ytcrossprod(x,y)outer(x,y)3.矩阵的运算A<-matrix(1:9,nrow=3,byrow=T);AA+1 #A的每个元素都加上1B<-matrix(1:9,nrow=3); BC<-matrix(c(1,2,2,3,3,4,4,6,8),nrow=3); C D<-2*C+A/B; D #对应元素进行四则运算x<-1:9A+x #矩阵按列与向量相加E<-A%*%B; E #矩阵的乘法y<-1:3A%*%y #矩阵与向量相乘crossprod(A,B) #A的转置乘以Btcrossprod(A,B) #A乘以B的转置4.矩阵的运算A<-matrix(c(1:8,0),nrow=3);At(A) #转置det(A) #求矩阵行列式的值diag(A) #提取对角线上的元素A[lower.tri(A)==T]<-0;A #构造A对应的上三角矩阵qr.A<-qr(A);qr.A #将矩阵A分解成正交阵Q与上三角阵R的乘积,该结果为一列表Q<-qr.Q(qr.A);Q;R<-qr.R(qr.A);R #显示分解后对应的正交阵Q与上三角阵Rdet(Q);det(R);Q%*%R #A=Q*Rqr.X(qr.A) #显示分解前的矩阵5.解线性方程组A<-matrix(c(1:8,0),nrow=3,byrow=TRUE)b<-c(1,1,1)x<-solve(A,b); x #解线性方程组Ax=bB<-solve(A); B #求矩阵A的逆矩阵BA%*%B #结果为单位阵6.非线性方程求根f<-function(x) x^3-x-1 #建立函数uniroot(f,c(1,2)) #输出列表中f.root为近似解处的函数值,iter为迭代次数,estim.prec为精度的估计值uniroot(f,lower=1,upper=2) #与上述结果相同polyroot(c(-1,-1,0,1)) #专门用来求多项式的根,其中c(-1,-1,0,1)表示对应多项式从零次幂项到高次幂项的系数7.求解非线性方程组(1)自编函数: (Newtons.R)Newtons<-function (funs, x, ep=1e-5, it_max=100){index<-0; k<-1while (k<=it_max){ #it_max 表示最大迭代次数x1 <- x; obj <- funs(x);x <- x - solve(obj$J, obj$f); #Newton 法的迭代公式norm <- sqrt((x-x1) %*% (x-x1))if (norm<ep){ index<-1; break #index=1 表示求解成功}; k<-k+1 }obj <- funs(x);list(root=x, it=k, index=index, FunVal= obj$f)} # 输出列表(2)调用求解非线性方程组的自编函数funs<-function(x){ f<-c(x[1]^2+x[2]^2-5, (x[1]+1)*x[2]-(3*x[1]+1)) # 定义函数组J<-matrix(c(2*x[1], 2*x[2], x[2]-3, x[1]+1), nrow=2,byrow=T) # 函数组的 Jacobi 矩阵list(f=f, J=J)} # 返回值为列表 : 函数值 f 和 Jacobi 矩阵 Jsource("F:/wenjian_daima/Newtons.R") # 调用求解非线性方程组的自编函数Newtons(funs, x=c(0,1))8.一元函数极值f<-function(x) x^3-2*x-5 # 定义函数optimize(f,lower=0,upper=2) # 返回值 : 极小值点和目标函数f<-function(x,a) (x-a)^2 # 定义含有参数的函数optimize(f,interval=c(0,1),a=1/3) # 在函数中输入附加参数9.多元函数极值(1)obj <-function (x){ # 定义函数F<-c(10*(x[2]-x[1]^2),1-x[1]) # 视为向量sum (F^2) } # 向量对应分量平方后求和nlm(obj,c(-1.2,1))(2)fn<-function(x){ # 定义目标函数F<-c(10*(x[2]-x[1]^2), 1-x[1])t(F)%*%F } # 向量的内积gr <- function(x){ # 定义梯度函数F<-c(10*(x[2]-x[1]^2), 1-x[1])J<-matrix(c(-20*x[1],10,-1,0),2,2,byrow=T) #Jacobi 矩阵2*t(J)%*%F } # 梯度optim(c(-1.2,1), fn, gr, method="BFGS")最优点 (par) 、最优函数值 (value)10.梯形求积分公式(1)求积分程序: (trape.R)trape<-function(fun, a, b, tol=1e-6){ # 精度为 10 -6N <- 1; h <- b-a ; T <- h/2 * (fun(a) + fun(b)) # 梯形面积 repeat{h <- h/2; x<-a+(2*1:N-1)*h; I <-T/2 + h*sum(fun(x)) if(abs(I-T) < tol) break; N <- 2 * N; T = I }; I}(2)source("F:/wenjian_daima/trape.R") # 调用函数f<-function(x) exp(-x^2)trape(f,-1,1)(3)常用求积分函数f<-function(x)exp(-x^2) # 定义函数integrate(f,0,1)integrate(f,0,10)integrate(f,0,100)integrate(f,0,10000) # 当积分上限很大时,结果出现问题integrate(f,0,Inf) # 积分上限为无穷大ft<-function(t) exp(-(t/(1-t))^2)/(1-t)^2 # 对上述积分的被积函数 e 2 作变量代换 t=x/(1+x) 后的函数integrate(ft,0,1) # 与上述计算结果相同,且精度较高第二部分、教材例题:1.随机抽样(1)等可能的不放回的随机抽样:> sample(x, n) 其中x为要抽取的向量, n为样本容量(2)等可能的有放回的随机抽样:> sample(x, n, replace=TRUE)其中选项replace=TRUE表示有放回的, 此选项省略或replace=FALSE表示抽样是不放回的sample(c("H", "T"), 10, replace=T)sample(1:6, 10, replace=T)(3)不等可能的随机抽样:> sample(x, n, replace=TRUE, prob=y)其中选项prob=y用于指定x中元素出现的概率, 向量y与x等长度sample(c("成功", "失败"), 10, replace=T, prob=c(0.9,0.1))sample(c(1,0), 10, replace=T, prob=c(0.9,0.1))2.排列组合与概率的计算1/prod(52:49)1/choose(52,4)3.概率分布qnorm(0.025) #显著性水平为5%的正态分布的双侧临界值qnorm(0.975)1 - pchisq(3.84, 1) #计算假设检验的p值2*pt(-2.43, df = 13) #容量为14的双边t检验的p值4.limite.central( )的定义limite.central <- function (r=runif, distpar=c(0,1), m=.5,s=1/sqrt(12),n=c(1,3,10,30), N=1000) {for (i in n) {if (length(distpar)==2){x <- matrix(r(i*N, distpar[1],distpar[2]),nc=i)}else {x <- matrix(r(i*N, distpar), nc=i)}x <- (apply(x, 1, sum) - i*m )/(sqrt(i)*s)hist(x,col="light blue",probability=T,main=paste("n=",i), ylim=c(0,max(.4, density(x)$y)))lines(density(x), col="red", lwd=3)curve(dnorm(x), col="blue", lwd=3, lty=3, add=T)if( N>100 ) {rug(sample(x,100))}else {rug(x)}}}5.直方图x=runif(100,min=0,max=1)hist(x)6.二项分布B(10,0.1)op <- par(mfrow=c(2,2))limite.central(rbinom,distpar=c(10,0.1),m=1,s=0.9)par(op)7.泊松分布: pios(1)op <- par(mfrow=c(2,2))limite.central(rpois, distpar=1, m=1, s=1, n=c(3, 10, 30 ,50)) par(op)8.均匀分布:unif(0,1)op <- par(mfrow=c(2,2))limite.central( )par(op)9.指数分布:exp(1)op <- par(mfrow=c(2,2))limite.central(rexp, distpar=1, m=1, s=1)par(op)10.混合正态分布的渐近正态性mixn <- function (n, a=-1, b=1){rnorm(n, sample(c(a,b),n,replace=T))}limite.central(r=mixn, distpar=c(-3,3),m=0, s=sqrt(10), n=c(1,2,3,10)) par(op)11.混合正态分布的渐近正态性op <- par(mfrow=c(2,2))mixn <- function (n, a=-1, b=1){rnorm(n, sample(c(a,b),n,replace=T))}limite.central(r=mixn, distpar=c(-3,3),m=0,s=sqrt(10),n=c(1,2,3,10)) par(op)第三部分、课后习题:3.1a=sample(1:100,5)asum(a)3.2(1)抽到10、J、Q、K、A的事件记为A,概率为P(A)=1(5220)其中在R中计算得:> 1/choose(52,20)[1] 7.936846e-15(2)抽到的是同花顺P(B)=(41)(91) (525)在R中计算得:> (choose(4,1)*choose(9,1))/choose(52,5) [1] 1.385e-053.3#(1)x<-rnorm(1000,mean=100,sd=100)hist(x)#(2)y<-sample(x,500)hist(y)#(3)mean(x)mean(y)var(x)var(y)3.4x<-rnorm(1000,mean=0,sd=1) y=cumsum(x)plot(y,type = "l")plot(y,type = "p")3.5x<-rnorm(100,mean=0,sd=1) qnorm(.025)qnorm(.975)t.test(x)由R结果知:理论值为[-1.96,1.96],实际值为:[-0.07929,0.33001]3.6op <- par(mfrow=c(2,2))limite.central(rbeta, distpar=c(0.5 ,0.5),n=c(30,200,500,1000))par(op)3.7N=seq(-4,4,length=1000)f<-function(x){dnorm(x)/sum(dnorm(x))}n=f(N)result=sample(n,replace=T,size = 1000)standdata=rnorm(1000)op<-par(mfrow=c(1,2)) #1行2列数组按列(mfcol)或行(mfrow)各自绘图hist(result,probability = T)lines(density(result),col="red",lwd=3)hist(standdata,probability = T)lines(density(standdata),col="red",lwd=3) par(op)。
电大在线编程实验报告(3篇)

第1篇一、实验目的通过本次在线编程实验,旨在提高我的编程能力,加深对编程语言的理解,熟悉编程环境的使用,并培养良好的编程习惯。
同时,通过实际编程练习,解决实际问题,提升我的逻辑思维和问题解决能力。
二、实验内容本次实验选择了电大在线编程平台提供的C语言编程课程,主要包括以下内容:1. C语言基本语法;2. 数据类型、变量和运算符;3. 控制结构(分支和循环);4. 函数的定义和调用;5. 数组、指针和字符串操作;6. 文件操作。
三、实验步骤1. 准备工作:登录电大在线编程平台,选择C语言编程课程,熟悉编程环境和操作界面。
2. 编写代码:根据实验指导书,逐个完成实验任务,编写相应的C语言程序。
3. 调试程序:使用调试工具,检查代码中的错误,修正语法错误和逻辑错误。
4. 运行程序:成功编译并运行程序,观察输出结果,确保程序功能符合预期。
5. 总结与反思:对实验过程中遇到的问题进行总结,分析原因,提出改进措施。
四、实验结果与分析1. C语言基本语法:通过实验,我掌握了C语言的基本语法,包括数据类型、变量、运算符等。
2. 控制结构:实验中,我学会了使用if语句、switch语句进行分支控制,以及for循环、while循环进行循环控制。
3. 函数:通过编写和调用函数,我了解了函数的定义、参数传递和返回值等概念。
4. 数组、指针和字符串操作:实验中,我掌握了数组的定义、初始化、访问和操作方法,了解了指针的概念和用法,以及字符串操作函数。
5. 文件操作:通过实验,我学会了使用文件操作函数,实现文件的读写操作。
五、实验总结通过本次在线编程实验,我收获颇丰。
以下是我对本次实验的总结:1. 编程能力得到提高:通过实际编程练习,我对C语言有了更深入的了解,编程能力得到提升。
2. 问题解决能力增强:在实验过程中,我遇到了各种问题,通过查阅资料、请教同学和老师,我学会了如何分析和解决实际问题。
3. 良好的编程习惯:在实验过程中,我养成了良好的编程习惯,如规范命名、注释代码、代码复用等。
数组菜单制作实验报告

一、实验目的1. 理解数组的基本概念和应用场景。
2. 掌握数组的创建、初始化和访问方法。
3. 学会使用数组实现简单的菜单制作功能。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3. 开发工具:PyCharm三、实验内容本次实验通过使用数组实现一个简单的菜单制作功能,主要分为以下几个步骤:1. 创建数组存储菜单项2. 打印菜单3. 获取用户输入并处理4. 根据用户选择执行相应操作四、实验步骤1. 创建数组存储菜单项```pythonmenu = ["1. 添加商品", "2. 查看商品", "3. 修改商品", "4. 删除商品", "5. 退出"]```2. 打印菜单```pythonprint("欢迎使用商品管理系统!")for i in range(len(menu)):print(f"{i + 1}. {menu[i]}")```3. 获取用户输入并处理```pythonwhile True:choice = input("请选择操作(1-5):")if choice == '5':print("感谢使用,再见!")breakelif choice in ['1', '2', '3', '4']:print(f"您选择了:{menu[int(choice) - 1]}") # 这里可以添加相应操作的具体实现else:print("输入有误,请重新输入!")```4. 根据用户选择执行相应操作```pythonif choice == '1':# 添加商品passelif choice == '2':# 查看商品passelif choice == '3':# 修改商品passelif choice == '4':# 删除商品pass```五、实验结果1. 运行程序后,首先显示欢迎信息,然后打印出菜单。
2022年国家开放大学《数据结构(本)》形考任务实践活动3

实验
数据结构课程实验报告
学生姓名
学 号
班 级
指导老师
实验名称
栈、队列、递归程序设计
实验成绩
实验报告
实 验 概 述
实验目的:
编写一个算法,输出指定栈中的栈底元素,并使得原栈中的元素倒置。
实验要求:
(1)正确理解栈的先进后出的操作特点,建立初始栈,通过相关操作显示栈底元素。
printf ("(2)栈为%s\n”, (StackEmpty(s)?"空":"非空"));
printf("(3)输入要进栈的数据个数:”);
scanf(飞d”, &n):
printf("依次输入进栈的%d个整数n);
for(i=0; i<n; i++) (
scanf&x);
Push(s, x);
(2)程序中要表达出建栈过程和取出栈底元素后恢复栈的入栈过程,按堆栈的操作 规那么打印结果栈中的元素。
实验基本原理:
(1)采用顺序栈,即用数组存储栈元素。
(2)设定一个临时队列,用来存放从初始栈中出栈的元素。
(3)取出栈底元素后,将队列中的元素逐一出队并压入初始栈中。
卖 验 内 容
实验设计思路、步骤和方法等:
x=Pop(s);
printf(*%d ", x);
InQueue(sq, x);
)
printf ("(10)栈为%s, ”, (StackEmpty(s)?"空":"非空〃));printf("队列为%s\n”, (QueueEmpty(sq)?"空":"非空〃));printf ("(11)出队/进栈的元素依次为;
数据类型实验报告(3篇)

第1篇一、实验目的1. 理解和掌握基本数据类型的概念及特点。
2. 掌握不同数据类型的存储方式和表示方法。
3. 能够根据实际需求选择合适的数据类型。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.8.53. 开发工具:PyCharm三、实验内容1. 基本数据类型实验2. 复杂数据类型实验3. 数据类型转换实验四、实验步骤及结果1. 基本数据类型实验(1)实验目的:了解基本数据类型的概念及特点。
(2)实验步骤:① 定义变量并赋值:a = 10,b = 'hello',c = 3.14② 输出变量的类型:print(type(a)),print(type(b)),print(type(c))(3)实验结果:变量a的类型为int,变量b的类型为str,变量c的类型为float。
2. 复杂数据类型实验(1)实验目的:了解复杂数据类型的概念及特点。
(2)实验步骤:① 定义列表:list1 = [1, 2, 3, 'a', 'b', 'c']② 定义元组:tuple1 = (1, 2, 3, 'a', 'b', 'c')③ 定义字典:dict1 = {'name': 'Tom', 'age': 18, 'gender': 'male'}④ 定义集合:set1 = {1, 2, 3, 'a', 'b', 'c'}(3)实验结果:列表list1的类型为list,元组tuple1的类型为tuple,字典dict1的类型为dict,集合set1的类型为set。
3. 数据类型转换实验(1)实验目的:掌握不同数据类型之间的转换方法。
(2)实验步骤:① 将字符串转换为整数:str1 = '123',int1 = int(str1)②将整数转换为浮点数:int2 = 10,float1 = float(int2)③ 将浮点数转换为字符串:float2 = 3.14,str2 = str(float2)(3)实验结果:字符串str1转换为整数int1的结果为123,整数int2转换为浮点数float1的结果为10.0,浮点数float2转换为字符串str2的结果为'3.14'。
(中央电大)数据结构实验报告3

中央广播电视大学实验报告(学科:数据结构)姓名班级学号实验日期成绩评定教师签名批改日期实验名称:实验三二叉树3.1 二叉树的顺序存储结构和链式存储结构【问题描述】设一棵完全二叉树用顺序存储方法存储于数组tree中,编写程序:(1)根据数组tree,建立与该二叉树对应的链式存储结构。
(2)对该二叉树采用中序遍历法显示遍历结果。
【基本要求】(1)在主函数中,通过键盘输入建立设定的完全二叉树的顺序存储结构。
(2)设计子函数,其功能为将顺序结构的二叉树转化为链式结构。
(3)设计子函数,其功能为对给定二叉树进行中序遍历,显示遍历结果。
(4)通过实例判断算法和相应程序的正确性。
【实验步骤】(1)运行PC中的Microsoft Visual C++ 6.0程序,(2)点击“文件”→“新建”→对话窗口中“文件”→“c++ Source File”→在“文件名”中输入“X1.cpp”→在“位置”中选择储存路径为“桌面”→“确定”,(3)输入程序代码,程序代码如下:#include<stdio.h>#include<malloc.h>#include<string.h>#include<stdlib.h>#include<memory.h>#define MaxSize 10typedef struct node{char data。
struct node *left,*right。
}NODE。
void Creab(char *tree,int n,int i,NODE *p)。
void Inorder(NODE *p)。
void main(){NODE *p。
char tree[MaxSize]。
int n=1。
int i=1。
printf("请输入完全二叉数的节点值(连续输入字符,以回车结束输入。
):")。
while((tree[n] = getchar( )) != '\n') n++。
数组和串实验总结(合集3篇)

【实验目的】(1)掌握数组的声明创建;(2)掌握数组的初始化;(3)掌握数组常用的操作;【实践1内容】打印数组元素该程序应提示用户输入几个整数,将它们存储到数组中,然后以向前和向后的顺序打印出这些整数。
完成程序,使其正常运行。
使用数组使程序足够灵活,无论用户想要多少个整数,它都可以工作。
运行示例如下:你要输入多少个数据? 4 请输入一个整数: 12 请输入一个整数: 8请输入一个整数: -2 请输入一个整数: 39正向顺序: 12 8 -2 39 逆向顺序: 39 -2 8 12数组和串实验总结第2篇行优先存储:掌握自己推导三角矩阵对角矩阵三对角矩阵(带状矩阵)的压缩存储|i-j|>1时,有ai,j = 0(1<=i,j<=n)行优先对于一个n*n的矩阵,最多只有n个非0元素,只需存储n个对角元素信息即可。
直接采用一维数组d[i]存储M(i,i)的值稀疏矩阵三元组 <行,列,值>定义一个新的结构体十字链表定义一个新的结构体杨辉三角形,又称贾宪三角形,帕斯卡三角形,是二项式系数在三角形中的一种几何排列。
二项式定理与杨辉三角形是一对天然的数形趣遇,它把数形结合带进了计算数学。
求二项式展开式系数的问题,实际上是一种组合数的计算问题。
用系数通项公式来计算,称为“式算”;用杨辉三角形来计算,称作“图算”。
其实,中国古代数学家在数学的许多重要领域中处于遥遥领先的地位。
中国古代数学史曾经有自己光辉灿烂的篇章,而杨辉三角的发现就是十分精彩的一页。
杨辉三角示例如下:通过二维数组实现杨辉三角形前N行的求值并打印输出。
实验3 数组编程

实验三数组编程(设计性实验)一、实验目的1.进一步理解和掌握Java语言中数组的概念;2.掌握数组在方法中的使用,包括把数组传递给方法和从方法中返回数组,并能使用数组进行程序设计。
二、实验教学要求1.性质:必做实验实验类型:设计性2.时间要求:在讲完“数组”之后安排,需要6学时。
2.对学生的要求:编写好程序。
3.对教师的要求:预做本实验。
4.对实验室的要求:在windows环境中装有Java开发工具(如J2SE5.0版),以及IE6.0以上版本。
二、实验原理创建Java数组需要下面三个步骤:①声明数组声明数组的语法格式有如下两种:数组元素类型数组名[ ];数组元素类型[ ] 数组名;如int a[ ];int[ ] a;②创建数组空间声明数组仅仅指定了数组的名字和数组元素的类型,要想真正使用数组还需要为它分配内存空间,即创建数组空间。
在创建数组空间时,必须指明数组的长度,以确定空间的精确大小。
语法格式为:数组名=new 数组元素类型[数组元素的个数];如:int a[ ];a=new int[10];以上两步可组合在一起,用一条语句完成:int a[ ]=new int[10];用new运算符为数组分配内存空间的同时,数组的每个元素都会被自动赋予一个默认值。
整型为0,浮点型为0.0,字符型为'\0',布尔型为false,引用型为null。
③初始化数组元素如果是基本数据类型,那么这个步骤可以自行省略。
也可以在创建数组空间的时候,同时将初始值给出。
如:int a[ ]={1,2,3,4}; //int[] a=new int[]{1,2,3,4}在Java语言中,一个数组就是一个对象。
每个数组都有一个属性length,用来指明数组的长度。
数组元素的类型可以是基本数据类型,也可以是类类型,因此可以使用数组来包含一系列的对象。
student ——类名student s[ ]=new student[50];创建元素需使用如下形式的代码段:for(int i=0;i<s.length;++i){s[i]=new student( );}三、实验实例1.数据排序。
使用函数输出指定范围内的fibonacci数c语言实验报告

使用函数输出指定范围内的fibonacci数c语言实验报告以下是一个使用函数输出指定范围内Fibonacci数的C语言实验报告:一、实验目的1. 掌握函数的使用方法;2. 掌握循环语句的使用方法;3. 掌握数组的使用方法。
二、实验内容1. 定义一个函数,用于计算Fibonacci数列的第n项;2. 定义一个函数,用于输出指定范围内的Fibonacci数列。
三、实验步骤1. 定义函数,计算Fibonacci数列的第n项。
可以使用递归或迭代的方式实现,这里采用迭代的方式实现。
```cint fibonacci(int n) {if (n <= 1) {return n;} else {return fibonacci(n-1) + fibonacci(n-2);}}```2. 定义函数,输出指定范围内的Fibonacci数列。
可以使用循环语句实现。
```cvoid print_fibonacci(int start, int end) {int i;for (i = start; i <= end; i++) {printf("%d ", fibonacci(i));}printf("\n");}3. 在主函数中调用print_fibonacci函数,输出指定范围内的Fibonacci数列。
```cint main() {int start, end;printf("请输入Fibonacci数列的起始项和结束项(用空格分隔):"); scanf("%d %d", &start, &end);printf("Fibonacci数列%d到%d为:", start, end);print_fibonacci(start, end);return 0;}```四、实验结果与分析在本次实验中,我们使用函数实现了计算Fibonacci数列和输出指定范围内的Fibonacci数列的功能。
数据结构实验三——二叉树基本操作及运算实验报告

《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目,以及二叉树常用运算。
问题分析:二叉树树型结构是一类重要的非线性数据结构,对它的熟练掌握是学习数据结构的基本要求。
由于二叉树的定义本身就是一种递归定义,所以二叉树的一些基本操作也可采用递归调用的方法。
处理本问题,我觉得应该:1、建立二叉树;2、通过递归方法来遍历(先序、中序和后序)二叉树;3、通过队列应用来实现对二叉树的层次遍历;4、借用递归方法对二叉树进行一些基本操作,如:求叶子数、树的深度宽度等;5、运用广义表对二叉树进行广义表形式的打印。
算法规定:输入形式:为了方便操作,规定二叉树的元素类型都为字符型,允许各种字符类型的输入,没有元素的结点以空格输入表示,并且本实验是以先序顺序输入的。
输出形式:通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印,再以广义表形式进行打印。
对二叉树的一些运算结果以整型输出。
程序功能:实现对二叉树的先序、中序和后序遍历,层次遍历。
计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。
对二叉树的某个元素进行查找,对二叉树的某个结点进行删除。
测试数据:输入一:ABC□□DE□G□□F□□□(以□表示空格),查找5,删除E预测结果:先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A(B(C,D(E(,G),F)))叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5,成功,查找的元素为E删除E后,以广义表形式打印A(B(C,D(,F)))输入二:ABD□□EH□□□CF□G□□□(以□表示空格),查找10,删除B预测结果:先序遍历ABDEHCFG中序遍历DBHEAGFC后序遍历DHEBGFCA层次遍历ABCDEFHG广义表打印A(B(D,E(H)),C(F(,G)))叶子数3 深度4 宽度3 非空子孙数7 度为2的数目2 度为1的数目3查找10,失败。
数组及其应用实验报告(3篇)

第1篇一、实验目的1. 熟练掌握数组的定义、初始化、赋值和输入输出方法。
2. 掌握一维数组和二维数组的操作方法。
3. 学会使用数组进行数据存储和排序。
4. 理解数组在实际编程中的应用场景。
二、实验环境硬件:个人电脑软件:Windows操作系统、C语言编译器三、实验内容1. 一维数组的定义、初始化和赋值2. 一维数组的输入输出3. 一维数组的查找与排序4. 二维数组的定义、初始化和赋值5. 二维数组的输入输出6. 二维数组的遍历7. 数组在实际编程中的应用案例四、实验步骤1. 一维数组的定义、初始化和赋值```cinclude <stdio.h>int main() {int array[5]; // 定义一个包含5个整数的数组array[0] = 1; // 赋值操作array[1] = 2;array[2] = 3;array[3] = 4;array[4] = 5;return 0;}```2. 一维数组的输入输出```cinclude <stdio.h>int main() {int array[5];printf("请输入5个整数:\n"); for (int i = 0; i < 5; i++) { scanf("%d", &array[i]);}printf("输入的数组元素为:\n"); for (int i = 0; i < 5; i++) { printf("%d ", array[i]);}return 0;}```3. 一维数组的查找与排序```cinclude <stdio.h>void selectionSort(int array[], int length) {for (int i = 0; i < length - 1; i++) {int minIndex = i;for (int j = i + 1; j < length; j++) {if (array[j] < array[minIndex]) {minIndex = j;}}int temp = array[minIndex];array[minIndex] = array[i];array[i] = temp;}}int main() {int array[5] = {3, 1, 4, 1, 5};int length = sizeof(array) / sizeof(array[0]); selectionSort(array, length);printf("排序后的数组为:\n");for (int i = 0; i < length; i++) {printf("%d ", array[i]);}return 0;}```4. 二维数组的定义、初始化和赋值```cinclude <stdio.h>int main() {int array[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}; return 0;}```5. 二维数组的输入输出```cinclude <stdio.h>int main() {int array[3][4];printf("请输入一个3x4的二维数组:\n");for (int i = 0; i < 3; i++) {for (int j = 0; j < 4; j++) {scanf("%d", &array[i][j]);}}printf("输入的二维数组为:\n");for (int i = 0; i < 3; i++) {for (int j = 0; j < 4; j++) {printf("%d ", array[i][j]);}printf("\n");}return 0;}```6. 二维数组的遍历```cinclude <stdio.h>int main() {int array[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}; for (int i = 0; i < 3; i++) {for (int j = 0; j < 4; j++) {printf("%d ", array[i][j]);}printf("\n");}return 0;}```7. 数组在实际编程中的应用案例(1)计算矩阵的转置```cinclude <stdio.h>void transposeMatrix(int matrix[][3], int rows, int cols, int transposed[][3]) {for (int i = 0; i < rows; i++) {for (int j = 0; j < cols; j++) {transposed[j][i] = matrix[i][j];}}}int main() {int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};int rows = 3, cols = 3, transposed[3][3];transposeMatrix(matrix, rows, cols, transposed);printf("矩阵的转置为:\n");for (int i = 0; i < rows; i++) {for (int j = 0; j < cols; j++) {printf("%d ", transposed[i][j]);}printf("\n");}return 0;}```(2)计算数组中最大值和最小值```cinclude <stdio.h>void findMaxMin(int array[], int length, int max, int min) { max = array[0];min = array[0];for (int i = 1; i < length; i++) {if (array[i] > max) {max = array[i];}if (array[i] < min) {min = array[i];}}}int main() {int array[] = {1, 3, 5, 7, 9};int length = sizeof(array) / sizeof(array[0]);int max, min;findMaxMin(array, length, &max, &min);printf("数组中的最大值为:%d,最小值为:%d\n", max, min);return 0;}```五、实验结果及分析本次实验通过一系列的实例,使我们对数组及其应用有了更深入的了解。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
x x x x大学计算机与信息技术学院for(int i=0;i<list.length;i++){System.out.print(" "+list[i]); //输出已排序数组}}}运行结果贴图:2.插入排序import java.util.*;public class LX3_2 {public static void main(String[] args) {double []text={ 7, 4, 3, 9, 0, 6};insertionSort(text);}public static void insertionSort(double [] list){for(int i=1;i<list.length;i++){double currentElement=list[i]; //找见现在排序的元素int k;for(k=i-1;k>=0&&list[k]>currentElement;k--){list[k+1]=list[k]; //移动出插入位置}list[k+1]=currentElement; //放入插入数据}for(int i=0;i<list.length;i++){System.out.print(" "+list[i]); //输出已排序数组}}}运行结果贴图:3冒泡排序import java.util.*;public class LX3_3 {public static void main(String[] args) {double []text={ 7, 4, 3, 9, 0, 6};Sort(text);}public static void Sort(double [] list){for(int i=0;i<list.length;i++){for(int j=list.length-1;j>i;j--){ //length-1 length超出围if(list[j]<list[j-1]){double t=list[j];list[j]=list[j-1];list[j-1]=t;}}}System.out.println("排序结果是:");for(int i=0;i<list.length;i++){System.out.print(" "+list[i]); //输出已排序数组}}}‘运行结果贴图:(2)编写程序实现两个矩阵的相加、相乘。
要求程序运行结果形如如下显示:Array c1 2 34 5 67 8 9Array d2 2 21 1 13 3 3Array c+d3 4 55 6 710 11 12Array c*d13 13 1331 31 3149 49 49for (int i = 0; i < 3; i++) {for (int j = 0; j < 3; j++) {Answer[i][j] = cheng1[i][0] * cheng2[0][j] + cheng1[i][1]* cheng2[1][j] + cheng1[i][2] * cheng2[2][j];}}shuChu(Answer);}}运行结果贴图:(3)将用“;”和“,”分割的包含数字字符的字符串“23,21.3,33;34,2,1.9,2.1;3,3,1,3,4,4.9”中的数据解析出来放在一个double类型的二维数组中,以分号分割二维数组的每一行,以逗号分割每行中的各个元素。
(利用String 的split方法)程序代码:(4)查看帮助、编写例子利用System类中的arraycopy()方法复制数组。
分别用Arrays类中的sort方法和binarySearch方法实现数组的排序和折半查找。
程序代码:1.复制数组:public class LX3_6 {public static void main(String[] args) {int[] old = { 1, 2, 3, 4, 5, 6, 7 };int[] copy = new int[7];System.arraycopy(old, 0, copy, 0, old.length);// TODO Auto-generated method stubfor (int i = 0; i < copy.length; i++) {System.out.println(copy[i]);}}}运行结果贴图:2.数组排序:import java.util.*;public class LX3_7 {public static void main(String[] args) { double[] te = { 7, 4, 3, 9, 0, 6 };Arrays.sort(te); // 多种方法重载for (int i = 0; i < te.length; i++) {System.out.println(te[i]);}}}运行结果贴图:3.折半查找:import java.util.*;public class LX3_8 {public static void main(String[] args) {double[] te = { 1, 9, 21, 31, 44, 56, 78, 99 };System.out.println("请输入要查找的数");Scanner input = new Scanner(System.in);int i = input.nextInt();System.out.println(Arrays.binarySearch(te, i));}}运行结果贴图:(5)随机生成100个小写字母,统计每个字母出现的次数,并显示出来。
(利用Math.random()方法随机产生)程序代码:public class LX3_9 {public static void main(String[] args) {char[] number = new char[100];for (int i = 0; i < number.length; i++) {number[i] = (char) ('a' + Math.random() * ('z' - 'a' + 1));}CountNumber(number);}public static void CountNumber(char[] Count) {int[] counts = new int[26];for (int i = 0; i < Count.length; i++) {counts[Count[i] - 'a']++; //count字符减字符存到相应的位置}SystemOut(counts);}public static void SystemOut(int[] syso) {for (int i = 0; i < syso.length; i++) {System.out.println((char) (i + 'a') + "出现的次数是:" + syso[i]);//i对应a~z }}}运行结果贴图:(6)建立一个不规则的二维数组如下,并在控制台显示,数组如下1 3 52 4 6 81 9 16 25 3610 20 301 2 3 4 5 6程序代码:public class LX3_10 {public static void main(String[] args) {int[][] new1 = { { 1, 3, 5 }, { 2, 4, 6, 8 }, { 1, 9, 16, 25, 36 }, { 10, 20, 30 }, { 1, 2, 3, 4, 5, 6 } };for (int i = 0; i < 5; i++) {for (int j = 0; j < new1[i].length; j++) {System.out.printf("%-4d", new1[i][j]);}System.out.println();}}}运行结果贴图:(7)编写两个重载的方法分别交换两个整型变量,和整型数组的第一个和第二个元素,运行并分析结果程序代码:public class LX3_11 {public static void main(String[] args) {int a = 2, b = 5;int[] c = { 2, 5};Switch(a, b);Switch(c);}public static void Switch(int a, int b) {int t;t = a;a = b;b = t;System.out.println("交换以后:");System.out.println("a=" + a + " b=" + b);}public static void Switch(int[] a) {int t;t = a[0];a[0] = a[1];a[1] = t;System.out.println("a[0]=" + a[0] + " a[1]=" + a[1]);}}运行结果贴图:课后作业题P153 5.16 5.23 5.25P184 6.13P186 6.26P202 7.1 7.2 7.6 7.23*5.16程序代码:public class LX3_12 {public static void main(String[] args) {for (int i = 2000; i <= 2010; i++) {System.out.println(i + "年的天数是" + numberOfDaysInYear(i));}}public static int numberOfDaysInYear(int year) {if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) { return 366;} else {return 365;}}}运行结果贴图:5.23程序代码:public class LX3_13 {public static void main(String[] args) {System.out.println("100个大写字母:");SysOut('A', 'Z');System.out.println("100个一位数:");SysOut('0', '9');}public static char getRandomCharacter(char ch1, char ch2) { return (char) (ch1 + Math.random() * (ch2 - ch1 + 1));}public static void SysOut(char zf1, char zf2) {for (int i = 0; i < 10; i++) {for (int j = 0; j < 10; j++) {System.out.printf("%-4c", getRandomCharacter(zf1, zf2));}System.out.println();}}}运行结果贴图:5.25程序代码:import java.util.*;public class LX3_14 {public static void main(String[] args) {Scanner input = new Scanner(System.in);System.out.println("请输入毫秒数:");long i = input.nextLong();System.out.println(convertMillis(i));}public static String convertMillis(long mills) {long a = mills / 3600000;long b = (mills - a * 3600000) / 60000;long c = (mills - a * 3600000 - b * 60000) / 1000;return (a + ":" + b + ":" + c); /* 转换为String类型 1.i+"空或字符串"; 2 String.valueOf(i);*/}}运行结果贴图:6.13程序代码:public class LX3_15 {public static void main(String[] args) {int[] a = { 1, 4, 13, 51 };System.out.println(getRandom(a));}public static int getRandom(int... numbers) { int s = (int) (1 + Math.random() * 54);for (int i = 0; i < numbers.length; i++) { int a = numbers[i] - s;if (a == 0) {s = getRandom(numbers);}}return s;}}运行结果贴图:7.1程序代码:import java.util.*;public class LX3_17 {/*** param args*/public static void main(String[] args) {System.out.println("Enter a 4-by-4 matrix now by row:");System.out.println("Sun of the matrix is " + add(creatArrays()));}public static int[][] creatArrays() {int[][] array1 = new int[4][4];Scanner input = new Scanner(System.in);for (int i = 0; i < 4; i++) {for (int j = 0; j < 4; j++) {array1[i][j] = input.nextInt();}}return array1;}public static int add(int[][] list) { int sum = 0;for (int i = 0; i < 4; i++) {for (int j = 0; j < 4; j++) {sum = sum + list[i][j];}}return sum;}}运行结果贴图:7.2程序代码:7.6程序代码:import java.util.Scanner;public class LX3_19 {/*** param args*/public static void main(String[] args) {System.out.print("Enter matrix1:");double[][] array1 = creatArrays();System.out.print("Enter matrix2:");double[][] array2 = creatArrays();double[][] array3 = Cheng(array1, array2);System.out.println("The matrices are multiplied as follows:");sysOut(array1, array2, array3);// TODO自动生成的方法存根}}return Answer;}}运行结果贴图:7.23程序代码:import java.util.*;public class LX3_20 {public static void main(String[] args) {double[][] arrayText = creatArrays();double su = 1 / count1(arrayText);double[][] arrayText2 = array2(arrayText);double[][] arrayText3 = array3Count(arrayText2, su);print(arrayText3);}}return arry3;}public static void print(double[][] list4) {for (int i = 0; i < 3; i++) {for (int j = 0; j < 3; j++) {System.out.printf("%2g ", list4[i][j]);}System.out.println();}}}运行结果贴图:。