精华内容
下载资源
问答
  • C语言循环链表

    2012-11-13 11:04:06
    用C实现的一个循环链表,供大家学习学习,希望得到高人指点。一起交流学习
  • C语言循环链表的简单应用,感兴趣的朋友可以看看。
  • /*****************************************************************************本程序对循环链表进行处理,分别对链表的长度进行设定、插入、删除和释放,并且通过对操作者的限制来防止因操作者的操作失误而带来...

    /*****************************************************************************

    本程序对循环链表进行处理,分别对链表的长度进行设定、插入、删除和释放,

    并且通过对操作者的限制来防止因操作者的操作失误而带来的不可设想的后果,本程序

    有较强的安全性程序的细节如下:

    *****************************************************************************/

    #include

    #include

    typedef struct stu                             //定义TYM结构体类型

    {

    char name[20];

    int score;

    struct stu *llink,*rlink;                      //  llink为左链域指针,rlink为右链域指针

    }TYM;

    TYM *Insert(TYM*head)                            //插入结点函数

    {

    int i;

    int pos,len;

    TYM *a,*s,*p,*q;

    printf("*********** Insert *************\n");

    if(head->llink!=NULL)                                                //如果链表存在

    {

    for(p=head->rlink,i=2;p!=head;p=p->rlink,i++);     //检测链表的长度

    printf("Position(No More Than %d): ",i);                //提示输入的值的范围

    scanf("%d",&pos);                                                 //输入插入的位置

    while(pos<0||pos>i)                                                //如果输入负数

    {

    printf("Please enter the correct!\nPosition(No More Than %d): ",i);

    scanf("%d",&pos);                                              //输入插入的位置

    }

    }

    printf("Lenth:\t\t\t  ");

    scanf("%d",&len);                                                       //输入插入的结点个数

    while(len<0)                                                                //如果输入负数

    {

    printf("Please enter the correct!\nLenth:\t\t\t  ");

    scanf("%d",&len);                               //输入插入的结点个数

    }

    if(len==0)  return head;                        //如果插入的结点数是0则返回head

    printf("Name:\tScore:\n");

    a = (TYM*)calloc(1,sizeof(TYM));                 //开辟一个空间,并将空间的首地址给a

    scanf("%s%d",a->name,&a->score);               //对a进行赋值

    for(p=a,i=1;i

    {

    q = (TYM*)malloc(sizeof(TYM));            //开辟一个新的空间

    scanf("%s%d",q->name,&q->score);         //对新空间赋值

    p->rlink = q;                     //使p的右链域指针指向q

    q->llink = p;                   //使q的左链域指针指向p

    p = q;                      //使p指向q

    }

    a->llink = p;                  //使新链表的左链域指针指向最后一个地址

    p->rlink = a;                  //使链表的最后一个变量的右链域指针指向新链表的首地址

    if(head->llink==NULL)  return a;       //如果链表存在,则返回a作首地址

    for(s=head,i=1;i

    {

    s = s->rlink;                    //使s指向右边的下一个结点

    }

    q = s->llink;          //将s的左链域指针的值保存到q中

    p->rlink = s;          //使链表的最后一个变量的右链域指针指向S

    s->llink = p;          //使s的左链域指针指向新链表的最后一个地址

    a->llink = q;          //使新链表的首地址的左链域指针指向q

    q->rlink = a;          //使原链表的断开结点的右链域指针指向新链表的首地址

    return pos==1?a:head;  //如果插入的位置为第一个,则返回a作首地址

    }

    TYM *DeleteNode(TYM *head)    //删除结点函数

    {

    int pos,len,i;

    TYM *s,*Llink,*Rlink;

    if(head->llink==NULL)  return head;     //如里链表不存在则返回head

    for(s=head->rlink,i=1;s!=head;s=s->rlink,i++);    //检测链表的长度

    printf("*********** Delete *************\nPosition(No More Than %d):\t",i);

    scanf("%d",&pos);         //输入要删除的结点的位置

    while(pos<0||pos>i)      //如果输入负数

    {

    printf("Please enter the correct!\nPosition(No More Than %d):\t",i);

    scanf("%d",&pos);         //输入要删除的结点的位置

    }

    printf("Lenth(No More Than %d):\t\t",i);

    scanf("%d",&len);        //输入删除个数

    while(len<0||len>i-pos+1)       //如果输入负数

    {

    printf("Please enter the correct!\nLenth(No More Than %d):\t\t",i);

    scanf("%d",&len);        //输入删除个数

    }

    if(len==0||i==1)   return head;    //如果不删除或只有一个结点则返回head

    for(s=head,i=1;i

    {

    s = s->rlink;

    }

    for(i=0;i

    {

    Llink = s->llink;   //将删除点的左链域指针保存到Llink

    Rlink = s->rlink;  //将删除点的右链域指针保存到Rlink

    Rlink->llink = Llink;  //将删除点的右边连接到左边

    Llink->rlink = Rlink;  //将删除点的左边连接到右边

    free(s);       //释放删除点

    s = Rlink;     //使s指向右边的下一个

    }

    return pos==1?s:head;  //如果插入的是首地址则返回S作首地址

    }

    void Release(TYM *head)     //释放函数

    {

    TYM *p,*q;

    p = head->rlink;        //使p指向首地址的右边第一个地址

    for(q=head;p!=q;head=p) //释放链表

    {

    p = head->rlink;    //p指向右边的下一个地址

    free(head);         //释放当前地址

    }

    if(head==q)             //如果释放完所有结点

    printf("******** Free success! *********\n");

    }

    void Print(TYM *head)    //输出函数

    {

    TYM *p;

    printf("*********** Output: ************\nName\tscore\n");

    for(printf("%s\t%d\n",head->name,head->score),p=head->rlink;p!=head;p=p->rlink)

    {                          //输出整条链表

    printf("%s\t%d\n",p->name,p->score); //输出当前结点的数据

    }

    }

    int main()

    {

    TYM *head,*p,*q;

    int len,i;

    printf("************ Input: ************\n");

    printf("Lenth:\t");

    scanf("%d",&len);                  //输入长度

    while(len<0)                            // 如果输入负数

    {

    printf("Please enter the correct!\n");

    printf("Lenth:\t");

    scanf("%d",&len);

    }

    head = (TYM*)calloc(1,sizeof(TYM));  //开辟一个空间,并使head指向它

    if(len==0)

    {

    head->llink = head->rlink = NULL;    //如果长度为0,则使head的左、右链域指针都为null

    }

    else

    {

    printf("Name:\tScore:\n");

    scanf("%s%d",head->name,&head->score);    //对head赋值

    if(len==1)

    head->llink = head->rlink = head;        //如果长度为1,则使head的左右链域指针都指向本身

    else

    {

    for(p=head,i=1;i

    {

    q = (TYM*)malloc(sizeof(TYM));       //开辟新空间

    scanf("%s%d",q->name,&q->score);    //对新空间赋值

    p->rlink = q;              //使p的右链域指针指向新空间

    q->llink = p;              //使新空间的左链域指针指向p

    p = q;                     //使p指向q

    }

    p->rlink = head;               //使最后一个地址的右链域指针指向首地址

    head->llink = p;               //使首地址的左链域指针指向尾地址

    }

    }

    if(head->llink!=NULL)    Print(head);   //如果链表存在则输出

    head = (TYM*)Insert(head);                //插入结点

    if(head->llink!=NULL)    Print(head);     //如果链表存在则输出

    head = (TYM*)DeleteNode(head);          //删除结点并返回首地址

    if(head->llink!=NULL)                             //如链表存在

    {

    Print(head);                                     //输出链表

    Release(head);                                      //释放链表

    }

    else free(head);                                          //释放head

    return 0;

    }

    /*************************************** 调试窗口 *********************************************/

    e910e29c19ac97c4fb496d26847f7b1c.png

    展开全文
  • c语言循环链表,一开始用头结点作为开端,创建一连串的节点,到最后一个节点的next指向head的下一个节点可以么。代码如下,虚心求教。 #include #include #define N 6 #define M 5 struct people { int num; ...
  • C语言循环链表的头节点是定义成变量好,还是定义成结构体好?
  • c语言循环链表的实现

    千次阅读 多人点赞 2018-09-01 13:22:57
    单链表有一定的缺陷,就是单向性,只能从一个结点到下一个节点,而不能访问到上一个结点,而循环链表就可以解决这一问题,当然,用双向链表更加方便 #include &lt;stdio.h&gt; #include &lt;stdlib.h&...

    单链表有一定的缺陷,就是单向性,只能从一个结点到下一个节点,而不能访问到上一个结点,而循环链表就可以解决这一问题,当然,用双向链表更加方便

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct node
    {
        int data;
        struct node *next;//指针域
        int size;//循环链表的长度
    }node,*linklist;//linklist为定义的指针结构体变量
    
    void create_list_head(linklist *l)//头插法建立循环链表
    {
        int i,j,x;
        linklist p,q;
        printf("please input length");
        scanf("%d",&j);
        (*l)=(node*)malloc(sizeof(node));
        (*l)->next=NULL;//必须定义,缺少error
        (*l)->size=j;
        for(i=0;i<j;i++)//头插法输入数据
        {
            scanf("%d",&x);
            p=(node*)malloc(sizeof(node));
            p->data=x;
            p->next=(*l)->next;
            (*l)->next=p;
        }
        //q=(node*)malloc(sizeof(node));
        q=(*l)->next;
        while(q->next!=NULL)//找到最后一个结点
        {
            q=q->next;
        }
        //printf("%d",q->data);
        q->next=(*l)->next;//将最后一个结点指向第一个结点
    
    
    
    }
    
    void create_list_tail(linklist *l)//尾插法建立循环链表
    {
        int i,j,x;
        linklist p,r,t;
        printf("please input the length");
        scanf("%d",&j);
        (*l)=(node*)malloc(sizeof(node));
        (*l)->next=NULL;
        (*l)->size=j;
        t=(*l);
        for(i=0;i<j;i++)
        {
            scanf("%d",&x);
            p=(node*)malloc(sizeof(node));
            p->data=x;
            t->next=p;
            t=p;//每新建一个结点在结束时都为最后一个结点,下一个节点在这个结点后面插入
    
        }
        t->next=NULL;
        r=(*l)->next;
        while(r->next!=NULL)
        {
            r=r->next;
        }
        r->next=(*l)->next;
    }
    
    void print_list_he(linklist *l)//打印输出
    {
        int i;
        linklist p;
        p=(*l)->next;
        for(i=0;i<(*l)->size;i++)
        {
            printf("%d\n",p->data);
            p=p->next;
        }
    }
    
    int main()
    {
        linklist a;
        create_list_head(&a);
        create_list_tail(&a);
        print_list_he(&a);
        return 0;
    }

     

    展开全文
  • 循环链表解决约瑟夫问题 题目不是很难啦,单纯记录一下自己学习的足迹。 如果对于需要的人能有帮助,那真是再好不过了嘻嘻♪(・ω・)ノ 题目 代码 #include<stdio.h> #include<stdlib.h> #...

    ecnu数据结构月考题:

    循环链表解决约瑟夫问题

    题目不是很难啦,单纯记录一下自己学习的足迹。
    如果对于需要的人能有帮助,那真是再好不过了嘻嘻♪(・ω・)ノ

    题目

    在这里插入图片描述
    在这里插入图片描述

    代码

    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    
    struct node{
        int name;
        struct node*next;
        };
    
    int main()
    {
        int n,m;
        struct node*head =(struct node*) malloc(sizeof(struct node));
        struct node*p,*q;
        int counts=1;
        int i;
    
        printf("This is a YSF(n,m) problem.\n");
        printf("Please input the integer n (n>=1).\n");
        scanf("%d",&n);
        printf("Please input the integer m (m>=1).\n");
        scanf("%d",&m);
    
        p=head;
        head->name=1;
        for(i=2;i<=n;i++){	//创建链表,并为每个结点编号。
            p->next=(struct node*)malloc(sizeof(struct node));
            p=p->next;
            p->name=i;
        }
        p->next=head;		//尾结点指针域指向头结点,构成环形链表。
    
        q=p;
        p=head;				//此时p指向头结点,q指向头结点的前一个结点。
        
        while(p!=p->next){		//跳出循环时,环形链表中只剩一个结点,指针域指向自身。
            for(counts=1;counts<m;counts++){//跳出循环时,p指向的是该被删除的结点。
                p=p->next;
                q=q->next;
            }
            printf("Get rid of : %d\n",p->name);
            q->next=p->next;
            p=p->next;			//把p指向的结点在链表中删除。
        }
        printf("The left element is : %d\n",p->name);
        return 0;
    }
    
    
    展开全文
  • 最近学习数据结构,需要用单循环链表解决约瑟夫问题,遇到了一些困难,记录一下。 1。构建的链表是否应该有头节点? 对于普通的单链表,我们设置头节点会带来很多方便,但是对于循环链表,因为我们要进行循环,但是...

    最近学习数据结构,需要用单循环链表解决约瑟夫问题,遇到了一些困难,记录一下。
    1。构建的链表是否应该有头节点?
    对于普通的单链表,我们设置头节点会带来很多方便,但是对于循环链表,因为我们要进行循环,但是我们不希望头节点加入进来,因此,我们最好是构建不含头结点的链表。
    2.单循环链表的构建。
    由于之前构建的链表是单链表,在构建循环链表时,尾节点与头指针的相连的方法。

    List* creatList()
    {
        int i = 0,data = 0;
        List* pHead = NULL,*pEnd = NULL,*pNew = NULL;
        for(i=0; i<5; i++)
        {
            pNew = (List*)malloc(sizeof(List));
            if(NULL == pNew)
            {
                printf("分配内存失败");
            }
            if(NULL == pHead)
            {
                pHead = pNew;
            }
            else
            {
                pEnd->pNext = pNew;
            }
            pEnd = pNew;
            printf("请输入节点元素的值:");
            scanf("%d",&data);
            pNew->data = data;
            length++;
        }
        pNew->pNext = pHead;//将尾节点的next域指向链表头
        return pHead;
    }
    

    通过最后将尾部节点的next域与链表头相连,实现循环链表的构建。可能是自己很少写链表结构,构建起来跟不熟练,自己总结关于链表的构建技巧:必须要声明一个尾指针,这个指针负责连接新建节点。
    3.找到指定位置,对指定位置节点进行删除。
    这一点比较好解决,用两个循环,一个循环让位于链表头的指针指向起始位置,另一个循环让位于起始位置的指针根据报数移动到相应位置。然后将这的位置的节点进行删除。
    在删除时要注意,我们需要两个指针,一个指针pPre指向要删除节点的前一个节点,另一个指针p指向要删除节点。然后pPre->next = p->next; 将p所指向的节点从链表中删掉,然后free(p),释放掉p所占的内存空间。然后要让p继续作为pPre的后继,所以,p = pPre->next;
    4,如果我们选中的是从头结点开始就删除,那怎末办?
    在写程序时,这个方面没有处理好,产生了bug
    根据3,需要一个指针指向所选节点,所以,在一开始,最好的方法就是让pPre指向尾节点,然后进行两次循环。
    ok,上代码

    void Joseph(List* pHead,int n,int m,int position)
    {
    
        if(n<m||m<1)
        {
            printf("报数间隔出错\n");
            exit(1);
        }
        if(n<position||position<1)
        {
            printf("起始位置出错\n");
            exit(1);
        }
        List* pFind = NULL;
        List* pPreFind = NULL;//用于表示pFind的上一个节点,并且开始时需要指向尾节点
        pPreFind = pHead;
        int k;
        for(k=1;k<length;k++)//指向尾节点
        {
            pPreFind = pPreFind->pNext;
        }
        pFind = pHead;//pFind指向头节点
        int i,j;
        for(i=1; i<position; i++)//移动到起始位置
        {
            pPreFind= pFind;
            pFind = pFind->pNext;
        }
    
        while(pFind->pNext!=pFind)
        {
            for(j = 1; j<m; j++)//移动规定位置
            {
                pPreFind = pFind;
                pFind = pFind->pNext;
            }
            pPreFind->pNext = pFind->pNext;//删除节点
            printf("%d出列",pFind->data);
            free(pFind);
            pFind = pPreFind->pNext;
        }
       printf("%d最后",pFind->data);
       free(pFind);
    }
    
    展开全文
  • #include <stdio.h> #include <stdlib.h>...// 创建一个循环链表 ,赋予的值分别为1,2,3,4.... LINKLIST *head = (LINKLIST*)malloc(sizeof(LINKLIST)); LINKLIST *p = head; he
  •  /*打印链表,并检查循环链表是不输入正确*/ for(i=1;i { for(j=1;j { r=p; p=p->next; } printf("出局人:%d\n",p->data); r->next=p->next; } } void main() { int x, z; printf("请输入总人数:"); scanf("%d",&...
  • 几乎不使用库函数,利用数据结构知识和C语言来写的循环链表电话本小程序
  • C语言循环链表实现

    2016-04-13 00:26:53
    现在把这两天完成的循环链表的程序发上来,供大家参阅。 循环单链表相对与单链表仅仅只是tail指向了header。这样便形成了一个环。循环链表的应用比较多,特别是在内存容量很小的单片机上,显得由为重要。 只怪...
  • 常见解决方法,递归或循环链表模拟循环链表模拟代码#include&lt;stdio.h&gt; //以30个人为例 ,每7个人出列为例 #include&lt;malloc.h&gt; #define elemtype int #define status int #define o...
  • 循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点,整个链表形成一个环。 循环链表的操作 1,循环链表的新操作 2, 获取当前游标指向的数据元素 3, 将游标重置指向链表中...
  • C语言写滴,有用到结构体,链表,有注释,很容易理解 猴子选大王 
  • 编号为1,2,3,…,n的n个人按顺序针方向围坐一张圆桌旁,每个人手中持有 ...首先输入一个正整数作为报数上限值m,然后,从第一个人开始按顺序针方向自1开始...用单循环链表来解决这一问题,实现的方法首先要定义链表结点,
  • 问题:用循环链表模拟约瑟夫问题,把41个人自杀的顺序编号输出。 代码展示 #include #include typedef struct node { int data; struct node *next; }node; node *create(int n) { node *p = NULL, *head; head = ...
  • c语言循环链表的问题

    2015-06-05 23:29:00
    今天,老师说了一道题,大意是,有一群小朋友10个人,但是老师只有一个苹果,只能给一个小朋友,于是老师...然后老师要求这个问题用循环链表解决,自己也顺带复习一下,直接上代码 struct data { int num; struct d...
  • #include "stdafx.h" #include #include //-------------------------------------------------------- typedef struct jos { int order; int mima;//每个人的密码 struct jos *link; }Node;
  • 根据小甲鱼的视频 自己写的约瑟夫环。
  • C语言循环链表创建,遍历,插入,删除,查找

    万次阅读 多人点赞 2018-09-08 22:26:53
    在开始程序之前说一个困扰的几天的东西,在链表做形参的时候什么时候用(**p)什么时候用(*p) 答案:只要是要修改head指针必须传递head的地址(用**p),否则传递head值即可(*p)。这与普通变量类似,当需要修改...
  • 约瑟夫环问题(C语言循环链表)

    千次阅读 多人点赞 2018-05-02 15:37:31
    一:问题描述约瑟夫环问题是一个数学的应用问题:...二:算法原理约瑟夫环运作如下:1:一群人围坐在一起成环状2:从某个编号开始报数(如:k)3:数到某个数(如:m)的时候,此人出列,下一个人重新报数4:一直循环...
  • C语言循环链表约瑟夫环问题

    千次阅读 2013-07-09 20:50:16
    本实验最难的部分是循环链表的建立过程,其余的都只是很简单的部分,先不讲了,看代码应该会好理解的。 # include # include typedef struct node { int number; struct node *next; }Lnode,*Linklist; ...
  • /******************************project :数据结构*function :循环链表之俄罗斯赌盘*Author :Rookie Uzz******************************copyright:2019.2.27 by UZT****************************/ 1 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,493
精华内容 997
关键字:

c语言循环链表

c语言 订阅