实验五数组（C++）

叁歲伎倆 2022-04-24 02:34 226阅读 0赞

## **实验五   数组（C++）** ##

**一、****实验目的**

1、进一步加深对数组的理解，掌握数组的定义方法；

2、掌握数组的处理方法、数组作为函数参数的使用方法，以及搜索与排序的应用。

3、理解内存动态分配的含义、熟练掌握内存动态分配方法；

**二、****实验内容**

1、打印不同的数：

编写一个程序，读入10个数，输出其中不同的数（即如果一个数出现多次，只打印一次）。

2、起泡排序：

利用起泡排序算法编写一个排序函数。

编写测试程序，读入一个含有10个双精度数字的数组，调用函数并显示排列后的数字。

3、游戏：存物柜问题：

一个学校有100个存物柜，100个学生。开学第一天所有存物柜都是关闭的。第一个学生（记为S1）来到学校后，打开所有的存物柜。第二个学生S2，从第二个存物柜（记为L2）开始，每隔两个存物柜，将它们关闭。第三个学生S3从第三个存物柜L3开始，每隔三个，将它们的状态改变（开着的关上，关着的打开）。学生S4，从L4开始，每隔四个改变它们的状态。学生S5，从L5开始，每隔五个改变状态。依此类推，直至学生S100改变L100的状态。

当所有学生完成这个过程，那些存物柜是开着的？编写一个程序求解此问题，显示所有开着的柜子号码，号码之间用一个空格隔开。

4、合并两个排列好的数组：

编写如下函数，合并两个排列好的数组，形成一个新的排列好的数组。

void merge(const int list1\[\], int size1, const int list2\[\], int size2, int list3\[\])

使用size1+size2次比较实现函数。编写测试程序，提示用户输入两个排列好的数组，并显示合并以后的数组。注意，输入数据的第一个数字是数组的元素数，而不是数组的一部分。假定数组大小不超过80。

5、检验子串：

编写如下函数，检验C字符串s1是否是C字符串s2的子串。如果匹配，返回s1在s2中的下标，否则返回–1。

int indexOf(const char s1\[\], const char s2\[\])

编写测试程序，读入两个C字符串，检验C字符串s1是否是C字符串s2的子串。

6、字符串中每个字母出现的次数：

请使用如下函数头编写函数，数出字符串中每个字母出现的次数。

void count(const char s\[\], int counts\[\])

counts是一个有26个元素的整数数组。const\[0\]，const\[1\]，…，const\[25\]分别记录a，b，…，z出现的次数。字母不分大小写，例如字母A和字母a都被看作a。

编写测试程序，读入字符串并调用count函数，显示非零的次数。

**三、****实验步骤、算法与结果分析**

**（一）数组**

***1、打印不同的数：编写一个程序，读入10个数，输出其中不同的数***

1.1 流程图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70][]

1.2 程序

#include<iostream>
    using namespace std;
    int main()
    {
    	const int size=10;
    	int list[size];
    	cout<<"Please enter ten numbers : "<<endl;
    	for(int i=0;i<size;i++)
    		cin>>list[i];
    	cout<<list[0]<<" ";
    	for(int m=1;m<size;m++)
    	{
    		for(int j=0;j<m;j++)
    		{
    			if(list[m]!=list[j])
    			{
    				if(j==m-1)
    					cout<<list[m]<<" ";
    				else
    					continue;
    			}
    			else
    				break;
    		}
    	}
    
    	cout<<endl;
    
    	return 0;
    }

1.3 结果

![20190411185549728.png][]

***2、起泡排序：利用起泡排序算法编写一个排序函数。***

***编写测试程序，读入一个含有10个双精度数字的数组，调用函数并显示排列后的数字。***

2.1 流程图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 1][]

2.2 程序

#include<iostream>
    using namespace std;
    
    const int size=10;
    
    void bubbleSort(double list[10]){
        double temp;
        bool changed = true;
    	do
    	{
    		changed = false;
    		for (int j = 0; j < size - 1; j++){
    			if (list[j] > list[j+1]){
    				temp=list[j];
    				list[j]=list[j+1];
    				list[j+1]=temp;
    				changed = true;
    			}
            }
        } while (changed==true);
    }
    
    int main()
    {
    	double list[size];
    	cout<<"Please enter ten number : \n";
    	for(int i=0;i<size;i++)
    		cin>>list[i];
        bubbleSort(list);
    
    	for(int k=0;k<size;k++)
    			cout<<list[k]<<" ";
        cout<<endl;
    
    	return 0;
    }

2.3 结果

![20190411190952110.png][]

*3、游戏：存物柜问题*

3.1 流程图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 2][]

3.2 程序

#include<iostream>
    using namespace std;
    
    int main()
    {
    	const int size=100;
    	bool list[size];
    	for (int i=0;i<size;i++)
    	{
    		list[i]=false;
    	}
    	for (int j=0;j<size;j++)
    	{
    		for (int k=j;k<size;k+=j+1)
    		{
    			if (list[k])
    				list[k]=false;
    			else
    			    list[k]=true;
    		}
    	}
    	for (int m=0;m<size;m++)
    	{
    		if (list[m])
    			cout<<m+1<<"  ";
    	}
    	cout<<endl;
    
    	return 0;
    }

3.3 结果

![20190411191310516.png][]

***4、合并两个排列好的数组：***

***编写如下函数，合并两个排列好的数组，形成一个新的排列好的数组。***

***void merge(const int list1\[\], int size1, const int list2\[\], int size2, int list3\[\])***

***Enter list1: 5 1 5 16 61 111***

***Enter list1: 4 2 4 5 6***

***The merged list is 1 2 4 5 5 6 16 61 111***

4.1 流程图

![20190411191912903.png][]

4.2 程序

#include<iostream>
    #include<string>
    using namespace std;
    
    void arrange(const int list[],int size);
    void merge(const int list1[], int size1, const int list2[],int size2,int list3[]);
    
    int main()
    {
    	int size1,size2,size3;
    	cout<<"Enter size1: ";
    	cin>>size1;
    	cout<<"Enter list1: ";
    	int list1[size1];
    	for (int i=0;i<size1;i++)
    		cin>>list1[i];
    	cout<<"Enter size2: ";
    	cin>>size2;
    	cout<<"Enter list2: ";
    	int list2[size2];
    	for (int i=0;i<size2;i++)
    		cin>>list2[i];
    	size3=size1+size2;
    	int list3[size3];
    	merge(list1,size1,list2,size2,list3);
    
    	cout<<endl;
    	return 0;
    }
    
    void merge(const int list1[], int size1, const int list2[],int size2,int list3[])
    {
        int temp;
    	for (int j=0;j<size1;j++)
    		list3[j]=list1[j];
    	for(int k=0;k<size2;k++)
    		list3[size1+k]=list2[k];
    	cout<<"The merged list is : ";
    	for (int m=0;m<(size1+size2)-1;m++)
    		for(int b=0;b<(size1+size2)-1;b++)
    			if (list3[b]>list3[b+1])
    			{
    				temp=list3[b];
    				list3[b]=list3[b+1];
    				list3[b+1]=temp;
    			}
    	for (int a=0;a<(size1+size2);a++)
    		cout<<list3[a]<<"  ";
    }
    /*
    void arrange(const int list3[],int size)
    {
        int temp;
    	for (int m=0;m<size-1;m++)
    		for(int b=0;b<size-1;b++)
    			if (list3[b]>list3[b+1])
    			{
    				temp=list3[b];
    				list3[b]=list3[b+1];
    				list3[b+1]=temp;
    			}
    }
    */

4.3 结果

![20190411191940614.png][]

***5、检验子串：***

***编写如下函数，检验C字符串s1是否是C字符串s2的子串。如果匹配，返回s1在s2中的下标，否则返回–1。***

***int indexOf(const char s1\[\], const char s2\[\])***

***编写测试程序，读入两个C字符串，检验C字符串s1是否是C字符串s2的子串。下面是程序的运行样例：***

Enter the first string: welcome
    Enter the second string: We welcome you!
    indexOf(“welcome”, “We welcome you!”) is 3

Enter the first string: welcome
    Enter the second string: We invite you!
    indexOf(“welcome”, “We invite you!”) is –1

5.1 流程图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 3][]

5.2 程序

#include<iostream>
    #include<cstring>
    using namespace std;
    
    int indexOf(char *s1, char *s2);
    int main()
    {
    	int size=999;
    	char s1[size],s2[size];
    	cout<<"Enter the first string : ";
    	cin.getline(s1,size);
    	cout<<"Enter the second string: ";
        cin.getline(s2,size);
    	cout<<"indexOf(\""<<s1<<"\", \""<<s2<<"\") is "<<indexOf(s1,s2)<<endl;
    
    	return 0;
    }
    
    int indexOf(char *s1, char *s2)
    {
    	int a,b,index,j,k;
    	a=strlen(s1);
    	b=strlen(s2);
    	bool s3[a];
    	for(int m=0;m<a;m++)
    		s3[m]=false;
    	for(int i=0;i<b-a+1;i++)      //控制s2的首字母
    	{
    		for(j=0,k=i;(j<a)&&(k<i+a);j++,k++)      //控制s2的总输出数
    			if(s1[j]==s2[k])
    			{
    				index=i;
    				s3[j]=true;
    			}
    			int h=0;
    			for(int n=0;n<a;n++)
    			{
    				if(s3[n]==false&&i==b-a)
    				{
    					return -1;break;
    				}
    				if(s3[n])
    					h++;
    			}
    			if(h==a)
    			{
    				return index;
    			}
    	}
    
    }

5.3 结果

![20190411192639285.png][]

![20190411192647510.png][]

***6、字符串中每个字母出现的次数：***

***请使用如下函数头编写函数，数出字符串中每个字母出现的次数。***

***void count(const char s\[\], int counts\[\])***

***counts是一个有26个元素的整数数组。const\[0\]，const\[1\]，…，const\[25\]分别记录a，b，…，z出现的次数。字母不分大小写，例如字母A和字母a都被看作a。***

***编写测试程序，读入字符串并调用count函数，显示非零的次数。***

6.1 流程图

![20190411194420877.png][]

6.2 程序

#include <iostream>
    using namespace std;
    
    const int num1 = 26;   //num1=letters
    const int num2 = 99;  //num2=string
    
    void countLetters(const char list[],int counts[])
    {
    	for(int i=0;i<num1;i++)
    		counts[i]=0;
    	for(int j=0;j<num2;j++)
    	{
    		counts[list[j]-'a']++;
    		counts[list[j]-'A']++;
    	}
    }
    void displayCounts(const int counts[])
    {
    	for (int i=0;i<num1;i++){
    		if(counts[i]!=0)
    			cout<<static_cast<char>(i+'a')<<" : "<<counts[i]<<"  times "<<endl;
        }
    }
    
    int main()
    {
    	char list[num2];
    	int counts[num1];
    	cout<<"Enter a string : ";
    	cin.getline(list,num2);
    	countLetters(list,counts);
    	displayCounts(counts);
    
    	return 0;
    }

6.3 结果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 4][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70]: /images/20220221/40861d177c4b45c2a505ea013723fc71.png
[20190411185549728.png]: /images/20220221/2f5c34ca662646f88a52fd0eabfba1af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 1]: /images/20220221/130a18162074401e84f8438d55c90576.png
[20190411190952110.png]: /images/20220221/45c0c330a8ea4408b31fc6a73eaa9130.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 2]: /images/20220221/ca544d7ec4de43d6abdf848b2f2db5d7.png
[20190411191310516.png]: /images/20220221/b4a099c5dfc84d4499d58c02f4481358.png
[20190411191912903.png]: /images/20220221/595376ab3ae44e09b543863942bbb8c6.png
[20190411191940614.png]: /images/20220221/79fa34434ff0445ab479324066d6457e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 3]: /images/20220221/6a287b01c2c94fd7a1b4811932bb13a6.png
[20190411192639285.png]: /images/20220221/6d83770aeb65462b86969aea44891ec4.png
[20190411192647510.png]: /images/20220221/cb50d1a4b7e540c69cd1d4ee996f1527.png
[20190411194420877.png]: /images/20220221/604a56d2a2684dc7ad01fc8f62a680db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 4]: /images/20220221/4e2604d1a2be47c7ab08ced7681e5a74.png