双向链表的增删改查



/*************************************************************************
    > File Name: 2.c
    > Author: zz
    > Mail: zzzkkk@outlook.com
    > Created Time: 2017年05月21日 星期日 13时37分32秒
 ************************************************************************/

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

#define T 1
#define F -1

typedef int Boolean;
typedef int ElementType;

struct Node
{
 struct Node* prior;
 ElementType value;
 struct Node* next;
};

typedef struct Node* node;

Boolean init(node* head);
Boolean insert_tail(node head, ElementType value);
Boolean insert_head(node head, ElementType value);
Boolean insert_index(node head, ElementType value, int index);
Boolean delete_index(node head, int index);
void delete_value(node head, ElementType value);
void update_value(node head, ElementType old_value, ElementType new_value);
void printP(node head);
void printN(node head);
int length(node head);

int main()
{
 int i;
 node head = NULL;

 init(&head);

 for (i = 0; i < 10; i++)
 {
  insert_head(head, i);
 }
 for (i = 0; i < 10; i++)
 {
  insert_tail(head, i);
 }
    printP(head);
 printN(head);

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

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

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

 update_value(head, 8, 88);
    printP(head);
 printN(head);

 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_tail(node head, ElementType value)
{
 node newnode = (node)malloc(sizeof(struct Node));
 if (NULL == newnode)
 {
  return F;
 }

 newnode->value = value;
  
 head->prior->next = newnode;
 newnode->next = head;

 newnode->prior = head->prior;
 head->prior = newnode;

 return T;
}

Boolean insert_head(node head, ElementType value)
{
 node newnode = (node)malloc(sizeof(struct Node));
 if (NULL == newnode)
 {
  return F;
 }

 newnode->value = value;

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

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

 return T;
}

Boolean insert_index(node head, ElementType value, int index)
{
 node temp = head;
 int i;

 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;
 }

 for (i = 0; i < index; i++)
 {
  temp = temp->next;
 }

 newnode->value = value;

 newnode->next = temp->next;
 temp->next = newnode;
 newnode->next->prior = newnode;
 newnode->prior = temp;
}

Boolean delete_index(node head, int index)
{
 if (index < 0 || index >= length(head))
 {
  printf("out of range\n");
  return F;
 }

 int i;
 for (i = 0; i < index; i++)
 {
  head = head->next;
 }

 node temp = head->next;
 head->next = head->next->next;
 head->next->prior = head;

 free(temp);

 return T;
}

void delete_value(node head, ElementType value)
{
 node temp = head;
 while(temp->next != head)
 {
  if (value == temp->next->value)
  {
   node temp2 = temp->next;
   temp->next = temp->next->next;
   temp->next->prior = temp;
   free(temp2);
  }
  else
  {
   temp = temp->next;
  }
 }
}

void update_value(node head, ElementType old_value, ElementType new_value)
{
 node temp = head;
 while (temp->next != head)
 {
  if (temp->next->value == old_value)
  {
   temp->next->value = new_value;
  }
  temp = temp->next;
 }
}

void printP(node head)
{
 node temp = head;
 while (temp->prior != head)
 {
  printf("%d ", temp->prior->value);
  temp = temp->prior;
 }
 printf("\n");
}

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

int length(node head)
{
 int count = 0;
 node temp = head;
 while (temp->next != head)
 {
  temp = temp->next;
  count++;
 }
 return count;
}