C语言----函数学习

一些概念：

传参次序：在调用函数的时候，参数的传递顺序是自右向左，不是同时传递的。

值传递：对形参的修改不会影响到实参。

指针传递：传递的其实是实参的地址，会对实参造成改变（一维or二维数组的数组名是首元素地址。）

栈：先进后出，后进先出原则。通常我们称入栈为保护现场，出栈为恢复现场。

栈区、堆区、字符串常量区、静态区（全局区）、代码区。

栈区中存放的为：形参，调用函数的返回值，局部变量。一般来说栈区的空间不会很大，Windows系统不超过1MB，Linux系统栈区不超过8MB。

练习：

1.通过调用函数的方式比较两个数

int intcmp(int a, int b)
{
	if(a > b)
	{
		return 1;
	}
	else if(a == b)
	{
		return 0;
	}
	else
	{
		return -1;
	}
}

int main(void)
{
	int i = 2;
	int k;

	k = intcmp(i + 1, i);
	printf("%d\n", k);
	return 0;
}

2.对两个数求和

int add(int a, int b)
{
	int ret;
	ret = a + b;
	return ret;
}

int main(void)
{
	int sum;
	sum = add(10, 20);
	printf("%d\n", sum);
	return 0;
}

递归调用 

递归调用是调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。

优点：函数递归只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的主要思考方式在于：把大事化小（这种思考方式十分重要）。

缺点：如果函数递归使用不恰当，会导致栈溢出，因为每一次函数调用都会在栈区上申请内存空间。

递归调用有两个条件

1.存在限制条件，当满足这个限制条件的时候，递归便不再继续。

2.每次递归调用之后越来越接近这个限制条件

递归调用的使用示例：

1.输出N的阶乘

int fn(int n)
{
	if(1 == n)
	{
		return 1;
	}
	else
	{
		return fn(n - 1) * n;
	}
}

2.输出某项斐波那契数列的值

int fib(int n)
{
	if(1 == n || 2 == n)
	{
		return 1;
	}
	else
	{
		return fib(n - 1) + fib(n - 2);
	}
}

3.汉诺塔

void move(char pole1, char pole2)
{
	printf("%c->%c\n", pole1, pole2);
}

void hanoid(int n, char pole1, char pole2, char pole3)
{
	if(1 == n)
	{
		move(pole1, pole3);
	}
	else
	{
		hanoid(n - 1, pole1, pole3, pole2);
		move(pole1, pole3);
		hanoid(n - 1, pole2, pole1, pole3);
	}
}

int main(void)
{
	hanoid(64, 'A', 'B', 'C');
	return 0;
}

4.递归调用在一维数组中的使用

void printArray(int a[], int len)
{
	int i;
	for(i = 0;i < len;++i)
	{
		printf("%d\n", a[i]);
	}
}

int sumOfArray(int a[], int len)
{
	int sum = 0;
	int i;
	for(i = 0;i < len;++i)
	{
		sum += a[i];
	}
	return sum;
}

void fn(int a[], int len)
{
	int i;
	for(i = 0;i < len;++i)
	{
		a[i] += 10;
	}
}

void reverse(int a[], int len)
{
	int i;
	for(i = 0;i < len / 2;++i)
	{
		int t = a[i];
		a[i] = a[len - i - 1];
		a[len - i - 1] = t;
	}
}

void choiceSort(int a[], int len)
{
	int i, j;
	for(i = 0;i < len - 1;++i)
	{
		for(j = i + 1;j < len;++j)
		{
			if(a[i] > a[j])
			{
				int t = a[i];
				a[i] = a[j];
				a[j] = t;
			}
		}
	}
}

void bubbleSort(int a[], int len)
{

}

void insertSort(int a[], int len)
{

}

int binaryFind(int a[], int len, int n)
{
	int begin = 0;
	int end = len - 1;
	int mid;
	while(begin <= end)
	{
		mid = (begin + end) / 2;
		if(a[mid] > n)
		{
			end = mid - 1;
		}
		else if(a[mid] < n)
		{
			begin = mid + 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;

}

int main(void)
{
	int a[] = {1,2,3,4,5,6,7,8,9,0, 11,12};
	int len = sizeof(a) / sizeof(a[0]);
	sumOfArray(a, len);
	choiceSort(a, len);
	int ret = binaryFind(a, len, -8);
	if(ret < 0)
	{
		puts("not found");
	}
	else
	{
		printf("index = %d, %d\n", ret, a[ret]);
	}
	printArray(a, sizeof(a) / sizeof(a[0]));
	return 0;

5.递归调用在字符串数组中的使用

void Puts(char s[])
{
	int i = 0;
	while(s[i] != '\0')
	{
		putchar(s[i]);
		++i;
	}
	putchar('\n');
}

int Strlen(char s[])
{
	int i = 0;
	while(s[i])
	{
		++i;
	}
	return i;
}

void Strcpy(char dest[], char src[])
{
	int i = 0;
	while(src[i])
	{
		dest[i] = src[i];
		++i;
	}
	dest[i] = 0;
}

void Strcat(char dest[], char src[])
{
	int i = 0;
	while(dest[i])
	{
		++i;
	}
	int j = 0;
	while(src[j])
	{
		dest[i++] = src[j++];
	}
	dest[i] = 0;
}

int Strcmp(char s1[], char s2[])
{
	int i = 0;
	while(s1[i] == s2[i] && s1[i] && s2[i])
	{
		++i;
	}
	return s1[i] - s2[i];
}

int main(void)
{
	char s1[100] = "Hello";
	char s2[100] = "World!";
	
	Strcat(s1, s2);
	Puts(s1);
	printf("%d\n", Strcmp("ANC", "abc"));
    Puts(s);


	return 0;
}

6.递归在二维数组中的使用

void printArray2D(int a[][4], int rows)
{
	int cols = sizeof(a[0]) / sizeof(a[0][0]);
	int i, j;

	for(i = 0;i < rows;++i)
	{
		for(j = 0;j < cols;++j)
		{
			printf("%2d ", a[i][j]);
		}
		puts("");
	}

}

int sumOfArray2D(int a[][4], int rows)
{
	int i, j;
	int sum = 0;
	for(i = 0;i < rows;++i)
	{
		for(j = 0;j < 4;++j)
		{
			if(0 == i || 0 == j || rows - 1 == i || 3 == j)
			{
				sum += a[i][j];
			}
		}
	}
	return sum;
}

void reverse(int a[], int len)
{
	int i;
	for(i = 0;i < len / 2;++i)
	{
		int t = a[i];
		a[i] = a[len - i - 1];
		a[len - i - 1] = t;
	}
}

void reverse2D(int a[][4], int rows)
{
	int i, j;
	int cols = sizeof(a[0]) / sizeof(a[0][0]);
	for(i = 0;i < rows;++i)
	{
		reverse(a[i], cols);
		/*
		for(j = 0;j < cols / 2;++j)
		{
			int t = a[i][j];
			a[i][j] = a[i][cols - j - 1];
			a[i][cols - j - 1] = t;
		}
		*/
	}
}


int main(void)
{
	int a[][4] = {1,2,3,4,5,6,7,8,9,10,11,12,13};
	int rows = sizeof(a) / sizeof(a[0]);
	printf("%d\n", sumOfArray2D(a, rows));
	reverse2D(a, rows);
	printArray2D(a, rows);

	


	return 0;
}

7.递归在二维字符串数组中的使用