1. #include <stdio.h>
    2. #include <malloc.h>
    3. #define OPT_SUCCESS 1
    4. #define OPT_FAILURE 0
    5. typedef int ElemType;
    6. struct LinkedList
    7. {
    8.     int data;
    9.     struct LinkedList *next;
    10.     struct LinkedList *prev;
    11. };
    12. typedef struct LinkedList Node;
    13. Node* InitList(){
    14.     Node *p;
    15.     p = (Node *) malloc (sizeof(Node));
    16.     if(p==NULL) return NULL;
    17.     p->data = 0;
    18.     p->next = NULL;
    19.     p->prev = NULL;
    20.     return p;
    21. }
    23. Node* NewNode(ElemType k){
    24.     Node* p;
    25.     p = (Node *)malloc(sizeof(Node));
    26.     if( p == NULL) return NULL;
    27.     p->data = k;
    28.     p->next = p->prev = NULL;
    29.     return p;
    30. }
    32. int IsEmptyList(Node* plist){
    33.     if(plist->next == plist->prev) return OPT_SUCCESS;
    34.     return OPT_FAILURE;
    35. }
    37. int IsCircleList(Node* plist){
    38.     Node *pSentry = plist->next;
    39.     Node *opt = pSentry;
    40.     if (pSentry->prev != NULL) return OPT_SUCCESS;
    41.     while(opt != NULL){
    42.         opt = opt->next;
    43.         if (opt == pSentry) return OPT_SUCCESS;
    44.     }
    45.     return OPT_FAILURE;
    46. }
    48. void DestoryList(Node* plist){
    49.     Node *pSentry = plist->next;
    50.     Node *opt = plist->next;
    51.     while(opt != NULL){
    52.         pSentry = opt;
    53.         opt = opt->next;
    54.         free(pSentry);
    55.     }
    56.     free(plist);
    57. }
    59. int AppendElem(Node* phead,ElemType e){
    60.     Node *plist;
    61.     plist = phead;
    62.     if(plist->next == NULL){
    63.         plist->next = NewNode(e);
    64.         plist->prev = NULL;
    65.         return OPT_SUCCESS; 
    66.     }
    67.     Node* pSentry = NULL;
    68.     Node* opt;
    69.     opt = plist->next;
    70.     while(opt!=NULL){
    71.         pSentry = opt;
    72.         if(opt->next!=NULL) opt = opt->next;
    73.         else break;
    75.     }
    76.     opt->next = NewNode(e);
    77.     opt->next->prev = pSentry;
    78.     opt->next->next = NULL;
    79.     return OPT_SUCCESS;
    80. }
    82. int HeadinterElem(Node* phead, ElemType e){
    83.     Node * plist;
    84.     plist = phead;
    85.     if (plist == NULL) return OPT_FAILURE;
    86.     if (plist->next == NULL){
    87.         plist->next = NewNode(e);
    88.         plist->prev = NULL;
    89.         return OPT_SUCCESS; 
    90.     }
    91.     Node *p;
    92.     p = NewNode(e);
    93.     p->next = plist->next;
    94.     p->prev = NULL;
    95.     plist->next = p;
    96.     if(p->next!= NULL)
    97.         p->next->prev = p;
    99.     return OPT_SUCCESS;
    100. }
    102. int DeleteElem(Node* plist,ElemType e){
    103.     if (plist == NULL) return OPT_FAILURE;
    105.     Node *pSentry = NULL;
    106.     Node* opt = plist;
    108.     while(opt != NULL){
    109.         pSentry = opt;
    110.         opt = opt->next;
    111.         if(opt->data == e){
    112.             pSentry->next = opt->next;
    113.             opt->next->prev = pSentry;
    114.             free(opt);
    115.             return OPT_SUCCESS;
    116.         }
    117.     }
    118.     return OPT_FAILURE;
    119. }
    121. int UpdateElem(Node* plist,ElemType e, ElemType update){
    122.     if (plist == NULL) return OPT_FAILURE;
    124.     Node *pSentry = NULL;
    125.     Node* opt = plist->next;
    127.     while(opt != NULL){
    128.         pSentry = opt;
    129.         opt = opt->next;
    130.         if(opt->data == e){
    131.             opt->data = update;
    132.             return OPT_SUCCESS;
    133.         }
    134.     }
    135.     return OPT_FAILURE;
    136. }
    138. Node* SearchElem(Node *plist, ElemType e){
    139.     if (plist == NULL) return OPT_FAILURE;
    140.     Node *pSentry = NULL;
    141.     Node* opt = plist;
    143.     while(opt != NULL){
    144.         pSentry = opt;
    145.         opt = opt->next;
    146.         if(opt->data == e){
    147.             return opt;
    148.         }
    149.     }
    150.     return NULL;
    151. }
    155. int main(){
    156.     Node* head;
    158.     head = InitList();
    159.     Node *opt =NULL;
    160.     printf("%d\n",IsEmptyList(head));
    161.     ElemType e;
    162.     for (int i = 0; i < 10; i++)
    163.     {
    164.         scanf("%d",&e);
    165.         if(HeadinterElem(head,e) == OPT_SUCCESS){
    166.             printf("Insert Success\n");
    167.         }else{
    168.             printf("Insert Failure\n");
    169.         }
    170.     }
    171.     opt = head->next;
    172.     int i = 0;
    174.     while(opt!=NULL){
    175.         printf("%d\n",opt->data);
    176.         opt = opt->next;
    177.         i++;
    178.         if(i > 100) break;
    179.     }
    183.     return 0;
    184. }