C语言100题（61~80）

第61题：

题目：打印出杨辉三角形（要求打印出10行）

解析：首先得知道杨辉三角形是什么

是这样的一幅图片，其规律是：①、每个数等于它上方两数之和；②、第n行的第m个数和第n-m+1个数相等；③、第n行的数字有n项；④、每行数字左右对称，由1开始逐渐变大。

int main()
{
	int i, j;
	int a[10][10];
	printf("\n");
	for (i = 0; i<10; i++) 
	{
		a[i][0] = 1;
		a[i][i] = 1;
	}
	for (i = 2; i<10; i++)
		for (j = 1; j<i; j++)
			a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
	for (i = 0; i<10; i++) 
	{
		for (j = 0; j <= i; j++)
			printf("%5d", a[i][j]);
		printf("\n");
	}
}

第62~65题：

题目：学习putpixel画点；画椭圆ellipse；利用ellipse and rectangle 画图；一个最优美的图案

解析：这4道题与之前的5道题也是相似，这里就不作关于画图的代码介绍。

第66题：

题目：输入3个数a,b,c，按大小顺序输出。

解析：获取3个输入，然后用指针获取地址，比较后进行交换。当然也可以嵌套循环比较

int main(void)
{
	int a, b, c;
	int *p1, *p2, *p3;
	printf("输入3个整数:\n");
	scanf("%d %d %d", &a, &b, &c);
	p1 = &a;
	p2 = &b;
	p3 = &c;
	if (a > b)
		swap(p1, p2);
	if (a > c)
		swap(p1, p3);
	if (b > c)
		swap(p2, p3);
	printf("%d %d %d\n", a, b, c);
}
void swap(int *s1, int *s2)
{
	int temp;
	temp = *s1;
	*s1 = *s2;
	*s2 = temp;
}

第67题：

题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

解析：设置max和min，先让max为第一个元素，min为最后一个元素。在遍历的时候，完成变换。注意：需要用一个标志位来判断是否发生交换，以避免最大的便是第一个，最小的便是最后一个。

int main(void)
{
	int num[MAXSIZE];
	int i;
	int max, min,loc,flag;
	printf("请输入10个数字:\n");
	for (i = 0; i < MAXSIZE; i++)
		scanf("%d", &num[i]);
	max = num[0];
	min = num[4];
	for (i = 1; i < MAXSIZE; i++)
	{
		if (max < num[i])
		{
			max = num[i];
			loc = i;
			flag = 1;
		}
	}
	if (1 == flag)
	{
		num[loc] = num[0];
		num[0] = max;
		flag == 0;
	}
	for (i = 8; i >= 0; i--)
	{
		if (min > num[i])
		{
			min = num[i];
			loc = i;
			flag = 1;
		}
	}
	if (1 == flag)
	num[loc] = num[9];
	num[9] = min;
	for (i = 0; i < MAXSIZE; i++)
		printf("%2d ", num[i]);
}

第68题：

题目：有 n个整数，使其前面各数顺序向后移 m 个位置，最后m个数变成最前面的 m 个数。

解析：此题要考虑数组的存储，考虑到频繁的插入与删除，不妨使用链表存储结构。如果采用数组的话，解题思路便是：设计一个逆序数组函数。首先将数组的前n-m个元素逆序；然后，将后m个元素逆序；最后，将整个数组逆序。

void reverse(int arr[], int start, int end)
{
	while (start < end)
	{
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
		start++;
		end--;
	}
}

void rotate(int arr[], int n, int m)
{
	//处理 m 的值大于数组长度的情况
	m = m % n;

	// 将前 n-m 个 元素逆序
	reverse(arr, 0, n - m - 1);

	// 将后 m 个元素逆序
	reverse(arr, n - m, n - 1);

	// 将整个数组进行逆序
	reverse(arr, 0, n - 1);
}

int main()
{
	int n;
	printf("请输入数组元素的个数：");
	scanf_s("%d", &n);

	int *arr = (int *)malloc(n * sizeof(int));
	printf("请输入数组元素：");
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &arr[i]);
	}

	int m;
	printf("请输入调整的位置：");
	scanf("%d", &m);

	rotate(arr, n, m);

	printf("数列经过旋转后：");
	for (int i = 0; i < n; i++)
	{
		printf("%d", arr[i]);
	}
	printf("\n");

	// 释放动态分配的内存
	free(arr);

	return 0;
}

第69题：

题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。

解析：此问题是约瑟夫问题，推荐您在网上搜索下此题的详细思路。此处我将使用循环链表解答此题。

struct Node
{
	int number;
	struct Node* next;
};

//创建循环链表并返回该链表的尾结点
struct Node* CircularList(int n)
{
	struct Node* head = NULL;
	struct Node* prev = NULL;

	for (int i = 1; i <= n; i++)
	{
		struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
		newNode->number = i; //赋予每个人编号
		newNode->next = NULL;

		//创建循环链表
		if (head == NULL)
		{
			head = newNode;
		}
		else
		{
			prev->next = newNode;
		}
		prev = newNode;
	}

	// 将最后一个节点的 next 指针指向头节点，形成循环链表
	if (prev != NULL)
	{
		prev->next = head;
	}

	return prev;

}

int josephus(int n, int m)
{
	if (n <= 0 || m <= 0)
	{
		return -1; // 输入参数无效
	}

	struct Node* head = CircularList(n);
	struct Node* current = head;
	struct Node* prev = NULL;

	// 找到循环链表的最后一个节点，用于循环判断
	while (current->next != head)
	{
		current = current->next;
	}

	int count = 1;
	while (current->next != current)
	{
		if (count == m)
		{
			//满足出圈条件
			prev->next = current->next; //链表右移
			struct Node* temp = current;
			current = current->next;
			free(temp);
			count = 1; //重新开始报数

		}
		else
		{
			//不满足就移向下一个人
			prev = current;
			current = current->next;
			count++;
		}
	}

	int lastNumber = current->number;
	free(current); // 释放最后一个节点的内存

	return lastNumber;
}

int main()
{
	int n, m;
	printf("请总人数：");
	scanf("%d", &n);
	printf("请输入想要淘汰的人的编号：");
	scanf("%d", &m);

	int lastNumber = josephus(n, m);
	printf("最后剩下的人的编号：%d.\n", lastNumber);

	return 0;
}

第70题：

题目：写一个函数，求一个字符串的长度，在 main 函数中输入字符串，并输出其长度。

解析：此题唯一的知识点，字符串实际上是使用空字符 \0 结尾

int CountLength(const char* str)
{
	int length = 0;
	while (str[length] != '\0')
	{
		length++;
	}
	return length;
}

int main()
{
	char str[100];
	printf("请输入字符串：");
	scanf("%s", str);

	int length = CountLength(str);
	printf("当前字符串长度为：%d", length);
	
	return length;
}

第71题：

题目：编写input()和output()函数输入，输出5个学生的数据记录。

解析：定义学生结构体，然后遍历输出

struct Student {
	char name[50];
	char sex[5];
	int age;
};

void input(struct Student students[], int count)
{
	printf("请依次输入学生的信息：姓名、性别、年龄\n");
	for (int i = 0; i < count; i++)
	{
		scanf("%s", &students[i].name);
		scanf("%s", &students[i].sex);
		scanf("%d", &students[i].age);
	}
}

void output(struct Student students[], int count)
{
	printf("\n学生记录为：\n");
	for (int i = 0; i < count; i++)
	{
		printf("姓名：%s\n", students[i].name);
		printf("性别：%s\n", students[i].sex);
		printf("年龄：%d\n", students[i].age);
	}
}

int main()
{
	struct Student students[5];
	int count = 5;

	input(students, count);
	output(students, count);
}

第72题：

题目：创建一个链表。

解析：此题考查数据与结构的基本知识点

typedef struct Node
{
	int data; //存放数据
	struct Node* next; //下一个节点
}Node;

Node* CreatNode(int data)
{
	Node* newNode = (Node*)malloc(sizeof(struct Node));
	if (newNode == NULL)
	{
		printf("内存分配失败");
		exit(1);
	}
	newNode->data = data;
	newNode->next = NULL;

	return newNode;
}

Node* InsertNode(Node* head, int data)
{
	Node* newNode = CreatNode(data);
	//判断头结点是否为空
	if (head == NULL)
	{
		head = newNode;
	}
	else
	{
		Node* current = head;
		//找到非空节点
		while (current->next != NULL)
		{
			current = current->next;
		}
		current->next = newNode;
	}
	return head;
}

void DisplayList(Node* head)
{
	Node* current = head;
	if (current == NULL)
	{
		printf("链表为空.\n");
	}
	else
	{
		printf("链表元素为：");
		while (current != NULL)
		{
			printf(" %d ", current->data);
			current = current->next;
		}
		printf("\n");
	}
}

void FreeList(Node* head)
{
	Node* current = head;
	while (current != NULL)
	{
		Node* temp = current;
		current = current->next;
		free(temp);
	}
}

int main()
{
	Node* head = NULL;

	//添加节点
	head = InsertNode(head, 1);
	head = InsertNode(head, 2);
	head = InsertNode(head, 3);

	//显示链表
	DisplayList(head);

	//释放链表内存
	FreeList(head);

	return 0;
}

第73题：

题目：反向输出一个链表。

解析：递归的方式即可解决

typedef struct Node
{
	int data; //存放数据
	struct Node* next; //下一个节点
}Node;

Node* CreatNode(int data)
{
	Node* newNode = (Node*)malloc(sizeof(struct Node));
	if (newNode == NULL)
	{
		printf("内存分配失败");
		exit(1);
	}
	newNode->data = data;
	newNode->next = NULL;

	return newNode;
}

Node* InsertNode(Node* head, int data)
{
	Node* newNode = CreatNode(data);
	//判断头结点是否为空
	if (head == NULL)
	{
		head = newNode;
	}
	else
	{
		Node* current = head;
		//找到非空节点
		while (current->next != NULL)
		{
			current = current->next;
		}
		current->next = newNode;
	}
	return head;
}

void DisplayList(Node* head)
{
	Node* current = head;
	if (current == NULL)
	{
		printf("链表为空.\n");
	}
	else
	{
		printf("链表元素为：");
		while (current != NULL)
		{
			printf(" %d ", current->data);
			current = current->next;
		}
		printf("\n");
	}
}

void ReversePrint(Node* head)
{
	if (head == NULL)
	{
		return;
	}
	
	ReversePrint(head->next);
	printf(" %d ", head->data);
}


void FreeList(Node* head)
{
	Node* current = head;
	while (current != NULL)
	{
		Node* temp = current;
		current = current->next;
		free(temp);
	}
}

int main()
{
	Node* head = NULL;

	//添加节点
	head = InsertNode(head, 1);
	head = InsertNode(head, 2);
	head = InsertNode(head, 3);

	//显示链表
	DisplayList(head);

	//反向输出链表
	printf("反向输出链表：");
	ReversePrint(head);
	printf("\n");

	//释放链表内存
	FreeList(head);

	return 0;
}

第74题：

题目：连接两个链表。

解析：找到第一个链表的尾结点，将尾结点的next连接到第二个链表的头结点

typedef struct Node
{
	int data; //存放数据
	struct Node* next; //下一个节点
}Node;

Node* CreatNode(int data)
{
	Node* newNode = (Node*)malloc(sizeof(struct Node));
	if (newNode == NULL)
	{
		printf("内存分配失败");
		exit(1);
	}
	newNode->data = data;
	newNode->next = NULL;

	return newNode;
}

Node* InsertNode(Node* head, int data)
{
	Node* newNode = CreatNode(data);
	//判断头结点是否为空
	if (head == NULL)
	{
		head = newNode;
	}
	else
	{
		Node* current = head;
		//找到非空节点
		while (current->next != NULL)
		{
			current = current->next;
		}
		current->next = newNode;
	}
	return head;
}

void DisplayList(Node* head)
{
	Node* current = head;
	if (current == NULL)
	{
		printf("链表为空.\n");
	}
	else
	{
		printf("链表元素为：");
		while (current != NULL)
		{
			printf(" %d ", current->data);
			current = current->next;
		}
		printf("\n");
	}
}

Node* LinkList(Node* list1, Node* list2)
{
	if (list1 == NULL)
	{
		return list2;
	}
	if (list2 == NULL)
	{
		return list1;
	}

	Node* current = list1;
	while (current->next != NULL)
	{
		current = current->next;
	}
	current->next = list2;

	return list1;
}


void FreeList(Node* head)
{
	Node* current = head;
	while (current != NULL)
	{
		Node* temp = current;
		current = current->next;
		free(temp);
	}
}

int main()
{
	Node* list1 = NULL;
	Node* list2 = NULL;

	//添加节点到第一个链表
	list1 = InsertNode(list1, 1);
	list1 = InsertNode(list1, 2);
	list1 = InsertNode(list1, 3);

	//添加节点到第二个链表
	list2 = InsertNode(list2, 4);
	list2 = InsertNode(list2, 5);
	list2 = InsertNode(list2, 6);
	
	// 连接两个链表
	Node* list = LinkList(list1, list2);

	//显示连接后的链表
	DisplayList(list);

	//释放链表内存
	FreeList(list);

	return 0;
}

第75题：

题目：输入一个整数，并将其反转后输出。。

解析：首先使用逐位循环取余的方法，去提取输入的整数的个十百位，然后通过乘以10加上余数的，最后再让输入的整数依次除以10即可。

int ReverseInteger(int num)
{
	int reversenum = 0;
	while (num != 0)
	{
		int remainder = num % 10;
		reversenum = reversenum * 10 + remainder;
		num /= 10;
	}
	
	return reversenum;
}

int main()
{
	int num;
	printf("请输入整数：");
	scanf("%d", &num);

	int reversenum = ReverseInteger(num);
	printf("反转后的整数为：%d", reversenum);

	return 0;
}

第76题：

题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，调用函数1/1+1/3+…+1/n(利用指针函数)。

解析：分别设计两个函数用于求解。然后需要掌握指针函数与函数指针的区别，指针函数：类型 *指针变量名 （参数列表），一个函数返回值是指针。
函数指针：类型（* 指针变量名）（参数列表）， 一个指针指向函数

double* CalculateSumEven(int n)
{
	double* sum = (double*)malloc(sizeof(double));
	*sum = 0.0;
	for (int i = 2; i <= n; i += 2)
	{
		*sum += 1.0 / i;
	}
	return sum;
}

double* CalculateSumOdd(int n)
{
	double* sum = (double*)malloc(sizeof(double));
	*sum = 0.0;
	for (int i = 1; i <= n; i += 2)
	{
		*sum += 1.0 / i;
	}
	return sum;
}


double* CalculateSum(int n)
{
	if (n % 2 == 0)
	{
		return CalculateSumEven(n);
	}
	else
	{
		return CalculateSumOdd(n);
	}
}

int main()
{
	int n;
	printf("请输入一个正整数：");
	scanf("%d", &n);

	double* result;
	result = CalculateSum(n);
	printf("和为：%.2f\n", *result);
}

第77题：

题目：填空练习（指向指针的指针）。

解析：在这道题目中，&s[k]的类型是char ** 。字符串数组s[]中的每个元素都是指向常量字符的指针，因此我们需要使用指向指针的指针来存储它们的地址。

int main()
{
	const char *s[] = { "man", "woman", "girl", "boy", "sister" };
	const char **q;
	int k;
	for (k = 0; k < 5; k++)
	{
		q = &s[k];
		printf("%s\n", *q);
	}
}

第78题：

题目：找到年龄最大的人，并输出。请找出程序中有什么问题。

解析：两个知识点，一个是结构体的初始化，一个是结构体的基本操作。

struct man
{
	char name[20];
	int age;
}person[3] = {"li", 18, "wang", 25, "sun", 22 };

int main()
{
	struct man *q = NULL;  //原来的代码缺少对结构体的初始化
	struct man *p; 
	int i, m = 0;
	p = person; //将p指向person数组的第一个元素
	for (i = 0; i < 3; i++)
	{
		if (m < p->age)
		{
			m = p->age;
			q = p; //满足条件，则将q指向当前人的结构体指针
		}
		p++; //移动p指针指向下一个结构体
	}
	printf("%s, %d\n", q->name, q->age);
}

第79题：

题目：字符串排序。

解析：此处我们用到了const void *。
const是定义常量，不可修改。
void的字面意思是“无类型”，void *则为“无类型指针”，void *可以指向任何类型的数据。因此，void * 类型指针，这个类型指针指向了实实在在的存放数据的地址，但是该地址存放的数据的数据类型我们暂时不知道。以及qsort函数。

int CompareStrings(const void *a, const void *b) 
{
	const char **str1 = (const char **)a;
	const char **str2 = (const char **)b;
	return strcmp(*str1, *str2);
}

int main()
{
	const char *strings[] = { "orange", "apple", "banana", "grape", "pear" };
	//计算字符串个数
	int numStrings = sizeof(strings) / sizeof(strings[0]);
	// qsort(指向待排序数组的第一个元素的地址,数组中元素的数量,size每个元素,比较函数的指针用于定义元素之间的比较规则)
	qsort(strings, numStrings, sizeof(strings[0]), CompareStrings);

	printf("排序后的字符串：\n");
	for (int i = 0; i < numStrings; i++)
	{
		printf("%s\n", strings[i]);
	}

	return 0;
}

第80题：

题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只 猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了 一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的， 问海滩上原来最少有多少个桃子？

解析：假设最开始的桃子数量为x个，第一个猴子来拿了（x-1）/5个，剩下(x-1)/5*4个桃子，依次循环判断。在写程序时要注意，从i=0~i=4，我们都应该满足，在第6只猴子也即是i=5时，应该不满足了，这时候应该跳出循环了，所以要对i=5进行判断，而不是对i=4进行判断。

int peach()
{
	int x = 6; //假设最开始的桃子的数量为6

	while (1)
	{
		int i;
		int remain = x;
		for (i = 0; i <= 5; i++)
		{
			if ((remain - 1) % 5 != 0)
			{
				break; //不满足条件则跳出循环
			}

			remain = (remain - 1) / 5 * 4; //计算剩下的桃子数量
		}
		if (i == 5)
		{
			return x; //找到满足条件的最小桃子数量
		}
		else
		{
			x++; //不满足则继续寻找
		}
	}
}

int main()
{
	int MinPeach = peach();

	printf("海滩上原来最少有 %d 个桃子\n", MinPeach);

	return 0;
}