单向链表--初始化、添加删除节点、排序链表

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

#define MAXBUF     1024

typedef struct LINK_LIST{
int data;
struct LINK_LIST *next;
}LINK_LIST;

LINK_LIST *get_node(LINK_LIST *head, int i);

int init_list(LINK_LIST *list)
{
list->data = 0;
list->next = NULL;

return 0;
}

void destroy_list(LINK_LIST *head)
{
LINK_LIST *tmp_list;

while(head != NULL)
{
tmp_list = head->next;
free(head);
head = tmp_list;
}
}

void clear_list(LINK_LIST *head)
{
LINK_LIST *tmp_list = head;

while(tmp_list != NULL)
{
tmp_list->data = 0;
tmp_list = head->next;
}
}

void print_list(LINK_LIST *head)
{
LINK_LIST *tmp_list = head;
int i = 0;

while(tmp_list != NULL)
{
printf("%3d ", tmp_list->data);
tmp_list = tmp_list->next;
if ((++i) % 10 == 0)
{
printf("\n");
}
}
}

int list_length(LINK_LIST *head)
{
int length = 0;
LINK_LIST *p = head;

while(p != NULL)
{
length++;
p = p->next;
}

return length;
}

int get_elem(LINK_LIST *head, int i, int *e)
{
int n = i;
LINK_LIST *p;

p = get_node(head, i);
*e = p->data;

return *e;
}

int locate_elem(LINK_LIST *head, int e, char compare)
{
int i = 0;
LINK_LIST *p = head;

switch(compare)
{
case '>':
while(p != NULL)
{
if (e > p->data)
{
return i;
}
p = p->next;
i++;
}
return -1;
break;

case '=':
while(p != NULL)
{
if (e == p->data)
{
return i;
}
p = p->next;
i++;
}
return -1;
break;

case '<':
while(p != NULL)
{
if (e < p->data)
{
return i;
}
p = p->next;
i++;
}
return -1;
break;

default:
return -1;
}
}

LINK_LIST *get_node(LINK_LIST *head, int i)
{
int n = 0;
LINK_LIST *p = head;

while((++n <= i) && p != NULL)
{
p = p->next;
}

return p;
}

int list_insert(LINK_LIST *head, int i, int e)
{
LINK_LIST *p, *insert;

insert = malloc(sizeof(LINK_LIST));
if (insert == NULL)
{
return -1;
}
insert->data = e;
insert->next = NULL;
p = get_node(head, i);
if (p == NULL)
{
return -1;
}
insert->next = p->next;
p->next = insert;

return 0;
}

int list_delete(LINK_LIST *head, int i, int *e)
{
LINK_LIST *p,*delete;

if (i > 0)
{
p = get_node(head, i-1);
delete = p->next;
p->next = delete->next;
free(delete);
}
else if (i == 0)
{
p = head->next;
free(head);
head = p;
}

return 0;
}

int list_sort_inc(LINK_LIST *head)
{
int i, j, length;
int tmp, min;
LINK_LIST *prev, *next;

length = list_length(head);
for(i = 0; i < length - 1; i++)
{
min = i;
for(j = i + 1; j < length; j++)
{
prev = get_node(head, min);
next = get_node(head, j);
if (next->data < prev->data)
{
min = j;
}
}
prev = get_node(head, min);
next = get_node(head, i);
tmp = next->data;
next->data = prev->data;
prev->data = tmp;
}
}

int main(void)
{
LINK_LIST *list_a, *list_b;
int length_a, length_b;
int i, n, e = 0;

list_a = malloc(sizeof(LINK_LIST));
list_b = malloc(sizeof(LINK_LIST));
if (list_a == NULL || list_b == NULL)
{
return -1;
}

init_list(list_a);
init_list(list_b);
for(i = 0; i < 20; i++)
{
list_insert(list_b, i, 20-i);
list_insert(list_a, i, 20-i);
}
list_sort_inc(list_a);
list_sort_inc(list_b);

length_a = list_length(list_a);
length_b = list_length(list_b);

for(i = 0; i < length_b; i++)
{
get_elem(list_b, i, &e);
if ((n = locate_elem(list_a, e, '=')) != -1)
{
list_insert(list_a, n, e);
}
}

list_sort_inc(list_a);

print_list(list_a);

destroy_list(list_a);
destroy_list(list_b);

return 0;
}