C语言学习日记——以数组为参数的函数调用

LanUU123

已于 2024-02-04 10:01:09 修改

阅读量464

点赞数 11

分类专栏：学习日记 c语言文章标签：学习 c语言

于 2024-01-31 22:16:11 首次发布

本文链接：https://blog.csdn.net/qq_61802519/article/details/135961471

版权

c语言同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

学习日记

9 篇文章 0 订阅

订阅专栏

学习目标：

对于以数组为参数的函数调用，今天的学习目标是理解函数的递归调用和嵌套调用。理解栈的概念，掌握一维数组，二维数组，字符数组为参数的函数调用并完成二维字符数组的相关练习。

学习内容：

2.1传参的顺序和方式

传参的顺序：自右向左

传参时要避免出现一下情况

k = int cmp(i++,i);

对于不同的编译器其结果可能不同，

2.2栈

栈储存返回地址，局部变量，形参。其中储存的元素执行先进后出原则。栈的主要作用是保护现场和恢复现场。在使用时要注意栈的溢出问题（只存不出）。

学习练习：

3.1.函数的递归调用：

函数在函数体内调用自己，但这样会消耗大量的内存空间。

阶乘

  3 int jiecheng(int n)
  4 {
  5     if(n == 1)
  6     {
  7         return 1;
  8     }
  9     return jiecheng(n - 1) * n;
 10 }

斐波那契数列

 12 int fib(int n)
 13 {
 14     if(1 == n || 2 == n)
 15     {
 16         return 1;
 17     }
 18     return fib(n - 1) + fib(n - 2);
 19   
 20 }

3.2一维数组为参数的函数调用

传参时除了首元素地址外还要有数组元素的个数

选择排序：

 56 void choiceSort(int a[],int len)
 57 
 58 {
 59 
 60     int i ,j;
 61     for(i = 0; i < len - 1;++i)
 62     {
 63         for(j =i + 1; j < len ;++j)
 64         {
 65             if(a[i] > a[j])
 66             {
 67                 int temp = a[i];
 68                 a[i] = a[j];
 69                 a[j] = temp;
 70             }
 71         }
 72     }
 73 }

冒泡排序：

 75 void bubbleSort(int a[],int len)
 76 {
 77     int i,j;
 78     for(i = len ; i > 0;--i)
 79     {
 80         for(j = 1; j < i ;++j)
 81         {
 82             if(a[j] > a[j + 1])
 83             {
 84                 int temp = a[j];
 85                 a[j] = a[j + 1];
 86                 a[j + 1] = temp;
 87             }
 88         }
 89     }                                                                                                                                                          
 90 }

插入排序：

 92 void inserSort(int a[],int len)
 93 {
 94     int i,j;
 95     for(i = len - 1;i > 0; --i)
 96     {
 97         int temp = a[i];
 98         j = i - 1;
 99         while( j >= 0 && a[j] > a[j + 1])
100         {
101             a[j + 1] = a[j];
102             --j;
103         }
104         a[j + 1] = temp;
105 
106     }
107 
108 }

二分查找：

111 int binaryFind(int a[],int len,int n)
112 {
113     int begin ,end,mid;
114     begin = 0;
115     end = len - 1;
116     while(begin <= end)
117     {
118         mid = (begin + end) / 2;
119         if(a[mid] == n)
120         {
121             return mid;
122         }
123         else if(a[mid] > n)
124         {
125             end = mid - 1;
126         }
127         else
128         {
129             begin = mid + 1;
130         }
131     }
132     return -1;
133                                                                                                                                                                
134 }

逆序输出：

 32 void reverse(int a[],int len)
 33 {
 34     int i = 0;
 35     for(i = 0;i<len / 2;++i)
 36     {
 37         int temp = a[i];
 38         a[i] = a[len -1 - i];
 39         a[len -1 -i] = temp;
 40     }
 41 }

3.3字符数组为参数的函数调用

传参时除了首元素地址外不需要数组元素的个数

strlen函数

136 int mystrlen(char a[])
137 {
138     int count = 0;
139     int i = 0;
140     while(a[i] != 0)
141     {
142         ++count;
143         ++i;
144     }
145     return count;
146 }
147

strcat函数

149 void mystrcat(char a[],char b[])
150 {
151     int i = 0;
152     int j = 0;
153     while( a[i] != 0)
154     {
155         ++i;
156     }
157     while( b[j] != 0)
158     {
159         a[i] = b[j];
160         ++i;
161         ++j;
162     }
163     a[i] = '\0';
164 }
165

strcpy函数

178 void mystrcpy(char a[],char b[])
179 {
180     int i =0;
181     while( b[i] != 0)
182     {
183         a[i] = b[i];
184         ++i;
185     }
186     a[i] = '\0';
187 }

strcmp函数

167 int mystrcmp(char a[],char b[])
168 {
169     int i = 0;
170     while( a[i] == b[i] && a[i] != 0 && b[i] != 0)
171     {
172         ++i;
173     }
174     return a[i] - b[i];
175 }

3.4多维数组为参数的函数调用

传参时除了首元素地址外需要二维数组的行数，参数的列数是写函数时定义好在程序运行时不可变的。

输出二维数组的边缘元素和

188 int bianyuan2d(int a[][4],int rows)
189 {                                                                                                                                                              
190     int j ,i,sum;
191     sum = 0;
192     for(i = 0;i < rows;++i)
193     {
194         for(j = 0;j < 4;++j)
195         {
196             if(i * j == 0 || i == 2 || j ==3)
197             {
198                 sum +=a[i][j];
199             }
200         }
201     }
202     return sum;
203 }

二维数组的逆序输出

206 void rivers2d(int a[][4],int rows)
207 {
208     int j ,i;
209     for(i = 0;i < rows;++i)
210     {
211         for(j = 0;j < 2;++j)
212         {
213             int stemp = a[i][j];
214             a[i][j] = a[i][4 - 1 - j];
215             a[i][4 -1 -j] = stemp;
216         }
217     }
218 }

学习产出：

用二维字符型数组作为函数参数，实现多个字符串的逆序，排序和二分查找。

比较函数

  2 int mystrcmp(char a[],char b[])                                                                                                                                
  3 {
  4     int i = 0;
  5     while( a[i] == b[i] && a[i] != 0 && b[i] != 0)
  6     {
  7         ++i;
  8     }
  9     return a[i] - b[i];
 10 }

复制函数

 11 int mystrcpy(char a[],char b[])
 12 {
 13     int i =0;
 14     while( b[i] != 0)
 15     {
 16         a[i] = b[i];
 17         ++i;
 18     }
 19     a[i] = '\0';
 20 }

二分查找函数

 22 int myBinaryFind(char a[][100],int rows,char n[100])
 23 {
 24     int begin = 0;
 25     int end = rows - 1;
 26     while(begin <= end)
 27     {
 28     int mid = (begin + end) / 2;
 29         if(mystrcmp(a[mid],n) == 0)
 30         {
 31             return mid;
 32         }
 33         else if(mystrcmp(a[mid],n) >0)
 34         {
 35             end = mid - 1;
 36         }
 37         else
 38         {
 39             begin = mid + 1;
 40         }
 41     }
 42     return -1;
 43 }

选择排序函数

 44 void mystrxuanze(char a[][100],int rows)
 45 {
 46     int i,j;
 47     for(i = 0; i < rows - 1;++i )
 48     {
 49         for(j = i+ 1; j < rows;++j)
 50         {
 51             if(mystrcmp(a[i] , a[j]) > 0)
 52             {
 53                 char room[100];
 54                 mystrcpy(room,a[i]);
 55                 mystrcpy(a[i],a[j]);
 56                 mystrcpy(a[j],room);
 57             }
 58         }
 59     }
 60 }

逆序输出函数

 61 void mynixv(char a[][100],int rows)
 62 {
 63     int i;
 64     for(i = 0;i < rows / 2 ;++i)
 65     {
 66         char room[100];
 67         mystrcpy(room ,a[i]);
 68         mystrcpy(a[i],a[rows - 1 - i]);
 69         mystrcpy(a[rows - 1 - i],room);
 70     }
 71 }

输出函数

 72 void myputs(char a[][100],int rows)
 73 {
 74     int i;
 75     for( i = 0; i < rows;++i)
 76     {
 77         puts(a[i]);
 78     }
 79 }

二分查找结果输出函数

 80 void printfBin(int a)
 81 {
 82     if(a >= 0)
 83     {
 84         printf("find,%d\n",a);
 85     }
 86     else
 87     {
 88         printf("no find\n");
 89     }
 90 }

主函数

 91 int main(void)
 92 {
 93     char t1[][100] = {"Hello","world","good","yes","GGbond","giao"};
 94     int rows = sizeof(t1) / sizeof(t1[0]);
 95     printf("原二维字符数组：\n");
 96     myputs(t1,rows);
 97     mynixv(t1,rows);
 98     printf("逆二维字符数组：\n");
 99     myputs(t1,rows);
100     mystrxuanze(t1,rows);
101     printf("排序二维字符数组：\n");
102     myputs(t1,rows);
103     printf("二分查找“yes”的结果：\n");
104     printfBin(myBinaryFind(t1,rows,"yes"));
105     printf("二分查找“EEbond”的结果：\n");
106     printfBin(myBinaryFind(t1,rows,"EEbond"));
107     return 0；
108 }

输出结果