带密码的约瑟夫杀人环

实验任务

建立一个顺序表存放10位学生信息(学号、姓名、班级)，并输出第5位同学的信息。

建立一个循环单链表，存入输入的10个字母，并输出第一次出现的某一个字母的位置。

带密码的约瑟夫杀人环

测试数据：m=20，n=7，密码：3，1，7，2，4，8，4

正确输出：6，1，4，7，2，3，5

1.建立一个顺序表存放10位学生信息(学号、姓名、班级)，并输出第5位同学的信息。

文件:

info.txt 存放学生信息

head.h 存储结构的声明

main.c 主程序

思路：

运行结果：

info.txt

Ahoj1
CS1
41709310111
Ahoj2
CS1
41709310112
Ahoj3
CS1
41709310113
Ahoj4
CS1
41709310114
Ahoj5
CS1
41709310115
Ahoj6
CS1
41709310116
Ahoj7
CS1
41709310117
Ahoj8
CS1
41709310118
Ahoj9
CS1
41709310119
Ahoj10
CS1
41709310110

head.h

//
//  head.h
//  1学生成绩
//
//  Created by hanoi_ahoj on 2018/9/28.
//  Copyright © 2018年 hanoi_ahoj. All rights reserved.
//

#ifndef head_h
#define head_h

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

typedef struct Student
{
    char* stu_class;    //班级
    char* stu_id;       //学号
    char* stu_name;     //学生姓名
}Stu;

#define ElemType Stu
#define MAXSIZE 100

typedef struct
{
    ElemType elem[MAXSIZE];
    int last;
}SeqList;

#endif /* head_h */

main.c

//
//  main.c
//  1学生成绩
//
//  Created by hanoi_ahoj on 2018/9/28.
//  Copyright © 2018年 hanoi_ahoj. All rights reserved.
//
#include "head.h"
#define FILE_PATH "info.txt"

void init(SeqList *L)
{
    FILE *fp = fopen(FILE_PATH, "r");
    if(NULL == fp)
    {
        exit(0);
    }
    for (int i=0; i<L->last; i++)
    {
        L->elem[i].stu_name = (char *)malloc(20);
        L->elem[i].stu_id = (char *)malloc(20);
        L->elem[i].stu_class = (char *)malloc(20);
        
        fscanf(fp, "%[^\n]%*c\n" , L->elem[i].stu_name);
        fscanf(fp, "%[^\n]%*c\n" , L->elem[i].stu_class);
        fscanf(fp, "%[^\n]%*c\n" , L->elem[i].stu_id);
    }
    
    fclose(fp);
}

void show_one_info(SeqList *L,int n)
{
    n=n-1;
    printf("%s\t\t",L->elem[n].stu_name);
    printf("%s\t\t",L->elem[n].stu_class);
    printf("%s\n",L->elem[n].stu_id);
}

void show_tittle()
{
    printf("姓名\t\t");
    printf("班级\t\t");
    printf("学号\n");
}

void show_all_info(SeqList *L)
{
    for (int i=0; i<L->last; i++)
    {
        printf("%s\t\t",L->elem[i].stu_name);
        printf("%s\t\t",L->elem[i].stu_class);
        printf("%s\n",L->elem[i].stu_id);
    }
}

int main(int argc, const char * argv[])
{
    printf("需要录入多少名同学信息?>");
    int n = 0;
    scanf("%d",&n);
    
    SeqList L;
    L.last = n;
    
    init(&L);
    printf("%d名学生信息录入完成，你想查看哪一位同学信息?>",n);
    scanf("%d",&n);
    
    show_tittle();
    show_one_info(&L,n);
    
    return 0;
}

2.建立一个循环单链表，存入输入的10个字母，并输出第一次出现的某一个字母的位置。

文件 main.c

我这里默认的是查找 **‘d’**在输入中第一次出现的位置

思路：

这个题目的主要目的是练习循环单链表的创建以及查找。

创建循环单链表只需在申请完最后一个节点后，把最后一个节点的next指向头节点。

查找：我在代码中使用一个工作指针p直接指向第一个节点，当p遇到下一个节点是头节点的时候就停止查找，然后输出。

运行结果：

main.c

//
//  main.c
//  2循环单链表
//
//  Created by hanoi_ahoj on 2018/9/28.
//  Copyright © 2018年 hanoi_ahoj. All rights reserved.
//

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

#define ElemType int
#define MAXSIZE 100

typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node, *LinkedList;

void InitLinkedList(LinkedList * CL)
{
    *CL = (LinkedList)malloc(sizeof(Node));
    (*CL)->next = *CL;
}

void CreateLinkedList(LinkedList CL)
{
    Node *rear, *s;
    rear = CL;
    char ch;
    while ((ch=getchar())!='$')
    {
        s=(Node *)malloc(sizeof(Node));
        s->data = ch;
        rear->next = s;
        rear = s;
    }
    rear->next = CL;
}

void ShowLinkedListData(LinkedList *L)
{
    Node *p = (*L)->next;
    while (p != *L)
    {
        printf("%c ",p->data);
        p = p->next;
    }
    printf("\n");
}

int FindData(LinkedList *L, char e)
{
    int i = 1;
    Node *p = (*L)->next;
    
    while (p != *L)
    {
        if (e == p->data)
        {
            return i;
        }
        else
        {
            p = p->next;
            i++;
        }
    }
    
    return i;
}

int main(int argc, const char * argv[])
{
    LinkedList L;
    InitLinkedList(&L);
    
    CreateLinkedList(L);
    ShowLinkedListData(&L);
    
    printf("%d\n",FindData(&L, 'd'));
    
    return 0;
}

3.带密码的约瑟夫杀人环。

文件 main.c

这里我把测试数据直接放在程序里了

思路：

节点结构，每个人一个编号和一个密码，还有指向下一个人的节点。

在GAME函数中

工作指针p寻找要kill的那个人

找到后保存这个人手上的密码，输出这个人的编号

临时指针q指向这个人，把下一个人的编号密码给工作指针p

kill q指向的这个人，继续用密码寻找下一个。

运行结果：

main.c

//
//  main.c
//  3约瑟夫环
//
//  Created by hanoi_ahoj on 2018/9/28.
//  Copyright © 2018年 hanoi_ahoj. All rights reserved.
//

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

#define ElemType int

typedef struct Node
{
    ElemType number;
    ElemType password;
    struct Node* next;
}Node, *LinkedList;

void InitLinkedList(LinkedList * L)
{
    *L = (LinkedList)malloc(sizeof(Node));
    (*L)->next = *L;
}

void ShowLinkedListData(LinkedList *L)
{
    Node *p = (*L)->next;
    while (p != *L)
    {
        printf("%d ",p->number);
        printf("%d ",p->password);
        printf("\n");
        p = p->next;
    }
}

void CreateJoeph(LinkedList *L,int len, int m[])
{
    Node *rear, *s;
    rear = *L;
    for (int i=0; i<len; i++)
    {
        s=(Node *)malloc(sizeof(Node));
        s->number = i+1;
        s->password = m[i];
        rear->next = s;
        rear = s;
    }
    rear->next = (*L)->next;
}

void GAME(LinkedList *L, int len, int begain)
{
    Node *p;
    Node *q;
    p = (*L)->next;
    for (int i=1; i<=len; i++)
    {
        for (int i=1; i<begain; i++)
        {
            p = p->next;
        }
        begain = p->password;
        printf("%d ",p->number);
        p->number = p->next->number;
        p->password = p->next->password;
        q = p->next;
        p->next = p->next->next;
        free(q);
    }
}

int main(int argc, const char * argv[])
{
    LinkedList L;
    InitLinkedList(&L);
    
    int begain = 20;
    int len = 7;
    int pwd[7] = {3,1,7,2,4,8,4};
    CreateJoeph(&L, len, pwd);
    //ShowLinkedListData(&L);
    GAME(&L, len, begain);
    
    return 0;
}

带密码的约瑟夫杀人环

实验任务

1.建立一个顺序表存放10位学生信息(学号、姓名、班级)，并输出第5位同学的信息。

2.建立一个循环单链表，存入输入的10个字母，并输出第一次出现的某一个字母的位置。

3.带密码的约瑟夫杀人环。

4.转载请随意

猜你喜欢