循环双链表的实现

#include <iostream>
using namespace std;
#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#include "time.h"
#define MAXSIZE 1000 /* 存储空间初始分配量 */
typedef int ElemType ;
typedef int status  ;

typedef struct Node{
    int data;
    struct Node *next;
    struct Node *prior;

}Node,*LinkList;

status initNOde(LinkList *L){
    (*L) = (LinkList)malloc(sizeof(Node));
    if(!(*L))
    return ERROR;
    else{
     (*L)->next = (*L);
     (*L)->prior = (*L);
     return OK;
    }

}

status isEmpty(LinkList L){
   if(L->next == L || L->prior== L){
    return OK;
   }else{
    return ERROR;
   }

}

status insertHead(LinkList L,int e){ //插入第一个元素
    LinkList head = (LinkList) malloc(sizeof(Node));
    head->data = e;

    head->prior = L;
    head->next = L;

    L->next = head;
    L->prior = head;
    return OK;

}


status insertNode(LinkList *L,int i ,int e){
    if(isEmpty((*L)))              //判断当前的链表是否为空
        return insertHead((*L),e); //返回是否在第一个位置插入了节点

    LinkList p = (*L);
    int j=1;
    while(j<i){   //p指向的节点不是头结点 i的值大于链表的长度
          p =  p->next;
          j++;
          if(p==(*L))
          return ERROR;
    }

    if(j>i)         //处理i=0的特殊情况
    return ERROR;


    LinkList newList = (LinkList)malloc(sizeof(Node));
    newList->data = e;

    newList->prior = p;     //当p指向最后一个位置时，判断依然是下面，不许要增加
    newList->next = p->next;
    p->next->prior = newList;
    p->next = newList;

}

status DeleteList(LinkList *L ,int i , ElemType *e ){
     if(isEmpty((*L)))
        return ERROR;
     LinkList p = (*L)->next;   //这里与插入不同的是从一个节点开始遍历，
                                //因为我们要操纵的是第i个位置
     int j=1;
     while(j<i){                //于插入同理，找到i的位置
        p = p->next;
        j++;
        if(p==(*L))
        return ERROR;
     }

     if(i<j)
        return ERROR;

     p->prior->next=p->next;
     p->next->prior =p->prior;

     *e = p->data;          //获取数据
     free(p);

}

status AlwaysInsertHead(LinkList *L,int n){//头插法
     srand(time(0));
    (*L) = (LinkList)malloc(sizeof(Node));
    (*L)->prior = (*L);
    (*L)->next = (*L);
    int i=0;
    LinkList p=(*L); //遍历的作用是指向新创建节点的位置
    for(;i<n;i++){
        LinkList  head = (LinkList)malloc(sizeof(Node));
        head->data = rand()%100+1;
        head->prior=(*L);
        head->next =p;

        p->prior=head;
        (*L)->next =head;
         p=head;
    }


}


status AlwaysInsertTail(LinkList *L,int n){//尾插法
        srand(time(0));
        (*L) = (LinkList)malloc(sizeof(Node));
        (*L)->next=(*L);
        (*L)->prior=(*L);

        int i=0;
        LinkList s=(*L);    //记录新创建节点的位置
        for(;i<n;i++){
            LinkList p = (LinkList)malloc(sizeof(Node));
            p->data = rand()%100+1;

            p->next = (*L); //总是插到最后一个位置
            p->prior = s;

            s->next = p;
            (*L)->prior = p;
            s = p;
        }


}


status getValue(LinkList L ,int i ,ElemType * e){
    if(isEmpty(L))
        return ERROR;
    int j=1;
    LinkList p = L->next;
    while(p!=L&&j<i){
        j++;
        p=p->next;
    }
    if(p==L||j>i){
        return ERROR;
    }
    *e = p->data;
    return OK;
}

int findEqualVaule(LinkList L ,ElemType e){
    if(isEmpty(L))
        return ERROR;
    int j=1;
    LinkList p = L->next;
    while(p!=L){
        if(p->data==e)
        return j;
        j++;
        p=p->next;
    }
    if(p==L){
        return ERROR;
    }
}

int ListLength(LinkList L){
    if(isEmpty(L))
        return ERROR;
    int j=0;
    LinkList p = L->next;
    while(p!=L){
        j++;
        p=p->next;
    }
   return j;

}

status ClearList(LinkList L){
    if(isEmpty(L))
        return ERROR;
    LinkList p=L->next;
    LinkList q;
    while(p!=L){
        q=p->next;
        free(p);
        p=q;
    }
    (L)->next  = (L);
    (L)->prior = (L);
    return OK;
}
int main(){
    LinkList node1 ;
    initNOde(&node1);            //初始化node1
                                 //开始测试插入功能
    insertNode(&node1,1,2);      //在第一个位置插入值为2的节点
    insertNode(&node1,2,3);
    insertNode(&node1,3,4);
    insertNode(&node1,2,6);
    insertNode(&node1,1,7);
    LinkList p = node1->next;   //p指向第一个节点
    while(p!= node1){
        printf("%d\n",p->data);
        p = p->next;
    }
    LinkList pr = node1->prior;
    while(pr !=node1){
        printf("%d\n",pr->data);
        pr = pr->prior;
    }
                                //插入功能测试完毕
    /******开始测试删除功能******/
    printf("\n");
    int value;
    DeleteList(&node1,1,&value);
    DeleteList(&node1,1,&value);
    DeleteList(&node1,2,&value);

    printf("删除节点的数据值%d\n",value);
    p = node1->next;   //p指向第一个节点
    while(p!= node1){
        printf("%d\n",p->data);
        p = p->next;
    }
    pr = node1->prior;
    while(pr !=node1){
        printf("%d\n",pr->data);
        pr = pr->prior;
    }

/******测试头插法功能开始******/
    printf("\n");
    LinkList node2;
    AlwaysInsertHead(&node2,10);
    LinkList h;
    h=node2->next;
    while(h!= node2){
            printf("%d\n",h->data);
            h = h->next;
        }
    printf("\n");
    LinkList h1;
    h1 = node2->prior;
    while(h1!=node2){
        printf("%d\n",h1->data);
        h1 = h1->prior;
    }

/******测试尾插法功能开始******/
printf("\n");
    LinkList node3;
    AlwaysInsertTail(&node3,3);
    LinkList t;
    t=node3->next;
    while(t!= node3){
            printf("%d\n",t->data);
            t = t->next;
        }
    printf("\n");
    LinkList t1;
    t1 = node3->prior;
    while(t1!=node3){
        printf("%d\n",t1->data);
        t1 = t1->prior;
    }

/******测试得到第i个位置的元素的值******/
    printf("\n");
    int result;
    getValue(node3,3,&result);
    printf("%d\n",result);

/******测试查找与value相等元素的位置******/
    printf("\n");
    int x = findEqualVaule(node1,4);
    printf("%d\n",x);

/******计算链表的长度******/
    printf("\n");
    int y = ListLength(node2);
    printf("%d\n",y);

/*****清空链表*****/
    printf("%p\n",node3);
    ClearList(node3);
    printf("%p\n",node3->next);
    printf("%p\n",node3->prior);

return 0;
}