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

对单向链表的初始化、插入/删除节点、打印链表、对链表排序等一系列简单的操作：

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