C语言之双向循环链表的使用

头文件

/**************************************************************
  > File Name: LinkList.h
  > Author: chengfeiyan
  > Mail: 1493789272@qq.com 
  > Created Time: 2018年08月06日 星期一 10时11分02秒
 **************************************************************/
#ifndef _LINKLIST_H
#define _LINKLIST_H

#define SUCCESS 10000
#define FAILURE 10001
#define TRUE    10002
#define FALSE   10003

typedef int ElemType;

struct node
{
    ElemType data;
    struct node *next;
    struct node *prior;
};

typedef struct node Node;

int LinkInit(Node **l);
int LinkInsrt(Node *l, int n, ElemType e);
int LinkTraverse(Node *l, void (*p)(ElemType));
int LinkLength(Node *l);
int LinkEmpty(Node *l);
int GetElem(Node *l, int p, ElemType *e);
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType));
int LinkDelete(Node *l, int p, ElemType *e);
int LinkClear(Node *l);
int LinkDestroy(Node **l);
int LinkReverse(Node *l);

#endif

自定义函数

## 有标注 //** 的为与双向链表的区别之处

// 双向循环链表

#include <stdio.h>
#include "LinkList.h"
#include <stdlib.h>

int LinkInit(Node **l)
{
    *l = (Node *)malloc(sizeof(Node) * 1);

    if(NULL == *l)
    {
        return FAILURE;
    }
    
    (*l)->next = (*l);                  //**
    (*l)->prior = (*l);                 //**

    return SUCCESS;
}

int LinkInsrt(Node *l, int n, ElemType e)
{
    Node *p = l;
    int k = 1;
    
    if(NULL == l)
    {
        return FAILURE;
    }

    if(n > LinkLength(l) + 1)           //**
    {
        return FAILURE;
    }

    while(k < n)                        //**
    {
        p = p->next;
        k++;
    }
    
    if(k > n)                           //**
    {
        return FAILURE;
    }

    Node *q = (Node *)malloc(sizeof(Node) * 1);

    if(NULL == q)
    {
        return FAILURE;
    }

    q->data = e;
    q->prior = p;
    q->next = p->next;
    p->next = q;
    if(l != q->next)                    //**       
    {
        q->next->prior = q;
    }

    return SUCCESS;
}

int LinkTraverse(Node *l, void (*p)(ElemType))
{
    if(NULL == l)
    {
        return FAILURE;
    }
    Node *q = l;

    while(q->next != l)             //**
    {
        q = q->next;
        p(q->data);

    }
    return SUCCESS;
}

/*int LinkReverse(Node *l)
{
    if(NULL == l)
    {
        return FAILURE;
    }
    Node *p = l->next;
    l->next = NULL;

    while(p != NULL)
    {
        Node *q = p;
        p = p->next;
        q->next = l->next;
        l->next = q;
    }
    return SUCCESS;
}*/
int LinkLength(Node *l)
{
    if(NULL == l)
    {
        return FAILURE;
    }

    int len = 0;
    Node *p = l->next;

    while(p != l)               //**
    {
        len++;
        p = p->next;
    }
    return len;
}

int LinkEmpty(Node *l)
{
    return(l->next == l && l->prior == l) ? TRUE : FALSE;       //**
}

int GetElem(Node *l, int p, ElemType *e)
{
    if(NULL == l || p < 1)
    {
        return FAILURE;
    }

    Node *q = l->next;                          //**
    int i;

    for(i = 1; i < p && q != l; i++)            //**
    {
        q = q->next;
    }

    if(q == l)                  //**
    {
        return FAILURE;
    }

    *e = q->data;

    return SUCCESS;
}

int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType))
{
    if(NULL == l)
    {
        return FAILURE;
    }

    Node *q = l->next;
    int len = 1;

    while(q != l)               //**
    {
        if(p(e, q->data) == TRUE)
        {
            return len;
        }
        len++;
        q = q->next;
    }

    return FAILURE;
}

int LinkDelete(Node *l, int p, ElemType *e)
{
    int k = 1;
    Node *q = l;

    if(l == NULL)
    {
        return FAILURE;
    }

    if(p > LinkLength(l) + 1)       //**
    {
        return FAILURE;
    }
    while(k < p)                    //**
    {
       // q->next->prior = q->prior;
        q = q->next;
        k++;
    }

    if(k > p)                       //**
    {
        return FAILURE;
    }

    Node *n = q->next;
    *e = n->data;
    q->next = n->next;
    
    n->next->prior = q;             //**
    
    free(n);

    return SUCCESS;
}

int LinkClear(Node *l)
{
    if (NULL == l)
    {
        return FAILURE;
    }

    Node *p = l->next;

    while(p != l)                   //**
    {
        l->next = p->next;
        free(p);
        p = l->next;
    }
    
    l->prior = l;                   //**

    return SUCCESS;
}   

int LinkDestroy(Node **l)
{
    if(NULL == *l)
    {
        return FAILURE;
    }

    free(*l);
    (*l) = NULL;

    return SUCCESS;
}

 主函数

#include <stdio.h>
#include "LinkList.h"
#include <stdlib.h>
#include <time.h>

void print(ElemType e)
{
    printf("%d ",e);
}

int equal(ElemType e1, ElemType e2)
{
    return (e1 = e2) ? TRUE : FALSE;
}

int main()
{
    int i, ret;
    Node *first = NULL;

    srand(time(NULL));

    ret = LinkInit(&first);                 //LinkInit --> LinkList
    if(ret == FAILURE)
    {
        printf("Init Failure!\n");
    }
    else
    {
        printf("Init Success!\n");
    }

    for(i = 0; i < 10; i++)
    {
        ret = LinkInsrt(first, i + 1, rand() % 20);
        
        if(ret == FAILURE)
        {
            printf("Insert Failure!\n");
        }
        else
        {
            printf("Insert Success!\n");
        }
    }

    ret = LinkTraverse(first, print);
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }
    
    ret = LinkReverse(first);
    if(ret == SUCCESS)
    {
        printf("Reverse Success!\n");
    }
    else
    {
        printf("Reverse Success!\n");
    }

    ret = LinkTraverse(first, print);
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

    ret = LinkLength(first);
    if(ret == FAILURE)
    {
        printf("Get Length Failure!\n");
    }
    else
    {
        printf("Length is %d.\n",ret);
    }
    
    ret = LinkEmpty(first);
    if(FALSE == ret)
    {
        printf("Empty FAILURE!\n");
    }
    else
    {
        printf("Empty SUCCESS!\n");
    }

    int p = 3;
    ElemType e;
    ret = GetElem(first, p, &e);

    if(ret == FAILURE)
    {
        printf("Get element failure!\n");
    }
    else
    {
        printf("The %dth element is %d.\n", p, e);  
    }

    e = 10;
    ret = LocateElem(first, e, equal);

    if(FAILURE == ret)
    {
        printf("%d is not exist!\n", e);
    }
    else
    {
        printf("%d is %dth element!\n", e, ret);
    } 

    ret = LinkDelete(first, p, &e);
    if(ret == SUCCESS)
    {
        printf("Delete %d Success!\n", e);
    }
    else
    {
        printf("Delete Failure!\n");
    }

    ret = LinkClear(first);
    if(ret == SUCCESS)
    {
        printf("Clear Success!\n");
    }
    else
    {
        printf("CLear Failure!\n");
    }

    ret = LinkTraverse(first, print);
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }
    
    ret = LinkDestroy(&first);
    if(ret == SUCCESS)
    {
        printf("Destroy Success!\n");
    }
    else
    {
        printf("Destroy Failure!\n");
    }

    for(i = 0; i < 10; i++)
    {
        ret = LinkInsrt(first, i + 1, rand() % 20);
        
        if(ret == FAILURE)
        {
            printf("Insert Failure!\n");
        }
        else
        {
            printf("Insert Success!\n");
        }
    }

    return 0;
}