嵌入式学习之路 14（C语言基础学习——指针操作一维整型数组）

一、指针基础

指针的概念

        地址表示内存单元的编号，也被称为指针。指针既是地址，也是一种专门用于处理地址数据的数据类型。
例如，变量a的地址或者十六进制表示的0x1000都可以视作指针。
 

指针变量的定义

语法：基类型 * 指针变量名。
        基类型可以是之前学过的各种数据类型，如整型、浮点型、字符型、结构体类型、函数类型等，它表示指针所指向的内存空间能够存放的数据类型。例如：int *p; 中，p就是一个指向整型数据的指针变量。
        *在定义时表示定义的是指针类型的变量。
        指针变量名需符合标识符命名规则。

指针类型

例如：在int *p;中，int *整体被称为指针类型，表示指向整型数据的指针类型。

指针变量的引用

例如：int a = 10; int *p = &a; ，p指向 a 。
*是指针运算符，为单目运算，运算对象只能是指针（地址）。
*p表示访问 p 所指向的基类型的内存空间，这是一种间接访问。其过程包括：首先拿出 p 中的地址，在内存中定位；然后偏移出 sizeof(基类型) 大小的一块空间；最后将偏移出的这块空间当作一个基类型变量来看。
例如，*p 的运算效果相当于直接访问的变量 a 。
类似地，对于int a; ，a的数据类型是 int ，&a的数据类型是 int* ，对于 float b; ，&b的数据类型是 float* 。

指针变量的初始化

如果指针变量没有初始化，此时的值是随机值（野指针）。
初始化可以让指针变量有明确的指向，例如：int a; int *p = &a; 或者 int *p = NULL（NULL 表示空指针，即 0 号地址）。

赋值

例如：int *p; p = &a;

定义多个指针变量

例如：int *p, *q; 表示定义了两个指针变量。
注意：定义时候的 * 是修饰变量名的，表示定义的是一个指针类型的变量。

为什么需要指针指针

指针可以实现被调函数修改主调函数中的数据。

二、指针作为函数的参数

1、形参是指针类型的变量，用来接收实参（实参是要操作的内存空间的地址）。
2、实参：要修改谁，就把谁的地址传进去，但要保证空间有效。
3、注意：被调函数中一定要有*p的运算（间接访问的操作）。
4、值传递只是实参数据赋值给了形参，而地址（指针传递）传递的是地址，可以实现被调修改主调。

练习：

#include <stdio.h>
 
// 函数：实现两个数相加，并将结果存储在指针所指的变量中
void ADD(int *a, int b) 
{
    *a = *a + b;  // 将指针 a 所指变量的值与 b 相加，并将结果存储回指针所指的变量
}
 
// 函数：找出两个数中的最大值和最小值，并通过指针返回
void maxandmin(int a, int b, int *max, int *min) 
{
    *max = a > b? a : b;  // 如果 a 大于 b，将 a 赋值给指针 max 所指的变量，否则将 b 赋值给它
    *min = a < b? a : b;  // 如果 a 小于 b，将 a 赋值给指针 min 所指的变量，否则将 b 赋值给它
}
 
// 函数：交换两个指针所指变量的值
void swap(int *a, int *b) 
{
    int temp = *a;  // 临时变量 temp 存储指针 a 所指变量的值
    *a = *b;  // 将指针 b 所指变量的值赋给指针 a 所指的变量
    *b = temp;  // 将临时变量 temp 的值赋给指针 b 所指的变量
}
 
// 主函数
int main() 
{
    int a = 2;  // 定义并初始化变量 a 为 2
    int b = 3;  // 定义并初始化变量 b 为 3
 
    int max;  // 定义变量用于存储最大值
    int min;  // 定义变量用于存储最小值
 
    // ADD(&a,b);  // 调用 ADD 函数，将 b 的值加到 a 上
    // printf("sum = %d\n",a);  // 输出相加后的结果
 
    // maxandmin(a,b,&max,&min);  // 调用 maxandmin 函数找出 a 和 b 的最大值和最小值
    // printf("max = %d, min = %d\n",max,min);
 
    printf("a = %d b = %d\n",a,b);  // 输出原始的 a 和 b 的值
    swap(&a,&b);  // 调用 swap 函数交换 a 和 b 的值
    printf("a = %d b = %d\n",a,b);  // 输出交换后的 a 和 b 的值
 
    return 0;
}

三、指针与一维整型数组

1、数组名代表数组首元素的地址，就是数组所在空间的首地址。例如：定义一个指向整型数组的指针变量可以写成 int *p = a; 或者 int *p = &a[0]; ，表示 p 指向了数组 a 。
2、数组名（数组首元素的地址）和 &a[0] 等价。
3、*p 等价于 a[0] 。
4、指针的运算：

&：取地址运算符。
*：解引用运算符。
p + 1：指针的算术运算，其偏移量取决于指针所指向的数据类型的大小。

指针的比较：

>  >=  <  <=  ==  !=

可以比较两个指针的大小或相等关系，但前提是这两个指针指向同一个数组或具有相同的基类型。

#include <stdio.h>
 
// 函数：打印数组元素
void printfArray(int *begin, int *end) 
{
    // 只要起始指针不超过结束指针，就持续执行循环
    while (begin <= end)  
    {
        // 打印起始指针所指向的元素，并将起始指针向后移动一位
        printf("%d ",*begin++);  
    }
    // 换行，使输出更清晰
    printf("\n");  
}
 
// 函数：找出数组中的最大值
int maxArray(int *a, int len) 
{
    int i;  // 定义循环变量
    // 初始化最大值为数组的第一个元素
    int max = *a;  
 
    // 遍历数组的每一个元素
    for (i = 0; i < len; i++)  
    {
        // 如果当前最大值小于数组中的某个元素
        if (max < *(a + i))  
        {
            // 更新最大值为该元素
            max = *(a + i);  
        }
    }
 
    // 返回最大值
    return max;  
}
 
// 函数：反转数组元素的顺序
void reversedOrder(int *begin, int *end) 
{
    int temp;  // 定义临时变量用于交换元素
 
    // 只要起始指针小于结束指针，就持续执行循环
    while(begin < end)  
    {
        // 交换起始指针和结束指针所指向的元素
        temp = *begin;  
        *begin = *end;  
        *end = temp;  
        // 起始指针向前移动一位
        begin++;  
        // 结束指针向后移动一位
        end--;  
    }
}
 
// 函数：选择排序
void choieSort(int *begin, int *end)  
{
    int *p = begin;  // 定义指向起始位置的指针
    int *q = NULL;  // 定义用于遍历的指针
 
    // 外层循环控制排序的轮数
    for (p = begin; p < end; p++)  
    {
        // 内层循环在每一轮中找出最小元素
        for (q = p + 1; q <= end; q++)  
        {
            // 如果当前元素大于后面的元素
            if (*p > *q)  
            {
                // 交换两个元素
                int t = *p;  
                *p = *q;  
                *q = t;  
            }
        }
    }
}
 
// 函数：冒泡排序
void bubbleSort(int *begin, int *end) 
{
    int *p = begin;  // 定义指向起始位置的指针
    int *q = NULL;  // 定义用于遍历的指针
 
    // 外层循环控制排序的轮数
    for (p = end; p > begin; p--)  
    {
        // 内层循环在每一轮中比较相邻元素
        for (q = begin; q < p; q++)  
        {
            // 如果当前元素大于下一个元素
            if (*q > *(q + 1))  
            {
                // 交换两个相邻元素
                int t = *q;  
                *q = *(q + 1);  
                *(q + 1) = t;  
            }
        }
    }
}
 
// 函数：插入排序
void insertSort(int *begin, int *end) 
{
    int *p = begin;  // 定义指向起始位置的指针
    int *q = NULL;  // 定义用于遍历的指针
 
    // 从第二个元素开始遍历
    for (p = begin + 1; p <= end; p++)  
    {
        int t = *p;  // 保存当前要插入的元素
        q = p;  // 记录当前位置
 
        // 寻找插入位置
        while (q > begin && *(q - 1) > t)  
        {
            // 将较大的元素向后移动
            *q = *(q - 1);  
            q--;  // 指针向前移动
        }
        // 插入元素
        *q = t;  
    }
}
 
// 函数：折半查找
int * binaryFind(int *begin, int *end, int n) 
{
    int *mid = NULL;  // 定义指向中间位置的指针
    int *ret = NULL;  // 定义用于存储查找结果的指针
 
    // 只要查找范围存在（起始指针小于等于结束指针）
    while (begin <= end)  
    {
        // 计算中间位置
        mid = begin + (end - begin) / 2;  
 
        // 如果要查找的值小于中间值
        if (n < *mid)  
        {
            // 在左半部分继续查找
            end = mid - 1;  
        }
        // 如果中间值小于要查找的值
        else if (*mid < n)  
        {
            // 在右半部分继续查找
            begin = mid + 1;  
        }
        // 如果找到匹配的值
        else  
        {
            // 记录找到的位置
            ret = mid;  
            break;  // 退出循环
        }
    }
 
    // 返回查找结果，如果未找到则为 NULL
    return ret;  
}
 
// 函数：折半查找（递归）
int *binaryFindR(int *begin, int *end, int n) 
{
    int *mid = begin + (end - begin) / 2;  // 计算中间位置
    int *ret = NULL;  // 定义用于存储查找结果的指针
 
    // 如果起始指针大于结束指针，说明未找到
    if (begin > end)  
    {
        return NULL;  
    }
 
    // 如果要查找的值小于中间值
    if (n < *mid)  
    {
        // 在左半部分递归查找
        end = mid - 1;  
        ret = binaryFindR(begin, end, n);  
    }
    // 如果中间值小于要查找的值
    else if (*mid < n)  
    {
        // 在右半部分递归查找
        begin = mid + 1;  
        ret = binaryFindR(begin, end, n);  
    }
    // 如果找到匹配的值
    else if (*mid == n)  
    {
        // 记录找到的位置
        ret = mid;  
    }
 
    // 返回查找结果，如果未找到则为 NULL
    return ret;  
}
 
// 函数：交换两个指针所指向的值
void swap(int *a, int *b) 
{
    int t = *a;  // 临时存储指针 a 所指向的值
    *a = *b;  // 将指针 b 所指向的值赋给指针 a 所指向的位置
    *b = t;  // 将临时存储的值赋给指针 b 所指向的位置
}
 
// 函数：快速排序
void quickSort(int *begin, int *end) 
{
    // 记录起始位置和结束位置
    int *p = begin;  
    int *q = end;  
 
    // 选择起始位置的元素作为基准值
    int *k = begin;  
 
    // 只要起始指针小于结束指针，就持续执行循环
    while (begin < end)  
    {
        // 从右向左找小于基准值的元素
        while(begin < end && *end >= *k)  
        {
            end--;  
        }
 
        // 从左向右找大于基准值的元素
        while (begin < end && *begin <= *k)  
        {
            begin++;  
        }
 
        // 交换找到的两个元素
        swap(begin, end);  
    }
 
    // 如果起始指针和结束指针相遇
    if (begin == end)  
    {
        // 将基准值与相遇位置的元素交换
        swap(k, begin);  
    }
 
    // 如果起始位置到结束位置减 1 的范围内还有元素，继续排序
    if (p < end - 1)  
    {
        quickSort(p, end - 1);  
    }
 
    // 如果起始位置加 1 到结束位置的范围内还有元素，继续排序
    if (begin + 1 < q)  
    {
        quickSort(begin + 1, q);  
    }
}
 
// 主函数
int main() 
{
    int a[] = {10,2,8,5,4,6,7,3,9,1};  // 定义并初始化整数数组
    int len = sizeof(a)/sizeof(a[0]);  // 计算数组的长度
 
    /*printf("max = %d\n",maxArray(a,len));
    printfArray(a,a+len-1);		//可以改变打印的起始位置和结束位置
    reversedOrder(a,a+len-1);
    printfArray(a,a+len-1);*/
 
    //choieSort(a,a+len-1);
    //bubbleSort(a,a+len-1);
    printfArray(a,a+len-1);
    //insertSort(a,a+len-1);
    //printfArray(a,a+len-1);
 
    /*int n;
    scanf("%d",&n);
    //int *ret = binaryFind(a,a+len-1,n);
    int *ret = binaryFindR(a,a+len-1,n);
    if (ret==NULL)
        printf("no found\n");
    else
        printf("found\n");
    */
 
    quickSort(a,a+len-1);  // 对数组进行快速排序
    printfArray(a,a+len-1);  // 打印排序后的数组
 
    return 0;
}

快速排序的思路