跟着小甲鱼学C—Lesson8递归

递归

递归本是算法的内容，但是C语言中有些麻烦的问题可以用递归轻松解决。如汉诺塔、谢尔宾斯基三角形、目录树的索引等等

在编程上递归从原理上来说就是函数调用自身这么一个行为

例：

#include<stdio.h>

void recursion(void);

void recursion(void)
{
	printf("Hi\n");
	recursion();
}
int main(void)
{
	recursion();
	return 0;
}
编译结果：
一直打印Hi，程序因为消耗完内存空间而崩溃

通过这个程序可以知道递归必须要有结束条件，否则程序将崩溃。

例如将程序改为：

#include<stdio.h>

void recursion(void);

void recursion(void)
{
	static int count = 10;//定义静态局部变量
	printf("Hi\n");
	if(--count)
	{
		recursion();
	}
}
int main(void)
{
	recursion();
	return 0;
}
编译结果：
Hi
Hi
Hi
Hi
Hi
Hi
Hi
Hi
Hi
Hi

• 写一个递归求阶乘的函数

先用for循环编写：

#include<stdio.h>

long fact(int num);

long fact(int num)
{
	long result;//因为阶乘的结果较大，所以定义结果的类型为long 
	
	for(result = 1;num>1;num--)
	{
		result*= num;
	}
    return result;
}

int main()
{
	int num;
	
	printf("请输入一个整数\n");
	scanf("%d",&num);
	
	printf("%d的阶乘是：%d",num,fact(num));
		
	return 0;
}
编译结果：
请输入一个整数
5
5的阶乘是：120

用递归编写：

#include<stdio.h>

long fact(int num);

long fact(int num)
{
	long result;//因为阶乘的结果较大，所以定义结果的类型为long 
	
	if(num>0)
	{
		result = num*fact(num-1);
	}
	else
	{
		result = 1;
	}
	return result;
}

int main()
{
	int num;
	
	printf("请输入一个整数\n");
	scanf("%d",&num);
	
	printf("%d的阶乘是：%d",num,fact(num));
		
	return 0;
}

比如用户输入num = 5；判断num>0，执行result = 5*fact(4),调用fact(4),判断num>0,执行result = 4*fact(3)以此类推，最后result = 1*fact(0),调用fact(0),判断num不大于0，执行result = 1，即返回result = 1,执行result = 1*fact(0) = 1*1，返回result = 1，执行result = 2*fact(1) = 2*1一次类推，最后结果为result = 5*4*3*2*1*1

 

• 实现递归要满足两个条件

（1）调用函数本身

（2）设置了正确的结束条件

注意：慎用递归！普通程序员用迭代，天才程序员用递归。但我们宁愿做普通的程序员（因为使用递归的程序在执行效率上没有任何的优势，相反使用递归更难以阅读和维护）。当然前面已经说到有些问题使用递归相当方便。

汉诺塔

       大梵天创造世界的时候做了三根柱子上，分别叫X、Y和Z ,在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

对于游戏的玩法，我们可以简单的分解为3个步骤：

—将前63个盘子（借助Z）从X移动到Y上

—将最底下的第64个盘子从X移动到Z上

—将Y上的63个盘子（借助X）移动到Z上

问题一：将前63个盘子（借助Z）从X移动到Y上

拆解为：

—将前62个盘子（借助Y）从X移动到Z上

—将最底下的第63个盘子从X移动到Y上

—将Z上的62个盘子（借助X）移动到Y上

 

问题二：将Y上的63个盘子（借助X）移动到Z上

拆解为：

—将前62个盘子（借助Z）从Y移动到X上

—将最底下的第63个盘子从Y移动到Z上

—将X上的62个盘子（借助Y）移动到Z上

......

编写程序：

#include<stdio.h>

void hanoi(int n,char x,char y,char z);

void hanoi(int n,char x,char y,char z)
{
	if(n==1)
	{
		printf("%c-->%c\n",x,z);
	}
	else
	{
		hanoi(n-1,x,z,y);
		printf("%c-->%c\n",x,z);
		hanio(n-1,y,x,z);
	}
}
int main()
{
	int n;
	
	printf("请输入汉诺塔的层数：\n");
	scanf("%d",&n);
	
	hanoi(n,'X','Y','Z');
	
	return 0;	
}
编译结果：
请输入汉诺塔的层数：
3
X-->Z
X-->Y
Z-->Y
X-->Z
Y-->X
Y-->Z
X-->Z

快速排序（递归的典型应用）

• 分治法

大事化小，小事化了

• 快速排序

快速排序算法的基本思想是：通过一趟排序将待排序数据分割成独立的两部分，其中一部分的所有元素均比另一部分的元素小，然后分别对这两部分继续进行排序，重复上述步骤直到排序完成。

https://blog.csdn.net/pengzonglu7292/article/details/84938910

图解快速排序

#include<stdio.h>

void quick_sort();

void quick_sort(int array[],int left,int right)
{
	int i = left,j = right;
	int temp;
	int pivot;
	
	pivot = array[(i+j)/2];
	
	while(i<=j)
	{
		//从左到右找到大于等于基准点的元素
		while(array[i]<pivot)
		{
			i++;
		 } 
		//从右到左找到小于等于基准点的元素
		 while(array[j]>pivot)
		 {
		 	j--;
		  } 
		//如果i<=j，则互换元素
		if(i<=j)
		{
			temp = array[i];
			array[i] = array[j];
			 array[j] = temp;
			 i++;
			 j--;
		 } 
	}
	
	if(left<j)
	{
		quick_sort(array,left,j);
	}
	if(right>i)
	{
		quick_sort(array,i,right);
	}
}

int main()

{
	int array[] = {73,188,111,118,181,78,185,115,104,67,46,99,111,109};
	int i,length;
	
	length = sizeof(array)/sizeof(array[0]);
	quick_sort(array,0,length-1);
	
	printf("排序后的结果是：\n");
	for(i = 0;i<length;i++)
	{
		printf("%d   ",array[i]);
		
		}
	return 0;	
}
编译结果：
排序后的结果是：
46   67   73   78   99   104   109   111   111   115   118   181   185   188

动态内存管理

前面学过了存储类型，说白了这些存储类型就是限定变量的作用域以及生存周期，他们都有一个共同的特征，那就是代码都需要服从预先定制的内存管理规则来行事

更灵活的内存管理方式

• malloc

—申请动态内存空间

函数原型：void  *malloc(size_t size)

注：

1. malloc函数向系统申请分配size个字节的内存空间，并返回一个指向这块空间的指针。
2. 如果函数调用成功，返回一个指向申请的内存空间的指针，由于返回类型是void指针（void*），所以它可以被转换成任何类型的数据；如果函数调用失败，返回值是NULL。另外，如果size参数设置为0，返回值也可能是NULL，但这并不意味着函数调用失败。

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int *ptr;
	
	ptr = (int *)malloc(sizeof(int));//malloc函数向系统申请分配一个整型变量占用的字节的内存空间；返回的void指针转换成int型
	if(ptr==NULL)
	{
		printf("分配内存失败！\n");
		return 0;
	}
	
	printf("请输入一个整数：");
	scanf("%d",ptr);
	
	printf("您输入的整数是：%d",*ptr); 
	
	return 0;
}
请输入一个整数：5
您输入的整数是：5

事实上malloc函数不仅可以申请存储基本数据类型的内存空间，它还可以申请一块任意尺寸的内存空间。对于任意尺寸的空间来说，由于申请得到的空间是连续的，所以经常使用数组来进行索引。

例：

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int *ptr = NULL;
	int i,num;
	
	printf("请输入待录入整数的个数：");
	scanf("%d",&num);
	
	ptr = (int *)malloc(num*sizeof(int));
	
	for(i=0;i<num;i++)
	{
		printf("请录入第%d个整数：",i+1);
		scanf("%d",&ptr[i]);
	}
	
	printf("您输入的整数是：");
	
	for(i = 0;i<num;i++)
	{
		printf("%d  ",ptr[i]);
		
	 } 
	 
	 free(ptr);
	 
	return 0;
}
编译结果：
请输入待录入整数的个数：3
请录入第1个整数：89
请录入第2个整数：56
请录入第3个整数：58
您输入的整数是：89  56  58

 

free

—释放动态内存空间

函数原型：void  free(void *ptr)

1. free函数释放ptr参数指向的内存空间。该内存空间必须是由malloc、calloc或realloc函数申请的。否则该函数将导致未定义行为。如果ptr的参数是NULL，则不执行任何操作。

注意：该函数并不会修改ptr参数的值，所以调用后它仍然指向原来的地方（但调用后这个指针指向的空间已经释放了，那么这个指针指向的地址没有改变，那么这个地址就变为非法空间）。

 

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int *ptr;
	
	ptr = (int *)malloc(sizeof(int));
	if(ptr==NULL)
	{
		printf("分配内存失败！\n");
		return 0;
	}
	
	printf("请输入一个整数：");
	scanf("%d",ptr);
	
	printf("您输入的整数是：%d",*ptr); 
	
	free(ptr);
	
	printf("您输入的整数是：%d",*ptr);
	
	return 0;
}
编译结果：
请输入一个整数：5
您输入的整数是：5您输入的整数是：10252752

内存泄漏的两种情况：

• 如果申请的动态内存空间没有及时释放会发生内存泄漏，程序会崩溃！因此函数malloc和函数free应该成对出现。
• 丢失内存块的地址

#include<stdio.h>
#include<stdlib.h>//使用malloc函数注意加头文件

int main()
{
	int *ptr;
	int num = 123;
	
	ptr = (int *)malloc(sizeof(int));
	if(ptr==NULL)
	{
		printf("分配内存失败！\n");
		return 0;
	}
	
	printf("请输入一个整数：");
	scanf("%d",ptr);
	
	printf("您输入的整数是：%d",*ptr); 
	
	ptr = &num;
	
	printf("您输入的整数是：%d",*ptr);
	
	free(ptr);
	
	
	return 0;
}
编译结果：警告

这里先是申请动态内存空间，用指针ptr指向这块空间，那么这块空间的地址就只有ptr知道，之后又将指针ptr指向其他地址，就意味着这块内存空间的地址就丢失了，更严重的是尝试对一个局部变量进行释放，就会导致编译出错。

 

calloc

—申请并初始化一系列内存空间

 

realloc

—重新分配内存空间