双向链表建立c语言
你的代码是有问题的，网络这个没法完整的上传代码
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<math.h>
typedefintstatus;
#defineOK1#defineERROR0
typedefstructlikelist
{
intdata;
structlikelist*front,*next;//建立双向链表
}Listnode;
Listnode*Create_list(Listnode*head,intn)//建立链表
{
Listnode*p,*q;
inti;
head=(Listnode*)malloc(sizeof(Listnode));
if(!head)
{
exit(-1);//创建不成功则退出程序
}
head->next=NULL;
p=head->next;
q=head;
printf("请输入%d个进程所要访问的磁道号:",n);
for(i=0;i<n;i++)
{
p=(Listnode*)malloc(sizeof(Listnode));
if(!p)
{
exit(-1);
}
q->next=p;
scanf("%d",&p->data);
p->front=q;
p->next=NULL;
q=p;
}
printf("输入磁道号已经完成 ");//用于测试程序在哪里执行出错
returnhead;
}
Listnode*Sort_list(Listnode*head)//对链表排序
{
inta;
if(!head->next)
{
printf("表空！");
exit(-1);
}
Listnode*p,*q;
p=head->next;
q=p->next;
for(;q->next!=NULL;p=p->next,q=q->next)
{
if((p->data)>(q->data))
{
a=p->data;
p->data=q->data;
q->data=a;
}
}/*while(q->next!=NULL){if((p->data)>(q->data)){a=p->data;p->data=q->data;q->data=a;}p=p->next;q=q->next;}*/
returnhead;
}
voidFangwen_list(Listnode*head,intn,intm)//访问链表，向磁道增加的方向，m用于记录开始访问的磁道号，n记录总共磁道号数目
{
Listnode*p,*q;//定义指向节点的指针
inti,j;
floatdistance=0;
floatsum=0;
floatave;
p=head->next;
printf("将要从%d号磁道向磁道号增加的方向访问: ",m);
printf("被访问的下一个磁道号 本次移动的距离 ");
for(i=0;i<n;i++)
{
if(p->data>=m)
{
q=p->front;
j=i;
break;
}
else
{
continue;
}
}
for(;i<n;i++)
{
printf(" %d",p->data);
distance=(float)fabs(m-(p->data));
m=p->data;
sum=(float)(sum+distance);
printf(" %f ",distance);//用于格式化的输出，
p=p->next;
}
printf(" ");
/*
for(;q!=head;)
{
printf(" %d",q->data);
distance=(float)fabs(m-q->data);
m=q->data;
sum=(float)(sum+distance);
printf(" %f ",distance);
q=q->front;
}
printf(" ");
*/
ave=(float)sum/n;//计算出平均长度
printf("平均寻道长度为:%.2f ",ave);
}
intmain()
{
Listnode*head;
intn;
intm;
printf("请输入进程要访问的磁道的总数:");
scanf("%d",&n);
head=Create_list(head,n);//链表返回头指针应该赋值，
Sort_list(head);
printf("请输入你要最开始访问的磁道号:");
scanf("%d",&m);
Fangwen_list(head,n,m);
system("pause");
return0;
}
Ⅱ 双向链表排序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<malloc.h>
#define ElemType int
int count=0;
typedef struct DulNode
{
ElemType data;
DulNode *prior;
DulNode *next;
}DulNode,*DulLinkList;
//初始化链表，结束后产生一个头结点指针
void InitDLList(DulLinkList *L)
{
(*L)=(DulLinkList)malloc(sizeof(DulNode));
(*L)->next=*L;
(*L)->prior=(*L)->next;
}
//对链表进行插入操作
void ListInsert(DulLinkList *L)
{
int i=0,n;
ElemType temp;
DulNode *s,*p;
p=(*L)->next;
printf("请输入插入元素数量：\n");
scanf("%d",&n);
count=n;
printf("请输入%d个自然数\n",n);
while(i<n)
{
scanf("%d",&temp);
s=(DulNode*)malloc(sizeof(DulNode));
s->data=temp;
while((p!=(*L))&&(p->data<temp))//查找所要插入的位置
{
p=p->next;
}
s->prior=p->prior;//新节点的插入
s->next=p;
p->prior->next=s;
p->prior=s;
p=(*L)->next;//将指针回指到链表第一个非空节点，主要是为了下次查找插入位置
i++;
}
}
void Display(DulLinkList L)
{
DulNode *p;
p=L->next;
printf("双向链表中的数据为:\n");
while(p!=L)
{
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
void Sort(DulLinkList *L)
{
ElemType temp;
DulNode *p,*q;
p=(*L)->next;
q=(*L)->prior;
if(count%2!=0)
q=q->prior;
p=p->next;
while(p!=q)
{
temp=p->data;
p->data=q->data;
q->data=temp;
p=p->next;
if(p!=q) //第二题只需交换节点数据
q=q->prior;//这几个if else语句需要仔细
else
break;
if(p!=q)
p=p->next;
else
break;
if(p!=q)
q=q->prior;
else
break;
}
}
void main()
{
DulLinkList L;
InitDLList(&L);//初始化链表
ListInsert(&L);//顺序插入数据
Display(L);//显示结果
Sort(&L);//第二题操作
Display(L);//第二题输出结果
}