C语言编程练习day14

约瑟夫问题
题目：一群猴子要选新猴王。新猴王的选择方法是：让N只候选猴子围成一圈，从某位置起顺序编号为1~N号。从第1号开始报数，每轮从1报到3，凡报到3的猴子即退出圈子，接着又从紧邻的下一只猴子开始同样的报数。如此不断循环，最后剩下的一只猴子就选为猴王。请问是原来第几号猴子当选猴王？
方法1：非单循环链表方法
思路：通过两层循环，外层循环来统计被淘汰的元素个数，当只剩下1个元素，即淘汰了n-1个时，外层循环结束，整体结束。内层循环决定每次淘汰哪一个元素，通过累加变量flag来计数，当flag=3时，淘汰该元素，即将该元素值置为1（默认为0)，并且只有当元素值为0时flag才加1，当元素值为1时跳过。
输入：11
输出：7
优化目标：通过单循环链表来完成

#include <stdio.h>

int main(){
	
	int number;
	scanf("%d", &number);
	int num[1024] = {0};//初始化全为0
	int eliminate = 0;//统计淘汰个数
	int flag = 0;//当falg=3时，淘汰一个
	
	while(eliminate < number-1){//eliminate < n-1,当只剩下1个时，结束while循环
		for(int i=0; i<number; i++){
			if(num[i] == 1);//a[i]==1表示已经淘汰的数
			else if(num[i] == 0){
				flag++;
			}
			if(flag == 3){
				num[i] = 1;//当flag累计到3时，淘汰该数
				flag = 0;
				eliminate++;//统计淘汰个数的变量加1
			}
		}
	}
	for(int i=0; i<number; i++){
		if(num[i] == 0){
			printf("%d", i+1);//输出最后那个没有被淘汰的数
			break;
		}
	}
	return 0;
}

方法2：通过单循环链表来做
思路：通过单循环链表循环访问结点，同样，当累加变量为3时，删除该结点，直到链表元素结点只有1个时，结束。输出最后这个元素结点。
输入：11
输出：7
优化目标：无

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

#define N 3
#define MAX 1024

//单循环链表结点
typedef struct CIRCLELINKNODE {
	struct CIRCLELINKNODE* next;
}CircleLinkNode;
//单循环链表
typedef struct CIRCLELINKLIST {
	CircleLinkNode head;
	int size;//统计结点个数
}CircleLinkList;
//数据结构体
typedef struct MYNUM {
	CircleLinkNode node;
	int value;//值
}MyNum;

/*比较函数
*@data1：待比较数据1
*@data1待比较数据2
*/
int CompareNode(CircleLinkNode* data1, CircleLinkNode* data2) {
	MyNum* num1 = (MyNum*)data1;//把链表结点类型强转为数据结点类型
	MyNum* num2 = (MyNum*)data2;
	if (num1->value == num2->value) {
		return 0;//若二则相等，则返回0；否则返回1
	}else {
		return 1;
	}
}

/*
*打印函数
*@dara：要打印的数据
*/
void PrintNode(CircleLinkNode* data) {
	MyNum* num = (MyNum*)data;
	printf("%d", num->value);
}

//初始化单循环链表
CircleLinkList* Init_CircleLinkList() {
	CircleLinkList* clist = (CircleLinkList*)malloc(sizeof(CircleLinkList));
	clist->head.next = &(clist->head);//初始化时，头节点的next指针指向自己
	clist->size = 0;

	return clist;
}

/*
*插入结点函数
*@clist：指向头结点的指针
*@pos：插入的位置
*@dada：插入的数据，为链表结点类型
*/
void Insert_CircleLinkList(CircleLinkList* clist, int pos, CircleLinkNode* data) {
	//判断参数的合法
	if (clist == NULL || data == NULL || pos < 0 || pos > clist->size) {
		return;
	}
	//辅助指针，指向头节点，插入数据时移动的指针
	CircleLinkNode* pCurrent = &(clist->head);
	for (int i = 0; i < pos; i++) {
		pCurrent = pCurrent->next;//找到插入的位置
	}
	//插入结点
	data->next = pCurrent->next;
	pCurrent->next = data;
	//结点总数加1
	clist->size++;
}
/*
*删除函数
*@clist：指向头结点的指针
*@data：待删除的结点
*/
void DeleteByValue_CircleLinkList(CircleLinkList* clist, CircleLinkNode* data) {
	//判断参数的合法性
	if (clist == NULL || data == NULL) {
		return;
	}
	//辅助指针，指向头节点，删除数据时移动的指针
	CircleLinkNode* pCurrent = &(clist->head);//指向待删除结点的前一个结点
	CircleLinkNode* pNext = pCurrent->next;//指向待删除结点
	for (int i = 0; i < clist->size; i++) {
		if (CompareNode(pNext, data) == 0) {//找到待删除结点
			pCurrent->next = pNext->next;//删除结点
			break;
		}
		//指针后移
		pCurrent = pNext;
		pNext = pNext->next;
	}
	//结点总数减1
	clist->size--;
}

/*
*统计数据结点个数函数
*@clist：指向头结点的指针
*/
int Size_CircleLinkList(CircleLinkList* clist) {
	return clist->size;
}

int main() {
	int number;
    scanf("%d", &number);
	MyNum num[MAX];

	//
	CircleLinkList* clist = Init_CircleLinkList();
	//
	for (int i = 0; i < number; i++) {
		num[i].value = i + 1;//数据初始化为1~number
		//插入结点，链接成单循环链表
		Insert_CircleLinkList(clist, i, (CircleLinkNode*)&num[i]);
	}
	//删除结点的判断条件，当index累加到3时，删除该结点
	int index = 1;
	//复制指针，指向第一个数据结点，
	CircleLinkNode* pCurent = clist->head.next;
	while (Size_CircleLinkList(clist) > 1) {//当链表中只要一个数据结点时，结束循环
		if (index == N) {//N=3，当index == N时，删除该结点
			index = 1;
			//删除结点时的辅助指针
			CircleLinkNode* pNext = pCurent->next;
			DeleteByValue_CircleLinkList(clist, pCurent);
			//指针后移，如果下一个结点是头节点，再后移一个
			pCurent = pNext;
			if (pCurent == &(clist->head)) {
				pCurent = pCurent->next;
			}
		}

		pCurent = pCurent->next;
		//如果当前指向头节点，再后移一个
		if (pCurent == &(clist->head)) {
			pCurent = pCurent->next;
		}
		index++;
	}
	if (Size_CircleLinkList(clist) == 1) {
		//只剩下一个结点时，输出该结点
		PrintNode(clist->head.next);
	}else{
		printf("Error!");
	}
}

我认为方法2比方法1好，虽然方法1代码少，但其时间复杂度为O(n^2)，而方法2仅一层while循环，时间复杂度为O(n)。虽然方法2的代码较多，单当你熟练链表的创建、插入和删除等基本操作时，就会发现，用链表解决约瑟夫问题，逻辑会比方法1好理解多。

2、有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数。
思路：把n个数存在数组1里面，然后把最后m个数放到数组2中，再把前面n-m个数依次放在数组2里，然后输出数组2
输入：10 4(n=10, m=4)
输出：
优化目标：无

#include "stdio.h"

int main(){
	
	int n, m;
	scanf("%d%d", &n, &m);
	
	int num1[1024];
	int num2[2024];
	
	for(int i=0; i<n; i++){
		scanf("%d", &num1[i]);//输入n个数
	}
	//把num1最后m个数，放到num2前m个数中
	for(int j=0; j<m; j++){
		num2[j] = num1[n-m+j];
	}
	//把num1前n-m个数，放到num2的m位置开始的后面
	for(int k=0; k<n-m; k++){
		num2[k+m] = num1[k];
	}
	//打印移动后的n个数
	for(int i=0; i<n; i++){
		printf("%d ", num2[i]);
	}
	return 0;
}

3、输入2个字符串str1和str2，要求删除字符串str1中出现的所有子串str2，即结果字符串中不能包含str2。输入在2行中分别给出不超过80个字符长度的、以回车结束的2个非空字符串，对应str1和str2。
思路：先找到子串，然后删除，需要注意的一点是，如果是子串嵌套(ccatat),删除第一个子串后，后面的又拼接成一个子串，这时循环变量需要往前移。
注意事项：题干说输入不超过80个字符长度，由于’\0’也要占一个位置，所以字符数组的长度要大于80，否则在PTA上会有边界情况错误。
输入：Tomcat is a male ccatat
cat
输出：Tom is a male

优化目标：无

#include <stdio.h>
#include <string.h>

#define MAX 1024

int main(){
	char str1[MAX], str2[MAX];//注意容量要大于80，因为‘\0’要占一个字符
	gets(str1);
	gets(str2);
	char c1, c2;
	int index = 0;
	int i = 0, j=0;

	for(i=0; (c1=str1[i])!='\0'; i++){
		if(c1 == str2[0]){//匹配到第一个相等的字符
            index = 0;
			for(j=i; j<i+strlen(str2);j++){//判断后面的字符是否连续相等
				if(str1[j] == str2[j-i]){
					index++;
				}
			}
			//找到子串，然后删除
            if(index == strlen(str2)){
                 for(j=i+strlen(str2); j<strlen(str1); j++){
                    str1[j-strlen(str2)]=str1[j];
                 }
                str1[j - strlen(str2)] = '\0';
			    i = -1;//让i冲头开始
		    }
		}
	}
    
	printf("%s", str1);
	return 0;
}

总结：今天在PTA上写了一些代码，总体不是很顺利，特别是第3题我提到的注意事项，把我坑惨了。后面几天会复写链表和栈，继续学写栈的应用和队列相关知识。