双向链表的建立 增删改 打印

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