第十一周作业

这个作业属于那个课程	C语言程序设计II
这个作业要求在哪里	https://edu.cnblogs.com/campus/zswxy/software-engineering-class1-2018/homework/3202
我在这个课程的目标是	学会使用递归函数
这个作业在那个具体方面帮助我实现目标	运用递归函数解决问题
参考文献	C语言程序设计II，CSDN博客，百度
一、本周完成的作业
==========

基础作业

7-1 汉诺塔问题* (10 分)

汉诺塔是一个源于印度古老传说的益智玩具。据说大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘，大梵天命令僧侣把圆盘移到另一根柱子上，并且规定：在小圆盘上不能放大圆盘，每次只能移动一个圆盘。当所有圆盘都移到另一根柱子上时，世界就会毁灭。

请编写程序，输入汉诺塔圆片的数量，输出移动汉诺塔的步骤。
输入格式
圆盘数 起始柱 目的柱 过度柱
输出格式
移动汉诺塔的步骤
每行显示一步操作，具体格式为：
盘片号: 起始柱 -> 目的柱
其中盘片号从 1 开始由小到大顺序编号。
输入样例：

3
a c b

输出样例;

1: a -> c
2: a -> b
1: c -> b
3: a -> c
1: b -> a
2: b -> c
1: a -> c

2）实验代码

#include<stdio.h>
void hanio(int n,char a,char b,char c);
int main ()
{
	int n;
	char a,b,c;

	scanf("%d
",&n);
	scanf("%c %c %c ",&a,&b,&c);

	hanio(n,a,b,c);
	return 0;
}

void hanio(int n,char a,char b,char c)
{
	if(n==1){
		printf("%d: %c -> %c
",n,a,b);
	}
	else{
		hanio(n-1,a,c,b);
		printf("%d: %c -> %c
",n,a,b);
		hanio(n-1,c,b,a);
	}
}

3 ）设计思路

4 ）运行结果截图

7-2 估值一亿的AI核心代码 (20 分)

以上图片来自新浪微博。
本题要求你实现一个稍微更值钱一点的 AI 英文问答程序，规则是：
无论用户说什么，首先把对方说的话在一行中原样打印出来；
消除原文中多余空格：把相邻单词间的多个空格换成 1 个空格，把行首尾的空格全部删掉，把标点符号前面的空格删掉；
把原文中所有大写英文字母变成小写，除了 I；
把原文中所有独立的 can you、could you 对应地换成 I can、I could—— 这里“独立”是指被空格或标点符号分隔开的单词；
把原文中所有独立的 I 和 me 换成 you；
把原文中所有的问号 ? 换成惊叹号 !；
在一行中输出替换后的句子作为 AI 的回答。
输入格式：
输入首先在第一行给出不超过 10 的正整数 N，随后 N 行，每行给出一句不超过 1000 个字符的、以回车结尾的用户的对话，对话为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。
输出格式：
按题面要求输出，每个 AI 的回答前要加上 AI: 和一个空格。
输入样例：

6
Hello ?
 Good to chat   with you
can   you speak Chinese?
Really?
Could you show me 5
What Is this prime? I,don 't know

输出样例：

Hello ?
AI: hello!
 Good to chat   with you
AI: good to chat with you
can   you speak Chinese?
AI: I can speak chinese!
Really?
AI: really!
Could you show me 5
AI: I could show you 5
What Is this prime? I,don 't know
AI: what Is this prime! you,don't know

2）关于这题

可能我只适合支付宝五个亿的项目，这个一个亿的项目不适合我

预习作业

第十二周的教学内容是：第十一章 指针进阶
请大家查阅资料，思考如下问题：
请举实例解释以下几个概念：数组指针，指针数组，指针函数，函数指针，二级指针，单向链表。（无实例不给分）
请用自己的理解回答。如果有引用他人的文字，请一定要标出出处（使用Markdown的链接方式）。

1.数组指针和数组指针

数组指针（也称行指针）
定义 int (p)[n];
()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。
如要将二维数组赋给一指针，应这样赋值：
int a[3][4];
int (p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。
p=a; //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]
p++; //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]
所以数组指针也称指向一维数组的指针，亦称行指针。
指针数组
定义 int p[n];
[]优先级高，先与p结合成为一个数组，再由int说明这是一个整型指针数组，它有n个指针类型的数组元素。这里执行p+1时，则p指向下一个数组元素，这样赋值是错误的：p=a；因为p是个不可知的表示，只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 p=a; 这里p表示指针数组第一个元素的值，a的首地址的值。
如要将二维数组赋给一指针数组:
int p[3];
int a[3][4];
p++; //该语句表示p数组指向下一个数组元素。注：此数组每一个元素都是一个指针
for(i=0;i<3;i++)
p[i]=a[i]
这里int p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]
所以要分别赋值。
这样两者的区别就豁然开朗了，数组指针只是一个指针变量，似乎是C语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。
还需要说明的一点就是，同时用来指向二维数组时，其引用和用数组名引用都是一样的。
比如要表示数组中i行j列一个元素：
(p[i]+j)、((p+i)+j)、((p+i))[j]、p[i][j]
优先级：()>[]>*
出处：http://www.cnblogs.com/hongcha717/archive/2010/10/24/1859780.html

2.指针函数

指针函数
定义：
指针函数，简单的来说，就是一个返回指针的函数，其本质是一个函数，而该函数的返回值是一个指针。
声明格式为：*类型标识符 函数名(参数表)
这似乎并不难理解，再进一步描述一下。
看看下面这个函数声明：

int fun(int x,int y);

这种函数应该都很熟悉，其实就是一个函数，然后返回值是一个 int 类型，是一个数值。
接着看下面这个函数声明：

int *fun(int x,int y);

这和上面那个函数唯一的区别就是在函数名前面多了一个*号，而这个函数就是一个指针函数。其返回值是一个 int 类型的指针，是一个地址。
这样描述应该很容易理解了，所谓的指针函数也没什么特别的，和普通函数对比不过就是其返回了一个指针（即地址值）而已。
指针函数的写法

int *fun(int x,int y);
int * fun(int x,int y)；
int* fun(int x,int y);

这个写法看个人习惯，其实如果*靠近返回值类型的话可能更容易理解其定义。
示例
（由于本人习惯于 Qt 中进行开发，所以这里为了方便，示例是在 Qt 工程中写的，其语法是一样的，只是输出方式不同）
来看一个非常简单的示例：

typedef struct _Data{
    int a;
    int b;
}Data;

//指针函数

Data* f(int a,int b){
    Data * data = new Data;
    data->a = a;
    data->b = b;
    return data;
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //调用指针函数
    Data * myData = f(4,5);
    qDebug() << "f(4,5) = " << myData->a << myData->b;

    return a.exec();
}

输出如下：

f(4,5) =  4 5

注意：在调用指针函数时，需要一个同类型的指针来接收其函数的返回值。
不过也可以将其返回值定义为 void*类型，在调用的时候强制转换返回值为自己想要的类型，如下：
//指针函数

void* f(int a,int b){
    Data * data = new Data;
    data->a = a;
    data->b = b;
    return data;
}

调用：

Data * myData = static_cast<Data*>(f(4,5));

其输出结果是一样的，不过不建议这么使用，因为强制转换可能会带来风险。
原文：https://blog.csdn.net/luoyayun361/article/details/80428882

3.函数指针

定义
函数指针，其本质是一个指针变量，该指针指向这个函数。总结来说，函数指针就是指向函数的指针。
声明格式：类型说明符 (*函数名) (参数)
如下：

int (*fun)(int x,int y);

函数指针是需要把一个函数的地址赋值给它，有两种写法：

fun = &Function；
fun = Function;

取地址运算符&不是必需的，因为一个函数标识符就表示了它的地址，如果是函数调用，还必须包含一个圆括号括起来的参数表。
调用函数指针的方式也有两种：

x = (*fun)();
x = fun();

两种方式均可，其中第二种看上去和普通的函数调用没啥区别，如果可以的话，建议使用第一种，因为可以清楚的指明这是通过指针的方式来调用函数。当然，也要看个人习惯，如果理解其定义，随便怎么用都行啦。
示例

int add(int x,int y){
    return x+y;
}
int sub(int x,int y){
    return x-y;
}
//函数指针
int (*fun)(int x,int y);

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //第一种写法
    fun = add;
    qDebug() << "(*fun)(1,2) = " << (*fun)(1,2) ;
	//第二种写法
    fun = &sub;
    qDebug() << "(*fun)(5,2) = " << (*fun)(5,3)  << fun(5,3)；

    return a.exec();
}

输出如下：

(*fun)(1,2) =  3
(*fun)(5,2) =  2 2

上面说到的几种赋值和调用方式我都分别使用了，其输出结果是一样的。
原文：https://blog.csdn.net/luoyayun361/article/details/80428882

4.二级指针

二级指针：

    在指针的定义时就说过，指针变量虽然保存的是别人的地址，但其本身也是有地址的。而指向指针地址的指针，就叫做二级指针。

那啥时候会用到二级指针？不急，先看下面代码：

#include <stdio.h>
int change_1(int b)
{
	b = 10;
	return b;	
}
int change_2(int *p)
{
	*p = 15;
}
int main(int argc, char const *argv[])
{
	int a = 5;
	change_1(a);
	printf("%d
",a);
	change_2(&a);
	printf("%d
",a);
	return 0;
}

你觉得输出是多少 ？ 编译后结果是 5和15 也就是说change_1()这个函数没有把a修改了。C语言中函数的传参是值传递，change_1()只不过是把实参a的值5传给了局部变量b，然后b在被赋值10并返回，函数结束， b的生命周期也结束了。而主函数中的a根本就没有发生变化。要修改a的值，就要用第二种方法，前面我们说了，指针指向的是地址， change_2()中p得到的是a所在的地址，而p就代表这个地址中的内容，我们对p进行修改，就代表我们对这个地址上的变量即 a进行了修改。

所以，想要修改一个数据的值，就要找到他的地址，用一级指针来修改。以此类推， 想要修改指针的值，我们就要找到指针的地址，用二级指针来对他进行修改。

下面可以看下这个代码的结果，可能会更清晰一点：

#include <stdio.h>
int main(int argc, char const *argv[])
{
	int a =5;
	int* p;
	p = &a;
	int** pp;
	pp = &p;

	printf("&a:%p
",&a);
	printf("&p:%p
",&p);
	printf("p:%p
",p);
	printf("&pp:%p
",&pp);
	printf("pp:%p
",pp);
	printf("*pp:%p
",*pp);
        printf("&(*pp):%p
",&(*pp));
	return 0;
}

取这些变量的地址，地址运算符“&”，运算操作是取地址。编译结果：

画个图：

可以很清楚的看到 a的地址被放入了一级指针p当中 p的地址被放入了二级指针pp当中

p == &a 说明 p == a pp == &p 说明pp == p *pp == &a 说明 **pp == a

也就是 **pp == *p == a

最后举个具体用例吧。

#include <stdio.h>
int main(int argc, char const *argv[])
{
	char* num[9]={"one","two","three","four","five","six","seven","eight","nine"};
	char** p;
	p = &num[0];
	int number;

	scanf("%d",&number);
	printf("English Number is %s
",*(p+number-1));

	return 0;
}

定义一个指针数组num，输入阿拉伯数字转换成英文数字。这里如果单单只有一级指针是不够的，一级指针只能找到字符串所在的位置，但是找不到其首地址，导致无法输出。所以需要二级指针二级寻址来输出。
原文：https://blog.csdn.net/Canger_/article/details/80547235
5.单向链表
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点；
列表是由结点构成，head指针指向第一个成为表头结点，而终止于最后一个指向NULL的指针。

二：学习进度条

周/日期	这周所花的时间	代码行数	学到的知识点简介	目前比较困惑的东西
3/4-3/9	3h	38	文件指针，文件的读写	对文件和数组还不是很理解
3/9-3/15	5h	75	预习了二维数组	对最大子数组的概念不清楚
3/16-3/22	4h	97	一维数组：选择排序法、二分查找法；二维数据：定义、引用、初始化，二维数组与矩阵。	不清楚二维数组的具体结构等
3/23-3/29	6h	80	字符串，字符串的初始化，预习了指针的定义，指针变量的初始化	对字符串的处理还有指针的运用不够了解
3/30-4/5	5h	50	定义指针变量，指针变量的运用	不是很会运用指针
4/6-4/12	6h	120	指针、数组和地址之间的关系	指针数组和地址之间的一些等价代换还不是很清楚
4/13-4/19	4h	140	处理字符串的函数，动态内存分配，字符指针与字符串的关系，预习了结构体，完成了预习题	字符串和指针之间的关系没太懂
4/20-4/26	5h	200	结构体的定义，运用	结构体类型还有变量的定义有点混
5/5-5/11	4h	50	宏定义，递归函数	递归函数的出口

三：学习感悟

这周的作业除了的第一题，书上有例题加上老师讲解过这题的算法，所以不难，但是第二题和第三题是真的看不懂，可能是我参加了支付宝五个亿的项目，所以这个一个亿的项目容不下我吧。