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

    2014-08-14 19:56:52
    自己写的双向循环链表,感觉写得不怎么样,有需要可以下,反正也不要分
  • c语言双向循环链表

    2015-06-07 20:09:00
    双向循环链表,先来说说双向链表,双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继...

    双向循环链表,先来说说双向链表,双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点.而循环链表之前也有说过,单链表中就是让最后一个结点的指针指向第一个结点就能构成一个循环链表,这里其实也是一样的,只不过多了一步,让第一个结点的前驱指向最后一个结点就行了,(这里介绍的是带头结点的双向循环链表,所以用第一个结点和头结点来区分两者).下面直接看看怎么创建一个带头结点的双向循环链表吧.

     1 #include<stdio.h>
     2 #include<stdlib.h>
     3 struct data
     4 {
     5     int num;
     6     struct data *front;                                        //指向它之前的结点
     7     struct data *next;                                        //指向它之后的结点
     8 };
     9 int main()
    10 {
    11     int n=1;
    12     struct data *p,*p1,*head;
    13     p=head=(struct data *)malloc(sizeof(struct data));    //创建一个带头结点的双向循环链表
    14     p->next=NULL;                                        //开始的时候把指向前面的和后面的指针都置为空
    15     p->front=NULL;
    16     p1=(struct data *)malloc(sizeof(struct data));        //创建新结点,向链表中添加数据
    17     p1->num=1;                                            
    18     while(n<=10)
    19     {
    20         n++;
    21         p->next=p1;                                        //让前一个结点p的尾指针指向这个结点p1
    22         p1->front=p;                                    //这个结点的头指针指向前一个结点
    23         p=p1;                                            //p1变为p
    24         p1=(struct data *)malloc(sizeof(struct data));    //创建新的结点p1,给其赋值并重复上面的循环
    25         p1->num=n;
    26     }
    27     p->next=head->next;                                //最后,由于是带头结点的双循环链表,所以要让最后一个结点的尾指针指向head之后的那个结点
    28     head->next->front=p;                            //让head之后的那个结点的头指针指向尾结点
    29     free(p1);
    30     return 0;
    31 
    32 }

    双向循环链表可以随时访问任何一个结点的前一个结点,所以,用来查找会很方便.它的删除和添加和单链表的操作差不多,只不过需要注意,有两个指针域,要分别让他们重新指向新的结点.还有一点需要注意,就是如果要删除的结点是第一个结点的话,需要让头结点重新指向.来一小段代码吧

     1 while(1)                        //循环寻找需要删除的结点
     2     {
     3         if(p->num==5)                    //寻找的条件
     4         {
     5             if(head->next==p)            //判断删除的结点是不是第一个结点
     6             {
     7                 head->next=p->next;        //如果是第一个结点,让头结点指向它之后的结点
     8             }
     9             p->front->next=p->next;            //当前结点的前一个结点为p->front,让它指向当前结点的下一个结点p->next
    10             p->next->front=p->front;        //让当前结点p的下一个结点p->next的前驱指向它的前一个结点p->front;这样就删掉了这个结点
    11             break;
    12         }
    13         p=p->next;
    14         
    15     }

    OK,好好加油! ! ! ^_^

    转载于:https://www.cnblogs.com/kingos/p/4559002.html

    展开全文
  • C语言双向循环链表

    2019-04-25 17:14:53
    struct Student *creat(void) //创建双向循环链表 { struct Student *head, *p1, *p2; int i, w; head = LINE malloc(sizeof(struct Student)); //给head分配内存空间 head->num = 0; head->score = 0.0; //对...

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #define LINE (struct Student *)

    struct Student
    {
    int num;
    float score;
    /char name[20];/
    struct Student *next;
    struct Student *prior;
    };

    static int n = 0;

    struct Student *creat(void) //创建双向循环链表
    {
    struct Student *head, *p1, *p2;
    int i, w;
    head = LINE malloc(sizeof(struct Student)); //给head分配内存空间
    head->num = 0;
    head->score = 0.0; //对head数据进行初始化
    head->next = head;
    head->prior = head; //head头和尾都指向自己本身
    p1 = p2 = head;
    printf(“请输入节点个数:\n”);
    scanf("%d", &w);
    printf("----请输入学号和成绩----\n"); //循环创建节点
    for (i = 0; i<w; i++)
    {
    p1->next = LINE malloc(sizeof(struct Student)); //为p1分配地址空间
    scanf("%ld%5f", &p1->next->num, &p1->next->score);
    p1 = p1->next; //给p1的赋值
    p1->prior = p2; //p1的头部指向p2
    p2 = p2->next; //p2尾部指向p1
    }
    p1->next = head; //p1最后的尾部重新回到head实现循环
    head->prior = p1; //head头部指向p1实现双向循环
    return head;
    }

    int getListlength(struct Student *node) //获取链表长度
    {
    struct Student *length;
    int len = 0; //统计链表的节点个数
    length = node->next; //length指向第一个节点
    while (length != node) //直到length循环链表一圈
    {
    len++;
    length = length->next; //指向下一节点
    }
    return len; //返回链表长度
    }
    struct Student *node(struct Student *node, int n) //寻找目标节点
    {
    struct Student *p;
    int i;
    p = node;
    for (i = 0; i <n; i++)
    {
    p = p->next; //遍历寻找节点
    }
    return p; //找到后返回该节点
    }

    void print_nodeshun(struct Student *head) //顺序输出节点
    {
    struct Student *p;
    p = head->next;
    printf("----链表内容输出如下----:\n");
    if (head != NULL)
    {
    do{
    printf("%ld,%5.1f\n", p->num, p->score);
    //p = p->prior; //指向前一个节点并输出
    p = p->next; //指向后一个节点并输出
    _sleep(500);
    } while (p->num != 0); //循环输出
    }
    }

    void print_nodeni(struct Student *head) //逆序输出节点
    {
    struct Student *p;
    p = head->prior;
    printf("----链表内容输出如下----:\n");
    if (head != NULL)
    {
    do{
    printf("%ld,%5.1f\n", p->num, p->score);
    p = p->prior; //指向前一个节点并输出
    //p = p->next; //指向后一个节点并输出
    _sleep(500);
    } while (p->num != 0);

    }
    

    }
    void add_node(struct Student *p, int n) //添加节点
    {
    struct Student *q, *New;
    q = node(p, n); //目标节点
    New = LINE malloc(sizeof(struct Student)); //为新节点分配空间
    printf(“请给新增的节点输入数据:\n”);
    scanf("%ld%f", &New->num, &New->score); //新节点输入数据
    New->next = q; //新节点的尾部指向原节点
    New->prior = q->prior; //新节点的首部指向原节点首部

    q->prior->next = New;                                     //原节点的上一节点的next指向新节点
    //原节点的上一节点的prior不变
    
    q->prior = New;                                             //原节点prior指向新节点
    原节点next不变
    

    }

    void delete_node(struct Student *p, int n) //删除节点
    {
    struct Student *q;
    q = node(p, n); //获取需要删除的节点
    q->prior->next = q->next; //该节点的上一节点(next)指向该节点的下一节点
    q->next->prior = q->prior; //该节点的下一节点(prior)指向该节点的上一节点

    free(q);                                                     //释放该节点所占据的内存
    

    }

    void change_node(struct Student *p, int n) //修改节点
    {
    struct Student *ch;
    int num;
    float score;
    ch = node(p, n); //获取需要修改数据的节点
    printf(“该节点目前数据是:\n%ld%5.1f\n”, ch->num, ch->score);
    printf(“请输入数据:\n”);
    scanf("%ld%f", &num, &score);
    ch->num = num; ch->score = score; //将变量的值赋给源节点
    printf(“修改后的数据为:\n”);
    printf("%ld %5.1f\n", ch->num, ch->score);
    }

    void find_context(struct Student *p, int n) //查询节点
    {
    struct Student *q;
    q = node(p, n); //获取目标节点
    printf(“该节点目前数据是:\n%ld %5.1f\n”, q->num, q->score);
    }

    int main()
    {
    struct Student *p;
    int a, m, x, h, f, w, leng; //分别表示所用到的输入序号
    char cp;
    p = NULL;
    show:printf("-----------------链表功能展示--------------------\n");
    printf("|-----------------------------------------------|\n");
    printf("|\t\t1.创建双向循环链表\t\t|\n");
    printf("|\t\t2.增加节点\t\t\t|\n");
    printf("|\t\t3.删除节点\t\t\t|\n");
    printf("|\t\t4.修改节点\t\t\t|\n");
    printf("|\t\t5.查询节点\t\t\t|\n");
    printf("|\t\t6.显示内容\t\t\t|\n");
    printf("|\t\t7.退出\t\t\t\t|\n");
    printf("|-----------------------------------------------|\n");
    printf("\n");

    printf("\t----请输入上述功能序号\n");
    scanf("%d", &a);
    switch (a)
    {
    case 1:
    	p = creat();
    	printf("\t----链表已创建,是否执行其他操作?Y/N\n");
    	scanf("%s", &cp);
    	if (cp == 'Y' || cp == 'y')
    	{
    		goto show;
    	}
    	else
    		goto BB;
    case 2:
    	if (p == NULL){ printf("链表为空,请先创建链表!\n"); goto show; }
    add:printf("\t----在第几个节点前插入?\n");
    	scanf("%d", &x);
    	if (x<1||x > (leng = getListlength(p)) + 1)
    	{
    		printf("插入的位置不在节点范围内!请重新输入!\n");
    		goto add;
    	}
    	add_node(p, x);
    	printf("\t----节点已添加,是否执行其他操作?Y/N\n");
    	scanf("%s", &cp);
    	if (cp == 'Y' || cp == 'y')
    	{
    		goto show;
    	}
    	else
    		goto BB;
    case 3:
    	if (p == NULL){ printf("链表为空,请先创建链表!\n"); goto show; }
    det:printf("\t----删除第几个节点?\n");
    	scanf("%d", &h);
    	if (h<1||h > (leng = getListlength(p)) + 1)
    	{
    		printf("删除的节点不在范围内!请重新输入!\n");
    		goto det;
    	}
    	delete_node(p, h);
    	printf("\t----指定节点已删除,是否执行其他操作?Y/N\n");
    	scanf("%s", &cp);
    	if (cp == 'Y' || cp == 'y')
    	{
    		goto show;
    	}
    	else
    		goto BB;
    case 4:
    	if (p == NULL){ printf("链表为空,请先创建链表!\n"); goto show; }
    change:printf("\t----需要修改哪个节点?\n");
    	scanf("%d", &f);
    	if (f<1||f > (leng = getListlength(p)))
    	{
    		printf("修改的节点不在范围内!请重新输入!\n");
    		goto change;
    	}
    	change_node(p, f);
    	printf("\t----节点已修改完成,是否执行其他操作?Y/N\n");
    	scanf("%s", &cp);
    	if (cp == 'Y' || cp == 'y')
    	{
    		goto show;
    	}
    	else
    		goto BB;
    case 5:
    	if (p == NULL){ printf("链表为空,请先创建链表!\n"); goto show; }
    serach:printf("\t----需要查询哪个节点?\n");
    	scanf("%d", &m);
    	if (m<1||m > (leng = getListlength(p)))
    	{
    		printf("查询的节点不在范围内!请重新输入!\n");
    		goto serach;
    	}
    	find_context(p, m);
    	goto show;
    	break;
    case 6:
    	if (p == NULL){ printf("链表为空\n"); goto show; }
    	printf("\t顺序输出请按1,逆序输出请按2\n");
    	scanf("%d", &w);
    	switch (w)
    	{
    	case 1:
    		print_nodeshun(p); goto show;
    	case 2:
    		print_nodeni(p); goto show;
    	default:goto BB;
    	}
    	break;
    case 7:
    BB : printf("\t----感谢使用!----\n"); break;
    default:printf("该功能暂未开放!\n"); break;
    }
    printf("\n");
    system("pause");
    return 0;
    

    }

    展开全文
  • C语言 双向循环链表的相关操作 #include<stdio.h> #include<stdlib.h> #include<time.h> typedef struct LinkListNode { int data; struct LinkListNode* prior; struct LinkListNode* next; }...

    C语言 双向循环链表的相关操作

    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    typedef struct LinkListNode
    {
    	int data;
    	struct LinkListNode* prior;
    	struct LinkListNode* next;
    }node,*LinkList;  //结构体变量类型
    
    void  GreatLinklistTail(LinkList* head); // 建立链表
    void LinkListInsert(LinkList* head); //插入节点
    void LinkListFind(LinkList* head); //查找数据 
    void LinkListnode_Delete(LinkList* head); //删除节点
    void LinkListDatePrint(LinkList* head);  //链表的输出
    void LinkListClean(LinkList* head);   //链表的整表删除 
    /**
    *为了建立、使用、维护链表,对链表的操作如下:
    *建立链表
    *遍历链表
    *尾部追加
    *删除结点
    *查找结点
    */
    /******************************************************************************/
    int main(void)
    {
    	LinkList head;
    	int i;
    	printf("*************************双向循环链表操作***************************\n\n");
    	printf("1.初始化双向循环链表\n\n2.插入节点 \n\n3.删除节点 \n\n4,查找节点\n\n0.释放内存操作完成\n\n"); 
    	while(1)
    	{
    		scanf("%d", &i);
    		switch(i)
    		{
    		
    			case 1:
    				{
    					printf("下面进行建立双向循环链表操作!\n"); 
    					GreatLinklistTail(&head);
    					LinkListDatePrint(&head);
    				}
    				break;
    			case 2:
    				{
    					printf("下面进行插入节点操作!\n"); 
    					LinkListInsert(&head);
    					LinkListDatePrint(&head);
    				}
    				break;
    			case 3:
    				{ 
    				printf("下面进行建立删除节点操作!\n"); 
    				LinkListnode_Delete(&head);
    				LinkListDatePrint(&head);
    				} 
    				break;
    			case 4:
    				{
    					printf("下面进行查找数据操作!\n"); 
    					LinkListFind(&head);
    				} 
    				break;
    			
    		}
    		if(i == 0)
    		{
    			break;
    		}
    	}
    	printf("双向链表操作结束!\n"); 
    	LinkListClean(&head);
    	system("pause"); 
    	return 0;
    }
    /**********************************************************************************/
    
    //双向循环链表初始化操作 
    void GreatLinklistTail(LinkList* head)
    {
    	node *p, *q = NULL;   //声明节点p 和q 
    	int i, j;
     
    	*head = (LinkList)malloc(sizeof(LinkList)); //为第一个节点开辟内存 
    	(*head)->next = *head;  //将第一个结构体指针的的next 指向第一个节点 
    	(*head)->prior = *head; // 将第一个结构体指针的的prior指向第一个节点 
    	
    	p = *head;
    	printf("请输入所要开辟节点的个数,输入0退出: \n");
    	scanf_s("%d", &i);
    	fflush(stdin);
    
    	if(i == 0)
    	{
    		return ;  //如果输入 0直接退出程序 
    	}
    		
    	else
    	{	
    		p = *head;  //令p指向第一个节点 便于操作
    		for (j = 1; j <= i; j++)
    		{
    			if(j == 1)  //开辟第一个节点时 
    			{	
    				printf("请输入第%d个节点所要存储的数据:", j);
    				scanf_s("%d", &p->data); 
    				fflush(stdin);
    				p->next = NULL;
    				p->prior = NULL;
    			}
    			else
    			{
    				q = (node*)malloc(sizeof(node));  //为q 开辟内存 
    				
    				if (!q)
    				{
    					return;  //分配内存失败退出  
    				}
    				
    				printf("请输入第%d个节点所要存储的数据:", j);
    				scanf_s("%d", &q->data);
    		 
    				q->prior = p;  //q的前驱指针指向 p节点
    				q->next = p->next; //将尾节点的next指向 空 
    				p->next = q;  // p的next指向 q 
    				p = q;		//通过循环建立双向链表    //同于建立双向链表 
    			} 
    		}
    		p->next = *head;  //此时p的位置在尾节点处 
    		(*head)->next->prior = p;  //头尾互指 
    	}
    	printf("单链表建立完毕!!!\n\n");  
    } 
    
    //打印数据函数 
    //链表数据的输出 
    void LinkListDatePrint(LinkList *head)
    {
    	node *p;
    	int j = 1;
    	printf("********************链表中的数据********************\n"); 
    
    	p = *head;
    	do
    	{
    		
    		printf("第%d个节点存储的数为:%d;\n", j, p->data);
    		j++;
    		p = p->next;  //循环遍历链表算法 
    		 
    	}while(p!= *head); //通过循环遍历 到next指向头结点的指针 
    	printf("链表数据打印完毕!!!\n\n"); 
    }
    
    //链表的整表删除
    /*思路:
    	1,声明节点p,q
    	2,将第一个节点赋给p,下一个赋给 q
    	3,循环执行释放p和将q赋给p操作
    */
    void LinkListClean(LinkList* head)
    {
    	node* p, * q;
    
    	p = *head;
    	while (p->next != *head)  //循环释放法则 
    	{
    		q = p->next;
    		free(p);
    		p = q;
    	}  
    	printf("单链表内存释放成功!!!\n");
    }
    
    //链表的数据插入操作
    void LinkListInsert(LinkList* head) //插入节点
    {
    	node *p, *s;  //声明循环遍历结构体指针p 和 插入节点 s 
    	int i, j = 1;
    
    	s = (node*)malloc(sizeof(node));  //为要插入的节点开辟内存  
    	
    	s->next = NULL;  //防止成为野指针
    	s->prior = NULL;
    	
    	printf("请输入要插入的节点的位置:");
    	scanf_s("%d", &i);
    	fflush(stdin);
    	
    	if(i == 1)
    	{
    		printf("请输入插入节点存储的值:");
    		scanf("%d", &s->data);
    		fflush(stdin);
    				
    		for(p = *head; p->next != *head; p= p->next)
    			;  //寻找最后一个节点 
    		
    		s->next = *head;
    		s->prior = (*head)->prior;
    		(*head)->prior = s;
    		p->next = s;
    		*head = s;   //将s作为第一个节点 
    	}
    	else
    	{
    		printf("请输入插入节点存储的值:");
    		scanf("%d", &s->data);
    		fflush(stdin);
    		
    		for(p = *head, j = 1; j < i; j++)
    		{
    			p = p->next;
    		}
    		
    		s->next = p;    //插入关键算法,画图即知 
    		s->prior = p->prior; 
    		p->prior->next = s;
    		p->prior = s;
    		
    	}
    	printf("节点插入成功!!!\n\n"); 
    }
    //节点的查找并返回节点的位置 
    
    void LinkListFind(LinkList* head)  //查找第i个元素
    {
    	node *target;
    	int  i, j = 1;
    
    	printf("请输入查找的数据:");
    	scanf_s("%d", &i);
    	fflush(stdin);
    
    	for (target = *head; target->data != i && target->next != *head; target = target->next)
    		j++;  //循环遍历寻找最后一个节点 
    	printf("该节点的位置是: %d\n\n", j);
    }
    
    //单链表节点删除操作
    void LinkListnode_Delete(LinkList* head)
    {
    	node *p, *target;  //声明节点p指向链表的第一个节点
    	int i;   //要删除的节点 
    	int j = 1; //声明一个计数器  
    	p = *head;  //p节点指向第一个节点 
    
    	printf("请输入要删除的节点标号:");
    	scanf_s("%d", &i);
    	fflush(stdin);
    
    	
    	if (i == 1)
    	{
    		for (target = *head; target->next != (*head); target = target->next)
    			;  //循环遍历寻找最后一个节点  
    			
    		target->next = p->next;
    		p->next->prior = target;
    		*head = p->next;  //把第二个节点再当成第一个节点 
    		
    		free(p);
    	}
    	else
    	{
    		for(j = 1; j < i; j++)
    		{
    			p = p->next;	 //找到第i个节点 
    		} 
    		
    		p->prior->next = p->next;
    		p->next->prior = p->prior;  
    		free(p);
    		
    		printf("节点删除成功!!!!\n\n"); 
    	}
    
    }
    
    
    展开全文
  • C语言双向循环链表api(源自gluster源码)基本的操作如增加、删除和遍历等 #include <stdio.h> #include <stdlib.h> #include <string.h> /*定义表头*/ struct list_head { struct list_head *...

    C语言双向循环链表api(源自gluster源码)
    基本的操作如增加、删除和遍历等

    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    /*定义表头*/
    struct list_head {
        struct list_head *next;
        struct list_head *prev;
    };
    
    /*表头初始化*/
    #define INIT_LIST_HEAD(head) do {           \
            (head)->next = (head)->prev = head; \
        } while (0)
    
    /*增加*/
    static inline void
    list_add (struct list_head *new, struct list_head *head)
    {
        new->prev = head;
        new->next = head->next;
    
        new->prev->next = new;
        new->next->prev = new;
    }
    
    /*删除*/
    static inline void
    list_del (struct list_head *old)
    {
        old->prev->next = old->next;
        old->next->prev = old->prev;
    
        old->next = (void *)0xbabebabe;
        old->prev = (void *)0xcafecafe;
    }
    
    /*判断链表是否为空*/
    static inline int
    list_empty (struct list_head *head)
    {
        return (head->next == head);
    }
    
    #define list_entry(ptr, type, member)                   \
        ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
    
    #define list_for_each(pos, head)                                        \
        for (pos = (head)->next; pos != (head); pos = pos->next)
    
    /*遍历,关于list_for_each_entry,百度*/
    #define list_for_each_entry(pos, head, member)              \
        for (pos = list_entry((head)->next, typeof(*pos), member);  \
             &pos->member != (head);                    \
             pos = list_entry(pos->member.next, typeof(*pos), member))
    
    /*例:先定义一个结构体*/
    typedef struct student
    {                   
        int num;        //学号
        int score;      //分数
        char name[20];
        struct list_head student_list;
    }STU;
    
    STU *head=NULL;
    
    int main(void)
    {
        STU *new=NULL;
    
        new = (STU *)malloc(sizeof(STU));
        bzero(new, sizeof(STU));
        new->num = 8;
        new->score = 8;
        strcpy(new->name, "8888");
        /*链表初始化*/
        if(head == NULL)
        {
            // head = (STU *)malloc(sizeof(STU));
            // bzero(head, sizeof(STU));
            head = new;
            INIT_LIST_HEAD(&head->student_list);
        }
        else
        {
            list_add(&new->student_list, &head->student_list);
        }
    
        if(list_empty(&head->student_list))
        {
            printf("list only head\n");
            printf("head->num:%d, score:%d, name:%s\n", head->num, head->score, head->name);
        }
        /*将新成员插入链表*/
        int i;
        for(i=0;i<5;i++)
        {
            new = (STU *)malloc(sizeof(STU));
            bzero(new, sizeof(STU));
            new->num = i;
            new->score = i+1;
            strcpy(new->name, "2233");
            list_add(&new->student_list, &head->student_list);
        }
        /*删除指定的成员*/
        STU *pos=NULL;
        list_for_each_entry(pos, &head->student_list, student_list)
        {
            if(pos->num == 2){
                list_del(&pos->student_list);
                free(pos);
                pos = NULL;
                break;
                // printf("num:%d, score:%d, name:%s\n", pos->num, pos->score, pos->name);
            }
        }
        /*遍历链表*/
        list_for_each_entry(pos, &head->student_list, student_list)
        {
            printf("num:%d, score:%d, name:%s\n", pos->num, pos->score, pos->name);
        }
        return 0;
    }

    转载于:https://blog.51cto.com/13603157/2285806

    展开全文
  • //p指向链表第一个元素    while(p != L)  {<!-- -->  p = p->next;  free(p->prev);  }    (*L)->next = *L;  (*L)->prev = *L; <p>}   <p>void DestroyList...
  • 双向循环链表的基本操作,用C语言编写,包括创建,插入,删除,查找,获值等……
  • C语言循环双向链表的生成,删除和打印
  • void InitDlist(Dlnode &head) //循环双向初始化 { head=(Dlnode)malloc(sizeof(DLnode)); head->prior=head; head->next=head; cout初始化成功!"; } void InsertDlist(DLnode *head,int i) //头插法 { ...
  • 二、相关知识1、双向循环链表如图所示,每个节点分别有前驱(prev)、后继(next)两个指针域,双链表支持两个方向的遍历,循环则指尾节点又可以重新指向到头节点;2、内核链表的实现(以3.10.25为例)2.1 头节点...
  • 实现思路:插入时候不是插入节点而是数据,通过自己提供的compare,和print函数进行特定类型的操作。而其余操作均可以定义一种通用的做法。#include #include <stdlib.h>typedef struct linknode{ ...
  •  /*循环10次插入10个节点进链表*/   for(i=0;i;i++){  students = (struct student *)malloc(sizeof(struct student));  if(!students){  printf("students malloc failed ...\n");  return 0;  }...
  • 昨天写完了,线性表的顺序表示,今天有琢磨了一天的链表,刚开始准备写一个普通的链表,后来想象这也太没挑战,干脆来一个双向循环聊表把。有挑战,我喜欢,好啦...C语言 双向循环链表的实现和结构 线性表的链式实现 
  • #include #include #define LEN sizeof(struct Student) typedef struct Student{  char name[12];  int num;  char sex[4];  int age;  char Class[6];  char health[10];... struct Student
  • //链表尾和头相连  mylist1->head.next->before=p1;//实现循环  }  printf("创建成功\n");  } void kill(plist mylist,int i) {  pnode tmp=NULL;  while(mylist->size!=1)  {  int ...
  • ————————————————————————————————————————————双向循环链表 //遍历等执行方法与普通双向链表相同,不单独列举- - - - - - - - - - - - - - - - - - - - - - - - - - -...
  • 如何用C语言指针,循环链表,实现内存管理,与malloc()和free()的功能相同。
  • 主要介绍了C语言中双向链表和双向循环链表详解的相关资料,需要的朋友可以参考下
  • 从linux内核移植出来,独立于用户数据结构,里面有实例参考。C语言代码。
  • C语言双向循环链表双向循环链表经典程序,用于指针进行编写的C语言程序。。。
  • 双向链表和双向循环链表和单向链表相比,多了一个前驱结点。如果他为空,那么next和prior都指向自己。而对于双循环链表,只需要最后一个元素的next指向head->next,head->next的prior指向最后一个节点即可。...
  • 在之前的文章中,我写过一篇关于C语言实现双向链表博文,介绍了双向链表的实现过程以及双向链表的优势,接下来我首先给大家介绍一下循环链表和双向链表的区别,之后再给大家介绍双向循环链表的具体实现。 循环链表和...
  • 查了好多资料,发现还是不全,干脆自己整理吧,至少保证在我的做法正确的,以免误导读者,也是给自己做个记录吧!... 阅读linux2.6.32.2中双向循环链表的实现,借鉴其内核代码,在应用层实现双向循环链表的建立,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 882
精华内容 352
关键字:

c语言双向循环链表

c语言 订阅