目录
【1】冒泡排序（从小到大）
【2】选择排序
【3】二维数组
【4】指针
【5】指针修饰
【6】大小端
【7】初见二级指针
练习：
【1】冒泡排序（从小到大）
#include <stdio.h>
//数组哪里的\0?自己和字符串区分下
void bubbleSort(int arr[], int size) {
int i, j, temp;
for (i = 0; i < size - 1; i++) {
for (j = 0; j < size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// 交换相邻的两个数字
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int arr[] = {5, 3, 8, 2, 1};
int size = sizeof(arr) / sizeof(arr[0]);
int i;
printf("排序前的数组：");
for (i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
bubbleSort(arr, size);
printf("排序后的数组：");
for (i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}【2】选择排序
#include<stdio.h>
#define N 5
int main(int argc, char const *argv[])
{
int a[N]={};
int i,j,k,t;
for(i=0;i<N;i++)
scanf("%d",&a[i]);
for(i=0;i<N-1;i++)
{
k=i;
for(j=i+1;j<N;j++)
if(a[k]>a[j])
k=j;
if(i != k)
{
t= a[i];
a[i]=a[k];
a[k]=t;
}
}
for(i=0;i<N;i++)
printf("%d ",a[i]);
printf("\n");
return 0;
}【3】二维数组
1.格式：
注意 ：行数可以省略，列数不能省略
2.元素个数：行数*列数
3.数组名：
int a[][3]={1,2,3,4,5,6};
a：表示第一行的首地址
a+1:表示第二行的首地址4.初始化：
1）全部初始化：
int a[2][3]={1,2,3,4,5,6};
int a[2][3]={{1,2,3},{4,5,6}};
第一行 第二行
2）部分初始化：未赋初值时值为0
int a[2][3]={1,2,3,4}; //123 400
int a[2][3]={{1,2},{5,6}}; //1 2 0 5 6 0
3) 未初始化：需要分别赋值，未赋初值值为随机值
int a[2][3]；5.内存分配：
a:第一行首地址
a+1:第二行首地址
a[0]:第一行第一列的地址
a[1]:第二行第一列的地址6.计算大小：
sizeof(数组名)
行*列*数据类型的大小
7.遍历数组：
for循环嵌套，外层行，内层列
for(i=0;i<2;i++)
for(j=0;j<3;j++)
printf("%d ",a[i][j]);练习：有一个3x4的矩阵（元素值不相同），要求输出其中最大值以及它的行号和列号
//下标替换法
#include<stdio.h>
int main(int argc, char const *argv[])
{
int a[3][4]={15,14,13,2,
5,9,46,56,
12,78,89,13};
int i,j,h=0,l=0;
for(i=0;i<3;i++)
for(j=0;j<4;j++)
if(a[i][j]>a[h][l])
{
h=i;
l=j;
}
printf("max:%d 行号：%d 列号：%d\n",a[h][l],h+1,l+1);
return 0;
}
练习：
猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个，第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
#include <stdio.h>
int calculatePeaches(int days) {
int peaches = 1;
for (int i = days; i >= 1; i--) {
peaches = (peaches + 1) * 2;
}
return peaches;
}
int main() {
int days = 10;
int totalPeaches = calculatePeaches(days);
printf("第一天共摘了 %d 个桃子。\n", totalPeaches);
return 0;
}
打印杨辉三角形的前十行：重点理清for的查看查看顺序，不要老是整体看，要分开看，一步步看
#include <stdio.h>
int main() {
int numRows = 10;
int triangle[numRows][numRows];
// 初始化杨辉三角形的第一列和对角线为1
for (int i = 0; i < numRows; i++) {
triangle[i][0] = 1;
triangle[i][i] = 1;
}
// 生成杨辉三角形的其他数值
for (int i = 2; i < numRows; i++) {
for (int j = 1; j < i; j++) {
triangle[i][j] = triangle[i-1][j-1] + triangle[i-1][j];
}
}
// 输出杨辉三角形的前十行
for (int i = 0; i < numRows; i++) {
for (int j = 0; j <= i; j++) {
printf("%d ", triangle[i][j]);
}
printf("\n");
}
return 0;
}【4】指针
1. 概念：
地址：在内存中每个字节都有编号，编号就是地址
指针：指针就是地址
指针变量：存放地址的变量
2. 定义格式：
例子：
int a=5;
int *p = &a;
char ch = 'a';
char * q = &ch;3. 指针操作符：
&：取地址，取变量的地址
* ：取内容，取地址里面的内容
&和*是互逆的，*&a == a &*p == p
4. 初始化：
指针使用前不仅要定义，还要初始化
1)将普通变量的地址赋值给指针变量
int a = 5;
1.int * p = &a;
printf("%d %d\n",a,*p);//a的值 5 5
printf("%p %p\n",&a,p);//a的地址
a = 10; //是地址，就有地址特性
printf("%d %d\n",a,*p);//a的值 10 10
*p = 20;
printf("%d %d\n",a,*p);//a的值 20 20
2.int * p = NULL;
p = &a;
2)将数组的首地址赋值给指针变量
char s[10]="hello";
char * p = s; //p指向hello字符串中字符h
3）将指针变量里面保存的地址赋值给另一个指针变量
int a= 20;
int *p = &a;
int *q = p;5. 指针运算：
1）算术运算
p++：指针向高地址方向移动一个数据单位，指针的指向发生变化
p--：指针向低地址方向移动一个数据单位，指针的指向发生变化
p+n：访问了高地址方向第n个数据的地址，指针的指向不发生变化
p-n：访问了低地址方向第n个数据的地址，指针的指向不发生变化
两个地址之间的差是相隔元素的个数
2） 关系运算
> < == !=
关系运算比较的是指向地址的高低
指向高地址的指针 大于 指向低地址的指针
int a[5]={};
int *p = &a[1];
int *q = &a[3];
q>p
注：只能在同一个数组间进行地址的比较6. 指针的大小：
sizeof(指针名)=4（32位操作系统）
总结：
1） 32位操作系统指针大小4字节，64位操作系统指针大小8字节
2） 内存地址是固定的，但是变量地址是不固定的
3） 指针类型根据指针指向空间的数据类型确定的
7. 段错误：Segmentation fault (core dumped)
原因有两条：
1）野指针，没有明确指向的指针
产生原因：1.指针变量没有初始化 2.指针p被free之后没有重新赋值
解决：int * p = NULL;
2)对非法空间赋值
练习：
将字符串转换成整型数字输出。用指针实现
要求：字符串为0-9组成，输出数据为一个整形数
Eg:char s[10]=”123”;printf(“%d\n”,num);//num=123;
#include <stdio.h>
int strToInt(char* str) {
int num = 0;
while (*str != '\0') {
num = num * 10 + (*str - '0');
str++;
}
return num;
}
int main() {
char s[10] = "123";
int num = strToInt(s);
printf("%d\n", num); // 输出：123
return 0;
}练习：字符串倒置(用指针实现) 如：hello->olleh
#include <stdio.h>
void reverseString(char* str) {
char* start = str;
char* end = str;
char temp;
// 找到字符串的末尾
while (*end != '\0') {
end++;
}
end--; // 指向最后一个非空字符
// 交换字符位置，直到两个指针相遇
while (start < end) {
temp = *start;
*start = *end;
*end = temp;
start++;
end--;
}
}
int main() {
char s[10] = "hello";
reverseString(s);
printf("%s\n", s); // 输出：olleh
return 0;
}【5】指针修饰
1.const
1）const int a=10; // int const a=10;
a=20; //报错，const修饰a为只读
定义一个指针p指向a,可以通过修改*p改变a的值
2)const int *p; //指针指向的内容不能修改，指针的指向可以修改
int const *p;
int a = 10;
const int *p = &a;
a)*p = 20; //报错，*p被const修饰，不能被赋值
b)int b = 20;p=&b; //√
3)int * const p;//指针的指向不能修改，指针指向的内容可以修改
int a=10;
int b = 20;
int * const p = &a;
a)*p = 20;//正确
b)p= &b;//错误
2.void
void a;//错误
void * p;//任意类型的指针
注意：通过void类型指针取数据时，需要对地址进行强转
（int *）p【6】大小端
在计算机存储超过一个字节数据的时候，会存在数据存储顺序的不同，分为大端和小端
大端：低地址存放高字节数据，高地址存放低字节数据
小端：低地址存放低字节数据，高地址存放高字节数据
举例：存数据0x12345678,起始地址，0x4000
0x4000 0x4001 0x4002 0x4003
大端： 12 34 56 78
小端： 78 56 34 12【7】初见二级指针
一级指针：存放变量的地址
二级指针：存放一级指针的地址
格式：存储类型 数据类型 **变量名；
例：
int a= 10;
int * p = &a;
int **q = &p;
访问a的值：
a *p **q
访问a的地址：
&a p *q
访问p的地址：
&p q练习：
给定一串字符"I love china",实现以单词为单位的逆序，如："china love i"
思路：可以先全部倒过来：anihc evol i,然后再把每个单词倒过来
#include <stdio.h>
#include <string.h>
int main(int argc, char const *argv[])
{
// char a[32] = "i love China";
char a[32]={};
scanf("%[^\n]",a);
char t;
char *p = a;
char *q = a + strlen(a) - 1;
char *k = NULL;
while (p < q)
{
t = *p;
*p = *q;
*q = t;
p++;
q--;
}
printf("%s\n", a);
p = q = a;
while (*p != '\0')
{
while (*p == ' ')
p++;
q = p; //找单词结尾
while (*q != ' ' && *q != '\0')
q++;
k = q; //暂存空格或\0地址
q--;
while (p < q)
{
t = *p;
*p = *q;
*q = t;
p++;
q--;
}
p=k;
}
printf("%s\n",a);
return 0;
}用指针将整型组s[8]={1,2,3,4,5,6,7,8}中的值逆序存放
#include <stdio.h>
void reverseArray(int* arr, int size) {
int* start = arr;
int* end = arr + size - 1;
int temp;
// 交换数组元素位置，直到两个指针相遇
while (start < end) {
temp = *start;
*start = *end;
*end = temp;
start++;
end--;
}
}
int main() {
int s[8] = {1, 2, 3, 4, 5, 6, 7, 8};
int size = sizeof(s) / sizeof(int);
reverseArray(s, size);
for (int i = 0; i < size; i++) {
printf("%d ", s[i]); // 输出：8 7 6 5 4 3 2 1
}
return 0;
}
