C语言学习记录—作业5

1. 字符串逆序

循环非指针版本

思路：逆置字符串，循环的方式实现非常简单
确定左边下标（第一个元素）和右边下标（最后一个元素）。
交换两个元素，每次左下标+1，有下标-1，直到左右下标相等说明只有一个元素，此时不需要再交换。

void reverse_string(char arr[], int sz)
{
	int left = 0;
	int right = sz;
	char tmp = ' ';
	while (left <= right)
	{
		tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;
		left++;
		right--;
	}
	printf("%s\n", arr);
}

循环指针版本

1. 给两个指针，left放在字符串左侧，right放在最后一个有效字符位置
2. 交换两个指针位置上的字符
3. left指针往后走，right指针往前走，只要两个指针没有相遇，继续2，两个指针相遇后，逆置结束

void reverse_string(char* arr)
{
	char* left = arr;
	char* right = arr + strlen(arr) - 1;

	while (left < right)
	{
		char tmp = *left;
		*left = *right;
		*right = tmp;

		left++;
		right--;
	}
}

递归版本

思路：交换第一个和最后一个，再交换第二个和倒数第二个，以此类推

只能逆序元素个数为奇数的数组

void reverse(char arr[], int left, int right)//此方法只能逆序元素个数为奇数的数组，正确版本看下方
{
	char tmp = arr[left];
	arr[left] = arr[right];
	arr[right] = tmp;
	
  如果if条件在这个位置，遇到元素个数为偶数的的数组会有以下情况
  当逆序到最后两个字符时，虽然字符被交换了，但下标还未+1，(调用自己时才+1)
  所以此时的左下边仍然小于右下标，所以又再次调用自己，导致已经被正确交换的两个字符又被交换了。
  下面函数为正确版本，即使交换也要左下标小于右下标。
	if (left < right)//这里不需要等于，因为等于说明只有一个字符，只剩一个字符不需要再交换
		reverse(arr, left + 1, right - 1);
}

正确版本

逆序正确版本
void reverse(char arr[], int left, int right)
{
	if (left < right)
	{
		char tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;
		reverse(arr, left + 1, right - 1);
	}
}

2. 递归和非递归分别实现求第n个斐波那契数

非递归方法

思路:第1个数+第2个数=第3个数。第2个数+第3个数=第四个数。又因为最开始两个数都是1，所以创建3个变量分别是第1、2个数（初始化为1），和第3个数。每次加完之后，把第3个数的值赋给第2个数；第2个数的值赋给第1个数。

int fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 2;
	int i = 0;

	if (n <= 2)
		return 1;

	for (i = 3; i <= n; i++)
	{
		c = a + b;
		a = b;
		b = c;
	}
	return c;
}
老师方法
int fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 1;

	while (n >= 3)
	{
		c = a + b;	//2=1+1		3=1+2	5=2+3
		a = b;		//a=1		a=2		a=3
		b = c;		//b=2		b=3		b=5
		n--;
	}
	return c;
}

递归版本

根据上方非递归可以总结出，任何一个数都是往前移动1和2的两个数相加。即n=(n-1)+(n-2)

最简单的情况是最开始的两个数，都是1。

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

3. 计算一个数的每位之和（递归实现）
写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和
例如，调用DigitSum(1729)，则应该返回1 + 7 + 2 + 9，它的和是19
输入：1729，输出：19

思路：这题和顺序打印每一位类似。首先要拆分每一位，在获取每一位之后再相加。

//DigitSum(1234)
//DigitSum(123)+4		等效于DigitSum(1234/10)+ 1234%10
//DigitSum(12)+3+4
//DigitSum(1)+2+3+4

//将给定数字拆分，直到只有1位
int DigitSum(unsigned int n)
{
	if (n > 9)
		return DigitSum(n / 10) + n % 10;
	else
		return n;
}
int main()
{
	unsigned int n = 0;
	scanf("%d", &n);
	int sum = DigitSum(n);
	printf("%d\n", sum);
	return 0;
}

4. 求n的k次方（递归实现）

思路：从指数入手，分3种情况：

k=0，无论n是几，都等于1（此为最简单的情况）
k>0，例如3^3可以理解为3*3^2（即n*n^k-1）
k<0，其实就是k>0时再取倒数

//Pow(n, k) -> n*Pow(n, k-1)
//k=0, 1
//k>0, Pow(n, k)->n* Pow(n, k - 1)
//k<0, 1/(Pow(n, -k))
//n的k次方可以看作，n乘以n的k-1次方，直到k=0
double Pow(int n, int k)
{
	if (k == 0)
		return 1;
	else if (k > 0)
		return n * Pow(n, k - 1);
	else
		//如果k是负数则进入下面代码，假设k是-2，那么-k=-(-2),结果就是2
		//然后进去k>0的部分,最后才返回到 1.0 / Pow(n, -k);
		return 1.0 / Pow(n, -k);
}
int main()
{
	int n = 0;
	int k = 0;
	scanf("%d%d", &n, &k);
	double ret = Pow(n, k);
	printf("%lf\n", ret);
	return 0;
}

4. 将数组A的内容和数组B的内容进行交换。(数组一样大)

int main()
{
	int arr1[] = { 1,3,5,7,9 };
	int arr2[] = { 2,4,6,8,0 };
	//不可以使用数组名进行交换，因为数组名是地址
	int i = 0;
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	for (i = 0; i < sz; i++)
	{
		int tmp = arr1[i];
		arr1[i] = arr2[i];
		arr2[i] = tmp;
	}

	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");

	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr2[i]);
	}
	printf("\n");
	return 0;
}

5. 冒泡排序

思路：假设有10个数(n=10)，那么每个数都要交换到指定位置需要9轮(n-1)，因为9个数交换完，最后一个数也在指定位置了。
第一轮交换的次数是9次(n-1)。
每一轮交换的次数比上一次-1，增加几轮少几次。

void bubble(int* arr, int sz)
{
	int i = 0;//i是需要交换多少轮
	for (i = 0; i < sz - 1; i++)
	{
		//j是元素下标，从下标为0的元素(也就是第一个元素)开始逐一比较
		//第1轮：第1个元素需要交换 元素个数-1次，10-1=9
		//第2轮：第2个元素需要交换 元素个数-2次，10-2=8
		//....
		//第9轮：第9个元素需要交换 元素个数-9次，10-9=1
		//结束，总共交换 元素个数-1轮，10-1=9
		int j = 0;//元素下标
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);

	bubble(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}