双向循环链表的 增 减 改 查 函数

 

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

#define T 1
#define F -1

typedef int Type;
typedef int Boolean;

struct node
{
    struct node *prior;
    Type value;
    struct node *next;
};
 
typedef struct node* Node;

Boolean init(Node *head);
Boolean insert_tail(Node head, Type value);
Boolean insert_head(Node head, Type value);
Boolean insert_index(Node head, Type index, Type value);
Boolean delete_index(Node head, Type index);
Boolean delete_value(Node head, Type value);
Boolean change_index(Node head, Type index, Type x);
Boolean change_value(Node head, Type old_value, Type new_value);
void search_index(Node head, Type index);
void search_value(Node head, Type value);
Boolean length(Node head);
Boolean printP(Node head);
Boolean printN(Node head);

int main()
{
    Node head = NULL;
    init(&head);
  
    int i;
    for (i = 0; i < 10; i++)
    {
        insert_tail(head, i);
    }
    printN(head);
    printP(head);  
 
    for (i = 0; i < 10; i++)
    {
        insert_head(head, i);
    }
    printN(head);
    printP(head);
 
    printf("length = %d\n", length(head));

    insert_index(head, 0, 99);
    insert_index(head, 11, 99);
    insert_index(head, length(head), 99);
    printN(head);
    printP(head);

    delete_index(head, 11);
    delete_index(head, 0);
    delete_index(head, length(head) - 1);
    printN(head);
    printP(head);

    delete_value(head, 0);
    printN(head);
    printP(head);

    change_index(head, 0, 100);
    printN(head);
    printP(head);
   
    change_value(head, 1, 101);
    printN(head);
    printP(head);

    search_index(head, 5);

    search_value(head, 101);

    return 0;
}

Boolean init(Node *head)
{
    Node newnode = (Node)malloc(sizeof(struct node));
    if (NULL == newnode)
    {
        return F;
    }
   
    newnode->next = newnode;
    newnode->prior = newnode;

    *head = newnode;
 
    return T;
}

Boolean insert_head(Node head, Type value)
{
    Node newnode = (Node)malloc(sizeof(struct node));
    if (NULL == newnode)
    {
        return F;
    }
   
    newnode->value = value;
    head->next->prior = newnode;
    newnode->prior = head;

    newnode->next = head->next;
    head->next = newnode;

    return T;
}

Boolean insert_index(Node head, Type index, Type value)
{
    if (index < 0 || index > length(head))
    {
        printf("out of range\n");
        return F;
  
    }
    Node newnode = (Node)malloc(sizeof(struct node));
    if (NULL == newnode)
    {
        return F;
    }
    int i;
    Node temp = head;
    for (i = 0; i < index; i++)
    {
        temp = temp->next;
    }
    newnode->value = value;
    temp->next->prior = newnode;
    newnode->prior = temp;

    newnode->next = temp->next;
    temp->next = newnode;

    return T;
}    
   
Boolean insert_tail(Node head, Type value)
{
    Node newnode = (Node)malloc(sizeof(struct node));
    if (NULL == newnode)
    {
        return F;
    }
   
    newnode->value = value;
    newnode->next = head;
    head->prior->next = newnode;
   
    newnode->prior = head->prior;
    head->prior = newnode;
   
    return T;
}
   
Boolean delete_index(Node head, Type index)
{
    if (index < 0 || index >= length(head))
    {
        printf("out of range\n");
        return F;
  
    }
    int i;
    Node temp = head;
    for (i = 0; i < index; i++)
    {
        temp = temp->next;
    }
    Node j = temp->next;
    temp->next = temp->next->next;
    temp->next->prior = temp;
    free(j);
 
    return T;
}

Boolean delete_value(Node head, Type value)
{
    Node j;
    Node temp = head;
    while (temp->next != head)
    {
        if (temp->next->value == value)
        {       
            j = temp->next;
            temp->next = temp->next->next;
            temp->next->prior = temp;
            free(j);
        }
        else
        {
            temp = temp->next;
        }
    }
}
Boolean change_index(Node head, Type index, Type x)
{
    int i;
    if (index < 0 || index >= length(head))
    {
        printf("out of range\n");
        return F;
    }
    for (i = 0; i <= index; i++)
    {
        head = head->next;
    }
    head->value = x;

    return T;
}

Boolean change_value(Node head, Type old_value, Type new_value)
{
    int count = 0;
    Node temp = head;
    while (temp->next != head)
    {
        if(temp->next->value == old_value)
        {
            count = 1;
            temp->next->value = new_value;
        }
        temp = temp->next;
    }
    if (count == 0)
    {
        printf("not find\n");
    }

    return T;
}

void search_index(Node head, Type index)
{
    int i;
    Node temp = head;
    if (index < 0 || index >= length(head))
    {
        printf("out of range\n");
    }
    for (i = 0; i < index; i++)
    {
        temp = temp->next;
    }
    printf(" %dindex = %dvalue\n", index, temp->next->value);

}

void search_value(Node head, Type value)
{
    int count = 0;
    Node temp = head;
    while (temp->next != head)
    {
        if (temp->next->value == value)
        {
            printf(" %dvalue = %dindex   ", value, count);
        }
        temp = temp->next;
        count++;
    }
    printf("\n");
}

Boolean length(Node head)
{
    int count = 0;
    Node temp = head;
    while (temp->next != head)
    {
        count++;
        temp = temp->next;
    }
   
    return count;
}
Boolean printP(Node head)
{
    Node temp = head;
    while (temp->prior != head)
    {
        printf("%d ", temp->prior->value);
        temp = temp->prior;
    }
    printf("\n");
}

Boolean printN(Node head)
{
    Node temp = head;
    while (temp->next != head)
    {
        printf("%d ", temp->next->value);
        temp = temp->next;
    }
    printf("\n");
}

运行结果如下：