循环链表学习笔记

#include <stdio.h>//单向循环链表，特点：尾节点不是指向NULL，而是指向前端的头节点
#include <stdlib.h>
#define T 1
#define F 2


typedef int type;
typedef int Boolean;


struct node
{
    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 value, int index);
Boolean delete_index(Node head, int index);
Boolean delete_value(Node head, type value);
Boolean find_index(Node head, int index);
Boolean find_value(Node head, type value);
Boolean update_index(Node head, int index, type new_value);
Boolean update_value(Node head, type old_value, type new_value);
Boolean length(Node head);
void print(Node head);


int main()
{
     Node head = NULL;
     int i;
     init(&head);
     for (i = 0; i < 20; i++)
     {
         insert_tail(head,i);
     }
     for (i = 0; i < 20; i++)
     {
         insert_head(head,i);
     }
     print(head);
     printf("\n");
     printf("length = %d\n",length(head));
     insert_index(head,99,2);
     print(head);
     printf("\n");
     
     delete_index(head, 0);
     print(head);


     delete_value(head,99);
     print(head);
     delete_value(head,0);
     print(head);


     find_index(head, 2);
     find_value(head,4);


     update_index(head,5,101);
     print(head);
     update_value(head,3,33);
     print(head);
     return 0;
}




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


Boolean insert_tail(Node head, type value)
{
    Node temp = head;
    Node newnode = (Node)malloc(sizeof(struct node));
    if (NULL == newnode)
    {
        return F;
    }
    newnode->value = value;
    newnode->next = head;
    while (temp->next != head)//因为head在不停地向后移动，所以这里便是和单链表的区别，单链表用NULL作为结束的标志，
                         //循环链表把head的值固定，作为结束的标志，用temp来遍历整个链表
    {
        temp = temp->next;
    }   
    temp->next = 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;
    newnode->next = head->next;
    head->next = newnode;
    return T;
}


Boolean insert_index(Node head, type value, int index)
{
    if (index < 0 || index > length(head))
    {
        return F;
    }


    Node newnode = (Node)malloc(sizeof(struct node));
    if (NULL == newnode)
    {
        return F;
    }
    int i;
    for (i = 0; i < index; i++)
    {
        head = head->next;
    }
    newnode->next = head->next;
    head->next = newnode;
    newnode->value = value;


    return T;
}


Boolean delete_index(Node head, int index)
{
    if (index < 0 || index > length(head))
    {
        return F;
    }
    
    int i;
    for (i = 0; i < index; i++)
    {
        head = head->next;
    }
    Node temp = head->next->next;
    free(head->next);
    head->next = temp;
  
    return T;
}


Boolean delete_value(Node head, type value)
{
    Node temp = head;
    while (temp->next != head)
    {
        if(value == temp->next->value)
        {
            Node temp2 = temp->next->next;
            free(temp->next);
            temp->next = temp2;
        }
        else
        {
             temp = temp->next;
        }
    }
    return T;
}
Boolean length(Node head)
{
    Node temp = head;
    int cont = 0;
    while (temp->next != head)
    {
        temp = temp->next;
        cont++;
    }
    return cont;
}


Boolean find_index(Node head, int index)
{
    if (index < 0 || index > length(head))
    {
        return F;
    }
    
    int i;
    for (i = 0; i <= index; i++)
    {
        head = head->next;
    }
    printf("index%d value%d\n", index, head->value);


    return T;
}


Boolean find_value(Node head, type value)
{
     Node temp = head;
     int cont = 0;
     while (temp->next != head)
     {  
         if (value == temp->value)
         {
             printf("index%d\n",cont);
         }
         temp = temp->next;
         cont++;
     }
    
     return T;
}


Boolean update_index(Node head, int index, type new_value)
{
    if (index < 0 || index > length(head))
    {
        return F;
    }
    
    int i;
    for (i = 0; i <= index; i++)
    {
        head = head->next;
    }
    head->value = new_value;
   
   return T;
}


Boolean update_value(Node head, type old_value, type new_value)
{
     Node temp = head;
     while (temp->next != head)
     {  
         if (old_value == temp->next->value)
         {
             temp->next->value = new_value;
         }
         temp = temp->next;
     }
    
     return T;
}


void print(Node head)
{
    Node temp = head;
    while (temp->next != head)
    {
        printf("   %d",temp->next->value);
        temp = temp->next;
    }
    printf ("\n");
}
总结：总的来说，循环链表是单向链表的进一步深化，大部分特点和单链表是一致的，但使用中应该注意其中的区别。