双向链表c语言实现

‘壹’ c语言实现的双向链表插入程序

//双向链表
#include<stdio.h>
#include <malloc.h>
typedef struct node
{
int i;
struct node *next,*prior;
}node;

node* create_list()
{
int a[]={1,2,3,8,9};
int j;
node *head,*p1,*p2;
p2=head=(node *)malloc(sizeof(node));
head->i=a[0];
head->next=head->prior=NULL;
for(j=1;j<5;j++)
{
p1=(node *)malloc(sizeof(node));
p1->i=a[j];
p1->prior=p2;
p1->next=NULL;

p2->next=p1;
p2=p1;
}
return head;
}

node * insert_list(node *head,int i,int num)
{
node *p,*q;
int j;

for(j=0,p=head;j<i&&p->next;j++)
{
p=p->next;
}

q=(node *)malloc(sizeof(node));
q->i=num;

q->prior=p->prior;
q->next=p;
if(i==0)//插入结点作为表头
{
head=q;
}
else
{
p->prior->next=q;
}
p->prior=q;

return head;
}

void printf_list(node *head)
{
node *p;
for(p=head;p;p=p->next)
{
printf("%d\t",p->i);
}
printf("\n");
}

void main()
{
struct node *head;

int i,num;
head=create_list();
printf_list(head);

scanf("%d",&i);
scanf("%d",&num);
head=insert_list(head,i,num);
printf_list(head);
}

‘贰’ c语言实现双向链表的问题

你的那个void CreateList(*&h,a[],n) 这个不是一个函数头吗！过好里边的是形参，就应该有类型名啊，应该是这样的把 void CreateList(DLinkList &h,char a[],int n)，还有你别搞得那么多指针行不，C中指针是最难得，你用引用啊，&就是引用，这个比较简单啊，你去网上看看用法吧，最好少用指针！

‘叁’ 双向链表排序c语言程序设计

/************************************************************************/
/*
	文件名		doublelnk.h
	作用			定义必要的结构体，并对双向链表的操作函数做声明
*/
/************************************************************************/

#ifndefDList_H
#defineDList_H
typedefintItem;
typedefstructNode*PNode;
typedefPNodePosition;
/*定义节点类型*/
typedefstructNode
{
	Itemid;		/*编号*/
	Itemdata;		/*数据域*/
	PNodeprevious;/*指向前驱*/
	PNodenext;		/*指向后继*/
}Node;
/*定义链表类型*/
typedefstruct
{
	PNodehead;		/*指向头节点*/
	PNodetail;		/*指向尾节点*/
	intsize;
}DList;

enumenumSortType
{
	ID,
	DATA
};

/*分配值为i的节点，并返回节点地址*/
PositionMakeNode(Itemid,Itemdata);

/*释放p所指的节点*/
voidFreeNode(PNodep);

/*构造一个空的双向链表*/
DList*InitList();

/*摧毁一个双向链表*/
voidDestroyList(DList*plist);

/*将一个链表置为空表，释放原链表节点空间*/
voidClearList(DList*plist);

/*返回头节点地址*/
PositionGetHead(DList*plist);

/*返回尾节点地址*/
PositionGetTail(DList*plist);

/*返回链表大小*/
intGetSize(DList*plist);

/*返回p的直接后继位置*/
PositionGetNext(Positionp);

/*返回p的直接前驱位置*/
PositionGetPrevious(Positionp);

/*将pnode所指节点插入第一个节点之前*/
PNodeInsFirst(DList*plist,PNodepnode);

/*将链表第一个节点删除并返回其地址*/
PNodeDelFirst(DList*plist);

/*获得节点的数据项*/
ItemGetItem(Positionp);

/*设置节点的数据项*/
voidSetItem(Positionp,Itemi);

/*删除链表中的尾节点并返回其地址，改变链表的尾指针指向新的尾节点*/
PNodeRemove(DList*plist);

/*在链表中p位置之前插入新节点S*/
PNodeInsBefore(DList*plist,Positionp,PNodes);

/*在链表中p位置之后插入新节点s*/
PNodeInsAfter(DList*plist,Positionp,PNodes);

/*返回在链表中第i个节点的位置*/
PNodeLocatePos(DList*plist,inti);

voidListTraverse(DList*plist,void(*visit)(Node));

/*对双向链表按照执行的排序方式进行排序*/
voidSortDLnk(DList*plist,enumSortTypesortType);

voidSortDLnkbyID(DList*plist);
voidSortDLnkbyData(DList*plist);
voidswapnode(PNodeanode,PNodebnode);
#endif


/************************************************************************/
/*
	文件名		doublelnk.cpp
	作用			对双向链表的操作函数进行具体实现
*/
/************************************************************************/
#include"doublelnk.h"
#include<malloc.h>
#include<stdlib.h>


/*分配值为i的节点，并返回节点地址*/
PositionMakeNode(Itemid,Itemdata)
{
	PNodep=NULL;
	p=(PNode)malloc(sizeof(Node));
	if(p!=NULL)
	{
		p->id=id;
		p->data=data;
		p->previous=NULL;
		p->next=NULL;
	}	
	returnp;
}

/*释放p所指的节点*/
voidFreeNode(PNodep)
{
	free(p);
}

/*构造一个空的双向链表*/
DList*InitList()
{
	DList*plist=(DList*)malloc(sizeof(DList));
	PNodehead=MakeNode(0,0);
	if(plist!=NULL)
	{
		if(head!=NULL)
		{
			plist->head=head;
			plist->tail=head;
			plist->size=0;
		}
		else
			returnNULL;
	}
	returnplist;
}

/*摧毁一个双向链表*/
voidDestroyList(DList*plist)
{
	ClearList(plist);
	free(GetHead(plist));
	free(plist);
}

/*判断链表是否为空表*/
intIsEmpty(DList*plist)
{
	if(GetSize(plist)==0&&GetTail(plist)==GetHead(plist))
		return1;
	else
		return0;
}
/*将一个链表置为空表，释放原链表节点空间*/
voidClearList(DList*plist)
{
	PNodetemp,p;
	p=GetTail(plist);
	while(!IsEmpty(plist))
	{	
		temp=GetPrevious(p);
		FreeNode(p);
		p=temp;
		plist->tail=temp;
		plist->size--;
	}
}

/*返回头节点地址*/
PositionGetHead(DList*plist)
{
	returnplist->head;
}

/*返回尾节点地址*/
PositionGetTail(DList*plist)
{
	returnplist->tail;
}

/*返回链表大小*/
intGetSize(DList*plist)
{
	returnplist->size;
}

/*返回p的直接后继位置*/
PositionGetNext(Positionp)
{
	returnp->next;
}

/*返回p的直接前驱位置*/
PositionGetPrevious(Positionp)
{
	returnp->previous;
}

/*将pnode所指节点插入第一个节点之前*/
PNodeInsFirst(DList*plist,PNodepnode)
{
	Positionhead=GetHead(plist);

	if(IsEmpty(plist))
		plist->tail=pnode;
	plist->size++;

	pnode->next=head->next;
	pnode->previous=head;

	if(head->next!=NULL)
		head->next->previous=pnode;
	head->next=pnode;

	returnpnode;
}

/*将链表第一个节点删除,返回该节点的地址*/
PNodeDelFirst(DList*plist)
{
	Positionhead=GetHead(plist);
	Positionp=head->next;
	if(p!=NULL)
	{
		if(p==GetTail(plist))
			plist->tail=p->previous;
		head->next=p->next;
		head->next->previous=head;
		plist->size--;

	}	
	returnp;
}

/*获得节点的数据项*/
ItemGetItem(Positionp)
{
	returnp->data;
}

/*设置节点的数据项*/
voidSetItem(Positionp,Itemi)
{
	p->data=i;
}

/*删除链表中的尾节点并返回地址，改变链表的尾指针指向新的尾节点*/
PNodeRemove(DList*plist)
{
	Positionp=NULL;
	if(IsEmpty(plist))
		returnNULL;
	else
	{
		p=GetTail(plist);
		p->previous->next=p->next;
		plist->tail=p->previous;
		plist->size--;
		returnp;
	}
}
/*在链表中p位置之前插入新节点s*/
PNodeInsBefore(DList*plist,Positionp,PNodes)
{
	s->previous=p->previous;
	s->next=p;
	p->previous->next=s;	
	p->previous=s;

	plist->size++;
	returns;
}
/*在链表中p位置之后插入新节点s*/
PNodeInsAfter(DList*plist,Positionp,PNodes)
{
	s->next=p->next;
	s->previous=p;

	if(p->next!=NULL)
		p->next->previous=s;
	p->next=s;

	if(p=GetTail(plist))
		plist->tail=s;

	plist->size++;
	returns;
}

/*返回在链表中第i个节点的位置*/
PNodeLocatePos(DList*plist,inti)
{
	intcnt=0;
	Positionp=GetHead(plist);
	if(i>GetSize(plist)||i<1)
		returnNULL;

	while(++cnt<=i)
	{
		p=p->next;
	}

	returnp;
}

/*依次对链表中每个元素调用函数visit()*/
voidListTraverse(DList*plist,void(*visit)(Node))
{
	Positionp=GetHead(plist);
	if(IsEmpty(plist))
		exit(0);
	else
	{

		while(p->next!=NULL)
		{
			p=p->next;
			visit(*p);
		}
	}
}


voidSortDLnk(DList*plist,enumSortTypesortType)
{
	switch(sortType)
	{
	caseID:
		SortDLnkbyID(plist);
		break;
	caseDATA:
		SortDLnkbyData(plist);
		break;
	}
}

voidSortDLnkbyID(DList*plist)
{
	PNodehead=plist->head;
	Nodetmpnode;
	Positioncurrnode=head;
	Positionbianlinode;
	while((currnode=currnode->next)!=NULL)
	{
		bianlinode=currnode;
		while((bianlinode=bianlinode->next)!=NULL)
		{
			if(currnode->id>bianlinode->id)
			{
				swapnode(currnode,bianlinode);
			}			
		}
	}	
}

voidSortDLnkbyData(DList*plist)
{
	PNodehead=plist->head;
	Nodetmpnode;
	Positioncurrnode=head;
	Positionbianlinode;
	while((currnode=currnode->next)!=NULL)
	{
		bianlinode=currnode;
		while((bianlinode=bianlinode->next)!=NULL)
		{
			if(currnode->data>bianlinode->data)
			{
				swapnode(currnode,bianlinode);
			}			
		}
	}	
}

voidswapnode(PNodeanode,PNodebnode)
{//这里面要特别注意防止前驱节点是头结点和后驱节点是Null的情况
	Nodetmpnode;
	tmpnode.id=anode->id;
	tmpnode.data=anode->data;

	anode->id=bnode->id;
	anode->data=bnode->data;

	bnode->id=tmpnode.id;
	bnode->data=tmpnode.data;
}/************************************************************************/
/*
	文件名		program.cpp
	作用			对双向链表的操作函数进行测试
*/
/************************************************************************/

#include"doublelnk.h"
#include<stdio.h>
voidprint(Nodenode)
{
	printf("数据项:id=%d,data=%d
",node.id,node.data);
}
intmain()
{
	DList*plist=NULL;
	PNodep=NULL;

	plist=InitList();
	p=InsFirst(plist,MakeNode(12,23));
	InsBefore(plist,p,MakeNode(2,54));
	InsAfter(plist,p,MakeNode(3,34));

	printf("p前驱位置的值为%d
",GetItem(GetPrevious(p)));
	printf("p位置的值为%d
",GetItem(p));
	printf("p后继位置的值为%d
",GetItem(GetNext(p)));


	printf("遍历输出各节点数据项:
");
	ListTraverse(plist,print);

	printf("按照ID排序后遍历输出:
");
	SortDLnk(plist,ID);
	ListTraverse(plist,print);

	printf("按照Data排序后遍历输出:
");
	SortDLnk(plist,DATA);
	ListTraverse(plist,print);

	printf("除了头节点该链表共有%d个节点
",GetSize(plist));
	FreeNode(DelFirst(plist));
	printf("删除第一个节点后重新遍历输出为:
");
	ListTraverse(plist,print);
	printf("除了头节点该链表共有%d个节点
",GetSize(plist));

	DestroyList(plist);
	printf("链表已被销毁
");

	return0;
}

程序总共分三部分， 分别是双向链表的头文件、源文件和测试程序

建立工程后，分别建立相应的文件并添加相应代码应该就可以

下面的图片是我的运行效果（声明：程序中很多代码参考了以为前辈的代码http://blog.csdn.net/hopeyouknow/article/details/6716177）

‘肆’ C语言双向链表

#include "stdio.h"
#include "stdlib.h"
typedef int ElemType;//元素类型
typedef struct DuLNode
{//双向链表
ElemType data;
struct DuLNode *prior, *next;
}DuLNode,*DuLinkList;
int Create(DuLinkList &L)
{//建立双向链表
DuLinkList p,q;
ElemType n,i;
L = (DuLinkList) malloc (sizeof(DuLNode));
L->next = NULL;
q = L;
printf("输入数据个数:");
scanf("%d",&n);
printf("输入数据元素:");
for ( i = 0; i < n; i++)
{
p = (DuLinkList) malloc (sizeof(DuLNode));
scanf("%d",&p->data);//插入数据
p->prior = q;
q->next = p;
p->next = 0;
q = q->next;
}
return 1;
}
int Visit(DuLinkList &L)
{//遍历双向链表
DuLinkList p;
p = L->next;
printf("双向链表为:");
while (p)
{
printf("%4d",p->data);
p = p->next;
}
printf("\n");
return 1;
}
int Clear(DuLinkList &L)
{
DuLinkList p;
p = L->next;
while(p)
{
L->next = p->next;
free(p);
p = L->next;
}
return 1;
}
main()
{
int i,e,s,num;
char c='y';
DuLinkList L;
Create(L);
Visit(L);
while (c=='y')
{
printf("\n\n\n1.双向链表插入元素\n2.双向链表中删除元素\n");
printf("3.判断双向链表元素是否对称\n");
printf("4.双向链表中奇数排在偶数前面\n");
printf("5.建立递增链表并有序插入元素\n\n");
printf("选择需要的操作\n\n");
scanf("%d",&num);
switch(num)
{
case 1:
printf("输入插入元素位置以及元素:\n");
scanf("%d%d",&i,&e);
ListInsert(L, i, e);
Visit(L);
break;
case 2:
printf("输入删除元素位置:");
scanf("%d",&i);
Delete(L,i,s);
printf("删除的元素为:%d\n",s);
Visit(L);
break;
case 3:
if(Same(L)) printf("链表对称\n");
else printf("链表不对称\n");
break;
case 5:
printf("清空原链表，建立递增链表:\n");
XCreate(L);
Visit(L);
break;
case 4:
printf("奇数放在偶数前面:\n");
Jiou(L);
Visit(L);
break;
}
printf("继续操作(y/n):\n");
scanf("%s",&c);
}
}

‘伍’ 怎样用c语言实现一个双向链表

双向链表的相关操作
实现功能：
1.
创建一个新链表。
2.
插入节点。
3.
删除节点。
4.
选择法排序链表（从小到大）。
5.
显示当前链表。
6.
退出程序
详细代码见参考资料

‘陆’ 使用C语言实现双向链表的建立、删除和插入

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
struct list{
int data;
struct list *next;
struct list *pre;
};
typedef struct list node;
typedef node *link;
link front=NULL,rear,ptr,head=NULL;

link push(int item){
link newnode=(link)malloc(sizeof(node));
newnode->data=item;
if(head==NULL)
{
head=newnode;
head->next=NULL;
head->pre=NULL;
rear=head;
}
else
{
rear->next=newnode;
newnode->pre=rear;
newnode->next=NULL;
rear=newnode;
}
return head;
}

void makenull(){
front=NULL;
rear=NULL;
}

empty(){
if(front==NULL)
return 1;
else
return 0;
}

int tops(){
if(empty())
return NULL;
else
return rear->data;
}

void pop(){
if(empty())
printf("stack is empty!\n");
else
rear=rear->pre;
}

void display(link l){
link p;
p=l;
while(p!=NULL){
printf("%d->",p->data);
p=p->next;
}
}

void main(){
int n,i;
printf("input your first data!\n");
scanf("%d",&n);
front=push(n);
/*another data*/
for(i=0;i<3;i++)
{
printf("input:\n");
scanf("%d",&n);
push(n);
}
ptr=front;
display(ptr);
printf("\n Please enter any key to pop");
pop();
ptr=front;
display(ptr);

}