2020数据结构课程设计【12.14】

1.线性结构（链表）题目-约瑟夫环

题目要求：
任务：编号是1,2,…,n的n个人按照顺时针方向围坐一圈，每个人只有一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个仍开始顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他在顺时针方向的下一个人开始重新从1报数，如此下去，直到所有人全部出列为止。设计一个程序来求出出列顺序。
要求：利用单向循环链表存储结构模拟此过程，按照出列的顺序输出各个人的编号。
测试数据：m的初值为20，n=7 ，7个人的密码依次为3，1，7，2，4，7，4，首先m=6，则正确的输出是什么？
要求：输入数据：建立输入处理输入数据，输入m的初值，n ，输入每个人的密码，建立单循环链表。
输出形式：建立一个输出函数，将正确的输出序列
数据结构：
typedef struct Node
{
int data;
int password;
struct Node *next;
}Node, *LinkList;
基本操作：初始化单链表；给每个人赋密码；确定需要处理的人数；确定开始的上限值；得到正确的顺序；输出结果。

思路：循环报数问题的升级版，在一次出列后要把查找次数m变成出列人的密码。因为涉及删除节点，故采用的时查找出列的上一个节点，然后写一个删除后继节点的函数。在建立链表后返回最后一个节点，以保证循环次数与节点编号一致 。问题关键在于正确的寻找节点，要求循环变量查找m-1次找到目的节点，故当m=1时需要特殊判断。其余时候只需向后再递推一个节点即可。

代码：

#include <bits/stdc++.h>

using namespace std;

typedef struct Node
{
    int data;//编号
    int password;//密码
    struct Node *next;
}Linknode,*Linklist;

int m,n;

Linknode* createlink(int n)//尾插法建立单循环报数链表
{
    int x;
    Linknode *p,*h,*r;
    h=new Linknode;
    h->next=NULL;
    r=h;
    for(int i=1;i<=n;i++){
        p=new Linknode;
        p->data=i;
        cin>>x;
        p->password=x;
        r->next=p;
        r=p;
    }
    p=h->next;
    r->next=p;
    return r;//返回首节点的前驱，让查找次数与编号一致
}

void OutLink(Linklist s)//出列下一个人的函数
{
    cout<<s->next->data<<" ";//输出出列编号
    m=s->next->password;//报数更新为出列人的密码
    s->next=s->next->next;//删除出列节点
    n--;
}

int main()
{
    cin>>m>>n;
    Linknode *p=createlink(n);
    int cnt=0;//设一循环变量
    while(n>0){
        if(cnt==m-1){//查找出列人的上一个节点
            OutLink(p);
            cnt=0;//循环变量归零，重新报数
        }
        if(m!=1){//m=1时需要特判，不需要再次向下循环
            p=p->next;
            cnt++;
        }
    }
    return 0;
}

3.树形结构 题目-二叉树的构造

题目要求：
任务：已知二叉树的层序和中序遍历序列，或已知二叉树的先序序列、中序序列，试编写算法建立该二叉树（ 用递归或非递归的方法都可以）。
要求：能够输入树的各个结点，并能够输出用不同方法遍历的遍历序列；分别建立建立二叉树存储结构的的输入函数、输出层序遍历序列的函数、输出先序遍历序列的函数；

思路：利用已有的知识和思路写出各种建树方法与遍历方法。

先序中序：先序先遍历的一定是根节点，故在中序序列中找到先序的第一个节点，并以该节点为中心，左侧遍历建左子树，右侧遍历建右子树即可。

中序层序：二叉树的根节点在层次遍历序列中要先于其子树首先被访问，所以层次遍历序列中第一个与中序序列中匹配的字符为中序序列的根结点。

代码：

#include <bits/stdc++.h>

using namespace std;

struct node//二叉树
{
    char data;
    struct node *lchild,*rchild;
};

typedef struct Queue//队列
{
    node *head;
    node *tail;
    int length;
}Queue;

int n;
char in[100];//先序遍历序列
char pre[100];//中序遍历序列
char level[100];//层序遍历序列


node *CreateTree_inpre(int index,int instart,int inend)//先序中序建树
{
    node *root=NULL;
    int mid=-1;//mid变量指示根节点的位置
    for(int i=instart;i<=inend;i++){//在中序序列中找到根节点位置
        if(pre[index]==in[i]){
            mid=i;
            break;
        }
    }
    if(mid!=-1){
        root=new node;//根节点创建
        root->data=pre[index];
        root->lchild=CreateTree_inpre(index+1,instart,mid-1);//递归建立左子树
        root->rchild=CreateTree_inpre(index+mid-instart+1,mid+1,inend);//递归建立右子树
    }
    return root;
}

node *CreateTree_inlevel(int l1,int r1,int l2,int r2)//中序层序建树
{
    if(l2>r2)//中序序列遍历完毕未找到根节点返回NULL
        return NULL;
    node *root=NULL;
    int flag=0,i,j;
    for(i=l1;i<=r1;i++){//在中序序列里找层序的元素，第一个相同的即是根节点
        for(j=l2;j<=r2;j++){
            if(level[i]==in[j])
            {
                flag=1;
                break;
            }
        }
        if(flag==1)
            break;
    }
    root=new node;
    root->data=level[i];
    root->lchild=CreateTree_inlevel(l1+1,r1,l2,j-1);//左子树在根节点左侧遍历
    root->rchild=CreateTree_inlevel(l1+1,r1,j+1,r2);//右子树在根节点右侧遍历
    return root;
}

int InitQueue(Queue &Q)//队列初始化函数
{
    Q.head=(node*)malloc(n*sizeof(node));
    if(!Q.head)
        return 0;
    Q.tail=Q.head;
    Q.length=n;
    return 1;
}

bool EmptyQueue(Queue Q)//判断队空函数
{
    if(Q.tail==Q.head)
        return 1;
    else return 0;
}

int InQueue(Queue &Q,struct node p)//入队函数
{
    if((Q.tail-Q.head+n)%n==n-1)
    	return 0;
    *Q.tail=p;
    Q.tail++;
    return 1;
}

int OutQueue(Queue &Q,struct node &p)//出队函数
{
    if(Q.head==Q.tail)
        return 0;
    p=*Q.head;
    Q.head++;
    return 1;
}

int LevelOrder(struct node *root)//层序遍历函数
{
    if(root==NULL)
        return 0;
    Queue Q;
    node p;
    InitQueue(Q);
    InQueue(Q,*root);
    while(!EmptyQueue(Q)){
        OutQueue(Q,p);
        cout<<p.data;
        if(p.lchild)
            InQueue(Q,*p.lchild);
        if(p.rchild)
            InQueue(Q,*p.rchild);
    }
    return 1;
}

void preorder(struct node* root)//先序遍历函数
{
    if(root){
        cout<<root->data;
        preorder(root->lchild);
        preorder(root->rchild);
    }
}

void inorder(struct node* root)//中序遍历函数
{
    if(root){
        preorder(root->lchild);
        cout<<root->data;
        preorder(root->rchild);
    }
}

void postorder(struct node* root)//后序遍历函数
{
    if(root){
        preorder(root->lchild);
        preorder(root->rchild);
        cout<<root->data;
    }
}

int main()
{
    node* root=NULL;
    cout<<"请输入二叉树的节点数:\n";
    cin>>n;
    cout<<"请输入二叉树的建立方式:\n1表示已知先序与中序遍历序列\n2表示已知中序与层序遍历序列\n";
    int f1;
    cin>>f1;
    switch(f1){
        case 1:{
            cout<<"请输入先序遍历序列:\n";
            cin>>pre;
            cout<<"请输入中序遍历序列:\n";
            cin>>in;
            root=CreateTree_inpre(0,0,n-1);
            break;
        }
        case 2:{
            cout<<"请输入中序遍历序列:\n";
            cin>>in;
            cout<<"请输入层序遍历序列:\n";
            cin>>level;
            root=CreateTree_inlevel(0,n-1,0,n-1);
            break;
        }
    }
    cout<<"请输出二叉树的遍历方式:\n1表示先序遍历\n2表示中序遍历\n3表示后序遍历\n4表示层序遍历\n";
    int f2;
    cin>>f2;
    switch(f2){
        case 1:{
            cout<<"先序遍历序列:\n";
            preorder(root);
            break;
        }
        case 2:{
            cout<<"中序遍历序列:\n";
            inorder(root);
            break;
        }
        case 3:{
            cout<<"后序遍历序列:\n";
            postorder(root);
            break;
        }
        case 4:{
            cout<<"层序遍历序列:\n";
            LevelOrder(root);
            break;
        }
    }
    return 0;
}