数据结果之双向链表

1创建循环链表，带头结点的
2判断双链表是否为空
3返回双链表的长度
4插入元素，返回1表示插入成功，0表示失败
5删除元素，返回1表示插入成功，0表示失败
6查找元素，查找成功返回1，失败返回0
7反向输出元素
8双向链表的排序,从小到大排序
9返回元素elem的前驱元素
10返回元素elem的后继元素,返回0表示失败
11顺序输出


  1 //数据结构之双链表
#include<stdio.h>
#include<stdlib.h>
typedef struct Dlinklist
{
    int data;
    struct  Dlinklist  *next;
    struct  Dlinklist  *pre;
}Dlinklist;

//创建循环链表，带头结点的
Dlinklist *dlinkcreate()
{
    int n=0,i=0;
    Dlinklist *dhead,*p,*q;
    dhead=(Dlinklist *)malloc(sizeof(Dlinklist));
    dhead->next=NULL;
    dhead->pre=NULL;
    p=dhead;
    printf("输入要插入节点的个数：\n");
    scanf("%d",&n);
    printf("输入各个元素：\n");
    for(i=0;i<n;i++)
    {
        q=(Dlinklist *)malloc(sizeof(Dlinklist));
        scanf("%d",&q->data);
        q->pre=p;
        p->next=q;
        p=q;
        p->next=NULL;
    }
    return dhead;
}
void dlinkdisplay(Dlinklist *dlist)
{
    if(dlist->next==NULL)
    {
        printf("双链表为空");
        exit(0);
    }
    Dlinklist  *p;
    p=dlist->next;
    while(p)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}
//判断双链表是否为空
int dlinkisempty(Dlinklist *dlist)
{
    if(dlist->next==NULL)
        return 1;
    else
        return 0;
}
//返回双链表的长度
int dlinklength(Dlinklist *dlist)
{
    int len=0;
    Dlinklist *p;
    p=dlist->next;
    while(p)
    {
        len++;
        p=p->next;
    }
    return len;
}
//插入元素，返回1表示插入成功，0表示失败,在第loc个元素之前插入,0表示在尾插入
int dlinkinsert(Dlinklist *dlist,int a,int loc)
{
    Dlinklist *p,*q;
    q=(Dlinklist *)malloc(sizeof(Dlinklist));
    q->data=a;
    q->next=NULL;
    q->pre=NULL;
    int i=1;
    if(loc<0||loc>dlinklength(dlist))
    {
        printf("参数不正确");
        return 0;
    }
    p=dlist->next;
    if(loc==0)//尾部插入
    {
        while(p->next)
        {
            p=p->next;
        }
        p->next=q;
        p=q->pre;
        return 1;

    }
    while(i<loc)
    {
        i++;
        p=p->next;
    }
    p->pre->next=q;
    q->pre=p->pre;
    q->next=p;
    p->pre=q;
    return 1;
}


//删除元素，返回1表示插入成功，0表示失败 删除第loc个元素
int dlinkdelete(Dlinklist *dlist,int loc) 
{
    Dlinklist *p;
    int i=1;
    p=dlist->next;
    if(loc<1||loc>dlinklength(dlist))
    {
        printf("参数不正确");
        return 0;
    }
    while(i<loc)
    {
        i++;
        p=p->next;
    }
    p->pre->next=p->next;
    p->next->pre=p->pre;
    free(p);
    return 0;
}
//查找元素，查找成功返回1，失败返回0
int dlinkfind(Dlinklist *dlist,int val)
{
    Dlinklist *p;
    if(dlist->next==NULL)
    {
        printf("双链表为空");
        return 0;
    }
    p=dlist->next;
    while(p)
    {
        if(p->data==val)
        {
            return 1;
        }
        p=p->next;
    }
    return 0;

}
//反向输出元素
void dlinkrdisplay(Dlinklist *dlist)
{
    Dlinklist *p;
    p=dlist->next;
    while(p->next)
    {
        p=p->next;
    }
    while(p!=dlist)
    {
        printf("%d  ",p->data);
        p=p->pre;
    }
    printf("\n");
}
//双向链表的排序,从小到大排序

void swap(int *a,int *b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}
void dlinksort(Dlinklist *dlist)
{
    Dlinklist *p,*q;
    p=dlist->next;
    q=p->next;
    while(p)
    {
        q=p;
        while(q)
        {
            if(p->data>q->data)
            {
                swap(&p->data,&q->data);
            }
            q=q->next;
        }
        p=p->next;
    }
}
//返回元素elem的前驱元素
int dlinklistpr(Dlinklist *dlist,int elem)
{
    Dlinklist *p=dlist->next;
    if(dlinkfind(dlist,elem)==0)
    {
        printf("elem 不存在");
        return 0;
    }
    else if(p->data==elem)
    {
        printf("elem 没有前驱元素\n");
        return 0;
    }
    else
    {
        while(p->data!=elem)
        {
            p=p->next;
        }
        return p->pre->data;
    }
}

//返回元素elem的后继元素,返回0表示失败
int dlinklistnext(Dlinklist *dlist,int elem)
{
    
    Dlinklist *p=dlist->next;
    if(dlinkfind(dlist,elem)==0)
    {
        printf("elem 不存在");
        return 0;
    }
    else
    {
        while(p->data!=elem)
        {
            p=p->next;
        }
        if(p->next==NULL)
        {
            printf("elem 不存在后继元素\n");
            return 0;
        }
        return p->next->data;
    }
}

//测试
void main()
{
    Dlinklist *dlist;
    dlist=dlinkcreate();
    printf("dlist 是否为空：%d\n",dlinkisempty(dlist));
    dlinkdisplay(dlist);
    printf("反向输出的序列为:");
    dlinkrdisplay(dlist);
    printf("dlist 的元素个数为：%d\n",dlinklength(dlist));
    dlinkinsert(dlist,100,3);
    printf("插入之后的序列：");
    dlinkdisplay(dlist);
    printf("删除之后的序列：");
    dlinkdelete(dlist,4);
    dlinkdisplay(dlist);
    printf("反向输出的序列为:");
    dlinkrdisplay(dlist);
    printf("查找元素(成功？)%d\n",dlinkfind(dlist,6));
    printf("排序之后的序列:");
    dlinksort(dlist);
    dlinkdisplay(dlist);
    printf("前驱元素为：%d\n",dlinklistpr(dlist,5));
    printf("后继元素为：%d\n",dlinklistnext(dlist,5));
    
}

---恢复内容结束---