C++笔记1（数组，冒泡排序，二维数组，函数，指针，结构体）

最新推荐文章于 2023-03-06 21:24:59 发布
最新推荐文章于 2023-03-06 21:24:59 发布
阅读量272 收藏 6
点赞数 1
分类专栏： 笔记 文章标签： c++ 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60440795/article/details/125526030
版权

C++

一、数组

1、数组特点

  • 数组每一个数据元素都是相同的数据类型
  • 数组是由连续的内存位置组成的

2、一维数组定义的三种方式

在这里插入图片描述

#include<iostream>
using namespace std;
int main() {
	//1.第一种定义方式
	/*
	int arr[3];
	arr[0] = 1;
	arr[1] = 2;
	arr[2] = 3;
	for (int i = 0; i < 3; i++) {
		cout << arr[i] << endl;
	}
	*/

	//2.第二种定义方式
	/*int arr[3] = {1,2,3};
	for (int i = 0; i < 3; i++) {
		cout << arr[i] << endl;
	}*/

	int arr2[] = { 5,6,7,8,9 };
	for (int i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++) {
		cout << arr2[i] << endl;
	}
	return 0;
}

3、一维数组数组名用途

  • 可以统计整个数组在内存中的长度
  • 可以获取数组在内存中的首地址
#include<iostream>
using namespace std;
int main() {
	//数组名用途
	//1.可以获取整个数组占用的内存空间大小
	int arr[5] = { 5,6,7,8,9 };
	cout << "整个数组所占空间的大小为：" << sizeof(arr) << endl;
	cout << "每个元素所占空间的大小为：" << sizeof(arr[0]) << endl;
	cout << "数组的元素个数为：" << sizeof(arr) / sizeof(arr[0]) << endl;

	//2.可以通过数组名获取到数组首地址
	cout << "数组首地址" << (int)arr << endl;
	//&为取址符号，（int）是强转为十进制
	cout << "数组中第一个元素地址" << (int)&arr[0] << endl;
	cout << "数组中第二个元素地址" << (int)&arr[1] << endl;

	//注意：arr = 100;错误，数组名是常量，因此不可以赋值

	return 0;
}

4、案例：五只小猪称体重

在这里插入图片描述

#include<iostream>
using namespace std;
//思路：访问每一个元素，如果这个元素比我自己创建的最大值要大，更新最大值
int main() {
	//创建每个小猪体重的数组
	int arr[5] = { 300,350,200,400,250 };
	//从数组中找到最大值
	int max = 0;
	for (int i = 0; i < 5; i++) {
	//如果访问的数组中的元素比我认定的最大值还要大，更新最大值
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}
	cout << "最重的小猪体重为：" << max;
	return 0;
}

5、 案例：数组元素逆置

在这里插入图片描述

#include<iostream>
using namespace std;
int main() {
	//实现元素逆置

	int arr[5] = { 1,3,2,4,5 };
	int start = 0;//起始下标的位置
	int end = sizeof(arr) / sizeof(arr[0]) - 1;

	while (start < end)
	{
		//实现元素互换
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
		//下标更新
		start++;
		end--;
	}
	cout << "数组逆置后的元素" << endl;
	for (int i = 0; i < 5; i++) {
		cout << arr[i] << endl;
	}

	return 0;
}

二、冒泡排序

一、

  1. 最常用的排序方法，对数组内元素进行排序
  2. 规则：比较相邻的元素，如果第一个比第二个大，就交换他们两个
  3. 对每一组相邻元素做同样的工作，执行完毕后，找到第一个最大值
  4. 重复以上的步骤，每次比较次数减1，直到不能再比较

二、规律

  • 排序总轮数 = 元素个数 - 1
  • 每轮对比次数 = 元素个数 - 排序轮数 - 1

在这里插入图片描述

#include<iostream>
using namespace std;
int main() {
	int arr[] = { 4,2,8,0,5,7,1,3,9 };
	//开始冒泡排序
	//排序总轮数  = 元素个数 - 1
	for (int i = 0; i < 9 - 1; i++) {
          //内层循环对比
		//每轮对比次数 =  元素个数 - 排序轮数 - 1
		for (int j = 0; j < 9 - i - 1; j++) {
			//如果第一个数字比第二个数字大，交换两个数字
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	cout << "排序后：" << endl;
	for (int i = 0; i < 9; i++) {
		cout << arr[i] << " ";
	}
	return 0;
}

三、二维数组

1、二维数组的定义方式

在这里插入图片描述

2、二维数组的数组名

  • 查看二维数组所占内存空间
  • 获取二维数组首地址
#include<iostream>
using namespace std;
int main() {
	int arr[2][3] = { 1,2,3,4,5,6 };
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 3; j++) {
			cout << arr[i][j]<<" ";
		}
		cout << endl;
	}
	cout << "整个数组的大小：" << sizeof(arr)<<endl;
	cout << "第一行数组的大小：" << sizeof(arr[0]) << endl;
	cout << "第一个数组的大小：" << sizeof(arr[0][0]) << endl;
	cout << "行数：" << sizeof(arr)/sizeof(arr[0]) << endl;
	cout << "列数：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
	cout << "二维数组的首地址：" << (int)arr<<endl;
	cout << "二维数组的第一行首地址：" << (int)arr[0] << endl;
	cout << "二维数组的第二行首地址：" << (int)arr[1] << endl;
	cout << "二维数组的第一个元素首地址：" << (int)&arr[0][0] << endl;//利用取地址符号

	return 0;
}

3、案例

在这里插入图片描述

//循环思想和利用循环做计算很重要
#include<iostream>
#include<string>
using namespace std;
int main() {
	//张三：100 100 100，李四：90 50 100，王五：60，70，80
	//计算每个人的总分

	int scores[3][3] = { {100,100,100},{90,50,40},{60,70,80} };
	string names[3] = { "张三","李四","王五" };
	for (int i = 0; i < 3; i++) {
		int sum = 0;
		for (int j = 0; j < 3; j++) {
			sum += scores[i][j];
		}
		cout << names[i]<<"的分数是："<<sum << endl;
	}

	return 0;

}

四、函数

1、作用

  • 将一段经常使用的代码封装在一起，减少重复代码，一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能

2、定义

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

//定义一个加法函数
int add(int a,int b){
int sum = a+b;
return sum;
}

3、值传递

  • 函数调用时实参将数值传入给形参
  • 值传递时，如果形参发生改变，并不会影响实参
#include<iostream>
using namespace std;
void swap(int num1,int num2){
int temp = num1;
num1 = num2;
num2 = temp;
}
int main(){
int a = 10;
int b = 20;
//当我们做值传递的时候，函数的形参发生变化，并不会影响实参
swap(a,b);
//a,b还是10，20
return 0;}

4、常见样式

  • 无参无返
  • 有参无返
  • 无参有返
  • 有参有返

5、函数声明

  • 声明可以多次，定义只能一次
int max(int a,int b);//函数声明

int main(){
int a = 100;int b  = 200;
cout << max(a,b);
return 0;}
//利用函数声明可以将函数定义写在main方法的后面
int max(int a,int b){
return a > b ? a : b;}

6、函数的分文件编写

  1. 作用：让代码结构更加的清晰
  2. 编写的步骤：在这里插入图片描述
    在这里插入图片描述
//swap.h
#include<iostream>
using namespace std;
//函数的声明
void swap(int a, int b);


//swap.cpp
#include"swap.h"
//函数的定义
void swap(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
	cout << "a=" << a<<endl;
	cout << "b=" << b << endl;
}


//函数的分文件编写.cpp
#include<iostream>
using namespace std;
#include"swap.h"
int main() {
	int a = 20;
	int b = 30;
	swap(a, b);
}

五、指针

1、基本概念及作用

  • 作用：可以通过指针间接访问内存
  • 内存编号是从0开始记录的，一般用十六进制的数组表示
  • 可以利用指针变量保存地址

2、定义和使用

  • 数据类型 * 变量名
#include<iostream>
using namespace std;
int main() {
	//1.定义指针
	int a = 10;
	int* p;
	p = &a;
	cout << "a的地址为：" << &a << endl;
	cout << "指针p为：" << p << endl;

	//2、使用指针
	//可以通过解引用的方式来找到指针指向的内存
	*p = 1000;//解引用
	cout << "a=" << a << endl;
	cout << "*p=" << *p << endl;

	return 0;

}

3、指针所占内存空间

  • 在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
  • 在64位操作系统下，指针是占8个字节空间大小，不管是什么数据类型
int a = 10;
int *p = &a;
cout<<sizeof(int *)<<endl;
cout<<sizeof(fioat *)<<endl;
cout<<sizeof(double *)<<endl;
cout<<sizeof(char *)<<endl;

4、空指针

1.空指针：指针变量向内存中编号为0的空间
2.用途：初始化指针变量
3.注意：空指针指向的内存是不可以访问的


#include<iostream>
using namespace std;
int main() {
	//指针变量p指向的内存地址编号为0的空间
	int* p = NULL;
	//访问空指针报错
	//内存编号为0~255为系统占用内存，不允许用户访问
	cout << *p << endl;
	return 0;
}

5、野指针

  • 指针变量指向非法的内存空间
  • 总结：空指针和野指针都不是我们申请的空间，因此不要访问
#include<iostream>
using namespace std;
int main() {
	//指针变量p指向内存地址编号为0x1100的空间
	int* p = (int*)0x1100;
	//访问野指针报错
	cout << *p << endl;
	return 0;

}

6、const修饰指针

  1. const修饰指针——常量指针
  2. const修饰常量——指针常量
  3. const既修饰指针，又修饰常量
#include<iostream>
using namespace std;
int main() {
	//指针的指向指的是改变地址值

	//1.const修饰指针（常量指针）
	int a = 10;
	int b = 10;
	const int* p = &a;
	//指针指向的值不能通过指针改变，但可以通过变量自身改变，指针的指向可以改变
	//*p = 20;//错误
	p = &b;//正确


	//2.const修饰常量(指针常量)
	//指针指向不可以改，指针指向的值可以通过指针更改_
	int* const p2 = &a;
	*p2 = 100;//正确
	//p2 = &b;错误


	//3.const既修饰指针又修饰常量
	const int* const p3 = &a;
	//指针的指向和指针指向的值都不可以改
	//*p3 = 100;//错误
	//p3 = &b;//错误
	return 0;
}

7、指针和数组

  • 作用：利用指针访问数组中的元素
#include<iostream>
using namespace std;
int main() {
	//利用指针访问数组中的元素
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int* p = arr;//*p是数组第一个元素
	for (int i = 0; i < 10; i++) {
		cout << *(p + i)<<" ";
	}
	cout << endl << "或者" << endl;
	//或者
	for (int i = 0; i < 10; i++) {
		cout << *p << " ";
		p++;
	}

	return 0;
}

8、指针和函数

  • 作用：利用指针作函数参数，可以修改实参的值
  • 总结：如果想改变实参就用地址传递，不想就用值传递
#include<iostream>
using namespace std;
//交换两个数（值传递）
void swap(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
}
//交换两个数（地址传递）
void swap2(int* p1, int* p2) {
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main() {

	int num1 = 20;
	int num2 = 30;
	swap(num1, num2);

	swap2(&num1, &num2);
	cout << num1 << " " << num2;
	return 0;
}

9、指针配合数组和函数案例

  • 案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序
#include<iostream>
using namespace std;
//案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序
//冒泡排序的函数
//参数一：数组首地址，参数二：数组长度
void bubbleSort(int* arr, int len) {
	for (int i = 0; i < len - 1; i++) {
		for (int j = 0; j < len - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

//打印数组
void printArray(int* arr, int len) {
	for (int i = 0; i < len; i++) {
		cout << arr[i]<<" ";
	}
}

int main() {
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	bubbleSort(arr, 10);
	printArray(arr, 10);
		return 0;
}

六、结构体

1、基本概念

  • 结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

2、定义和使用

  • 语法：struct 结构体名{ 结构体成员列表 }；
  • 创建变量的三种方式：在这里插入图片描述方式一和方式二用的比较多
  • 总结：在这里插入图片描述
#include<iostream>
using namespace std;
#include<string>//新版2022可以不用

struct Student {
	string name;
	int age;
	int score;
}s3;

int main() {
	//通过学生类型创建具体学生

	//方法一：struct Student s1
	//struct Student s1;
	//省略形式
	Student s1;

	//给s1属性赋值，通过.访问结构体变量中的属性
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;
	cout << "姓名：" << s1.name << "年龄：" << s1.age << "分数：" << s1.score;
	
	cout << endl;
	//方法二：struct Student s2 = {……}
	struct Student s2 = { "李四", 19, 80 };
	cout << "姓名：" << s2.name << "年龄：" << s2.age << "分数：" << s2.score;

	cout << endl;
	//方式三：在定义结构体的时候顺便创建结构体变量
	s3.name = "王五";
	s3.age = 16;
	s3.score = 80;
	cout << "姓名：" << s3.name << "年龄：" << s3.age << "分数：" << s3.score;
	return 0;
}

3、结构体数组

  • 作用：将自定义的结构体放入到数组中方便维护
  • 语法： struct 结构体名 数组名[元素个数] = { { }，{ }，…{ } }
#include<iostream>
using namespace std;
struct Student {
	string name;
	int age;
	int score;
};
int main() {
	struct Student stuArr[3] = {
		{"张三",18,100},
	     {"李四",28,99},
		{"王五",38,66}
	};

	stuArr[2].age = 22;
	stuArr[2].name = "赵六";
	stuArr[2].score = 55;


	//遍历结构体数组
	for (int i = 0; i < 3; i++) {
		cout << "姓名：" << stuArr[i].name 
			<< "年龄：" << stuArr[i].age 
			<< "分数：" << stuArr[i].score 
			<< endl;
	}


	return 0;
}

4、结构体指针

  • 作用：通过指针访问结构体的成员
  • 利用操作符 -> 可以通过结构体指针访问结构体属性
#include<iostream>
using namespace std;
struct student {
	string name;
	int age;
	int score;
};
int main() {
	//1.创建结构体变量
	struct student s = { "张三", 18 ,66 };

	//2.通过指针指向结构体变量
	
	student* p = &s;

	//3.通过指针访问结构体变量中的数据
	//通过结构体指针访问结构体中的属性，需要利用‘->’
	cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score;
	return 0;
}

5、结构体嵌套结构体

  • 作用：结构体中的成员可以是另一个结构体
  • 例如：每一个老师辅导一个学员，一个老师的结构体中，记录每一个学生的结构体
#include<iostream>
using namespace std;
struct student {
	string name;
	int age;
	int score;
};
//定义老师结构体
struct teacher {
	int id;
	string name;
	int age;
	struct student stu;//学生结构体
};
int main() {
	//创建老师
	teacher t;
	t.id = 10000;
	t.name = "老王";
	t.age = 50;
	t.stu.name = "小王";
	t.stu.age = 18;
	t.stu.score = 88;
	cout << "老师姓名： " << t.name << " 老师编号： " << t.id << " 老师年龄： " << t.age
		<< " 老师辅导的学生姓名： " << t.stu.name << " 学生年龄： " << t.stu.age << " 学生分数: "
		<< t.stu.score;
	return 0;

}

6、结构体做函数参数

  • 作用：将结构体作为参数向函数中传递
  • 传递方式：（1）值传递（2）地址传递
  • 总结： 如果你不想修改主函数的数据，用值传递，返之用地址传递
#include<iostream>
using namespace std;
struct student {
	string name;
	int age;
	int score;
};

//打印学生信息的函数
//1.值传递
void printStudent(struct student s) {
	s.age = 100;
	cout << "子函数打印 姓名： " << s.name << "  年龄： " << s.age << "  分数： " << s.score<<endl;
}


//2.地址传递
void printStudent2(struct student* p) {
	p->age = 300;
	cout << "子函数2打印 姓名： " << p->name << "  年龄： " << p->age << "  分数： " << p->score<<endl;

}
int main() {
	//结构体做函数参数
	//将学生传入到一个参数中，打印学生身上所有的信息

	student s;
	s.age = 18;
	s.name = "张胜男";
	s.score = 44;
	//printStudent(s);
	printStudent2(&s);
	cout << "main函数打印 姓名： " << s.name << "  年龄： " << s.age << "  分数： " << s.score;

	return 0;
}

7、结构体中const的使用场景

  • 作用： 用const来防止误操作
#include<iostream>
using namespace std;
struct student {
	string name;
	int age;
	int score;
};
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
//void printStudent(student s) 
void printStudent( const student* s)
{//加入const之后，一旦有修改的操作就会报错，可以防止误操作
	//s->age = 100;报错
	cout << "姓名：" << s->name << "  年龄：" << s->age << " 分数：" << s->score<<endl;
}
int main() {
	struct student s = { "张三",15 ,70 };
	printStudent(&s);
	//通过函数来打印结构体的变量信息

	return 0;
}

8、结构体案例1

在这里插入图片描述

#include<iostream>
using namespace std;
struct student {
	string name;
	int score;
};
struct teacher {
	string tName;
	struct student sArr[5];
};

//给老师和学生赋值的函数
//参数也可以用指针
void allocateSpace(struct teacher tArr[], int len) {
	string nameSeed = "ABCDE";
	//给老师开始赋值
	for (int i = 0;i<len;i++){
		tArr[i].tName = "Teacher_";
		tArr[i].tName += nameSeed[i];

		//通过循环给每名老师所带的学生赋值
		for (int j = 0; j < 5; j++) {
			tArr[i].sArr[j].name = "Student_";
			tArr[i].sArr[j].name += nameSeed[j];
			int ran = rand() % 61+40;//40~100分
			tArr[i].sArr[j].score = ran;

		}
	}
}

//打印所有的信息
void printInfo(struct teacher tArr[], int len) {
	for (int i = 0; i < len; i++) {
		cout << "老师姓名：" << tArr[i].tName << endl;
		for (int j = 0; j < 5; j++) {
			cout << "\t学生姓名：" << tArr[i].sArr[j].name
				<< "考试分数：" << tArr[i].sArr[j].score<<endl;

		}
	}
}
int main() {
	//随机数种子
	srand((unsigned int)time(NULL));
	 teacher tArr[3];
	 allocateSpace(tArr, 3);
	 printInfo(tArr, 3);

	return 0;
}

9、结构体案例2

在这里插入图片描述

#include<iostream>
using namespace std;
struct hero {
	string name;
	int age;
	string sex;
};
//冒泡排序 实现年龄升序排序
void bubbleSort(struct hero heroArr[], int len) {
	for (int i = 0; i < len - 1; i++) {
		for (int j = 0; j < len - 1 - i; j++) {
			//如果j下标的年龄大于j+1的，就交换
			if (heroArr[j].age > heroArr[j + 1].age) {
				struct hero temp = heroArr[j];//用struct型的temp
				heroArr[j] = heroArr[j + 1];
				heroArr[j + 1] = temp;
			}
		}
	}
}
void print(struct hero heroArr[], int len) {
	for (int i = 0; i < len; i++) {
		cout << "  姓名：" << heroArr[i].name << "  年龄：" << heroArr[i].age << "  性别：" << heroArr[i].sex << endl;
	}
}
	int main(){
		struct hero heroArr[5] = {
			{"刘备",23,"男"},
			{"关煜",22,"男"},
			{"张飞",20,"男"},
			{"赵云",21,"男"},
			{"貂蝉",19,"女"}
		};
		bubbleSort(heroArr, 5);
		print(heroArr, 5);
		return 0;
	}
明灭18
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++_成绩统计（二维数组）_冒泡排序（指针配合函数与数组）
CY994349264的博客
07-27 971
#include<iostream> using namespace std; #include<string> //成绩统计 int main() { //1、创建二维数组 int scroes[3][3] = { {100,100,100}, {100,95,100}, {100,100,96}, }; string names[3] = {...
二维数组实现冒泡排序
王山而的博客
12-02 2283
实现了一维数组的排序，同时二位数组也可实现排序。 利用C++实现，以下为主函数 #include<iostream> using namespace std; #define N 3 void paixu(int (*p)[N]); void out(int (*p)[N]); int main() { int a[N][N],i,j; cout<<"输入数据"<<endl; for(i=0;i<N;i++) fo...
c++排序函数对二维数组排序_算法｜数组冒泡排序和二分查找
weixin_39840606的博客
11-29 175
数组排序的方法有超过十种，冒泡排序是一种相对容易理解的排序方法。通过相邻元素的大小比较和交换，通过一个循环可以将一个最大(或最小)元素移动到数组序列的最后。再通过一个外循环便可以实现全部元素的排序。对冒泡排序可以通过一个标志逻辑值标识在一趟排序中确认是否有相邻元素的交换，没果在一趟排序中相邻元素都没有进行过交换，那也就是说明整个序列已经是一个有序的状态了，排序操作可以提前结束。二分查找相对于顺序查...
二维数组冒泡排序
YanJiDao的博客
11-18 891
import java.util.Arrays; public class Task03 { public static void main(String[] args) { int[][] a={{1,10,4,3},{6,11,12,5,13},{8,2,14,15,16,17},{18,9,7,19,20}}; int i,j,k; for(i=0;i for(j
C二维数组冒泡排序
风情路96号
03-22 956
#include　　int main()　　{ 　　int a[2][3]={6,5,4,3,2,1}; //注释内容为当二维数组为a[x][y]后要变的内容　　int i,j,k,m,n,temp;　　 for(i=0;i　　 　　 for(k=1;k　　 for(i=0;i　　 {　　 n=i+1;　　 m=0;　　 }　　 else 　　 {　　 n=i;　　 m=j+1;　　 }　　 if
c++笔记.docx
05-26
本文档记录了个人对C++的学习心得，涵盖了C++基础知识点，包括 Switch 结构、While 语句、循环语句、break 语句、数组计算、冒泡排序法、选择排序法、逆序、指针、结构数组等。 一、Switch 结构的运用 Switch 结构...
c ++ 学习笔记1
08-03
在C++中，可以声明一维、二维或多维数组，并通过索引来访问其元素。示例中的`int arr[10]`就是一个包含10个整数的一维数组。 5. **函数**：函数是可重用的代码块，可以接收参数并返回值。在C++中，我们可以定义自己...
《B站-青岛大学-王卓老师-数据结构与算法基础》自学心得、笔记（C++语言实现）.zip
最新发布
02-27
在算法部分，排序算法如冒泡排序、选择排序、插入排序、快速排序、归并排序等，各有特点，理解它们的时间复杂度和适用场景是必要的。搜索算法如线性搜索、二分搜索、广度优先搜索等，也是算法基础的重要组成部分。 ...
数据结构学习笔记(c++)
03-02
在C++中，可以声明一维、二维或多维数组。理解数组的动态分配和静态分配以及数组的边界检查至关重要。 2. **链表**：链表由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表分为单链表、双链表和循环...
免费下载:C语言难点分析整理.doc
02-29
37. 函数指针数组与返回数组指针的函数 186 38. 右左法则- 复杂指针解析 189 39. 回车和换行的区别 192 40. 堆和堆栈的区别 194 41. 堆和堆栈的区别 198 42. 如何写出专业的C头文件 202 43. 打造最快的Hash表 207 44...
c语言二维数组冒泡排序
09-08
c++ c语言编写 二维数组的 冒泡排序 范例
冒泡排序c＋＋
01-06
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。
二维数组如何进行冒泡排序
07-18
思路以及注意点、说明我都加在了代码旁边的注释里，好好悟悟！
二维数组全排列代码C++版
03-10
二维数组全排列生成方法，采用递归方法实现，10*24大概用时30min，有待进一步改进
二维数组的四种排序（绝对经典）
06-09
二维数组的排序，其中包含冒泡排序、选择排序、插入排序和快速选择排序。
5.C++数组（一维数组，二维数组，冒泡排序）
m0_48716770的博客
07-18 462
一、一维数组 二、二维数组
二维数组进行冒泡排序
weixin_64755790的博客
09-08 2108
二维数组冒泡排序
Java冒泡排序思路及代码代码代码
caixuanji的博客
05-13 267
Java冒泡排序 两层循环，外层冒泡轮数，内层循环依次比较 思路 比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换它们的位置 每一次比较，都会产生一个最大，或者一个最小的数字 下一轮则可以少一次排序 依次循环，直到结束 代码： public static int[] sort(int[] array){ int temp =0; for (int i = 0; i < array.length; i++) { boolea
[数据结构]：11-冒泡排序（顺序表指针实现形式）（C语言实现）
Chandni_小月月
03-06 899
此专栏包含408考研数据结构全部内容，除其中使用到C++引用外，全为C语言代码。使用C++引用主要是为了简化指针的使用，避免二重指针的出现。
c语言结构体数组冒泡排序
12-18
以下是C语言结构体数组...`bubbleSort`函数实现了冒泡排序算法，其中`arr`参数为结构体数组，`n`参数为数组长度。在`main`函数中定义了一个包含5个学生信息的结构体数组`students`，并输出排序前和排序后的学生信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值