博客

#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”);

}

运行结果如下：