C语言入门——第十一课

已于 2023-10-24 16:10:00 修改
阅读量70 收藏
点赞数
分类专栏： C语言 文章标签： c语言 java 算法 1024程序员节
于 2023-10-22 17:20:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54231818/article/details/133891680
版权

一、第十课作业复盘

题目：定义大小为100的整型数组，使用随机函数给数组元素赋值，数值范围为1…100，并且排序，使用冒泡排序实现。

复盘中需要注意的点：

数组作为形参的时候，我们一般使用指针类写法，并且一定要判空、判空、判空！！（三遍，希望下次不要忘记了）。

判空的方法有两种，如下所示：

#include <assert.h>
int Init_Array(int *br,int n)
{
    //法一：if判断，若为空，返回-1
    if(br == NULL)
    {
        return -1;
    }
    //法二：断言，如果断言括号里条件满足，继续执行
    //如果不满足，终止程序
    assert(br!=NULL);
}

所以初始化数组的代码如下：

int Init_Array(int* br, const int n)
{
	assert(br != 0 || n > 0);
	srand(time(NULL));
	for (int i = 0; i < n; i++)
	{
		br[i] = rand() % 100 + 1;
	}
	return br[n];
}

另外，如果形参不可以被改变我们一般要给形参加上const，保证程序的安全性。

如下：打印数组的功能代码。

void Show_Array(const int *br,const int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%5d", br[i]);
		if ((i+1) % 10 == 0)
		{
			printf("\n");
		}
	}
	printf("\n");
}

冒泡排序函数：

int Bubble_Sort(int *br, const int n)
{
	assert(br != 0|| n > 0);
	for (int i = 0; i < n-1; i++)
	{
		for (int j = 0; j < n - i - 1; j++)
		{
			if (br[j] > br[j+1])
			{
				int temp = br[j];
				br[j] = br[j + 1];
				br[j + 1] = temp;
			}

		}
	}
	return br[n];
}

 主函数：

int main()
{
	const int n = 100;
	int br[100] = { 0 };
	Init_Array(br, n);
	Show_Array(br, n);
	Bubble_Sort(br, n);
	Show_Array(br, n);
}

完整代码如下：

#define  _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<assert.h>

int Init_Array(int* br, const int n)
{
	assert(br != 0 || n > 0);
	srand(time(NULL));
	for (int i = 0; i < n; i++)
	{
		br[i] = rand() % 100 + 1;
	}
	return br[n];
}

void Show_Array(const int *br,const int n)
{
	assert(br != 0 || n > 0);
	for (int i = 0; i < n; i++)
	{
		printf("%5d", br[i]);
		if ((i+1) % 10 == 0)
		{
			printf("\n");
		}
	}
	printf("\n");
}
int Bubble_Sort(int *br, const int n)
{
	assert(br != 0|| n > 0);
	for (int i = 0; i < n-1; i++)
	{
		for (int j = 0; j < n - i - 1; j++)
		{
			if (br[j] > br[j+1])
			{
				int temp = br[j];
				br[j] = br[j + 1];
				br[j + 1] = temp;
			}

		}
	}
	return br[n];
}
int main()
{
	const int n = 100;
	int br[100] = { 0 };
	Init_Array(br, n);
	Show_Array(br, n);
	Bubble_Sort(br, n);
	Show_Array(br, n);
}

 结果如下所示：

优化

1.冒泡排序的两数交换可以使用交换函数。

void Swap(int* ap, int *bp)
{
	int temp = *ap;
	*ap = *bp;
	*bp = temp;
}

更新冒泡函数Bubble_Sort()

int Bubble_Sort(int *br, const int n)
{
	assert(br != 0|| n > 0);
	for (int i = 0; i < n-1; i++)
	{
		for (int j = 0; j < n - i - 1; j++)
		{
			if (br[j] > br[j+1])
			{
				Swap(&br[j], &br[j + 1]);
			}

		}
	}
	return br[n];
}

2.已经排好序之后跳出循环

我们将随机生成的数限制在10个数。每次跑一趟排序，我们将它打印出来，需要更新的代码如下：

主函数：

int main()
{
	const int n = 10;//更新
	int br[10] = { 0 };//更新
	Init_Array(br, n);
	Show_Array(br, n);
	Bubble_Sort(br, n);
	Show_Array(br, n);
}

冒泡函数：

int Bubble_Sort(int *br, const int n)
{
	assert(br != 0|| n > 0);
	for (int i = 0; i < n-1; i++)
	{
		for (int j = 0; j < n - i - 1; j++)
		{
			if (br[j] > br[j+1])
			{
				Swap(&br[j], &br[j + 1]);
			}

		}
		Show_Array(br, n);//更新
	}
	return br[n];
}

运行结果如下：

我们可以看到从倒数第三次开始已经完成排序了，序列已经整体有序，我们还是将它继续循环，继续打印，这样显然没有必要，怎么处理这样的情况：

做法：添加标志位，代码如下：

int Bubble_Sort(int *br, const int n)
{
	assert(br != 0|| n > 0);
	for (int i = 0; i < n-1; i++)
	{
		int flag = 0;
		for (int j = 0; j < n - i - 1; j++)
		{
			if (br[j] > br[j+1])
			{
				Swap(&br[j], &br[j + 1]);
				flag = 1;
			}
		}
		if (flag == 0)
		{
			break;
		}
		Show_Array(br, n);
	}
	return br[n];
}

我们在循环开始时初始化一个标志flag，令它等于0，如果在循环过程中比较发现有大的在小的前面，我们就进行交换，并将标志设置成1，表示我此次循环是做了改动的，变换了顺序。

但是，如果我循环一遍我的元素，发现前面都是小的，后面都是大的，前一个都比后一个小，那么说明我不需要交换，说明我的排序结束了，这组数已经有序了，所以我们不改变标志，如果没有进行交换，没有改变标志，那么说明我们排序结束，所以我们使用break退出循环就可以啦！ 

break可以从当前循环退出。

冒泡排序第一个循环，代表一趟，如果一趟从上到下，再由下至上

更新代码如下： 

void Bubble_Sort(int *br, const int n)
{
	assert(br != 0|| n > 0);
	for (int i = 0; i < n-1; i++)
	{
		int flag = 0;
		for (int j=i ; j <n-1-i;j++ )
		{
			if (br[j] > br[j+1])
			{
				Swap(&br[j], &br[j + 1]);
				flag = 1;
			}
		}
		if (flag == 0)
		{
			break;
		}
		for (int j = n - 2 - i; j > i; j--)
		{
			if (br[j + 1] < br[j])
			{
				Swap(&br[j + 1], &br[j]);
			}
		}
		Show_Array(br, n);
	}
}

添加反向遍历,实现双向冒泡,可以在每轮排序中更快地将最大/最小元素移到两端，这样的作用是提高运行的效率。使用双冒泡的方法，可以反向检查排序的正确性，优化了代码。

我的问题是为什么int j = n - 2 - i为什么写成n-1-i会内存溢出呀，因为i不能大于n-1，所以最大值是n-2，j=n-2-i，在i取n-2的时候是0，如果你写j=n-1-i那么，n-1-n-2结果为-1，br[-1]，会读取数组的前一个地址，造成内存溢出。

3.避免出现重复的数

 写一个避免重复的函数

int FindValues(const int* br, const int n, const int value)
{
	int pos = -1;
	if (*br == NULL || n < 1) return pos;
	for (int i = 0; i < n; i++)
	{
		if (br[i] == value)
		{
			pos = i;
			break;
		}
	}
	return pos;
}

更新初始化的代码：

int Init_Array(int* br, const int n)
{
	int i = 0;
	assert(br != 0 || n > 0);
	srand(time(NULL));
	while (i < n)
	{
		int value = rand() % 100 + 1;
		if (FindValues(br, i, value) == -1)
		{
			br[i] = value;
			i+=1;
		}
	}
	return 0;
}

刚才我们FindValues函数是从前往后遍历，现在我们从后往前遍历，简化一下算法：

int FindValues(const int *br, const int n, const int value) {
  int pos = n - 1;
  while (value != br[pos] && pos >= 0) {
    --pos;
  }
  return pos;
}

此时我们打印一下代码的循环次数，我们可以看到，代码的循环次数远远大于我们想象的100次，越往后，随机值重复的概率越大，所以需要再次循环生成新的数。

int Init_Array(int *br, const int n) {
  int i = 0;
  int sum = 0;
  assert(br != 0 || n > 0);
  srand(time(NULL));
  while (i < n) {
    int value = rand() % 100 + 1;
    if (FindValues(br, i, value) == -1) {
      br[i] = value;
      i += 1;
    }
    sum += 1;
  }
  printf("sum = %d\n",sum);
  return 0;
}

sum = 408循环408次，效率太低。越往后重复的概率越大，需要循环的次数更多。 想要优化来减少循环次数，推荐查表法。我们定义一个数组，数组下边是从0-10，我们给数组的每个元素存储0元素。

#define _CRT_SECURE_NO_WARNINGS
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void Swap(int *ap, int *bp) 
{
  int temp = *ap;
  *ap = *bp;
  *bp = temp;
}
int FindValues(const int *br, const int n, const int value) 
{
  int pos = n - 1;
  while (value != br[pos] && pos >= 0) {
    --pos;
  }
  return pos;
}
int Init_Array(int *br, const int n) {
  int i = 0;
  int sum = 0;
  int *ip;
  assert(br != 0 || n > 0);
  srand(time(NULL));
  ip = (int *)malloc(sizeof(int) * (n + 1));
  if(ip == NULL)
    return -3;
  for (int j = 0; j <= n;++j)
  {
    ip[j] = 0;
  }
    while (i < n)
    {
      int value = rand() % 100 + 1;
      if (ip[value]==0)
      {
        br[i] = value;
        ip[value] = 1;
        i += 1;
      }
      sum += 1;
    }
  printf("sum = %d\n", sum);
  return 0;
}

void Show_Array(const int *br, const int n) {
  assert(br != 0 || n > 0);
  for (int i = 0; i < n; i++) {
    printf("%5d", br[i]);
    if ((i + 1) % 10 == 0) {
      printf("\n");
    }
  }
  printf("\n");
}
void Bubble_Sort(int *br, const int n) {
  assert(br != 0 || n > 0);
  for (int i = 0; i < n - 1; i++) {
    int flag = 0;
    for (int j = i; j < n - 1 - i; j++) {
      if (br[j] > br[j + 1]) {
        Swap(&br[j], &br[j + 1]);
        flag = 1;
      }
    }

    for (int j = n - 2 - i; j >= i; j--) {
      if (br[j + 1] < br[j]) {
        Swap(&br[j + 1], &br[j]);
        flag = 1;
      }
    }
    if (flag == 0) {
      break;
    }
    // Show_Array(br, n);
  }
}
int main() {
  const int n = 100;
  int br[n];
  Init_Array(br, n);
  Show_Array(br, n);
  Bubble_Sort(br, n);
  Show_Array(br, n);
}

查表法代码有一点提升，但是总体不是很大，后续这个题目会继续被优化。 

连续空间的两种获取方式

动态和静态

泛型指针void*

void*：泛型指针，是任何类型的地址都可以存放。

示例如下：

int main()
{
  int a = 10;
  char ch = 'a';
  double dx = 12.23;
  float ft = 12.33f;
  void *vp = NULL;
  vp = &a;
  vp = &ch;
  vp = &dx;
  vp = &ft;
}

需要注意的是，泛型指针可以直接获取其他任何类型的地址；

但是其他类型的地址获取泛型指针的地址需要加上地址转换，示例代码如下：

int main()
{
  void *vp;
  int *ip;
  ip = (int *)vp;
}

malloc动态生成数组

在VS2019中，不能够动态的定义数组，定义数组的时候不能够使用变量，使用常变量也不可以呢，因为常变量是在链接过程中才将变量值替换，所以我们需要动态生成数组。动态生成数组的方法是：malloc(动态内存管理)。

malloc和calloc的区别

malloc：分配内存

calloc:分配并清零内存 

malloc申请内存的时候要释放内存，free只可以释放堆区自己申请的内存空间。

int main()
{
  int *ip = NULL;
  ip = (int *)malloc(sizeof(int));
  if(NULL == ip)
    exit(1);
  *ip = 100;
  printf("%08x =>%d\n", ip,*ip);
  free(ip);
  ip = NULL;
  return 0;
}

结果代码如下： 

上述代码是给ip指针变量在堆空间生成了一个4个字节大小的空间。

注意：malloc使用结束后一定要free，另外还需要将指针置为空，要不然还是有各种风险。

野指针：定义指针没有初始值：int *p;

空指针，int* ip = NULL

失效指针,free(ip)

失效指针之后一定要置为空ip=NULL

作业

free怎么知道要释放多少空间?

malloc在申请空间的时候会将申请的空间大小和地址存储在运行时库里，被称作内存控制块，当你使用free函数释放的时候，会自动调用内存控制块，释放对应字节个数的内存。

爱学习的时小糖
关注
专栏目录
用c语言函数br,ic函数,C Primer Plus（第6版）第二章编程练习答案
weixin_36445525的博客
05-20 1024
第二章 C语言概述(P37-P38)5 编写一个程序，生成如下输出：函数Brazil, Russia, India, ChinaspaIndia, China,codeBrazil, Russiathree除了main()之外，该程序还要调用两个自定义函数：一个名为br()，调用一次打印一次"Brazil, Russia"；另外一个名为ic()，调用一次打印一次"India, China"。其余...
C 语言函数教程<br>讲解C语言函数的使用
08-25
C 语言函数教程<br>讲解C语言函数的使用 C 语言函数教程<br>讲解C语言函数的使用
c语言中a|b 是什么意思
戴某某
08-03 8万+
是位运算,先把a,b转化成二进制,然后位相或,有1出1,无1出0 比如 a=5 b=2 5的二进制表示是101 2的二进制表示是 10 那么101|10=111 111十进制表示是7 所以a|b=7 如果a=3 b=2 那么a|b 结果是 11|10=11 a|b=3 ...
为什么vm不直连br-int，多了个qbr
liuliuzi_hz的博客
01-13 3027
Ideally, the TAP device vnet0 would be connected directly to the integration bridge, br-int. Unfortunately, this isn’t possible because of how OpenStack security groups are currently implemented. Op
C语言入门——《明解C语言》入门篇第四章练习
weixin_49249463的博客
11-20 1469
《明解C语言》入门篇第四章练习记录，明解C语言入门篇第四章练习答案
C语言入门——循环嵌套
jsnsbhzukkzns的博客
01-20 1768
其实循环嵌套没有什么新鲜的。你只需要理解循环体是什么就好。循环体就是程序在一定条件下反复执行的一段代码。而循环嵌套就是把某个循环塞到另一个循环的循环体里面去。a
C语言入门——循环
jsnsbhzukkzns的博客
01-20 2366
遇到do......while语句时，先执行一次循环体，然后进行判断，如果为true则继续执行，false则跳出。两个分号之间是循环执行的判断条件， 第二个分号后面是一轮循环结束后对变量的更改。如果有多层循环，只能跳出break所在的最内层循环。显然，这个程序员永远无法脱单，因为在程序遇到continue时，后面的所有代码都不再执行而开启下一轮循环。for循环有一个小细节：在for循环内（包括括号内和循环体中）定义的变量，循环结束后会被销毁。在上面的代码中，当i是6的倍数时，直接跳出循环，循环不再执行。
C语言入门——class7
You_mo_的博客
12-04 979
数组是一种储存一组相同类型元素的集合。首先数组里需要有元素，至少要为1个。其次数组里的元素是类型相同的。数组分为一维数组和多维数组。
c语言入门——操作符
finish_speech的博客
11-14 599
浅浅水一篇
C语言基础知识入门大全
热门推荐
weixin_55305220的博客
05-11 60万+
C语言一经出现就以其功能丰富、表达能力强、灵活方便、应用面广等特点迅速在全世界普及和推广。C语言不但执行效率高而且可移植性好，可以用来开发应用软件、驱动、操作系统等。C语言也是其它众多高级语言的鼻祖语言，所以说学习C语言是进入编程世界的必修课！简单来说，一个C程序就是由若干和组成。就是一条预处理命令, 它的作用是通知C语言编译系统在对C程序进行正式编译之前需做一些预处理工作。就是实现代码逻辑的一个小的单元。一个C程序有且只有一个主函数，即main函数。注释是写给程序员看的，不是写给电脑看的。C语言注释方法有
C语言入门——数字特征值
m0_73063550的博客
11-03 512
对数字求特征值是常用的编码算法，奇偶特征是一种简单的特征值。对于一个整数，从个位开始对每一位数字编号，个位是1号，十位是2号，以此类推。这个整数在第n位上的数字记作x，如果x和n的奇偶性相同，则记下一个1，否则记下一个0。按照整数的顺序把对应位的表示奇偶性的0和1都记录下来，就形成了一个二进制数字。你的程序要读入一个非负整数，整数的范围是[0,1000000]，然后按照上述算法计算出表示奇偶性的那个二进制数字，输出它对应的十进制值。提示：将整数从右向左分解，数位每次加1，而二进制值每次乘2。
C语言入门——时间换算
topdyd的博客
10-21 8420
浙江大学 C语言入门第二周编程练习 时间换算 题目内容： UTC是世界协调时，BJT是北京时间，UTC时间相当于BJT减去8。现在，你的程序要读入一个整数，表示BJT的时和分。整数的个位和十位表示分，百位和千位表示小时。如果小时小于10，则没有千位部分；如果小时是0，则没有百位部分；如果小时不是0而分小于10分，需要保留十位上的0；如果小时是0而分小于10分的，则不需要保留十位上的0。如112
C语言入门——信号报告
topdyd的博客
10-21 1491
浙江大学 C语言入门第二周编程练习 信号报告 题目内容： 无线电台的RS制信号报告是由三两个部分组成的： R(Readability) 信号可辨度即清晰度. S(Strength) 信号强度即大小. 其中R位于报告第一位，共分5级，用1—5数字表示. Unreadable Barely readable, occasional words distinguishable R
初识C语言———C语言基础入门
m0_60172128的博客
04-28 1万+
关键字typedef typedef顾名思义是类型定义，这里应该理解成类型重命名。 int main() { unsigned int num1 = 0; //创建无符号整形 return 0; } 但是我们使用unsigned int太长了，每次敲起来很麻烦，我们就可以用typedef typedef unsigned int uint; int main() { unsigned int num1 = 0; //无符号整形 uint num2 = 1; r..
中国大学MOOC《程序设计入门——C语言》翁恺————答案分享
海人的博客
03-30 1万+
** 这份代码为去年我学习时写的，与现在课程的题目可能有些出入，所以代码仅供参考。 ** 1.输出“Hello World”（5分） 题目内容： 请输出一行，内容为 Hello World 请注意大小写。 由于这一周只是简单地介绍了C程序的基本框架，还不能做很多事情，甚至还不能做数据的输入，所以这一周的题目也非常简单。 第二周会仔细介绍如何在中M和拼题A做题，如果你一时无法搞定如何提交这周的作业，...
C/C++漏洞检测数据集汇总
最新发布
阿航的博客
09-13 1080
漏洞检测这个方向最近几年尤为热门，尤其是与深度学习技术相结合的研究，同时一些公开可用的数据集的出现也进一步推动了这些技术的发展。本篇文章总结归纳了目前在 C/C++ 源代码漏洞检测方向的一些公开数据集以及相关文献。
SX_c语言替换文件中的字符串_22
Narnat的博客
09-12 257
项目实现中有时候需要根据一些设置的值替换掉代码文件中的一些字符串，让显示有所变化，这里有两种方式替换。可以对全局文件做查找操作，找到所有目标文件的位置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值