当前位置:   article > 正文

嵌入式学习笔记十三——C语言指针变量、一维数组的指针、快速排序

嵌入式学习笔记十三——C语言指针变量、一维数组的指针、快速排序

指针变量

指针初始化

指针变量初始化:如果没有初始化,指针是随机值,既野指针。初始化可以让指针变量有明确的指向。

  1. int a = 10;
  2. int *p = &a;//指针初始化
  3. int *p = NULL; //NULL 0号地址 --- 空指针

指针赋值

  1. int * p;
  2. p = NULL;
  3. int a;
  4. int *p;
  5. p = &a;
  6. int *p,q; //p是指针类型 int *
  7. //q是int型
  8. int *p,*q; //此时表示定义了两个 int*类型的变量 p 和q
  9. //注意:
  10. //定义时候的 * 修饰变量名的 表示定义的是一个指针类型的变量

为什么需要地址?

    为了实现被调修改主调函数,值传递无法改变主函数中的数据,如果要对数据进行修改,就要用到指针进行地址传递。

指针作为函数的参数

形参:指针类型变量,用来接收实参,实参是要操作的内存空间的地址。

实参:需要修改的变量的地址,被调函数1中一定要有*运算

体会指针,被调修改主调,练习:1.找出两个数中最大值 和 最小值写成函数 2.写swap()函数,实现交换两数的值。     

  1. #include <stdio.h>
  2. void add(int n,int m,int *sum)
  3. {
  4. *sum = n + m;
  5. }
  6. void findMaxMin(int n,int m,int *max,int *min)
  7. {
  8. if(n>m)
  9. {
  10. *max = n;
  11. *min = m;
  12. }
  13. else
  14. {
  15. *max = m;
  16. *min = n;
  17. }
  18. }
  19. void Swap(int *a,int *b)
  20. {
  21. int t = *a;
  22. *a = *b;
  23. *b = t;
  24. }
  25. int main(void)
  26. {
  27. int x=5,y=10;
  28. int sum;
  29. int max;
  30. int min;
  31. // add(x,y,&sum);
  32. // printf("%d\n",sum);
  33. // findMaxMin(x,y,&max,&min);
  34. // printf("max = %d\nmin = %d\n",max,min);
  35. Swap(&x,&y);
  36. printf("x = %d\ny = %d\n",x,y);
  37. return 0;
  38. }

形参中的指针类型变量,只需定义需要修改的变量就可以,其他的值如果也用地址来操作就有些多于了,效率也会降低。需要修改的数据,在传入实参时要用取地址&来传入地址。

指针和一维整型数组

int  a[5]; 数组名a表示数组首元素的地址,数组名是个常量不能自增自减。

a =>&a[0]   a[0]的数据类型是int,&a[0]的数据类型是int*(指针类型)

int *p = a; p指向数组a

指针运算:&取地址,*指针运算(访问运算对象指向的地址)

p+1,p+n,p-1,p-n,p++,p--:表示(+向后,-向前)跳过了一个或n个基类型。

对数组指针进行自加减:

  1. //打印数组
  2. void printArray(int *a,int len)
  3. {
  4. int i = 0;
  5. for (i = 0;i < len ;++i)
  6. {
  7. printf ("a[%d] = %d\n",i,*a++);
  8. // printf ("a[%d] = %d\n",i,a[i]);
  9. // printf ("a[%d] = %d\n",i,i[a]);
  10. // printf ("a[%d] = %d\n",i,*(a+i));
  11. }
  12. }

1. a <=>  &a[0]//a[0]的数据类型 -- int型 ,&a[0]  地址的类型 -- int* 

int *p = a; //表示 p指向数组a

此时*p等价于a[0],*p 访问指针p指向的地址中的内容。*p  <=> a[0]

2.*(p+i) <=> a[i] <=> *(a+i)//a是一个地址,代表首元素首地址,所以a = & a[0]  <=> p
 a[i]  <=> *(a+i)
 i[a]  <=> *(i+a) //a[i]==i[a];

所以上述代码中所有printf打印的内容都相同。

3.如果p,q,都是地址,则:

p - q     //表示差了多少元素(基类型)

两指针相减,必须是同一类型的指针  
          
p + q     是不允许的,会报错,没有意义。 

用指针可以实现用迭代的方式实现逆序,排序和查找。

练习:

1. 准备一个数组,找数组中的最大值 ,用指针完成。

2.数组逆序。

3.对数组排序。
 下面的代码只要修改主函数就能实现相关功能。

  1. void findMax(int *a,int len)//找最大值
  2. {
  3. int i = 0;
  4. int max = *a;
  5. for (i = 0;i < len;++i)
  6. {
  7. if (*(a+i)>max)
  8. max = *(a+i);
  9. }
  10. return max;
  11. }
  12. void printArray2(int *begin,int *end)//打印
  13. {
  14. while (begin <= end)
  15. printf("%d ",*begin++);
  16. putchar('\n');
  17. }
  18. void revArray(int *begin,int *end)//数组逆序
  19. {
  20. int t;
  21. while(begin < end)//不用等于
  22. {
  23. t = *begin;
  24. *begin=*end;
  25. *end = t;
  26. ++begin;
  27. --end;
  28. }
  29. }
  30. void selectSort(int *begin,int *end)//选择排序
  31. {
  32. int *p;
  33. int *q;
  34. for (p = begin;p < end;++p)
  35. {
  36. for (q = p+1;q <= end;++q)
  37. if (*q < *p)
  38. Swap(q,p);
  39. }
  40. }
  41. void bubbleSort(int *begin,int *end)//冒泡排序
  42. {
  43. int *p;
  44. int *q;
  45. for (p = end;p >begin;--p)
  46. {
  47. for (q = begin;q < p;++q)
  48. {
  49. if (*q > *(q+1))
  50. Swap(q,q+1);
  51. }
  52. }
  53. }
  54. void insertSort(int *begin,int *end)//插入排序
  55. {
  56. int *p;
  57. int *q;
  58. for (p = begin+1;p <= end;++p)
  59. {
  60. int t = *p;
  61. q = p;
  62. while (q > begin && t < *(q-1))
  63. {
  64. *q = *(q -1);
  65. --q;
  66. }
  67. *q = t;
  68. }
  69. }
  70. int * binaryFind(int *begin,int *end,int n)//二分查找
  71. {
  72. int *ret = NULL;
  73. int *mid;
  74. while (begin <= end)
  75. {
  76. mid = begin + (end - begin)/2;
  77. if(*mid < n)
  78. end = mid - 1;
  79. else if (*mid > n)
  80. begin = mid +1;
  81. else
  82. {
  83. ret = mid;
  84. break;
  85. }
  86. }
  87. return ret;
  88. }
  89. int main(void)
  90. {
  91. int a[] = {1,5,7,8,4,1,3};
  92. int len = sizeof(a)/sizeof(a[0]);
  93. // printArray2(a,a+len-1);
  94. int max = 0;
  95. findMax(a,5,&max);
  96. printf("max = %d\n",max);
  97. insertSort(a,a+len-1);
  98. // revArray(a,a+len-1);
  99. int n;
  100. scanf("%d",&n);
  101. printArray2(a,a+len-1);
  102. return 0;
  103. }

快速排序

思想:使用分治法的策略来把一个序列分为较小和较大的两个子序列,然后递归地排序两个子序列。快速排序的基本思想可以概括为以下几个步骤:

1.选择基准值:从数组中选择一个元素作为基准值(pivot),通常选择第一个元素、最后一个元素或中间元素。

2.分区操作:重新排列数组,使得所有比基准值小的元素都在基准值的左边,所有比基准值大的元素都在基准值的右边。这个称为分区(partitioning)的过程。

3.递归排序:递归地将上述步骤应用到基准值左边和右边的子数组上。

4.结束条件:当子数组的大小减少到1或0时,递归结束。

理解过程:

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/IT小白/article/detail/951424
推荐阅读
相关标签
  

闽ICP备14008679号