❶ 双向链表的顺序插入算法
#include <stdio.h>
#include <stdlib.h>
typedef struct tagDbNode
{
int num;
struct tagDbNode * pre;
struct tagDbNode * next;
} DbNode, * pdbNode;
//创建结点
pdbNode CreateNode(int num)
{
pdbNode pnode = (pdbNode)malloc(sizeof(DbNode));
pnode->num = num;
pnode->pre = pnode->next = pnode; //创建新结点时，让其前驱和后继指针都指向自身
return pnode;
}
//创建链表
pdbNode CreateList(int head) //参数给出表头结点数据 （表头结点不作为存放有意义数据的结点）
{
pdbNode pnode = (pdbNode)malloc(sizeof(DbNode));
pnode->num = head;
pnode->pre = pnode->next = pnode;
return pnode;
}
//获取链表的长度
int GetLength(pdbNode *node) // 参数为链表的表头结点
{
int i=1;
pdbNode x=*node;
pdbNode y=x->next;
while(y!=x)
{
y=y->next;
i++;
}
return(i);
}
//插入新结点,顺序插入
pdbNode InsertNode(pdbNode *node,int num) // 参数1是链表的表头结点，参数2是要插入的结点（结点数据为num）
{
pdbNode x=*node;
pdbNode y=x;
x=x->next;
if(y->num<num)
{
pdbNode a=(pdbNode)malloc(sizeof(tagDbNode));
a->num=num;
a->next=y;
a->pre=y->pre;
y->pre->next=a;
y->pre=a;
(*node)=a;//
return a;
}
while(x!=y)
{
if(x->num<num)
{
pdbNode a=(pdbNode)malloc(sizeof(tagDbNode));
a->num=num;
a->next=x;
a->pre=x->pre;
x->pre->next=a;
x->pre=a;
return y;
}
else
{
x=x->next;
}
}
pdbNode a=(pdbNode)malloc(sizeof(tagDbNode));
a->num=num;
a->next=y;
a->pre=y->pre;
y->pre->next=a;
y->pre=a;
return y;
}
//打印整个链表
void PrintList(pdbNode node) // 参数为链表的表头结点
{
pdbNode pnode;
if (NULL == node) return;
pnode= node->next;
printf("%d ", node->num);
while (pnode != node)
{
printf("%d ", pnode->num);
pnode = pnode ->next;
}
printf("\n");
}
//测试程序
#include <stdio.h>
#include <stdlib.h>
//#include "dblist.h"
#define FALSE 0
#define TRUE 1
void main()
{
int nChoose;
int num;
bool bFlag = FALSE;
pdbNode pnode;
pdbNode list = CreateList(0);
pdbNode *head=&list;//是指向指针的指针，因为头结点会变，而这种变化要传回来，只能用指向指针的指针
while(FALSE == bFlag)
{
printf("主目录\n");
printf("1. 插入一个节点\n");
printf("2. 删除一个节点\n");
printf("3. 查找节点\n");
printf("4. 打印链表\n");
printf("5. 删除链表\n");
printf("0. 退出\n\n");
scanf("%d", &nChoose);
switch(nChoose)
{
case 1:
printf("请输入要插入的数据:");
scanf("%d", &num);
list = InsertNode(head, num);
PrintList(*head);
break;
case 2:
printf("请输入要删除的数据:");
scanf("%d", &num);
//DeleteNode(*head, num);
break;
case 3:
printf("请输入要查找的数据:");
scanf("%d", &num);
//pnode = FindNode(list, num);
if (NULL != pnode)
{printf("查找成功!\n");
}
else
{ printf("没有这个数据!\n");
}
break;
case 4:
PrintList(list);
break;
case 5:
//DeleteList(list);
break;
case 6:
printf("这各表的长度为： %d", GetLength(head));
break;
case 0:
//DeleteList(list);
bFlag = TRUE;
}
}
}
我的这个答案，在函数调用的时候，利用的是指向指针的指针，因为开始没有注意到你用的函数有头结点的返回值，所以和你原来给的变动较大，不过还是希望我写的你可以理解，因为我的注释较少（太懒了），所以，将就着看吧
❷ 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);//第二题输出结果
}