链表例题

NO.1 约瑟夫环问题

采用单向循环表的数据结构，即将链表的尾元素的指针指向链首元素。每个结点除了指针域外，还有两个域分别存放 id 和 password 。

 

约瑟夫环（约瑟夫问题）是一个数学的应用问题：

已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。通常解决这类问题时我们把编号从0~n-1，最后[1]结果+1即为原问题的解。

解决问题的基本步骤：

（1）建立n个结点（无头结点）的单向循环链表；

（2）从链表第一个结点起循环计数寻找第m个结点；

（3）输出该结点的id值；

（4）根据m值不断从链表中删除结点，直到链表为空。

#include<stdio.h>
#include<stdlib.h>
#define MAX 100

typedef struct NodeType        //自定义结构体类型
{
    int id;
    int password;
    struct NodeType *next;        //用于指向下一个结点的指针
}NodeType;

void CreatList(NodeType **, int);    //创建单向循环链表
NodeType *GetNode(int, int);        //得到一个结点
void PrintList(NodeType *);            //打印循环链表
int IsEmptyList(NodeType *);        //判空
void JosephusOperate(NodeType **, int);        //运行环求解

int main(void)
{
    int n = 0;
    int m = 0;
    NodeType *pHead = NULL;
    do
    {
        if (n>MAX)
        {
            printf("人数太多，请重新输入！\n");
        }
        printf("请输入人数n（最多%d个）：", MAX);
        scanf("%d", &n);
    } while (n>MAX);
    printf("请输入初始密码m：");
    scanf("%d", &m);
    CreatList(&pHead, n);        //创建单向循环链表
    printf("\n----------打印循环链表---------\n");
    PrintList(pHead);        //打印链表
    printf("\n----------打印出队情况---------\n");
    JosephusOperate(&pHead, m);        //运行
    return 1;
}

void CreatList(NodeType **ppHead, int n)        //创建有n个结点的循环链表pphead 
{
    int i = 0;
    int iPassword = 0;
    NodeType *pNew = NULL;
    NodeType *pCur = NULL;
    for (i = 1; i <= n; i++)
    {
        printf("输入第%d个人的密码：",i);
        scanf("%d", &iPassword);
        pNew = GetNode(i, iPassword);
        if (*ppHead == NULL)
        {
            *ppHead = pCur = pNew;
            pCur->next = *ppHead;
        }
        else
        {
            pNew->next = pCur->next;
            pCur->next = pNew;
            pCur = pNew;
        }
    }
    printf("完成单向循环链表的创建!\n");
}

NodeType *GetNode(int iId, int iPassword)
{
    NodeType *pNew = NULL;
    pNew = (NodeType *)malloc(sizeof(NodeType));
    if (!pNew)
    {
        printf("Error, the memory is not enough!\n");
        exit(-1);
    }
    pNew->id = iId;
    pNew->password = iPassword;
    pNew->next = NULL;
    return pNew;
}

void PrintList(NodeType *pHead)
{
    NodeType *pCur = pHead;
    if (!IsEmptyList(pHead))
    {
        printf("--ID-- --PASSWORD--\n");
        do
        {
            printf("%3d %7d\n", pCur->id, pCur->password);
            pCur = pCur->next;
        } while (pCur!=pHead);
    }
}

int IsEmptyList(NodeType *pHead)
{
    if (!pHead)
    {
        printf("The list is empty!\n");
        return 1;
    }
    return 0;
}

void JosephusOperate(NodeType **ppHead, int iPassword)
{
    int iCounter = 0;
    int iFlag = 1;
    NodeType *pCur = NULL;
    NodeType *pPrv = NULL;
    NodeType *pDel = NULL;
    pPrv = pCur = *ppHead;
    while (pPrv->next != *ppHead)
    {
        pPrv = pPrv->next;
    }
    while (iFlag)
    {
        for (iCounter = 1; iCounter < iPassword; iCounter++)
        {
            pPrv = pCur;
            pCur = pCur->next;
        }
        if (pPrv==pCur)
        {
            iFlag = 0;
        }
        pDel = pCur;
        pPrv->next = pCur->next;
        pCur = pCur->next;
        iPassword = pDel->password;
        printf("第%d个人出列（密码：%d）\n", pDel->id, pDel->password);
        free(pDel);
    }
    *ppHead = NULL;
    getchar();
}

 2.一元多项式加减计算

#include<stdio.h>
#include<malloc.h>

typedef struct Polynomail
{
    float coef;
    int expn;
    struct Polynomail *next;
}Polyn;

Polyn *creatPoly(void);
void printPoly(Polyn *P);
Polyn *addPoly(Polyn *pa, Polyn *pb);
Polyn *subtractPoly(Polyn *pa, Polyn *pb);

Polyn *subtractPoly(Polyn *pa, Polyn *pb)
{
    Polyn *h = pb;
    Polyn *p = pb->next;
    Polyn *pd;
    while (p)
    {
        p->coef *= -1;
        p = p->next;
    }
    pd = addPoly(pa, h);
    for (p = h->next; p; p = p->next)
        p->coef *= -1;
    return pd;
}

Polyn *addPoly(Polyn *pa, Polyn *pb)
{
    Polyn *qa = pa->next;
    Polyn *qb = pb->next;
    Polyn *headc, *pc, *qc;

    pc = (Polyn *)malloc(sizeof(Polyn));
    pc->next = NULL;
    headc = pc;
    while (qa != NULL && qb != NULL)
    {
        qc = (Polyn *)malloc(sizeof(Polyn));
        if (qa->expn < qb->expn)
        {
            qc->coef = qa->coef;
            qc->expn = qa->expn;
            qa = qa->next;
        }
        else if (qa->expn == qb->expn)
        {
            qc->coef = qa->coef + qb->coef;
            qc->expn = qa->expn;
            qa = qa->next;
            qb = qb->next;
        }
        else
        {
            qc->coef = qb->coef;
            qc->expn = qb->expn;
            qb = qb->next;
        }
        if (qc->coef != 0)
        {
            qc->next = pc->next;
            pc->next = qc;
            pc = qc;
        }
        else
            free(qc);
    }
    while (qa != NULL)
    {
        qc = (Polyn *)malloc(sizeof(Polyn));
        qc->coef = qa->coef;
        qc->expn = qa->expn;
        qa = qa->next;
        qc->next = pc->next;
        pc->next = qc;
        pc = qc;
    }
    while (qb != NULL)
    {
        qc = (Polyn *)malloc(sizeof(Polyn));
        qc->coef = qb->coef;
        qc->expn = qb->expn;
        qb = qb->next;
        qc->next = pc->next;
        pc->next = qc;
        pc = qc;
    }
    return headc;
}

void printPoly(Polyn *P)
{
    Polyn *q = P->next;
    int flag = 1;
    if (!q)
    {
        putchar('0');
        printf("\n");
        return;
    }
    while (q)
    {
        if (q->coef > 0 && flag != 1)
            putchar('+');
        if (q->coef != 1 && q->coef != -1)
        {
            printf("%g", q->coef);
            if (q->expn == 1)
                putchar('X');
            else if (q->expn)
                printf("X^%d", q->expn);
        }
        else
        {
            if (q->coef == 1)
            {
                if (!q->expn)
                    putchar('1');
                else if (q->expn == 1)
                    putchar('X');
                else
                    printf("X^%d", q->expn);
            }
            if (q->coef == -1)
            {
                if (!q->expn)
                    printf("-1");
                else if (q->expn == 1)
                    printf("-X");
                else
                    printf("-X^%d", q->expn);
            }
        }
        q = q->next;
        flag++;
    }
    printf("\n");
}

Polyn *creatPoly(void)    //建立 
{
    Polyn *head, *rear, *s;
    int c, e;

    head = (Polyn *)malloc(sizeof(Polyn));
    rear = head;
    printf("请输入多项式的系数和指数项（0结束输入）");
    scanf("%d%d", &c, &e);
    while (c != 0)
    {
        s = (Polyn *)malloc(sizeof(Polyn));
        s->coef = c;
        s->expn = e;
        rear->next = s;
        rear = s;
        printf("请继续输入多项式的系数和指数项（0结束输入）");
        scanf("%d%d", &c, &e);
    }
    rear->next = NULL;
    return head;
}

int main(void)
{
    Polyn *p1, *p2, *p3, *p4;

    printf("多项式1：\n");
    p1 = creatPoly();
    printf("多项式2：\n");
    p2 = creatPoly();
    printf("您输入的多项式如下所示：\n");
    printPoly(p1);
    printPoly(p2);
    p3 = addPoly(p1, p2);
    p4 = subtractPoly(p1, p2);
    printf("多项式相加后的结果如下：\n");
    printPoly(p3);
    printf("多项式相减后的结果如下：\n");
    printPoly(p4);
}