今天发疯，写一下学校的数组作业

用户11039545

发布于 2024-03-28 17:22:41

590

发布于 2024-03-28 17:22:41

文章被收录于专栏：c语言c语言

苦数组不会写题久矣，所以今天来写一下咕咕了许久的数组程序设计题

统计各分数段学生人数

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
	int score = 0;
	int excellent = 0;
	int pass = 0;
	int fail = 0;
	printf("请输入学生的成绩:");
	while (1) {	
		scanf("%d", &score);
		if (score >= 85) {
			excellent++;
		}
		if (score >= 60 && score <= 84) {
			pass++;
		}
		if (score < 60 && score>0) {
			fail++;
		}
		if (score <= 0) {
			break;
		}
	}
	printf("优秀的人数是：%d", excellent);
	printf("通过的人数是：%d", pass);
	printf("不及格的人数是：%d", fail);
	return 0;
}

输入 10个整数，求它们的平均值，并输出大于平均值的数据的个数

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
	int arr[10] = { 0 };
	int sum = 0;
	float ave = 0;
	int i = 0;
	int count = 0;
	for (i = 0; i < 10; i++) {
		printf("请输入一个整数：");
		scanf("%d", &arr[i]);
	}
	sum += arr[i];
	ave = (float)sum / 10;
	if (arr[i] > ave) {
		count++;
		printf("%d", arr[i]);	
	}
	return 0;
}

选择排序法

首先看一下选择排序的原理

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
void SelectionSort(int arr[], int n) {
	for (int i = 0; i < n - 1; i++) {
		//为什么这里是n-1呢？因为对于最后一个元素，不需要再和后面的元素比较进行排序了，当前已经是排完序的结果
		int minindex = i;//将最小值的值定义为i
		for (int j = i + 1; j < n; j++) {//为啥这里是i+1呢？因为例如对于第一个元素需要和第二个元素之后的元素进行比较
			if (arr[j] < arr[minindex]) {
				minindex = j;
}
				int temp = 0;
				temp = arr[minindex];
				arr[minindex] = arr[i];
				arr[i] = temp;//然后交换此次查找到的最小值和原始的最小值
			}
		}
	}
}
void PrintArray(int arr[], int n){
	for (int j = 0; j < n; j++) {
		printf("%d", arr[j]);
	}
	printf("\n"); 将换行符移出循环，使所有数字都在同一行打印，然后换行（原先写错）
}

int main(){
	int arr[] = { 13,45,78,76,33,44,58,82 };
	int n = sizeof(arr) / sizeof(arr[0]);
	SelectionSort(arr, n);
	printf("排序完成的数组是：\n");
	PrintArray(arr, n);
	return 0;
}

再来看看这道题目吧，与基本的选择排序不同，它要将n放在数组中进行排序

#define _CRT_SECRUE_NO_WARINGS
#include<stdio.h>
int selectionsort(int arr[],int n) {
	int i, j, minindex, temp;
	for (i = 0; i < n; i++) {
		minindex = i;

	}

}
int main() {
	int n;
	printf("请输入正整数n(n大于1且小于等于10):");
	scanf("%d", &n);
	if (n <= 1 || n > 10) {
		printf("输入的n不符合要求");
		return 1;//返回非0值表示程序异常结束
	}
	int arr[n] = { 0 };
	for (int i = 0; i < n; i++) {
		printf("请输入整数");
		scanf("%d", &arr[n]);
	}
	selectionsort(arr, n);
}

冒泡排序

最直接的冒泡排序

如果是对10个数字进行冒泡排序，那么需要进行9轮比较，每轮比较需要进行9+8+...+1次比较

如果是上述代码，运行存在一定问题。因为数组的传参只传首元素的地址。所以sz=sizeof(arr)/sizrof(arr[0]),即4/4=1。所以计算出的结果错误。

所以我们需要在外面计算好sz数值的大小，再进行计算。

#include<stdio.h>
void Bubble_sort(int arr[], int sz) {
	for (int i = 0; i < sz - 1; i++) {//这里为什么是sz呢，因为最后一个数字不用冒泡排序啦
		int j = 0;
		for ( j = 0; j < sz - i- 1; j++) {//每一次冒泡排序比较的次数都要根据其所在位置来决定
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = temp;
			}
		}
	}
}
int main() {
	int arr[] = { 3,2,9,4,7,8,1,5,6 };
	int i = 0;
	int sz;
	 sz = sizeof(arr) / sizeof(arr[0]);
	 Bubble_sort(arr, sz);
	for (i = 0; i < sz; i++) {
		printf("%d", arr[i]);
	}
	return 0;
}

冒泡排序的优化 1

上述代码存在的问题是：可能循环并没有完成，但是已经排序完成，这时候我们就可以加一个标记来判定排序是否完成。如果进行了交换，代表排序没有完成，如果没有进行交换，代表排序已经完成。所以，我们有了一个想法：在每次交换完成后，在最后一个交换的位置进行标记，其右侧为有序，其左侧为无序。我们在下一次循环中，只要对无序的进行冒泡排序即可。

#include<stdio.h>
void Bubble_sort(int arr[], int sz) {
	int limit = sz - 1;//有序数的边界（只需要对有序数的左侧进行排序）
	int last_change = 0;//标记每轮最后一次交换的位置
	for (int i = 0; i < sz - 1; i++) {//这里为什么是sz呢，因为最后一个数字不用冒泡排序啦
		int flag = 0;//假设数组已经为有序状态
		int j = 0;
		for (j = 0; j < limit; j++) {//只需要对无序部分进行排序
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = temp;//如果交换了，则说明数组无序，flag标记为1
                flag=1;
                last_change=j;//标记最后一次交换的位置
			}
		}
	}
    limit=last_change;//每一次交换完成后，更新有序数的边界，其边界位置就是上一次交换的位置
    if(flag==0){
            break;
    }
}
    
int main() {
	int arr[] = { 3,2,9,4,7,8,1,5,6 };
	int i = 0;
	int sz;
	sz = sizeof(arr) / sizeof(arr[0]);
	Bubble_sort(arr, sz);
	for (i = 0; i < sz; i++) {
		printf("%d", arr[i]);
	}
	return 0;
}

冒泡排序的优化2

#include<stdio.h>
void Bubble_sort(int arr[], int sz)
   {
	for (int i = 0; i < sz - 1; i++) 
    {//这里为什么是sz呢，因为最后一个数字不用冒泡排序啦
		int j = 0;
		for ( j = 0; j < sz - i- 1; j++)
        {//每一次冒泡排序比较的次数都要根据其所在位置来决定
			if (arr[j] > arr[j + 1]) 
            {
				int temp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = temp;
                flag=0;//如果进行了一次交换，则证明数组是无序的，那么此时将flag设定为0
			}
		}
	}
   if(flag==0)
   {
     break;//如果有序，直接结束循环，可以使得冒泡排序的效率提升
    }
}
int main() {
	int arr[] = { 3,2,9,4,7,8,1,5,6 };
	int i = 0;
    int flag=1;//假设目前已经有序
	int sz;
	 sz = sizeof(arr) / sizeof(arr[0]);
	 Bubble_sort(arr, sz);
	for (i = 0; i < sz; i++)
    {
		printf("%d", arr[i]);
	}
	return 0;
}

冒泡排序的优化3（qsort函数）

以上的冒泡排序都有共同的缺点，那就是只能对整形数据进行排序，如果要比较的对象为结构体等其他类型，我们就无法使用上述的代码进行比较。由此，我们介绍一个新的函数，为qsort函数。

我们来研究一下这个函数的参数。

void qsort(void*base,size_t num,size_t width,int(__cdecl*compare)(const void*elem1,const void*elem2));

下面逐个解析各个参数 void*base：你要排序的数据起始位置

size_t num：待排序元素数据个数

size_t width：待排序的数据元素的大小（单位是字节）

//__cdecl可以删，为函数调用约定） *compare const void*elem1,const void*elem2//函数指针，比较函数 compare传入的是比较不同的函数的地址，e1指向要比较的第一个元素，e2指向要比较的第二个元素的地址。e1和e2是我们要比较的两个元素的地址，会主动调用比较函数，然后把e1和e2的两个元素进行比较，然后进行排序。

查看这个比较函数的用法：

我们在原来代码的基础上进行修改，我们需要修改哪些方面？比较的方法需要修改，不同的数据类型，比较的方法不同。这里我们就使用了回调函数（回调函数不是由函数的实现方调用的，而是在特定的条件发生时另一方调用的）

#include<stdio.h>
int cmp_int(const void*e1,const void*e2)//比较两个整型元素，e1指向一个整型元素，e2指向另一个整型元素
{ 
   if(*e1>*e2)
    return 1;
   else if(*e1=*e2)
        return 0;
   else 
        return -1;
}
    

int main() {
	int arr[] = { 3,2,9,4,7,8,1,5,6 };
	int i = 0;
    int flag=1;//假设目前已经有序
	int sz;
	 sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr,sz,sizeof(arr[0]),cmp_int);
	for (i = 0; i < sz; i++)
    {
		printf("%d", arr[i]);
	}
	return 0;
}

void*（无具体类型的指针）指针不能直接进行解引用操作。下面来介绍void*指针。

如果直接如图所示引用地址，左边的地址是char*类型的，右边是int类型的，这样会导致编译错误。当我们使用void*类型的指针时，就可以避免这个问题。又因为void*无具体类型，所以不能对其进行解引用操作，也不能加减整数的操作。修改上面那段代码：

#include<stdio.h>
int cmp_int(const void*e1,const void*e2)//比较两个整型元素，e1指向一个整型元素，e2指向另一个整型元素
{ 
   if(*(int*)e1>*(int*)e2)//强制类型转化为int*类型
    return 1;
   else if(*(int*)e1=*(int*)e2)
        return 0;
   else 
        return -1;
}

为简化代码，我们也可以这样设计：

int cmp_int(const void*e1,const void*e2)//比较两个整型元素，e1指向一个整型元素，e2指向另一个整型元素
{
   return(*(int*)e1-*(int*)e2);
}

这个函数，默认是升序排列，如果想让它实现降序的功能，我们可以调换一下顺序

int cmp_int(const void*e1,const void*e2)//比较两个整型元素，e1指向一个整型元素，e2指向另一个整型元素
{
   return(*(int*)e2-*(int*)e1);//逻辑相反
}

这样就实现了降序排序。

qsort函数还能对其他数据类型进行排序。下面设计一个函数，在结构体中，按照名字排序。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name), ((struct Stu*)e2)->name);//这句话的意思就是取出Stu所指向的结构体中包含的数据项name
}
struct Stu
{
	char name[20];
	int age;
};
void test1()//测试test1来比较结构体数据
{
	struct Stu s[] = { {"zhangsan",17},{"lisi",18},{"wangwu",20} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s,sz,sizeof(s[0],cmp_stu_by_name)
}

int main() 
{
	test1();

}

再设计一个函数，按照年龄来排序。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->age), ((struct Stu*)e2)->age);//这句话的意思就是取出Stu所指向的结构体中包含的数据项age
}
struct Stu
{
	char name[20];
	int age;
};
void test2()//测试test2来比较结构体数据
{
	struct Stu s[] = { {"zhangsan",17},{"lisi",18},{"wangwu",20} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s,sz,sizeof(s[0],cmp_stu_by_age)
}

int main() 
{
	test2();

}

接下来，我们通过qsort函数来设计这个冒泡排序。

#include<stdio.h>
void Bubble_sort(void*base,int sz,int width,int(*cmp)(const void*e1,const void*e2) {
	for (int i = 0; i < sz - 1; i++) {//这里为什么是sz呢，因为最后一个数字不用冒泡排序啦
		int j = 0;
        int flag=1;
		for ( j = 0; j < sz - i- 1; j++) {//每一次冒泡排序比较的次数都要根据其所在位置来决定
			if (cmp)(base+j,base+(j+1))
              {
				
		}
	}
}
int main() {
	int arr[] = { 3,2,9,4,7,8,1,5,6 };
	int i = 0;
	int sz;
	 sz = sizeof(arr) / sizeof(arr[0]);
	 Bubble_sort(arr, sz);
	for (i = 0; i < sz; i++) {
		printf("%d", arr[i]);
	}
	return 0;
}

上方代码中比较函数行不通，我们考虑将base强制转化为别的类型，先考虑将 void*转化为int*，但这样显然不太好，因为int*跳过的字节数为4，我们只想跳过一个字节，因此我们将其转化为char*类型，再加上j*width。将比较函数改为下图：

if (cmp)((char*)base+j*width,(char*)base+(j+1)*width)

#include<stdio.h>
SWap(char*buffet1,char*buffet2,int width)//从第一个字节开始交换
{
    for(i=0;i<width;i++)
    {
     int tmp=*buffet1;
     *buffet1=*buffet2;
     *buffet2=tmp;
     buffet1++;
     buffet2++;
    }

void Bubble_sort(void*base,int sz,int width,int(*cmp)(const void*e1,const void*e2) {
	for (int i = 0; i < sz - 1; i++) {//这里为什么是sz呢，因为最后一个数字不用冒泡排序啦
		int j = 0;
        int flag=1;
		for ( j = 0; j < sz - i- 1; j++) {//每一次冒泡排序比较的次数都要根据其所在位置来决定
			if (cmp)((char*)base+j*width,(char*)base+(j+1)*width)>0)
              {
				Swap((char*)base+j*width,(char*)base+(j+1)*width，width);//调用swap函数
			}
		}
	}
}
int main() {
	int arr[] = { 3,2,9,4,7,8,1,5,6 };
	int i = 0;
	int sz;
	 sz = sizeof(arr) / sizeof(arr[0]);
	 Bubble_sort(arr, sz);
	for (i = 0; i < sz; i++) {
		printf("%d", arr[i]);
	}
	return 0;
}

我们只知道要交换的元素的起始位置是不够的，我们还需要知道数据的宽度（单位：字节），所以我们传入其宽度。

找出矩阵中绝对值最大的数的行下标和列下标

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main() {
	int i, j, n,max,temp;
	int arr[6][6] = {0};
	int max = arr[0][0];
	printf("请输入一个正整数n:\n");
	for (i = 0; i < n; i++) {
		for (j = 0; i < n; j++)
			scanf("%d", &arr[i][j]);
	}
	int x, y;
	for (i = 0; i < n; i++) {
		for (j = 0; i < n; j++)
			if (fabs(arr[i][j] > max)) {
				x = i;
				y = j;
			}
	}
	printf("绝对值最大的元素为:%d，下标分别为:%d,%d", max, x, y);
	return 0;
}

将数组中的数字逆序存放

与这个题目类似的题目在上一篇数组的文章中写过，但是这道思路不同，这道题是逆序存放已有的数组。

#include<stdio.h>
int main() {
	int a[10] = { 0,1,2,3,4,5,6,7,18,9 };
	int i;
	int t;
	for (i = 0; i < 10 / 2; i++) {//逆序只需要交换最头和最尾，只需要看一半
		t = a[i];
		a[i] = a[10 - i - 1];
		a[10 - 1 - i] = t;

	}
	for (i = 0; i < 10; i++) {
		printf("%d\n", a[i]);
	}

	return 0;
}

输入密码登录账号

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() {
	char a[] = "abc", b[100];
	int k = 0;
	printf("请输入密码:\n");
	do
	{
		scanf("%s", b);
		if (strcmp(a, b) != 0) {
			k++;
		}
		else break;

	} while (k <= 2);
	if (k > 2) {
		printf("非法用户!\n");
	}
	else printf("欢迎光临\n");
	return 0;
}

以上就是数组作业的全部内容，欢迎交流！

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2023-12-25，如有侵权请联系 cloudcommunity@tencent.com 删除

int