【深入理解指针2】——顶级理解！

已于 2024-06-04 18:55:13 修改
阅读量1.5k 收藏 32
点赞数 57
分类专栏： C语言 文章标签： 排序算法 算法 数据结构 c语言 开发语言
于 2024-06-03 12:47:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_81301620/article/details/139221320
版权

大家好，今天小编给大家带来的是C语言中关于指针的理解的第二部分，干货超多哦，一起来来看看吧！

1.数组名的理解

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%p\n", arr);//008FFB14
	printf("%p\n", &arr);//008FFB14
	return 0;
}

理解：数组名表示数组首元素的地址，除了两种特例外

特例：

1.sizeof(数组名）：求的是整个数组的大小，单位是字节
2. &数组名：取的是整个数组的地址

除此之外，任何地⽅使⽤数组名，数组名都表⽰⾸元素的地址。

那么&arr和arr又有什么区别呢？

#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("&arr[0]   = %p\n", &arr[0]);
printf("&arr[0]+1 = %p\n", &arr[0]+1);
printf("arr       = %p\n", arr);
printf("arr+1     = %p\n", arr+1);
printf("&arr      = %p\n", &arr);
printf("&arr+1    = %p\n", &arr+1);
return 0;
}

在这里插入图片描述
理解：

  1. 这⾥我们发现&arr[0]和&arr[0]+1相差4个字节，arr和arr+1 相差4个字节，是因为&arr[0] 和 arr 都是⾸元素的地址，+1就是跳过⼀个元素。
  2. 但是&arr和&arr+1相差40个字节，这是因为&arr表示的是获整个数组的地址，+1于是跳过了整个数组即4*10==40个字节

2.使用指针访问数组

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p+i));
	}
	return 0;
}

说明：

  1. 指针变量p存放的是数组首元素的地址
  2. p+i等价于&arr[0+i]
  3. p[i]等价于*（p+i） ，同理arr[i] 应该等价于 *(arr+i)，编译器处理数据时，⾸元素的地址+偏移量求出元素的地址，然后解引⽤来访问的。

3.数组传参的本质

3.1一维数组传参的本质

理解：
传递的是数组⾸元素的地址。
形参部分可以写成指针的形式，也可以写成数组形式，实质还是指针 。

void test(int arr[])//参数写成数组形式，本质上还是指针
{
	printf("%d\n", sizeof(arr));
}
void test(int* arr)//参数写成指针形式
{
	printf("%d\n", sizeof(arr));//计算⼀个指针变量的⼤⼩
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	test(arr);
	return 0;
}

***总结：一维数组传参，参数的部分可以写成数组的形式，也可以写成指针的形式，但本质上还是指针

3.2二维数组传参的本质

3.2.1学习指针数组之前的二维数组传参

void test(int  a[3][5], int r, int c)//形参也写成了二维数组的形式
{
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)//遍历行
	{
		for (j = 0; j < c; j++)//遍历列
		{
			printf("%d ", a[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7} };
	test(arr, 3, 5);
	return 0;
}

3.2.2使用数组指针

理解：⾸先我们再次理解⼀下⼆维数组，⼆维数组其实可以看做是每个元素是⼀维数组的数组，也就是⼆维数组的每个元素是⼀个⼀维数组。那么⼆维数组的⾸元素就是第⼀⾏，是个⼀维数组。
说明：

  1. 数组名表示首元素的地址。
  2. 二维数组数组名表示第一行的地址，是一维数组的地址。
  3. 第一行的数组类型 int[5]，第一行的地址的类型就是数组指针类型，int(*)[5]
  4. 那么，二维数组传参的实质上是传递了地址，传递的是第一行这个一维数组的地址。

既然传递的是地址，那么形参也可以写成指针的形式，如下：

void test(int(*p)[5], int r, int c)//形参写成了指针的形式
{
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7} };
	test(arr, 3, 5);//数组名表示首元素的地址，二维数组的数组名则表示第一行一维数组的地址
	return 0;
}

数组传参总结：

  1. 形参可以是数组，也可以是指针（数组指针）
  2. 实参是函数的地址，形参只能是函数指针
  3. 创建一个数组指针来接受二维数组首元素即第一行的地址

4.冒泡排序

排序：

冒泡排序，选择，插入，快速，堆排序，希尔排序

冒泡排序的思想：

两两相邻的元素比较，如果不满足顺序就交换，满足就进行下一对。

void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{
int i = 0;
for(i=0; i<sz-1; i++)
{
int flag = 1;//假设这⼀趟已经有序了
int j = 0;
for(j=0; j<sz-i-1; j++)
{
if(arr[j] > arr[j+1])
{
flag = 0;//发⽣交换就说明，⽆序
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
if(flag == 1)//这⼀趟没交换就说明已经有序，后续⽆序排序了
break;
}
}
int main()
{
int arr[] = {3,1,7,5,8,9,0,2,4,6};
int sz = sizeof(arr)/sizeof(arr[0]);
bubble_sort(arr, sz);
int i = 0;
for(i=0; i<sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}

5.二级指针

一级指针
int a=10;
int *p=&a;//p就是一级指针变量
int **pp=&p;//pp是二级指针变量，是用来存放一级指针变量的地址
int ***ppp=&pp;//ppp是三级指针变量
解引用*  =  开锁

说明：

int**pp=&p;
前一个解引用表示：pp指向对象是int*类型，
后一个解引用表示：pp是指针变量

一级指针与二级指针的联系：

在这里插入图片描述

6.指针数组

6.1什么是指针数组？

理解：存放指针（地址)的数组 int*arr[10];
类比：

  • 整型数组：int arr[10]; 存放整型的数组

  • 字符数组：char s[10]; 存放字符的数组

    在这里插入图片描述
    在这里插入图片描述

6.2指针数组模拟二维数组

下面是模拟实现二维数组：

#include <stdio.h>
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	//数组名是数组⾸元素的地址，类型是int*的，就可以存放在parr数组中
	int* parr[3] = { arr1, arr2, arr3 };
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", parr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

在这里插入图片描述

理解：
parr[i]是访问parr数组的元素，parr[i]找到的数组元素指向了整型⼀维数组，parr[i][ j]就是整型⼀维数组中的元素。

8.字符指针变量

8.1类比和联系

类比：整形指针： int*p 指向整型的指针，存放的是整型的地址。

char*p=“hello world”;//常量字符串，不可修改
字符数组，把字符串首字符的地址放进去，等价于：

char arr[]=“hello world”;
char*p=arr;

const char*p="hello world";//常量字符串，不可修改 
*p='q';//err
3=5;//err

8.2使用

使用：打印字符串，只需提供起始地址，就可以打印

char arr[]="abcdef";
char*p=arr;//数组名表示首元素的地址
printf("%S\n",arr);//
printf("%s\n",p);//
//注：打印字符串，只需提供起始地址，就可以打印

8.3辨析题

辨析题：

#include <stdio.h>
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char *str3 = "hello bit.";//常量字符串不可修改
const char *str4 = "hello bit.";//内容相同的常量字符
//串没有必要保留两份，因为str3和str4指向同一个常量字符串，
//指针指向同一块内存
if(str1 ==str2)
printf("str1 and str2 are same\n");
else
printf("str1 and str2 are not same\n");
if(str3 ==str4)
printf("str3 and str4 are same\n");
else
printf("str3 and str4 are not same\n");
return 0;
}

在这里插入图片描述
**理解：**这⾥str3和str4指向的是⼀个同⼀个常量字符串。C/C++会把常量字符串存储到单独的⼀个内存区域。
当⼏个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。但是⽤相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。

9. 数组指针变量

9.1什么是数组指针变量？

类比和联系：

我们知道，指针数组，是一种数组，数组中存放的是指针（地址）。那么，指针变量是什么呢？
类比：
字符指针： charp 指向字符的指针，存放的是字符的地址
整形指针： intp 指向整型的指针，存放的是整型的地址
数组指针：是一种指针变量，存放数组的地址
怎么取？：&arr 得到的是整个数组的地址

9.2 数组指针变量怎么初始化？

int arr[10]={0};
int (*p)[10]=&arr;//p是数组指针，p指向的是数组，10个元素，int类型

理解：p先和*结合，说明p是一个指针变量，然后指着指向的是⼀个⼤⼩为10个整型的数组。所以p是⼀个指针，指向⼀个数组，叫 数组指针。

说明：

  • int 是指向的数组的元素的类型
  • p是数组指针变量名
  • 10是p指向数组的元素个数

例：

char arr[5];//p是数组指针
char(*p)[5]=&arr;//char (*)[5]是数组指针类型
//去掉名字得到类型

10.函数指针变量

10.1什么是函数指针变量？

之前我们已经知道了，整型指针，字符指针，数组指针等；那么，函数指针变量又是什么呢？

函数指针是一种指针变量，存放函数的地址，从而通过地址来调用函数。

10.2函数指针变量的创建

tip: &函数名 和 函数名 都表示函数的地址。

int arr[8] = { 0 };
int(*pf)(int,int) = &Add;//pf是函数指针变量
int(*pa)[8] = &arr;//pa是数组指针变量

在这里插入图片描述

10.3函数指针变量的使用

通过函数指针调⽤指针指向的函数。

#include <stdio.h>
int Add(int x, int y)//加法函数
{
return x+y;
}
int main()
{
//创建和初始化
int(*pf3)(int, int) = Add;//pf3是函数指针变量
printf("%d\n", (*pf3)(2, 3));//使用
printf("%d\n", pf3(3, 5));//*可以去掉
return 0;
}

``

	int(*pf)(int, int) = &Add;
	去掉名字，就是类型 int (*)(int,int)
	int r1 = (*pf)(3, 7);
	int r2 = pf(4, 5);
	int r2 = Add(3, 7);

10.4两端代码分析

来源：《C陷阱和缺陷》

1.(*(void (*)())0)();

整体看，此代码是一次函数调用
从里向外看，void()()是函数指针类型
//1.将0强制转化成void()()型的函数指针
//2.调用0地址处放的这个函数

2.void (*signal(int , void(*)(int)))(int);

整体看，此代码是一次函数声明
//1.声明的函数名是signal
//2.signal有两个参数：int , void(*)(int)
//3.signal的返回类型void *(int)

10.5 typedef关键字

10.5.1 介绍：typedef 是⽤来类型重命名的，可以将复杂的类型，简单化。

10.5.2 几种常见的重命名：

1.类型重命名
typedef unsigned int uint;
//将unsigned int 重命名为uint

2.整型指针类型重命名
typedef int* ptr_t;
//将 int* 重命名为 ptr_t

3.数组指针类型重命名（有点区别）
typedef int(*parr_t)[5]; 
//将int(*)[5]重命名为 parr_t
//新的类型名必须在*的右边（语法要求）

4.函数指针重命名（有点区别）
 typedef void(*pf_t)(int);
//将 void(*)(int) 类型重命名为 pf_t 
//新的类型名必须在*的右边（语法要求）

10.5.3场景模拟

1.整型重命名
typedef unsigned int unit;
int main()
{
	unsigned int num1;
	unit num2;
	return 0;
}

2.数组指针类型重命名
//typedef int(*)[5] parr_t;//err语法错误，要写在里面
typedef int(*parr_t)[5];
int main()
{
	int arr[5] = { 0 };
	int(*p)[5] = &arr;
	parr_t p2 = &arr;
}

10.5.4 typedef和define的区别

typedef int* ptr_t;
#define PTR_T int*;
int main()
{
	ptr_t p1;
	PTR_T p2;

	ptr_t p1, p2;//p1,p2是整型指针
	PTR_T p3, p4;//p3是int*型，p4是int型

	return 0;
}

11.函数指针数组

11.1什么是函数指针数组？

再次类比，我们不难想到：
什么是函数指针数组？——存放函数指针的数组

11.2函数指针数组的定义

int (*parr1[3])();//函数指针数组的定义
parr1先和[]结合，说明parr1是数组
数组存放的内容呢？是int (*)()类型的函数指针

去掉名字就是类型
int (*[3])();

12.转移表

函数指针数组的用途：转移表

12.1常规写法实现计算器

计算器的一般实现：


//计算器的一般实现
int add(int x, int y)
{
	return x + y;
}

int sub(int x, int y)
{
	return x - y;
}

int mul(int x, int y)
{
	return x * y;
}

int div(int x, int y)
{
	return x / y;
}

int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	
	do
	{
		printf("*********************************\n");
		printf("  1:add                  2:sub   \n  ");
		printf("  3:mul                  4:div   \n  ");
		printf("  0:exit                         \n");
		printf("*********************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入操作数： ");
			scanf("%d %d", &x, &y);
			ret = add(x, y);
			printf("%d\n", ret);
			break;
		case 2:
			printf("请输入操作数： ");
			scanf("%d %d", &x, &y);
			ret = sub(x, y);
			printf("%d\n", ret);
			break;
		case 3:
			printf("请输入操作数： ");
			scanf("%d %d", &x, &y);
			ret = mul(x, y);
			printf("%d\n", ret);
			break;
		case 4:
			printf("请输入操作数： ");
			scanf("%d %d", &x, &y);
			ret = div(x, y);
			printf("%d\n", ret);
			break;
		case 0:
			printf("推出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

12.2使用函数指针数组，转移表 实现计算器

是不是感觉很冗余呢？接下来看看使用了函数指针数组的写法吧！

int add(int x, int y)
{
	return x + y;
}

int sub(int x, int y)
{
	return x - y;
}

int mul(int x, int y)
{
	return x * y;
}

int div(int x, int y)
{
	return x / y;
}

int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	int(*p[5])(int x,int y) = { 0,add,sub,mul,div };//转移表，将函数放在数组中
	do
	{
		printf("*********************************\n");
		printf("  1:add                  2:sub   \n  ");
		printf("  3:mul                  4:div   \n  ");
		printf("  0:exit                         \n");
		printf("*********************************\n");
		printf("请选择：");
		scanf("%d", &input);
		if (input >= 1 && input <= 4)
		{
			printf("请输入操作数：");
			scanf("%d%d", &x, &y);
			ret = (*p[input])(x, y);
			printf("%d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出计算器\n");
		}
		else
		{
			printf("选择错误\n");
		}
		

	} while (input);
	return 0;
}

总结

以上就是摆子今天给各位带来的有关指针的进阶的一些内容，还请一键三连加关注，感谢感谢！我们下期再见！！！

那就摆吧
关注
  • 57
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
专栏目录
深入理解DNS系列——概念篇
走在架构师的路上
09-19 669
DNS(一) Conception DNS(Domain Name System)是一个分布式分级管理的数据库。他存储的是hostname与IP的对应关系、邮件路由信息以及其他互联网应用数据等等。 Domain Name 说到DNS就离不开域名（Domain Name），因为DNS主要解析以及存储的对象是域名相关的数据。域名是一种树状结构，形如:www.baidu.com的多级文本构成，其中不同层级用"."来进行区分。同时域名的层级是从右往左递增的。例如上面的www.baidu.com从右往左开始： 根
Java——深入理解Java异常体系
用代码征服天下
11-14 140
该系列博文会告诉你如何从入门到进阶，一步步地学习Java基础知识，并上手进行实战，接着了解每个Java知识点背后的实现原理，更完整地了解整个Java技术体系，形成自己的知识框架。 前言： Java的基本理念是“结构不佳的代码不能运行”。 “异常”这个词有“我对此感到意外”的意思。问题出现了，你也许不清楚该如何处理，但你的确知道不应该置之不理；你要停下来，看看是不是有别人或在别的地方，能够处理这个...
《深入理解java虚拟机（第2版）》笔记（4/完结）
EvilDjango的博客
06-23 359
声明：本文是对《深入理解java虚拟机（第2版）》的片段摘录，版权属于原作者。本文仅供学习交流使用，严禁用于商业用途。7 早期（编译期）优化Java语言的“编译期”其实是一段“不确定”的操作过程，因为它可能是指一个前端编译器（其实叫“编译器的前端”更准确一些）把*.java文件转变成*.class文件的过程；也可能是指虚拟机的后端运行期编译器（JIT编译器，Just In Time Compile...
2.3 数据库-深入理解
老李头喽博客
12-03 1408
在CPU访问寄存器时，都趋于聚集在一片连续的区域中，这就被称为局部性原理。 局部性原理又分为时间局部性（temporal locality） 和空间局部性 （spatial locality） 。时间局部性: 如果程序中的某条指令一旦执行，不久以后该指令可能再次执行;如果某数据被访问过，不久以后该数据可能再次被访问。产生时间局部性的典型原因，是由于在程序中存在着大量的循环操作。 简单来说：被引用过一次的存储器位置在未来会被多次引用空间局部性: 一旦程序访问了某个存储单元，在不久之后，其附近的存储单元也将被访
java的异常体系_Java——深入理解Java异常体系
weixin_33269743的博客
02-20 169
该系列博文会告诉你如何从入门到进阶，一步步地学习Java基础知识，并上手进行实战，接着了解每个Java知识点背后的实现原理，更完整地了解整个Java技术体系，形成自己的知识框架。前言：Java的基本理念是“结构不佳的代码不能运行”。“异常”这个词有“我对此感到意外”的意思。问题出现了，你也许不清楚该如何处理，但你的确知道不应该置之不理；你要停下来，看看是不是有别人或在别的地方，能够处理这个问题。只...
深入Java多线程——Java内存模型深入（2）
江左煤郎的博客
06-19 99
【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> ...
深入理解synchronized底层原理，一篇文章就够了！
yangguoqi的专栏
05-20 451
前言 一、synchronized的特性 1.1 原子性 1.2 可见性 1.3 有序性 1.4 可重入性 二、synchronized的用法 三、synchronized锁的实现 3.1 同步方法 3.2 同步代码块 四、synchronized锁的底层实现 五、JVM对synchronized的优化 5.1 锁膨胀 5.1.1 偏向锁 5.1.2 轻量级锁 5.1.3 重量级锁 5.2 锁消除 5.3 锁粗化 5.4 自旋锁与自适
深入理解synchronized底层原理
qq_43842093的博客
04-27 335
文章目录前言一、synchronized的特性1.1 原子性1.2 可见性1.3 有序性1.4 可重入性二、synchronized的用法三、synchronized锁的实现3.1 同步方法3.2 同步代码块四、synchronized锁的底层实现五、JVM对synchronized的优化5.1 锁膨胀5.1.1 偏向锁5.1.2 轻量级锁5.1.3 重量级锁5.2 锁消除5.3 锁粗化5.4 自旋锁与自适应自旋锁结语 前言 如果某一个资源被多个线程共享，为了避免因为资源抢占导致资源数据错乱，我们需要对线程
空指针的传说——从神秘出生到打败AI败类
weixin_36092143的博客
05-03 333
很久以前，只听天空一道闪电，Java开发的异常家族中出现了一个神秘的成员，它的名字叫做「空指针」。出生时，空指针并不能为人类所用，反而给人类带来困扰和痛苦。 然而就在空指针出生并不断成长的同时，人类世界同时诞生了由邪恶代码构成的AI败类，其拥有的破坏力非常罕见。所有异常家族的高手都畏惧AI败类的力量，关键时刻空指针挺身而出。。。
Android架构——MVP架构一点理解
zhewen的博客
05-18 4359
1. 框架初识 首先讲框架之前，要问自己一个问题，为什么要用到框架？框架的使用能给自己的开发带来什么好处？ 在撰写代码时，会发现随着代码越来越多，理清代码的逻辑越来越困难，且想尽可能的少些Activity。且随着迭代轮次的增多，功能也会随之增删，这时候如果没有一个好的架构，在迭代过程中程序将会被破坏，工作展开极其困难。 MVP框架又是什么？ 在撰写代码时，要避免创建神类。即避免创建无所不知，无所不...
深入理解Linux虚拟内存详解(MMU、页表结构)
j简说Linux的博客
11-08 1577
前言：内存是程序得以运行的重要物质基础。如何在有限的内存空间运行较大的应用程序，曾是困扰人们的一个难题。为解决这个问题，人们设计了许多的方案，其中最成功的当属虚拟内存技术。Linux作为一个以通用为目的的现代大型操作系统，当然也毫不例外的采用了优点甚多的虚拟内存技术。 一，虚拟内存 为了运行比实际物理内存容量还要大的程序，包括Linux在内的所有现代操作系统几乎毫无例外的都采用了虚拟内存技术。虚拟内存技术，可让系统看上去具有比实际物理意义内存大的多的内存空间，并为实现多道程序的执行创造了条件。 (1)虚.
别翻了，这篇文章绝对让你深刻理解java类的加载以及ClassLoader源码分析【JVM篇二】
热门推荐
宜春
12-01 5万+
点进文章的盆友不如先来做一道非常常见的面试题，如果你能做出来，可能你早已掌握并理解了java的类加载机制，若结果出乎你的意料，那就很有必要来了解了解java的类加载机制了。代码如下嗯哼？其实上面程序并不是关键，可能真的难不倒各位，不妨做下面一道面试题可好？如果下面这道面试题都做对了，那没错了，这篇文章你就不用看了，真的。
内存详解——理解 JVM 如何使用 Windows 和 Linux 上的本机内存
jsea的专栏
05-12 2307
  理解 JVM 如何使用 Windows 和 Linux 上的本机内存 Andrew Hall, 软件工程师, IBM 2009 年 5 月 11 日 Java™ 堆耗尽并不是造成 java.lang.OutOfMemoryError 的惟一原因。如果本机内存 耗尽，则会发生普通调试技巧无法解决的 OutOfMemoryError。本文将讨论本机内存的概念，Java 运
总结——操作系统
Python自学记录
03-20 2269
文章目录进程与线程的概念，以及为什么要有进程线程，其中有什么区别，他们各自又是怎么同步的多线程和多进程的不同有了进程，为什么还要有线程？游戏服务器应该为每个用户开辟一个线程还是一个进程，为什么？多进程和多线程的使用场景单核机器上写多线程程序，是否需要考虑加锁，为什么？线程需要保存哪些上下文，SP、PC、EAX这些寄存器是干嘛用的线程间的同步方式，最好说出具体的系统调用一二进程状态转换图，动态就绪，...
排序算法（冒泡排序，选择排序，插入排序，快速排序）
qq_63126439的博客
09-03 700
相邻的数据两两比较，小的放前面，大的放后面。
第三章 数组（5）
qq_62387839的博客
09-03 956
例如，一个拥有6个元素的数组，在排序过程中每一次循环的排序过程和结果如下图所示，绿色的数字处于正在进行比较的状态，蓝色的数字表示处于等待排序的状态，黑色的数字表示已经完成排序的状态。冒泡排序的基本思路是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。算法比较的次数为数组长度减1，因为最后一次比较时，只剩下两个等待比较的元素，完成这两个元素的比较之后，整个数组就完成了排序。
C# 排序算法之冒泡排序
最新发布
学习和分享
09-04 558
它使用了两层嵌套的循环：外层循环控制排序的总轮数，内层循环负责在每一轮中进行实际的元素比较和交换。内层循环每完成一轮，就能确保数组中的最大元素被“冒泡”到它应该在的位置（即数组的末尾）。因此，随着外层循环的进行，需要排序的元素数量逐渐减少，直到整个数组排序完成。它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。需要注意的是，冒泡排序的时间复杂度为O(n^2)，在数据量较大时效率较低，因此它并不适用于需要高效排序的场合。方法用于打印排序后的数组，以便于验证排序结果。
常用排序算法（上）
qq_58761784的博客
09-01 1236
当我们学到数据结构时，就无法避开算法，排序是一类常见且常用的算法，在日常生活中，我们在网上购物，筛选价格时用到了排序，查看该商品销量的高低时用到了排序，而这些功能都是我们程序员使用排序算法将其转化成代码实现的。既然排序如此重要，我们当然要好好把排序学好了。
理解C指针：AT&T汇编详解
"C指针原理教程之AT&T汇编，深入理解C指针，c语言指针，C指针原理" 在深入理解C指针的过程中，AT&T汇编语言起着重要的作用，尤其是在Linux系统中。AT&T汇编与Intel汇编在语法上有显著区别，这使得对汇编语言有一定...
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值