备案控制台
探索云世界
开发者社区 安全 文章 正文

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

2024-03-19 22
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 今天发疯，写一下学校的数组作业


统计各分数段学生人数

#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;
}

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

文章标签：
数据安全/隐私保护
pearlthriving
目录
相关文章
pearlthriving
|
1月前
今天发疯，写一下学校的函数作业
今天发疯，写一下学校的函数作业
pearlthriving
22 0
Hong_zh0
|
3月前
|
C语言
《吉师作业》(2)之迟来的答案
《吉师作业》(2)之迟来的答案
Hong_zh0
32 0
Enovo_飞鱼
|
Java
Java程序设计（六）作业
Java程序设计（六）作业
Enovo_飞鱼
91 0
Enovo_飞鱼
|
Java
Java程序设计（九）作业
Java程序设计（九）作业
Enovo_飞鱼
99 1
Enovo_飞鱼
|
算法 Java
Java程序设计（三）作业
Java程序设计（三）作业
Enovo_飞鱼
57 0
Enovo_飞鱼
|
Java
Java程序设计（八）作业
Java程序设计（八）作业
Enovo_飞鱼
60 0
Enovo_飞鱼
|
存储 Java 数据库连接
Java程序设计（七）作业
Java程序设计（七）作业
Enovo_飞鱼
92 0
Enovo_飞鱼
|
Java
Java程序设计（二）作业
Java程序设计（二）作业
Enovo_飞鱼
41 0
Enovo_飞鱼
|
Java
Java程序设计（一）作业
Java程序设计（一）作业
Enovo_飞鱼
42 0
Enovo_飞鱼
|
Java
Java程序设计（四）作业
Java程序设计（四）作业
Enovo_飞鱼
63 0