数组及结构化程序设计实验报告
c语言实验报告《数组》
c语言实验报告《数组》C语言实验报告：数组引言：C语言是一门广泛应用于计算机编程领域的高级编程语言，其强大的功能和灵活性使得它成为了许多程序员的首选。
在C语言中，数组是一种非常重要的数据结构，它能够存储多个相同类型的元素，并通过索引来访问和操作这些元素。
本篇实验报告将重点介绍C语言中的数组，并通过实例来展示其用法和特性。
一、数组的定义和声明在C语言中，数组的定义和声明非常简单。
我们可以通过以下方式来定义一个数组：```数据类型数组名[数组大小];```其中，数据类型表示数组中元素的类型，数组名是我们给数组起的名称，而数组大小则表示数组中元素的个数。
例如，我们可以定义一个包含5个整数的数组：```int numbers[5];```这样，我们就成功地声明了一个名为numbers的整数数组，它包含了5个元素。
二、数组的初始化在声明数组的同时，我们还可以为数组的元素赋初值。
这个过程称为数组的初始化。
C语言提供了多种初始化数组的方式，例如：```int numbers[5] = {1, 2, 3, 4, 5};```上述代码将数组numbers的前5个元素分别初始化为1、2、3、4和5。
我们也可以只给部分元素赋初值，未赋初值的元素将自动被初始化为0：```int numbers[5] = {1, 2, 3};```这样，数组numbers的前3个元素将分别被初始化为1、2和3，而后两个元素将被初始化为0。
三、数组的访问和操作数组的访问和操作是我们使用数组的重要环节。
在C语言中，我们可以通过索引来访问和操作数组中的元素。
数组的索引从0开始，即第一个元素的索引为0，第二个元素的索引为1，以此类推。
例如，我们可以通过以下方式来访问数组numbers的第一个元素：```int firstNumber = numbers[0];```上述代码将数组numbers的第一个元素赋值给变量firstNumber。
同样，我们也可以通过索引来修改数组中的元素：```numbers[0] = 10;```上述代码将数组numbers的第一个元素修改为10。
c语言实验7数组实验报告
实验报告课程名称程序设计实验项目名称数组班级与班级代码14级计算机科学与技术1班实验室名称（或课室） SS1-332专业计算机科学与技术任课教师学号：姓名：实验日期：2014年月日广东商学院教务处制一．实验目的1.熟练掌握一维数组、二维数组的定义、赋值、输入、输出方法。
2.熟练掌握字符数组和字符串函数的使用。
3.熟练掌握一位数组以及一位数组元素的存储关系。
4.熟练掌握一位数组和二维数组的使用以及在函数中的传递。
5.通过上机实践掌握与数组有关的算法。
二、实验内容上机题1输入并运行以下程序。
实验内容：用2个数组对第3个数组进行赋值#include<stdio.h>main(){int i,a[5],b[5],c[5];a[0]=2,a[1]=6,a[2]=4,a[3]=8,a[4]=9;b[0]=2,b[1]=7,b[2]=9,b[3]=5,b[4]=3;for(i=0;i<=4;i++){c[i]=a[i]*b[i];printf("c[%d]=%d\n",i,c[i]);}}实验步骤○1int a[5]：整型一维数组说明，a是数组名，也是数组的起始地址，该数组可以存储5个整数。
a[0]～a[4]也可以看成是变量标识字符，[]中的数值称为数组下标，下标从0开始。
○2数组赋值方法和一般变量一样。
例如，a[0]=2表示将2赋给a[0]。
运行结果上机题2 输入并运行以下程序。
实验内容：对不指明数组的数组进行赋值并用循环结构进行求和#include<stdio.h>main(){int sum,i;int a[]={5,8,4,6,4,3,8,2,4,5,6};sum=0;for(i=0;i<=10;i++)sum+=a[i];printf("sum=%d\n",sum);}实验结果实验小结○1对全部元素赋初值时，可以不指定数组长度，C编译系统自动根据初值个数来决定数组长度。
C语言程序设计实验报告 数组
C语言程序设计实验报告数组实验目的：1. 了解数组的概念和使用方法；2. 掌握数组的定义和初始化；3. 掌握数组的遍历和元素访问；4. 掌握数组的排序算法和查找方法。
实验内容：一、数组的定义和初始化：1. 在C语言中，数组是一组有序、相同类型的元素的集合。
数组中的每个元素可以通过一个下标来标识，下标从0开始，最大为元素个数减1。
2. 定义数组的语法：类型名数组名[元素个数];3. 数组的初始化：可以在定义数组的同时进行初始化，也可以在定义后逐个赋值，还可以用花括号{}将初始值逐一列出进行初始化。
示例代码：```// 定义数组并初始化int a[5] = {5, 4, 3, 2, 1};// 定义数组后逐个赋值int b[3];b[0] = 1;b[1] = 2;b[2] = 3;// 使用花括号逐一初始化int c[] = {1, 2, 3, 4, 5};```二、数组的遍历和元素访问：1. 数组的遍历：可以使用for循环来遍历数组中的每个元素。
```int a[5] = {5, 4, 3, 2, 1};printf("%d", a[1]); // 输出4```三、数组的排序算法和查找方法：1. 排序算法：常用的数组排序算法有冒泡排序、插入排序和快速排序等。
```void bubbleSort(int a[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (a[j] > a[j + 1]) {temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;}}}}```2. 查找方法：常用的数组查找方法有线性查找和二分查找等。
实验结果：本次实验主要学习了数组的定义、初始化、遍历、元素访问、排序算法和查找方法。
数据结构实验报告一
数据结构实验报告一数据结构实验报告一一、引言数据结构是计算机科学中非常重要的一门课程，它研究的是数据的组织、存储和管理方式。
在本次实验中，我们将学习并实践一些常用的数据结构，包括数组、链表和栈。
通过实验，我们将深入理解这些数据结构的原理和应用。
二、实验目的本次实验的目的是通过编写代码实现一些常用的数据结构，并测试它们的功能和性能。
通过实际操作，我们将掌握这些数据结构的基本操作和使用方法。
三、实验过程1. 数组数组是一种线性数据结构，它由一组连续的存储单元组成。
在本次实验中，我们将实现一个动态数组，它可以根据需要自动调整大小。
我们首先定义一个数组类，包含插入、删除和查找等基本操作。
然后，我们编写测试代码，验证数组的功能和性能。
2. 链表链表是另一种常用的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中，我们将实现一个单向链表。
我们首先定义一个节点类，然后定义一个链表类，包含插入、删除和查找等基本操作。
最后，我们编写测试代码，验证链表的功能和性能。
3. 栈栈是一种特殊的线性数据结构，它只能在一端进行插入和删除操作。
栈的特点是后进先出（LIFO）。
在本次实验中，我们将实现一个栈。
我们首先定义一个栈类，包含入栈、出栈和查看栈顶元素等基本操作。
然后，我们编写测试代码，验证栈的功能和性能。
四、实验结果通过实验，我们成功实现了动态数组、单向链表和栈的基本操作。
我们编写了测试代码，并对这些数据结构的功能和性能进行了验证。
实验结果表明，这些数据结构在不同场景下都有很好的表现，并且可以满足我们的需求。
五、实验总结本次实验让我们更加深入地理解了数据结构的原理和应用。
通过实际编写代码并进行测试，我们掌握了数组、链表和栈等常用数据结构的基本操作和使用方法。
实验过程中，我们遇到了一些问题，但通过不断的调试和优化，最终成功解决了这些问题。
通过本次实验，我们不仅提高了编程能力，也增强了对数据结构的理解和应用能力。
数组程序设计实验报告
数组程序设计实验报告数组程序设计实验报告引言在计算机科学领域，数组是一种重要的数据结构，用于存储和操作大量相同类型的数据。
数组的使用广泛，无论是在算法设计还是软件开发中，都扮演着重要的角色。
本实验旨在通过编写数组程序，探索数组的特性和应用。
一、数组的定义与初始化数组是一种由相同类型的元素组成的集合，每个元素都可以通过索引访问。
在程序中，我们可以通过声明数组变量来定义一个数组。
例如，int numbers[5]就定义了一个包含5个整数的数组。
数组的初始化可以在声明时进行，也可以在后续的代码中进行。
二、数组的基本操作1. 访问数组元素数组元素可以通过索引来访问，索引从0开始。
例如，numbers[0]表示数组numbers的第一个元素。
通过循环遍历数组，我们可以逐个访问数组中的元素。
2. 修改数组元素数组元素的值可以通过索引进行修改。
例如，numbers[0] = 10将把数组numbers的第一个元素的值修改为10。
3. 数组的长度数组的长度是指数组中元素的个数。
在C语言中，可以通过sizeof运算符来获取数组的长度。
例如，sizeof(numbers) / sizeof(numbers[0])将返回数组numbers的长度。
三、数组的应用1. 数组的排序数组排序是数组程序设计中常见的任务之一。
常见的排序算法包括冒泡排序、选择排序和插入排序。
通过对数组元素进行比较和交换，可以将数组按照升序或降序排列。
2. 数组的搜索数组搜索是另一个常见的任务，它涉及在数组中查找特定的元素。
线性搜索是一种简单直观的搜索方法，它逐个比较数组元素，直到找到目标元素或搜索完整个数组。
二分搜索是一种更高效的搜索方法，它要求数组事先有序。
3. 多维数组除了一维数组，我们还可以使用多维数组来存储和处理更复杂的数据。
二维数组是最常见的多维数组形式，它可以看作是一个表格或矩阵。
通过使用行和列的索引，我们可以访问和修改二维数组中的元素。
结构化程序设计实训报告
一、实验背景结构化程序设计是一种计算机编程方法，旨在提高程序的可读性、可维护性和可扩展性。
通过使用顺序结构、选择结构和循环结构等基本程序结构，可以使程序更加清晰、易于理解。
本次实训旨在通过实践操作，使学生掌握结构化程序设计的基本思想和方法，提高编程能力。
二、实验目的1. 掌握结构化程序设计的基本思想。
2. 熟练掌握三种基本程序结构：顺序结构、选择结构和循环结构。
3. 学会利用结构化程序设计思想解决数据处理问题。
4. 掌握VF（Visual FoxPro）程序调试的基本方法，能进行基本的程序设计。
三、实验内容及步骤1. 实验内容本次实训主要包括以下内容：（1）顺序结构：编写一个简单的程序，实现数字1到10的累加。
（2）选择结构：编写一个程序，根据用户输入的年龄判断是否成年。
（3）循环结构：编写一个程序，计算1到100的整数之和。
（4）结合以上结构，实现一个简单的学生成绩管理系统。
2. 实验步骤（1）在VFP环境下新建一个程序文件，命名为“结构化程序设计实验.prg”。
（2）编写程序代码，实现实验内容。
（3）保存程序文件。
（4）运行程序，验证程序功能。
（5）对程序进行调试，解决可能出现的问题。
四、实验过程及结果1. 顺序结构实验代码如下：```visual foxpro顺序结构实验clearlocal sum = 0for i = 1 to 10sum = sum + iendfor"1到10的累加和为：" + str(sum) ```运行结果：1到10的累加和为：55 2. 选择结构实验代码如下：```visual foxpro选择结构实验clearlocal age = 18if age >= 18"您已成年"else"您还未成年"endif```运行结果：您已成年3. 循环结构实验代码如下：```visual foxpro循环结构实验clearlocal sum = 0for i = 1 to 100sum = sum + iendfor"1到100的整数之和为：" + str(sum)```运行结果：1到100的整数之和为：50504. 学生成绩管理系统代码如下：```visual foxpro学生成绩管理系统clearlocal score_list = {}local input_scorefor i = 1 to 5"请输入第" + str(i) + "位学生的成绩："input_score = input("请输入成绩：") aadd(score_list, input_score) endforlocal max_score = score_list[1]local min_score = score_list[1]for i = 2 to len(score_list)if score_list[i] > max_scoremax_score = score_list[i]endifif score_list[i] < min_scoremin_score = score_list[i]endifendfor"最高分为：" + str(max_score)"最低分为：" + str(min_score)```运行结果：请输入第1位学生的成绩：90请输入第2位学生的成绩：85请输入第3位学生的成绩：78请输入第4位学生的成绩：92请输入第5位学生的成绩：88最高分为：92最低分为：78五、实验总结1. 实验收获通过本次实训，我掌握了以下内容：（1）顺序结构、选择结构和循环结构的语句格式、功能及使用方法。
数组程序设计实验报告
数组程序设计实验报告《数组程序设计实验报告》在计算机科学领域，数组是一种非常重要的数据结构，它可以存储多个相同类型的数据，并且可以通过索引来访问和操作这些数据。
在本次实验中，我们将使用数组来设计和实现一些简单的程序，以加深对数组的理解和应用能力。
实验一：数组的基本操作在这个实验中，我们首先学习了如何声明和初始化数组，然后进行了一些基本的数组操作，比如访问数组元素、修改数组元素、以及遍历数组等。
通过这些操作，我们对数组的基本特性有了更深入的了解，并且能够更加灵活地使用数组来存储和处理数据。
实验二：数组的排序算法在这个实验中，我们学习了几种常见的数组排序算法，比如冒泡排序、选择排序和插入排序。
通过实现这些排序算法，我们深入理解了数组元素之间的比较和交换操作，以及不同排序算法的时间复杂度和空间复杂度。
同时，我们也学会了如何根据具体的需求选择合适的排序算法来优化程序性能。
实验三：数组的应用案例在这个实验中，我们将学习如何利用数组来解决实际的问题。
比如，我们可以使用数组来实现一个简单的学生成绩管理系统，或者用数组来存储和统计一组数据的频率分布。
通过这些案例，我们不仅能够加深对数组的理解，还能够提高自己的编程能力和解决问题的能力。
总结通过本次实验，我们对数组的基本操作、排序算法和应用案例有了更深入的了解，同时也提高了自己的编程能力和问题解决能力。
数组作为一种重要的数据结构，在实际的软件开发中有着广泛的应用，因此我们需要不断地学习和掌握数组的相关知识，以便更好地应用它们来解决实际的问题。
希望通过这次实验，我们能够更加熟练地使用数组，并且能够将所学到的知识应用到实际的软件开发中去。
《C程序设计》之数组实验报告
实验项目：数组（二）实验内容：实验1：输入两个字符串A和B，判断字符串B是否在A中出现，如果出现，给出在A中出现的位置（即B 串的第一个字符在A中第一次出现的位置,从一开始计）。
示例：A串：abcabcdeabcdefg B串：abcde结果：B串包含在A串中，位置是4实验2：输入10个人的姓名（拼音），用冒泡法排序，然后再用折半法查找给定的一个人名是否存在，如果存在给出位置。
姓名示例：Long Zhengji实验3：实现字符串联。
程序实现：程序：实验1：字符串的包含关系#include<stdio.h>#include<string.h>void main(){ char A[20],B[20];int n,m=0,i,j,a,b;printf("输入字符串A：");gets(A);printf("输入字符串B：");gets(B);a=strlen(A);b=strlen(B);printf("\n");for(i=0;i<=a-1;i++){ n=1;if(A[i]==B[0]){ n=0;for(j=1;j<=b-1;j++)if(A[i+j]!=B[j])n++;}if(!n){ printf("B串包含在A串中，位置是%d\n",i+1);m++;}}if(m==0)printf("B串不在A串中\n");}实验2：输入10个人的姓名（拼音），用冒泡法排序，然后再用折半法查找给定的一个人名是否存在，如果存在给出位置。
#include <stdio.h>#include <string.h>#define N 11void main(){char temp[10],name[10];char c;char str[N][20];int i,j,sign,top,bott,loca,flag=1,mid;printf("请输入10个人的名字：");printf("\n");for(i=0;i<11;i++)gets(str[i]);for(j=0;j<11;j++)for(i=0;i<10-j;i++)if(strcmp(str[i],str[i+1])>0){strcpy(temp,str[i]);strcpy(str[i],str[i+1]);strcpy(str[i+1],temp);}printf("对此10人的名字的排序为:\n");for(i=0;i<11;i++)printf("%s\n",str[i]);printf("\n");while(flag){printf("要查找的名字:");scanf("%s",name);sign=0;top=0;bott=N-1;if(strcmp(name,str[0])<0||strcmp(name,str[N-1])>0) loca=-1;while((!sign)&&(top<=bott)){mid=(bott+top)/2;if(strcmp(name,str[mid])==0){loca=mid;printf("找到了:%s，位于:%d\n",name,loca+1); sign=1;}else if(strcmp(name,str[mid])<0)bott=mid-1;elsetop=mid+1;}if(!sign||loca==-1)printf("没有此名\n");printf("是否继续(Y/N)？");scanf(" %c",&c);if(c=='N'||c=='n')flag=0;}}实验3：实现字符串联：#include<stdio.h>void main(){char s1[80],s2[40];int i=0,j=0;printf("输入字符1：");scanf("%s",s1);printf("输入字符2:");scanf("%s",s2);while(s1[i]!='\0')i++;while(s2[j]!='\0')s1[i++]=s2[j++];s1[i]='\0';printf("串起来的字符是：%s\n",s1);}运行结果：实验1：字符串的包含关系B在A中：B不在A中：实验2：输入10个人的姓名（拼音），用冒泡法排序，然后再用折半法查找给定的一个人名是否存在，如果存在给出位置。
数组程序实验报告
数组程序实验报告
《数组程序实验报告》
在计算机科学中，数组是一种非常重要的数据结构，它可以用来存储一系列相同类型的数据。
在本次实验中，我们将对数组程序进行实验，并对其进行详细的报告。
实验目的：
1. 了解数组的定义和基本操作
2. 掌握数组的初始化和赋值
3. 理解数组的遍历和查找
4. 掌握数组的排序和插入操作
实验步骤：
1. 定义一个数组并初始化
2. 对数组进行赋值操作
3. 遍历数组并查找特定元素
4. 对数组进行排序操作
5. 实现数组的插入操作
实验结果分析：
在实验过程中，我们成功地定义了一个数组并进行了初始化，然后对数组进行了赋值操作。
通过遍历数组并查找特定元素，我们发现数组的查找操作是非常高效的。
在对数组进行排序操作时，我们发现数组的排序操作能够快速地对数据进行排序。
最后，我们实现了数组的插入操作，成功地向数组中插入了新的元素。
结论：
通过本次实验，我们对数组的定义和基本操作有了更深入的了解，掌握了数组的初始化、赋值、遍历、查找、排序和插入操作。
数组作为一种重要的数据结构，在实际编程中具有广泛的应用价值，我们需要不断地加强对数组的理解和掌握，以便更好地应用于实际项目中。
通过本次实验的实践操作，我们对数组的实际应用有了更深入的了解，相信在今后的编程实践中，我们能够更加熟练地运用数组来解决实际的问题。
希望通过本次实验报告的分享，能够对大家有所帮助，也希望大家能够在今后的学习和工作中不断地加强对数组的理解和应用。
数组实验报告实验小结
一、实验背景随着计算机技术的不断发展，数组作为一种基本的数据结构，在编程领域得到了广泛的应用。
为了更好地理解和掌握数组的相关知识，我们进行了一系列的数组实验。
本次实验报告将对实验过程进行总结，并对实验结果进行分析。
二、实验目的1. 理解数组的基本概念和特点；2. 掌握数组的创建、访问和操作方法；3. 熟悉数组在编程中的应用；4. 培养实验操作能力和问题解决能力。
三、实验内容1. 数组的定义与创建2. 数组的初始化3. 数组元素的访问与修改4. 数组的排序与查找5. 数组的应用实例四、实验过程1. 数组的定义与创建实验一：定义一个整型数组，并初始化为10个元素。
代码如下：```c#include <stdio.h>int main() {int arr[10];// 初始化数组for (int i = 0; i < 10; i++) {arr[i] = i 2;}// 打印数组元素for (int i = 0; i < 10; i++) {printf("%d ", arr[i]);}printf("\n");return 0;}```2. 数组的初始化实验二：使用初始化列表直接初始化数组。
代码如下：```c#include <stdio.h>int main() {int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};// 打印数组元素for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) { printf("%d ", arr[i]);}printf("\n");return 0;}```3. 数组元素的访问与修改实验三：访问和修改数组元素。
代码如下：```c#include <stdio.h>int main() {int arr[5] = {1, 2, 3, 4, 5};// 访问数组元素printf("The first element is: %d\n", arr[0]);// 修改数组元素arr[0] = 10;printf("After modification, the first element is: %d\n", arr[0]); return 0;}```4. 数组的排序与查找实验四：使用冒泡排序算法对数组进行排序。
C语言程序设计实验报告-数组
一、实验项目名称数组二、实验目的1．掌握数组的基本概念，包括：数组的定义、数组的类型、数组的初始化、数组的赋值、数组元素下标的范围、数组元素的正确以及引用数组元素的输入/输出。
2．掌握字符数组与字符串的使用方法。
理解字符数组与其它数组的区别、理解字符串及其特点。
掌握常用的字符串处理库函数的用法并清楚对字符串的简单处理。
3．掌握与数组相关的算法，包括排序算法和查找算法等。
三、实验内容进行有关数组的程序设计。
具体内容：1．编程实现：对任意一个一维数组，从中找出数组元素的最大值和最小值。
要求：（1）数组为整型数组（10个元素）。
（2）使用scanf函数实现数组元素的输入。
在输入前给出必要的提示。
（3）输出时给出必要的说明，首先输出原始的10个元素，换行后输出最大值以及最大值在数组中的位置、最小值以及最小值在数组中的位置。
（4）如果现改为20个元素的数组，怎样修改程序？修改程序后，运行程序进行检查。
如果需要数组元素不断改变，应怎样修改程序？2．编程实现：在给定的字符串中查找满足条件的第一个字符。
要求：（1）字符串采用初始化的方式处理。
（2）通过scanf函数读入一个任意字符。
（3）在字符串中查找该字符，如果存在该字符，输出该字符在字符串中的位置以及相应的说明。
如果不存在该字符，则要给出相应的信息。
3．编程实现：首先任意输入一个大于2且小于10的整数n，再输入一个由n决定的二维整型数组（n ⨯n），形成n ⨯n阶矩阵，将矩阵中最大元素所在的行和最小元素所在的行对调后，再输出该矩阵（注意：数组不允许动态定义）。
例如：原始数据：n=4 结果数据：1 2 3 4 8 11 14 163 5 9 10 3 5 9 108 11 14 16 1 2 3 415 2 7 6 15 2 7 6要求：（1）本题中所涉及到的循环都采用for语句。
（2）在输入/输出时进行必要的说明。
（3）对输入的2～10之间的整数（例如4）以n=4的格式输出。
数组程序实验报告
数组程序实验报告数组程序实验报告引言：数组是一种常见的数据结构，它可以存储多个相同类型的元素，并通过索引来访问和操作这些元素。
在本次实验中，我们将学习如何使用数组来解决一些实际问题，并通过编写相应的程序来验证其有效性。
实验目的：1. 理解数组的概念和基本操作。
2. 掌握数组在不同场景下的应用。
3. 提高编程能力和问题解决能力。
实验内容：本次实验分为两个部分，分别是数组的创建和初始化，以及数组的操作和应用。
一、数组的创建和初始化：在编写数组程序之前，我们首先需要了解如何创建和初始化一个数组。
数组的创建可以通过声明一个变量并指定其类型为数组来实现，如int[] numbers;。
而数组的初始化则可以通过直接赋值或使用循环来实现。
1. 直接赋值初始化：例如，我们可以通过以下方式创建一个整型数组，并直接给数组元素赋值：int[] numbers = {1, 2, 3, 4, 5};2. 使用循环初始化：数组的初始化也可以通过使用循环来实现，这样可以方便地对数组进行批量赋值。
int[] numbers = new int[5];for (int i = 0; i < numbers.length; i++) {numbers[i] = i + 1;}二、数组的操作和应用：在实际应用中，我们经常需要对数组进行一些操作，例如遍历、查找最大/最小值、排序等。
下面我们将介绍几个常见的数组操作和应用。
1. 数组的遍历：遍历数组可以通过使用循环结构来实现，通过循环遍历数组的每个元素，并进行相应的操作。
int[] numbers = {1, 2, 3, 4, 5};for (int i = 0; i < numbers.length; i++) {System.out.println(numbers[i]);}2. 数组的查找：在数组中查找特定元素可以使用线性查找或二分查找等算法。
这里我们以线性查找为例，来实现查找某个元素的功能。
结构化程序设计(实验报告)
VFP数据库与程序设计作业与实验报告(第七章结构化程序设计)学号：姓名：专业：教师：第七章结构化程序设计【实验题目】结构化程序设计【实验目的】通过本次实验，让学生掌握程序文件的建立、修改和运行，程序设计常用命令，程序的顺序、选择和循环结构。
【实验准备】1.复习第七章程序设计基础所学知识，预习实验内容，写出相关命令和程序。
2.准备好前次实验所用的文件数据。
3.启动VFP6.0，将“我的VFP实验作业”文件夹设置为默认工作目录。
【实验内容及实验步骤】1.顺序结构程序设计1) 程序功能：显示学生表中前两条记录的学号、姓名、性别和入学成绩。
（将以下程序空格填写完整，建立程序并调试运行，将运行结果截图。
）use xs?”学号姓名性别入学成绩”?xh,xm,xb,rxcj？skip 1 &&移动指针到第二条记录? xh,xm,xb,rxcj &&显示信息use 运行结果（把截图放在此处）：2)编写程序，分别统计学生表中男生及女生的总人数。
并分别计算男、女生的入学平均成绩。
（提示：统计人数用COUNT集函数，计算平均成绩用AVG集函数。
请把正确的程序写在此处）clearselect xb,count(*),avg(rxcj) from xs group by xb into array aa?'男生总人数',aa(1,2)?'女生总人数',aa(2,2)?'男生入学平均成绩',aa(1,3)?'女生入学平均成绩',aa(2,3)2. 分支结构程序设计1） 程序功能： 完善下述程序段，计算分段函数的值。
⎪⎩⎪⎨⎧--=,103,13,2X X X Y 5522≥<≤<X X XCLEARINPUT “请输入X 的值：” to XIF X<2Y=2*XELSE IF x>=2.and.x<5Y=3*X-1ELSE Y=3*x-10ENDIFENDIF?”函数值 Y=”,Y2） 程序功能：在成绩(cj)表中查找学号为“0206101”且课程代号为“03”的记录，并给出成绩等级(优90-100;良80-89；中70-79；及格60-69；不及格60分以下)。
C语言程序设计实验报告数组
C语言程序设计实验报告（数组）1实验目的（1）熟练掌握一维数组，二维数组的定义，初始化和输入、输出方法；（2）熟练掌握字符数组和字符串函数的使用；（3）掌握与数组有关的常用算法（查找、排序等）。
2实验内容编写函数catStr(char str1[],char str2[])用于进行两个字符串的连接，编写函数lenStr(char str[])用于统计一个字符串的长度，并在主函数中调用。
要求：1、不允许用strcat()和strlen()字符处理库函数；2、在主函数以直接初始化的方式输入两个字符串str1和str2.调用函数strlen()计算并返回两个字符串的长度；3、调用函数catstr()连接两个字符串（将str2连接在str1后面）；4、调用函数lenstr()计算并返回连接后字符串的长度；5、在主函数中输入两个原始的字符串及几个字符串的长度，以及处理后字符串及其长度。
．算法描述流程图 3catStr函数lenStr函数开始开始定义函数定义函数lenStr(char str[])catStr(char str1[],char str2[])i=0;声名变量并赋i,j声名变量i=0,j=0初值m[i]!='\0'str1[i]!='\0' 真假str2[j]!='\0'printf(%d,i);str1[i+j]=str2[j];i++str1[i+j]='\0';结i++,j+结束主函数开始声名变量s1[50]=shi,s2[50]=weiyu;调用函数lenStr();并输调用函数catStr()的s1,s2输出出连接后的字符串字符长度输出连接后字再次调用函符串的长lenStr(结束源程序4#include<stdio.h>#include<string.h>catStr(char str1[],char str2[]) void{ int i,j;for (i=0;str1[i]!='\0';i++);for(j=0;str2[j]!='\0';j++) str1[i+j]=str2[j];str1[i+j]='\0';}lenStr(char m[] ){int i;for (i=0;m[i]!='\0';i++);printf(%d,i); }void main(){char s1[50]=orever,s2[50]=more;printf(s1=%s,s2=%s,s1,s2);printf(\s1的长度:);lenStr(s1);printf(\s2的长度:);lenStr(s2);catStr(s1,s2);printf(\连接后的字符:);printf(%s\n,s1);牰湩晴尨连接后字符的长度:);lenStr(s1);printf(\);}5测试数据s1=forever, s2=more6运行结果7出现问题及解决方法在输入程序时，少写了半边引号，调试时发现存在错误，找到了错误并加以改正。
数组程序设计实验结论
数组程序设计实验结论
在这次实验中，我们研究了数组的程序设计。
数组是一种常见的数据结构，它是由一组相同类型的元素组成的有序集合。
在这次实验中，我们研究了用C语言实现数组的基本操作，
包括插入元素、删除元素、搜索元素和排序元素等。
我们还研究了如何实现一个动态数组，它可以自动扩展容量，以容纳更多的元素。
我们也研究了如何使用数组来实现多项式的表达式，以及如何计算这个多项式的值。
我们还探讨了如何使用数组来存储二维图形的点的坐标，以及如何在图形中画出线段、圆和椭圆等图形。
最后，我们还研究了数组的时间复杂度，即操作数组所需要的时间。
我们发现，插入、删除和搜索元素的时间复杂度均为O（n），而排序数组的时间复杂度可以达到O（nlogn）。
总的来说，我们通过本次实验，对数组的程序设计有了更深入的理解。
我们研究了如何实现和使用数组，并了解了数组的时间复杂度。
数组的灵活性和高效的操作使它成为编程中最常用的数据结构之
一，因此，本次实验对我们的研究和实践都有很大的帮助。
结构数组实验报告
一、实验目的1. 理解结构体的概念及其在C语言中的定义和使用方法。
2. 掌握结构体数组的概念和操作，包括结构体数组的声明、初始化和访问。
3. 通过实际操作，加深对结构体数组在实际问题中的应用理解。
二、实验内容本次实验主要围绕结构体数组进行，具体内容包括：1. 定义一个学生结构体，包含学生的姓名、学号、年龄和成绩等字段。
2. 创建一个学生结构体数组，用于存储多个学生的信息。
3. 编写程序，实现以下功能：- 向结构体数组中添加学生信息。
- 根据学号查找学生信息。
- 按成绩对学生信息进行排序。
- 输出所有学生信息。
三、实验步骤1. 定义学生结构体：```ctypedef struct {char name[50];int id;int age;float score;} Student;```2. 创建学生结构体数组：```cStudent students[10]; // 假设最多存储10个学生信息```3. 向结构体数组中添加学生信息：```cvoid addStudent(Student s, char name, int id, int age, float score) { strcpy(s->name, name);s->id = id;s->age = age;s->score = score;}```4. 根据学号查找学生信息：```cStudent findStudentById(Student students, int size, int id) {for (int i = 0; i < size; i++) {if (students[i].id == id) {return &students[i];}}return NULL;}```5. 按成绩对学生信息进行排序（使用冒泡排序算法）：```cvoid sortStudentsByScore(Student students, int size) {for (int i = 0; i < size - 1; i++) {for (int j = 0; j < size - i - 1; j++) {if (students[j].score > students[j + 1].score) {Student temp = students[j];students[j] = students[j + 1];students[j + 1] = temp;}}}}```6. 输出所有学生信息：```cvoid printStudents(Student students, int size) {for (int i = 0; i < size; i++) {printf("Name: %s, ID: %d, Age: %d, Score: %.2f\n",students[i].name, students[i].id, students[i].age, students[i].score); }}```四、实验结果通过以上步骤，我们实现了一个简单的学生信息管理系统。
C语言 上机实验报告5 数组
打开Microsoft Visual C++ 6.0 ,创建文本并输入
五、源程序与运行结果：
六、上机实践收获和体会:
上机实验操作让我更加深刻的了解语言，要上机度多实践才能将C语言编程能力上升到了更高层次。
昆明理工大学信息工程与自动化学院学生实验报告
（2009—2010学年第1学期）
课程名称：结构化程序设计方法与C语言开课实验室：计算中心308室2009年12月2日
年级、专业、班
学号
姓名
成绩
实验项目名称
数组
指导教师
教师
评语
教师签名：
年 月 日
一、实验内容和目的
内容：计算10个同学中成绩最高的一个
目的：熟悉数组的使用
二、设计思路（程序设计框图）
起泡法
输入10个数赋值给a[10]
j=0
i=0
a[i]>a[i+1]？
是
否
t=a[i];
a[i]=a[i+1];
a[i+1]=t;
i++
直到i>9-jj++直 Nhomakorabeaj>9
输出a[10]
交换法
输入10个数赋值给a[10]
i=0
j=i+1
a[j]>a[i]？
是
否
t=a[j];
a[j]=a[i];
a[i]=t;
j++
直到j=n
i++
直到i=n-1
输出a[10]
选择法
输入10个数赋值给a[10]
i=0，k=i
j=i+1
数组程序实验报告
一、实验目的1. 理解数组的概念和基本操作。
2. 掌握数组的创建、初始化、赋值、遍历、排序等基本操作。
3. 通过实验加深对数组在实际问题中的应用。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 编译器：Visual Studio 2019三、实验内容1. 数组的创建与初始化2. 数组的赋值与遍历3. 数组的排序四、实验步骤1. 数组的创建与初始化（1）创建一个整型数组，名为array，大小为10。
```cppint array[10];```（2）使用循环对数组进行初始化。
```cppfor (int i = 0; i < 10; i++) {array[i] = i 2;}```2. 数组的赋值与遍历（1）将一个整型变量value赋值给数组的第一个元素。
```cppint value = 100;array[0] = value;```（2）使用循环遍历数组，打印每个元素的值。
```cppfor (int i = 0; i < 10; i++) {cout << "array[" << i << "] = " << array[i] << endl; }```3. 数组的排序（1）选择排序算法对数组进行排序。
```cppfor (int i = 0; i < 10 - 1; i++) {int minIndex = i;for (int j = i + 1; j < 10; j++) {if (array[j] < array[minIndex]) {minIndex = j;}}int temp = array[i];array[i] = array[minIndex];array[minIndex] = temp;}```（2）打印排序后的数组。
数据结构数组的实验报告
一试验目的和要求1. 实验目的了解数组的两种存储表示方法，并掌握数组在以行动为主的存储结构中的地址计算方法。
2.. 实验要求熟悉掌握数组的类型定义和表示方式；能够进行灵活的运用。
二实验环境本程序可以在98/2000/XP下运行,可以用VC++6.0执行三程序的逻辑框图四. 程序源代码#include<iostream.h>#include <iomanip.h>#include<malloc.h>#define TRUE 1#define ERROR 0#define OK 1#define MAXISIZE 100#define MAXRC 10struct Triple{int i,j; //行下标，列下标int e; //非零元数的值};struct TSMatrix{Triple data[MAXISIZE+1];int rpos[MAXRC+1];int mu,nu,tu; //矩阵的行数，列数，非零元数};int CreateSMatrix(TSMatrix &M){int i,m,n,f,num[MAXRC+1];int e;int k;for(i=0;i<=MAXRC;i++){M.rpos[i]=0;}cout<<"请依次输入矩阵的行数，列数，非零元数:\n";cin>>M.mu>>M.nu>>M.tu;M.data[0].i=0;for(i=1;i<=M.tu;i++){do{cout<<"输入第"<<i<<"个非零元素所在的行(1~"<<M.mu<<"),列(1~"<<M.nu<<"),元素值:\n";cin>>m>>n>>e;k=0; f=m;if(m<1||m>M.mu||n<1||n>M.nu){ k=1;cout<<"元素的行列数输入错误!\n";}if(m<M.data[i-1].i||m==M.data[i-1].i&&n<=M.data[i-1].j)k=1;}while(k);M.data[i].i=m;M.data[i].j=n;M.data[i].e=e;}for(i=1;i<=M.mu;i++){num[i]=0;}for(i=1;i<=M.tu;i++){num[M.data[i].i]++;}M.rpos[1]=1;for(i=2;i<=M.mu;i++){M.rpos[i]=M.rpos[i-1]+num[i-1];}return OK;}void DestroySMatrix(TSMatrix &M){M.mu=0;M.nu=0;M.tu=0;}void PrintSMatrix(TSMatrix M){int i;cout<<M.mu<<"行"<<M.nu<<"列"<<M.tu<<"个非零元数\n";cout<<"行列元素值\n";for(i=1;i<=M.tu;i++)cout<<M.data[i].i<<setw(4)<<" "<<M.data[i].j<<setw(4)<<""<<M.data[i].e<<endl;}int Cmp(int a,int b){ if(a<b) return 1;else if(a==b) return 0;else return -1;}int AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix &Q) {int p,i,tp1,tp2,j,q,s;Q.mu = M.mu; Q.nu = N.nu; Q.tu = 0;for(i=1;i<=M.mu;i++){if(i<M.mu){tp1=M.rpos[i+1];}else{tp1=M.tu+1;}if(i<N.mu){tp2=N.rpos[i+1];}else{tp2=N.tu+1;}j=M.rpos[i];q=N.rpos[i];while(j<tp1||q<tp2){if(M.data[j].j<N.data[q].j){if(j<tp1){s=0;for(p=N.rpos[i];p<tp2;p++){if(M.data[j].j==N.data[p].j){s=1;break;}}if(s==0){Q.tu++;Q.data[Q.tu].i=i;Q.data[Q.tu].j=M.data[j].j;Q.data[Q.tu].e=M.data[j].e;}j++;continue;}else{Q.tu++;Q.data[Q.tu].i=i;Q.data[Q.tu].j=N.data[q].j;Q.data[Q.tu].e=N.data[q].e;q++;continue;}}if(M.data[j].j==N.data[q].j&&j<tp1&&q<tp2) {if(M.data[j].e+N.data[q].e!=0){Q.tu++;Q.data[Q.tu].i=i;Q.data[Q.tu].j=M.data[j].j;Q.data[Q.tu].e=M.data[j].e+N.data[q].e;}j++;q++;continue;}if(M.data[j].j>N.data[q].j){if(q<tp2){s=0;for(p=M.rpos[i];p<tp1;p++){if(M.data[p].j==N.data[q].j){s=1;break;}}if(s==0){Q.tu++;Q.data[Q.tu].i=i;Q.data[Q.tu].j=N.data[q].j;Q.data[Q.tu].e=N.data[q].e; }q++;continue;}else{Q.tu++;Q.data[Q.tu].i=i;Q.data[Q.tu].j=M.data[j].j; Q.data[Q.tu].e=M.data[j].e;j++;continue;}}if(j==tp1&&q<tp2){s=0;for(p=M.rpos[i];p<tp1;p++) {if(M.data[p].j==N.data[q].j) {s=1;break;}}if(s==0){Q.tu++;Q.data[Q.tu].i=i;Q.data[Q.tu].j=N.data[q].j; Q.data[Q.tu].e=-1*N.data[q].e; }q++;continue;}if(j<tp1&&q==tp2){s=0;for(p=N.rpos[i];p<tp2;p++){if(M.data[j].j==N.data[p].j){s=1;break;}}if(s==0){Q.tu++;Q.data[Q.tu].i=i;Q.data[Q.tu].j=M.data[j].j;Q.data[Q.tu].e=M.data[j].e;}j++;continue;}}}return OK;}int SubSMatrix(TSMatrix M,TSMatrix N,TSMatrix &Q) {int i,l;for(i=1;i<=N.tu;i++)N.data[i].e*=-1;l=AddSMatrix(M,N,Q);return l;}void main(){ char a;int h;TSMatrix A,B,C;cout<<"创建矩阵A:\n";CreateSMatrix(A);PrintSMatrix(A);cout<<endl;cout<<"创建矩阵B:\n";CreateSMatrix(B);PrintSMatrix(B);cout<<endl;cout<<"*********************************************************** *******************"<<endl;cout<<"选择操作:"<<"1.求两稀疏矩阵的和"<<"2.求两稀疏矩阵的差"<<"3.退出";cout<<endl;cin>>a;while(a!='3'){switch(a){case '1':h=AddSMatrix(A,B,C);if(h==1){cout<<"两稀疏矩阵的和为:\n";PrintSMatrix(C); cout<<endl;}else cout<<"该两稀疏矩阵不能求和!\n"; break;case '2':h=SubSMatrix(A,B,C);if(h==1){ cout<<"两稀疏矩阵的差为:\n";PrintSMatrix(C); cout<<endl;}else cout<<"该两稀疏矩阵不能求差!\n"; break;default: cout<<"输入错误!请重新输入\n";}cout<<"请重新选择操作:"<<"1.求两稀疏矩阵的和"<<"2.求两稀疏矩阵的差"<<"3.退出"<<endl;cin>>a;}DestroySMatrix(A);DestroySMatrix(B);DestroySMatrix(C);}五. 实验数据和结果分析六.总结数组一般不作插入或删除操作，一旦建立了数组，则结构中的数据元素个数和元素之间的关系就不再发生变动。
编程数组结构实验报告
一、实验目的1. 理解数组的定义和特点。
2. 掌握数组的创建、初始化和访问方法。
3. 熟悉数组的基本操作，如插入、删除、查找等。
4. 提高编程能力，增强对数据结构的理解和应用。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 数组的定义和特点2. 数组的创建和初始化3. 数组的访问4. 数组的基本操作5. 数组的排序6. 数组的查找四、实验步骤1. 数组的定义和特点（1）定义：数组是一种基本的数据结构，用于存储相同数据类型的元素序列。
（2）特点：- 数组中的元素具有相同的数据类型；- 数组中的元素按照一定的顺序排列；- 数组中的元素可以通过下标进行访问。
2. 数组的创建和初始化（1）创建：使用列表（list）创建数组。
```python# 创建一个整型数组array = [1, 2, 3, 4, 5]```（2）初始化：可以使用多种方式初始化数组。
```python# 使用列表推导式初始化一个数组array = [i for i in range(1, 6)]# 使用列表切片初始化一个数组array = [0] 5```3. 数组的访问```python# 访问数组中的元素print(array[0]) # 输出：1print(array[-1]) # 输出：5```4. 数组的基本操作（1）插入```python# 在数组末尾插入一个元素array.append(6)# 在指定位置插入一个元素array.insert(2, 7)```（2）删除```python# 删除数组中的指定元素del array[2]# 删除数组中的最后一个元素array.pop()```（3）查找```python# 查找数组中指定元素的位置index = array.index(3) print(index) # 输出：2```5. 数组的排序```python# 对数组进行升序排序array.sort()# 对数组进行降序排序array.sort(reverse=True)```6. 数组的查找```python# 使用内置函数查找数组中指定元素if 4 in array:print("元素4存在于数组中。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
}
public static void printStarRecursion (int i,int size) {
if (i == 0)
return;
printStarRecursion (i - 1, size);
for (int k = 0;k < size - i; ++k)
2、随机生成两个0~255之间的整数，如果生成的两个整数相等，重新生成，否则求出它们的最大公约数和最小公倍数。（随机数的生成：请参看课本第七章7.3 Math类的静态方法random()或
3、（选做题）使用递归的方法，对用户给定的n，输出n行星号。如图为n=4
*
* * *
* * * * *
* * * * * * *
il.*;
public class test {
public static void main (String args[]) {
Scanner reader=newScanner(System.in);
int n=reader.nextInt();
printStar (n);
深 圳 大 学 实 验 报 告
课程名称：Java程序设计
实验项目名称：数组及结构化程序设计
学院：计算机与软件学院
姓名：学号：
日期：2014-10-8
指导教师：王平
一、实验目的与实验环境：
数组的使用，结构化程序设计。
二、方法、步骤：
1、要求用户从键盘输入数目，生成数组存放若干个同学的姓名、数学成绩，将成绩按降序排序。输出排序后的姓名与成绩。
}
Student ts =newStudent();
ts.test(stu);
ts.display(stu);
reader.close();
}
privatevoiddisplay(String[][] s) {
for(inti = 0; i < s.length; i++) {
for(intj = 0; j < s[i].length; j++) {
五、指导教师批阅意见：
成绩评定：
指导教师签字：
年月日
+" ");
}
;
}
}
privatevoidtest(String[][] s) {
for(intj = 0; j < s.length; j++) {
for(inti = 0; i < s.length- 1; i++) {
String[] ss;
if(s[i][1].compareTo(s[i + 1][1]) < 0) {
" ");
for (int k = 0;k < 2 * i - 1; ++k)
"*");
;
}
public static void printStar (int size) {
printStarRecursion(size, size);
}
}
4、实验结论及思考：
答：通过这次实验，熟悉了eclipse编程环境，对于java编程语言的应用也愈加熟练。
三、实验过程及结果：(源代码和程序运行截图)
1.代码：
packagetest1;
importjava.util.*;
publicclassStudent {
publicstaticvoidmain(String args[]){
Scanner reader=newScanner(System.in);
Random random=newRandom();
intn1=random.nextInt(256);
intn2=random.nextInt(256);
while(n1==n2){
n1=random.nextInt(256);
n2=random.nextInt(256);
}
"生成的二个数为%d和%d\n",n1,n2);
intnumber=0;
"请输入学生个数：");
number = reader.nextInt();
String[][] stu=newString[number][2];
for(inti=0;i<number;i++){
stu[i][0]=reader.next();
stu[i][1]=reader.next();
ss = s[i];
s[i] = s[i + 1];
s[i + 1] = ss;
}
}
}
}
}
截图：
2。代码：
packagetest1;
importjava.util.*;
publicclassMath {
publicstaticvoidmain(String args[]){
Scanner reader=newScanner(System.in);
intm=fun1(n1,n2);
"最大公约数为："+m);
"最小公倍数为："+(n1*n2)/m);
reader.close();
}
publicstaticintfun1(inta1,intb1){
intc;
c=a1%b1;
while(c>0) {
a1=b1;
b1=c;
c=a1%b1;
}
returnb1;