Основы программирования

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define MAXSIZE 100				//макс. размер списка
 
typedef int T;					
typedef struct LNODE LNODE;			//   переопределяем типы
typedef struct list list;			//   для удобства
typedef enum {false,true} bool;		
struct LNODE
{
	int key;					// эл-нт списка
	T info;
	struct LNODE *next;
}node;
 
struct list						//создаём список
{
	int size;					//его размер
	int count;					//счётчик
	LNODE *head, *tail;			//указатель на начало и конец
};
 
bool is_list_empty (list l);				//пустой список
bool is_list_overflow (list l);				//переполнение списка
void init_list (list *l);					//инициализация списка
void clear_list (list *l);					//очищение списка
void append_to_head (list *l,LNODE *n);		//добавить к началу
void append_to_tail (list *l,LNODE *n);  	//добавить в конец
void insert (list *l,LNODE *n,int k);		//вставить эл-нт
LNODE *find (list *l,int k);				//найти эл-нт
 
                                                 //Описываем все эти ф-ции
bool is_list_empty (list l)
{
	return (l.count==0)?(true):(false);
}
 
bool is_list_overflow (list l)
{
	return (l.count==MAXSIZE)?(true):(false);
}
 
void init_list (list *l)
{
	l->count=0;
	l->size=0;
	l->tail->next=NULL;
}
 
void append_to_head	(list *l,LNODE *n)
{
	if (!is_list_overflow(*l))
		if(is_list_empty(*l))
		{
			l->head=l->tail=n;
			n->next=NULL;
			l->count=1;
		}
		else
		{
			n->next=l->head;
			l->head=n;
			l->count++;
		}
}
 
void append_to_tail (list *l,LNODE *n)
{
	if (!is_list_overflow(*l))
		if(is_list_empty(*l))
		{
			l->head=l->tail=n;
			n->next=NULL;
			l->count=1;
		}
		else
		{
			l->tail->next=n;
			n->next=NULL;
			l->tail=n;
			l->count++;
		}
}
 
void insert (list *l,LNODE *n,int k)
{
	LNODE *temp;
	if(is_list_empty(*l))
	{
		LNODE *cnode;
		for(cnode=l->head; ((cnode->key!=k)&&(cnode->next!=NULL)); cnode=cnode->next);
		temp=cnode->next;
		cnode->next=n;
		n->next=temp;
		l->count++;
		l->tail=n;
	}
	else append_to_tail (l,n);
}
 
LNODE *find (list *l,int k)
{
	LNODE *temp = NULL;
	if(!is_list_empty(*l))
	{
		while((temp!=NULL)&&(temp->key!=k))
		{
			temp = temp->next;
		}
	}
	return temp;
}
 
void print_list(list *l) 		                    //печать списка
{
	LNODE *temp = NULL;
	if(!is_list_empty(*l))
	{
		temp = l->head;
		printf("Key(value)\n");
		while((temp!=NULL))
		{
			printf("%i(%i) -> ", temp->key, temp->info);
			temp = temp->next;
		}
		printf("NULL");
	}
}
 
 
int main()
{
	list *l;				  //создаём список
	int i;
	LNODE *current,*previous;	          //указатели на текущий и пред. эл-нт
	LNODE *max, *min;			  //указатели на макс. и мин. эл-нт
	l=(list*)malloc(sizeof(list));	          //выделяем память под список
	init_list(l);					//инициализируем список
	randomize();					//инициализируем рандом
	for(i=0;i<10;i++)
	{
		current=(LNODE*)malloc(sizeof(node));	
		current->key=i;
		current->info=random(MAXSIZE);	       //заполняем список случайными числами
		append_to_tail(l,current);
	}
	max=l->head;
	min=l->head;
	current=l->head;
	while(current!=NULL)				
	{									
		if(current->info>max->info)		//проходим по списку и ищем макс. и мин. элементы
		{								
			max=current;				
		}							
		if(current->info<min->info)			
		{							
			min=current;			
		}							
		current=current->next;			
	}
	printf("\n\n\n");
	print_list(l);					// выводим список на экран
	printf("\n\n\n");
	previous=(LNODE*)malloc(sizeof(node));
	previous->key=min->key;				
	previous->info=min->info;			// делаем чтобы макс. эл-нт указывал
	current=max->next;					// на минимальный, а мин. на след. после
	max->next=previous;					// максимального. Т.е. вставляем мин.
	previous->next=current;				// эл-нт после макс.
	print_list(l);						// печатаем получившийся список
	return 0;
}