双向循环链表

#ifndef _LINKLIST_H

#define _LINKLIST_H

 

#define FAILURE 10000

#define SUCCESS 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 LinkInsert(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);

 

#endif

 

 

 

 

 

 

#include "LinkList.h"

#include <stdlib.h>

#include <stdio.h>

 

int LinkInit(Node **l)

{

*l = (Node *)malloc(sizeof(Node) * 1); //分配头结点 l 就是头指针

if (NULL == *l)

{

return FAILURE;

}

 

(*l)->next = (*l); //头结点指针域为空

(*l)->prior = (*l); //双向链表，头结点prior指针为空 **

 

return SUCCESS;

}

 

int LinkInsert(Node *l, int n, ElemType e) //n 插入的位置

{

Node *p = l;

int k = 1; //k 移动的次数

 

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不是最后一个结点 **

{

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 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) //p 位置

{

if (NULL == l || p < 1) //入参判断 p不能小于0

{

return FAILURE;

}

 

Node *q = l->next; //双向循环链表，q指向第一个结点 //**

int i;

 

for (i = 1; i < p && q != l; i++) //循环p次，同时满足q不为空 双向循环链表 i = 1**

{

q = q->next;

}

 

if (q == l) //如果q为空，说明p（位置）大于长度 **

{

return FAILURE;

}

 

*e = q->data; //q已经指向第p个结点

 

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;

}

q = q->next;

len++;

}

 

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) //判断位置p是否合法 **

{

return FAILURE;

}

 

while (k < p) //**

{

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;

//p->next->prior = l;

free(p);

p = l->next;

}

 

l->prior = l; //**

 

return SUCCESS;

}

 

int LinkDestroy(Node **l)

{

if (l == NULL)

{

return FAILURE;

}

free(*l);

(*l) = NULL;

 

return SUCCESS;

}

 

#if 0

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;

q->prior = l;

l->next = q;

}*/

 

Node *p = (*l)->next;

Node *tmp;

 

if (p == NULL)

{

return FAILURE;

}

 

if (p->next == NULL)

{

return FAILURE;

}

 

printf("xxxxx\n");

while (p->next != NULL)

{

tmp = p->next;

p->next = p->prior;

p->prior = tmp;

p = p->next;

}

printf("%d\n", p->data);

tmp = p->next;

p->next = p->prior;

p->prior = (*l);

 

(*l)->next = p;

 

return SUCCESS;

}

#endif

 

 

 

 

 

#include "LinkList.h"

#include <stdio.h>

 

void print(ElemType e)

{

printf("%d ", e);

}

 

int equal(ElemType e1, ElemType e2)

{

return (e1 == e2) ? TRUE : FALSE;

}

 

int main()

{

int ret, i;

Node *first = NULL; //头指针

 

srand(time(NULL));

 

ret = LinkInit(&first);

if (ret == FAILURE)

{

printf("Init Failure!\n");

}

else

{

printf("Init Success!\n");

}

 

for (i = 0; i < 10; i++)

{

ret = LinkInsert(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 Falure!\n");

}

else

{

printf("\nTraverse Success!\n");

}

 

/*ret = LinkReverse(&first);

if (ret == SUCCESS)

{

printf("Reverse Success!\n");

}

else

{

printf("Reverse Failure!\n");

}

 

ret = LinkTraverse(first, print);

if (ret == FAILURE)

{

printf("\nTraverse Falure!\n");

}

else

{

printf("\nTraverse Success!\n");

}*/

 

ret = LinkLength(first);

if (ret == FAILURE)

{

printf("Get Length Failure!\n");

}

else

{

printf("length %d\n", ret);

}

 

ret = LinkEmpty(first);

if (ret == TRUE)

{

printf("List is empty!\n");

}

else if (ret == FALSE)

{

printf("List is not empty!\n");

}

 

int p = 10;

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 not exist!\n", e);

}

else

{

printf("%d is %dth element!\n", e, ret);

}

 

p = 1;

ret = LinkDelete(first, p, &e);

if (ret == FAILURE)

{

printf("Delete Failure!\n");

}

else

{

printf("Delete %d Success!\n", e);

}

 

ret = LinkTraverse(first, print);

if (ret == FAILURE)

{

printf("\nTraverse Falure!\n");

}

else

{

printf("\nTraverse Success!\n");

}

 

ret = LinkClear(first);

if (ret == SUCCESS)

{

printf("Clear Success!\n");

}

else

{

printf("Clear Failure!\n");

}

 

ret = LinkEmpty(first);

if (ret == TRUE)

{

printf("List is empty!\n");

}

else if (ret == FALSE)

{

printf("List is not empty!\n");

}

 

ret = LinkDestroy(&first);

if (ret == SUCCESS)

{

printf("Destroy Success!\n");

}

else

{

printf("Destroy Failure!\n");

}

 

for (i = 0; i < 10; i++)

{

ret = LinkInsert(first, i + 1, rand() % 20);

if (ret == FAILURE)

{

printf("Insert Failure!\n");

}

else

{

printf("Insert Success!\n");

}

}

 

return 0;

}