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

简介: 今天发疯,写一下学校的数组作业



统计各分数段学生人数

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

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

相关文章
|
7月前
今天发疯,写一下学校的函数作业
今天发疯,写一下学校的函数作业
33 0
|
7月前
|
调度
【错题集-编程题】主持人调度(一)(排序)
【错题集-编程题】主持人调度(一)(排序)
|
数据采集 JSON 数据可视化
大数据分析考科目三到底哪里容易被挂
大数据分析考科目三到底哪里容易被挂
|
Java
Java程序设计(九)作业
Java程序设计(九)作业
136 1
【C#】【平时作业】习题-3-数组
【C#】【平时作业】习题-3-数组
78 0
【C#】【平时作业】习题-3-数组
|
Go 开发者
函数课堂练习题和作业 | 学习笔记
简介:快速学习函数课堂练习题和作业
146 0
函数课堂练习题和作业 | 学习笔记
|
Java
Java程序设计(八)作业
Java程序设计(八)作业
97 0
|
设计模式 算法 Java
Java程序设计(五)作业
Java程序设计(五)作业
104 0
|
算法 Java
Java程序设计(三)作业
Java程序设计(三)作业
84 0
|
存储 Java 数据库连接
Java程序设计(七)作业
Java程序设计(七)作业
115 0