C语言笔记-day04

P34_递归

1、递归的应用

汉诺塔

2、递归的实质

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

3、编写递归程序需要注意的地方

递归出口：递归程序需要正确设置结束条件，否则递归程序会一直走下去，直到崩溃。

递归点：将重复的事情交给程序做（自顶向下思考）

4、递归的优势和劣势

优势：递归的思考角度跟通常的迭代（你可以理解为 for 循环之类的）迥然不同，所以有时候使用迭代思维解决不了的问题，使用递归思维则一下子迎刃而解。

劣势：递归的执行效率通常比迭代低很多，所以递归程序要更消耗时间；由于递归函数是不断调用函数本身，在最底层的函数开始返回之前，程序都是一致在消耗栈空间的，所以递归程序要“吃”更多的内存空间；递归的结束条件设置非常重要，因为一旦设置错误，就容易导致程序万劫不复（崩溃）。

5、案例说明

5.1. 阶乘

#include <stdio.h>
int recursion(int num);

int recursion(int num) {
  if (num == 1) {
    return 1;
  }
  return num * recursion(num - 1);
}
int main() {
  int ret = recursion(10);
  printf("ret = %d", ret); // ret = 3628800
  return 0;
}

P35_hanoi问题

1、问题描述

汉诺塔问题是指：一块板上有三根针 A、B、C。A 针上套有 64 个大小不等的圆盘，按照大的在下、小的在上的顺序排列，要把这 64 个圆盘从 A 针移动到 C 针上，每次只能移动一个圆盘，移动过程可以借助 B 针。但在任何时候，任何针上的圆盘都必须保持大盘在下，小盘在上。从键盘输入需移动的圆盘个数，给出移动的过程。

2、算法思想

对于上述游戏的玩法，可以简单分解为三个步骤：

将前 63 个盘子从 X 移动到 Y上，确保大盘在小盘下。
将最底下的第 64 个盘子从 X 移动到 Z 上。
将 Y 上的 63 个盘子移动到 Z 上。

在游戏中，由于每次只能移动一个圆盘，所以在移动的过程中显然要借助另外一根针才可以实施。也就是说，步骤 1 将 1~63 个盘子移到 Y 上，需要借助 Z；步骤 3 将 Y 针上的 63 个盘子移到 Z 针上，需要借助 X。

所以我们把新的思路聚集为以下两个问题：

问题一：如何将 X 上的 63 个盘子借助 Z 移到 Y 上？
问题二：如何将 Y 上的 63 个盘子借助 X 移到 Z 上？

解决这两个问题的方法跟解决“如何将 X 上的 64 个盘子借助 Y 移动到 Z 上？”这个问题是一样的，都是可以拆解成 1、2、3 三个步骤来实现。

问题一（“如何将 X 上的 63 个盘子借助 Z 移到 Y 上？”）拆解为：

将前 62 个盘子从 X 移动到Z上，确保大盘在小盘下。
将最底下的第 63 个盘子移动到 Y 上。
将 Z 上的 62 个盘子移动到 Y 上。

问题二（“如何将 Y 上的 63 个盘子借助 X 移到 Z 上？”）拆解为：

将前 62 个盘子从 Y 移动到 X 上，确保大盘在小盘下。
将最底下的第 63 个盘子移动到 Z 上。
将 X 上的 62 个盘子移动到 Y 上。

没错，汉诺塔的拆解过程刚好满足递归算法的定义，因此，对于如此难题，使用递归来解决，问题就变得相当简单了！

3、代码实现

#include <stdio.h>
void hanoi(int num, char x, char y, char z);

void hanoi(int num, char x, char y, char z)
{
	// 设置递归出口
	if (num == 1)
	{
		// 只有一个的时候，直接移动
		// 注意这里的目标柱和辅助柱和 num!=1的情况不一样。
		printf("num：%d   %c 移动到 %c\n", num, x, z);
		return;
	}
	// 递归点
	// 1.先把上面一堆移走，一并移动到辅助柱
	hanoi(num - 1, x, z, y);
	// 2.把下面一块移动到目标柱
	printf("num：%d   %c 移动到 %c\n", num, x, z);
	// 3.把辅助柱上面所有的，移动到目标柱
	hanoi(num - 1, y, x, z);
}
int main()
{
	hanoi(3, 'x', 'y', 'z');
	return 0;
}

4、总结

本实例中定义的 hanoi() 函数是一个递归函数，它有四个形参"n"“x”“y”“z”。“n” 是移动的圆盘个数，“x”“y”“z” 分别表示三根针，其功能是把 x 上的 n 个圆盘移动到 z 上。当 n=1 时，直接把 x 上的圆盘移到 z 上，输出"x—Z"。当 n!=1 时，则递归调用 hanoi() 函数，把 (n-1) 个圆盘从 x 移到 y，输出"x—-z"；再递归调用 hanoi() 函数，把 (n-1) 个圆盘从 y 移到 z。在递归调用函数的过程中"n=n-1"，n 的值逐次递减，最后 n=1，终止递归调用，逐层返回，移动过程结束。

P36_快速排序

1、快速排序概念

通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。主要采用分治法和挖坑填数等方法，分治法就是大问题分解成各个小问题，堆小问题求解，使得大问题得以解决。

2、算法思路

我们先搞清楚这个堆排序思想，先把逻辑搞清楚，不着急写代码。

我们首先有一个无序数组，比方说

int[] arr={4,2,8,0,5,7,1,3,9};

2.1. 第一步，取基准数

基准数（枢轴），取数组的第一个元素，此时基准数：arr[0]=4

并定义两个变量i和j分别指向无序数组的第一个元素start和最后一个元素end。

//起始
int i=start;
int j=end;
//获取基准数
int temp=arr[start];

2.2. 第二步，分区过程

分区过程，将比基准数大的数全放到它的右边，比基准数小的或者相等的数全放到它的左边。

我们首先把第一个元素arr[0]=4定义为基准元素，此时数组第一个位置就是坑，那么我们要从数组的右边向左开始查找小于基准数的元素，并与坑互换位置。

while(i<j){
  //从右向左去找比基准数小的
  while(i<j&&arr[j]>=temp){
    j--;
  }
  //判断相等，填坑
  if(i<j){
    arr[i]=arr[j];
    i++;
  }
}

换好位置之后，现在转换，从数组的左边向右边查找比基准数大的元素：

while(i<j){
    //从右向左去找比基准数小的
    while(i<j&&arr[j]>=temp){
        j--;
    }
    //判断相等，填坑
    if(i<j){
        arr[i]=arr[j];
        i++;
    }
    //从左向右去找比基准数大的
    while(i<j&&arr[i]<temp){
        i++;
    }
    //判断相等，填坑
    if(i<j){
        arr[j]=arr[i];
        j--;
    }
}

换好位置之后，现在又重新开始从数组右边向左边开始查找，比基准数小的元素：

不断重复此类操作，直到分成左右两个分区，再把基准数填入坑中，这样第一趟排序完成。如下：

//把基准数放到i=j的位置
arr[i]=temp;

2.3. 第三步，对两个区间重复进行分区操作

这里，我们对分好的两个区间重复进行上述分区操作，直到每个区间只有一个元素为止。

重复进行以上操作，直到左右两边分区都是有序排列，整个排序过程也就完成了：

//对左半边部分进行快排
QuickSort(arr,start,i-1);
//对右半边部分进行快排
QuickSort(arr,i+1,end);

3、完整代码

java版本

import java.util.Arrays;

public class Quick_Sort {
  public static void main(String[] args) {
    int[] arr=new int[]{4,2,8,0,5,7,1,3,9};
    System.out.println(Arrays.toString(QuickSort(arr,0,arr.length-1)));
  }
  public static int[] QuickSort(int[] arr,int start,int end){
    //起始
    int i=start;
    int j=end;
    //获取基准数
    int temp=arr[start];
    //i<j为循环条件
    if(i<j){
      while(i<j){
        //从右向左去找比基准数小的
        while(i<j&&arr[j]>=temp){
          j--;
        }
        //判断相等，填坑
        if(i<j){
          arr[i]=arr[j];
          i++;
        }
        //从左向右去找比基准数大的
        while(i<j&&arr[i]<temp){
          i++;
        }
        //判断相等，填坑
        if(i<j){
          arr[j]=arr[i];
          j--;
        }
      }
      //把基准数放到i=j的位置
      arr[i]=temp;
      //对左半边部分进行快排
      QuickSort(arr,start,i-1);
      //对右半边部分进行快排
      QuickSort(arr,i+1,end);
    }
    return arr;
  }
}

c版本

#include <stdio.h>

int arr[] = {1, 10, 3, 4, 9, 2, 22,0};

void quikeSort(int arr[], int _left, int _right);

void quikeSort(int arr[], int _left, int _right)
{
	int left = _left;
	int right = _right;
	int pivot = arr[left];

	while (left < right)
	{
		// 右边开始向中间缩小索引
		while (left < right && arr[right] <= pivot)
		{
			right--;
		}
		// 填坑
		if (left < right)
		{
			arr[left] = arr[right];
			left++;
		}
		// 左边开始向中间缩小索引
		while (left < right && arr[left] >= pivot)
		{
			left++;
		}
		// 填坑
		if (left < right)
		{
			arr[right] = arr[left];
			right--;
		}
	}
	// 填充基准值
	arr[left] = pivot;

	if (_left < right - 1)
	{
		quikeSort(arr, _left, right - 1);
	}

	if (left + 1 < _right)
	{
		quikeSort(arr, left + 1, _right);
	}
}

int main()
{
	int len = sizeof(arr) / sizeof(int);
	quikeSort(arr, 0, len - 1);
	for (int i = 0; i < len; i++)
	{
		printf("%d  ", arr[i]);
	}

	return 0;
}

4、算法分析

4.1. 时间复杂度

快速排序最坏时间复杂度是O(n^2)，最好的时间复杂度为O(nlogn)，从而平均时间复杂度最后算出来也是O(nlogn)。

4.2. 空间复杂度

空间复杂度是O(1)，因为没有用到额外开辟的集合空间。

4.3. 算法稳定性

快速排序是不稳定的排序算法。因为我们无法保证相等的数据按顺序被扫描到和按顺序存放。

最坏时间复杂度是O(n^2)，最好的时间复杂度为O(nlogn)，从而平均时间复杂度最后算出来也是O(nlogn)。

P37_动态内存管理 1

malloc
申请动态内存空间

free
释放动态内存空间

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

realloc
重新分配内存空间

1、malloc

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

malloc函数向系统申请分配size个字节的内存空间，并返回一个指向这块空间的指针。

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

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

int main()
{
	int *ptr;

	ptr = (int *)malloc(sizeof(int));
	if (ptr == NULL) {
		printf("分配内存失败！\n");
		exit(1);
	}

	printf("请输入一个整数：");
	scanf("%d", ptr);

	printf("你输入的整数是：%d\n", *ptr);
	free(ptr);

	return 0;
}

2、free

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

free函数释放ptr参数指向的内存空间。

该内存空间必须是由malloc、calloc或realloc函数申请的。否则，该函数将导致未定义行为。如果ptr参数是NULL，则不执行任何操作。注意：该函数并不会修改ptr参数的值，所以调用后它仍然指向原来的地方（变为非法空间）。

没有即使释放内存空间，内存泄漏

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

int main(void)
{
	while (1)
	{
		malloc(1024);
	}

	return 0;
}

3、内存泄漏

总结一下，导致内存泄漏主要有两种情况：

隐式内存泄漏（即用完内存块没有及时使用free函数释放）
丢失内存块地址

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

int main()
{
	int *ptr;
	int num = 123;

	ptr = (int *)malloc(sizeof(int));
	if (ptr == NULL)
	{
		printf("分配内存失败！\n");
		exit(1);
	}

	printf("请输入一个整数：");
	scanf("%d", ptr);

	printf("你输入的整数是：%d\n", *ptr);

	ptr = &num;
	printf("你输入的整数是：%d\n", *ptr);

	free(ptr);

	return 0;
}

P38_动态内存管理 2

1、初始化内存空间

以mem开头的函数被编入字符串标准库，函数的声明包含在string.h这个头文件中：

memset – 使用一个常量字节填充内存空间
memcpy – 拷贝内存空间
memmove – 拷贝内存空间
memcmp – 比较内存空间
memchr – 在内存空间中搜索一个字符

2、calloc

函数原型：
void *calloc(size_t nmemb, size_t size);

calloc函数在内存中动态地申请nmemb个长度为size的连续内存空间（即申请的总空间尺寸为nmemb * size），这些内存空间全部被初始化为0。

calloc函数与malloc函数的一个重要区别是：

calloc函数在申请完内存后，自动初始化该内存空间为零
malloc函数不进行初始化操作，里边数据是随机的

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
   int i, n;
   int *a;
 
   printf("要输入的元素个数：");
   scanf("%d",&n);
 
   a = (int*)calloc(n, sizeof(int));
   printf("输入 %d 个数字：\n",n);
   for( i=0 ; i < n ; i++ ) 
   {
      scanf("%d",&a[i]);
   }
 
   printf("输入的数字为：");
   for( i=0 ; i < n ; i++ ) {
      printf("%d ",a[i]);
   }
   free (a);  // 释放内存
   return(0);
}