双向循环链表操作

双链表:
1 2 3 4 5 6 7 8 9 10 11 12

1 3 5 7 9 11 12 10 8 6 4 2
1。设计节点
typedef int datatyped
typeddef struct node
{
typedata data;
struct node * next;
struct node *prev;

}listnode ,*linklist;

2.初始化空双向循环链表
linklist init_list()
{
linklist l=malloc(sizeof(listnode))
if(l!=NULL)
{

l->next=l;
l->prev=l;
}
return l;

}

3.插入
bool insert_prev(linklist new,linklist L)
{
//新节点前后关系
new->n=L
new->p=L-p;

//新节点前一节点的后面关系
L->p->n=new;
//新节点后一节点的前面关系
L->p=new;

return true;

}

4.显示
show()
{

}
remove_node(linklist pl)
{
pl->p->n=pl->n;
pl->n->p=pl->p;
pl->p=pl->n=NULL;

}
move_p(linklist pl,linklist L)
{
remove_node(pl);
insert_prev(pl,L);

}

5.
ran(linklist L)
{
linklist pl=L->p,q;

int i=0;
while(pl!=L)
{
if((pl->data)%2==0 && i==1)
{
//删除和插入操作
move_p(pl,L);
pl=q;
}
else
q=pl;

pl=pl->p;

i=1;
}

}

int main()
{
linlist L=init_list();

for(i=1;i<=n;i++)
{
linklist new =malloc();
new->data=i;

insert_prev(new,L);

}

ran(L)

show(L)

}

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int datatype;
typedef struct node
{
datatype data;
struct node *next;
struct node *prve;
}listnode,*linklist;

linklist init_list()
{
linklist L = malloc(sizeof(listnode));
if(L!=NULL)
{
L->next = L;
L->prve = L;
}
return L;
}

bool insert_prve(linklist new,linklist L)//在L的前驱插入节点
{
new->next = L;
new->prve = L->prve;
L->prve->next = new;
L->prve = new;
return true;

}
/* while(q->prve ! = q)
{

}
*/
bool cir_insert(linklist L)//显示奇偶显示1 3 5 7 9 10 8 6 4 2
{
linklist p=L->prve,q;
// s = L->next;
while(p != L)//注意循环条件
{

if(p->data%2==0)
{ q=p->prve;//记录p的前驱,以便p指针向前移动
p->prve->next = p->next;
p->next->prve = p->prve;
p->prve = L->prve;
L->prve->next = p;
p->next = L;
L->prve = p;
p=q;//之前记录的指针。

}
p=p->prve;

}
return true;
}

void show(linklist L)//打印循环链表数据
{ linklist p =L;
while(p->next!=L)
{ p = p->next;
printf("%d\t",p->data);
}
printf("\n");

}
int main()
{
linklist L;
L = init_list();
int i;
for(i=1;i<=10;i++)
{
linklist new = malloc(sizeof(listnode));
new->data = i;
insert_prve(new,L);
}
cir_insert(L);
show(L);
return 0;

}

时间: 2024-10-12 04:32:59

双向循环链表操作的相关文章

C语言通用双向循环链表操作函数集

说明 相比Linux内核链表宿主结构可有多个链表结构的优点,本函数集侧重封装性和易用性,而灵活性和效率有所降低.     可基于该函数集方便地构造栈或队列集.     本函数集暂未考虑并发保护. 一  概念 链表是一种物理存储单元上非连续.非顺序的存储结构,数据元素的逻辑顺序通过链表中的指针链接次序实现.链表由一系列存储结点组成,结点可在运行时动态生成.每个结点均由两部分组成,即存储数据元素的数据域和存储相邻结点地址的指针域.当进行插入或删除操作时,链表只需修改相关结点的指针域即可,因此相比线性

1.Go-copy函数、sort排序、双向链表、list操作和双向循环链表

1.1.copy函数 通过copy函数可以把一个切片内容复制到另一个切片中 (1)把长切片拷贝到短切片中 package main import "fmt" func main() { s1 := []int {1,2} s2 := []int{3,4,5,6} //copy的是角标,不会增加元切片的长度 copy(s1,s2) fmt.Println(s1) //[3 4] fmt.Println(s2) //[3 4 5 6] } (2)把短切片拷贝到长切片中 package ma

复习下C 链表操作(双向循环链表,查找循环节点)

双向循环链表  和 单向循环链表 查找循环节点 思路都是一样. 快慢指针查找法. 理论可参考 c 链表之 快慢指针 查找循环节点 typedef struct Student_Double { char name[10]; int point; struct Student_Double *preStu; struct Student_Double *nextStu; } StudentDouble; StudentDouble * CreateDoubleCircleLink_Table(){

线性表.04.链式存储结构(双向循环链表)

以下是用双向循环链表实现的线性表 #include <stdio.h> #include <stdlib.h> #include <time.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType;//ElemType这里假设为int,可以根据需要进行更改 typedef int Status;//Status是函数的类型,其值是函数结果状态代码,如OK等 t

基于双向循环链表的学生管理系统

基于双向循环链表实现的学生管理系统,包括初始化,插入,删除,查抄,保存,自动按照姓名排序功能,退出并保存功能. 实现思想是将程序的各个部分划分为三个层次.主函数为界面层,即客户端层:其中后缀为Student的一般是某个功能的调度函数,属于逻辑层的内容:在调度函数之下有相应的被调度的函数,也就是相应功能的实现函数,一般后缀名为Node,意思就是这个函数直接操作链表中的结点,可以简单的划分为实现层: 这样分层实现呢有利于代码维护和个功能之间对包含或者重叠功能的直接调用,从而提高代码重用度,而降低代码

学生管理系统——基于双向循环链表

基于双向循环链表实现的学生管理系统,包括初始化,插入,删除,查抄,保存,自动按照姓名排序功能,退出并保存功能. 实现思想是将程序的各个部分划分为三个层次.主函数为界面层,即客户端层:其中后缀为Student的一般是某个功能的调度函数,属于逻辑层的内容:在调度函数之下有相应的被调度的函数,也就是相应功能的实现函数,一般后缀名为Node,意思就是这个函数直接操作链表中的结点,可以简单的划分为实现层: 这样分层实现呢有利于代码维护和个功能之间对包含或者重叠功能的直接调用,从而提高代码重用度,而降低代码

Linux内核中的通用双向循环链表

开发中接触Linux越来越多,休息放松之余,免不了翻看翻看神秘的Linux的内核.看到双向链表时,觉得挺有意思的,此文记下. 作为众多基础数据结构中的一员,双向循环链表在各种“教科书”中的实现是相当的标准和一致的. 大概就是下面这个样子: 1 typedef struct node_tag{ 2 //T data; 3 struct node_tag *prev; 4 struct node_tag *next; 5 }node; 当你需要某种类型的链表时,把数据成员之类的往节点里塞就是了.比如

c语言双向循环链表

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

数据结构基础(12) --双向循环链表的设计与实现

双向链表的操作特点: (1) "查询" 和单链表相同; (2)"插入" 和"删除"时需要同时修改两个方向上的指针. 但是对于双向循环链表则在表尾插入非常的迅速, 只需O(1)的时间,因为有指向前面的指针, 因此双向循环链表会很容易的找到位于表尾的元素,因此双向循环链表比较适用于频繁在表尾插入的情况. 空链表: 双向循环链表节点构造: class DoubleListNode { private: Type data; DoubleListNode