准备新新新

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

#define ARRAY_SIZE(x)	(sizeof(x)/sizeof(x[0]))

int Random(int begin, int end)
{
	return (rand() % (end - begin) + begin);
}

void ArrayInit(int arr[], int len);
void ArrayShow(int arr[], int len);
void BubbleSort(int arr[], int len);
void SelectionSort(int arr[], int len);
void QuickSort(int arr[], int left, int right);
void InsertionSort(int arr[], int len);

int arr[9];

int main(int argc, char *argv[], char **env)
{
	printf("%s:Enter\n", __FUNCTION__);
	
	printf("%s(argc:%d)\n", __FUNCTION__, argc);

	int i;

	for (i = 0; i < argc; i ++)
	{
		printf("%s(argv[%d]:%s)\n", __FUNCTION__, i, argv[i]);
	}

	for (i = 0; env[i] != NULL; i ++) 
	{
		printf("%s(env[%d]:%s)\n", __FUNCTION__, i, env[i]);
	}
	
	srand((unsigned)time(NULL));
	ArrayInit(arr, ARRAY_SIZE(arr));
	BubbleSort(arr, ARRAY_SIZE(arr));
	
	srand((unsigned)time(NULL));
	ArrayInit(arr, ARRAY_SIZE(arr));
	SelectionSort(arr, ARRAY_SIZE(arr));
	
	srand((unsigned)time(NULL));
	ArrayInit(arr, ARRAY_SIZE(arr));
	printf("%s:Enter\n", "QuickSort");
	ArrayShow(arr, ARRAY_SIZE(arr));
	QuickSort(arr, 0, ARRAY_SIZE(arr) - 1);
	ArrayShow(arr, ARRAY_SIZE(arr));
	printf("%s:Exit \n", "QuickSort");
	
	srand((unsigned)time(NULL));
	ArrayInit(arr, ARRAY_SIZE(arr));
	InsertionSort(arr, ARRAY_SIZE(arr));

	printf("%s:Exit \n", __FUNCTION__);

	return 0;
}

void ArrayInit(int arr[], int len)
{
	int i;
	
	for (i = 0; i < len; i ++)
	{
		arr[i] = Random(1, 99);
	}
}

void ArrayShow(int arr[], int len)
{
	int i;
	
	for (i = 0; i < len; i ++)
	{
		printf("%2d ", arr[i]);
	}
	printf("\n");
}

void BubbleSort(int arr[], int len)
{
	printf("%s:Enter\n", __FUNCTION__);
	ArrayShow(arr, len);
	
	if ((NULL == arr) || (len < 0))
	{
		return;
	}

	int i, j;
	
	for (i = 0; i < len - 1; i ++)
	{
		for (j = 0; j < len - 1 - i; j ++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp;
				
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	
	ArrayShow(arr, len);
	printf("%s:Exit \n", __FUNCTION__);
}

void SelectionSort(int arr[], int len)
{
	printf("%s:Enter\n", __FUNCTION__);
	ArrayShow(arr, len);
	
	if ((NULL == arr) || (len < 0))
	{
		return;
	}
	
	int i, j;
	
	for (i = 0; i < len; i ++)
	{
		int min;

		min = arr[i];
		for (j = i; j < len; j ++)
		{
			if (min > arr[j])
			{
				int temp;
				
				temp = arr[j];
				arr[j] = min;
				min = temp;
			}
		}
		arr[i] = min;
	}
	
	ArrayShow(arr, len);
	printf("%s:Exit \n", __FUNCTION__);
}

void QuickSort(int arr[], int left, int right)
{	
	if ((NULL == arr) || (left > right))
	{
		return;
	}
	
	int l, r, key;
	key = arr[left];
	l = left;
	r = right;
	while (l < r)
	{
		while (arr[r] >= key && l < r)
			r --;
		while (arr[l] <= key && l < r)
			l ++;
		
		if (l < r)
		{
			int temp;
			
			temp = arr[l];
			arr[l] = arr[r];
			arr[r] = temp;
		}
	}
	arr[left] = arr[l];
	arr[l] = key;

	QuickSort(arr, left, l - 1);
	QuickSort(arr, l + 1, right);
}

void InsertionSort(int arr[], int len)
{
	printf("%s:Enter\n", __FUNCTION__);
	ArrayShow(arr, len);
	
	if ((NULL == arr) || (len < 0))
	{
		return;
	}
	
	int i, j;
	
	for (i = 0; i < len; i ++)
	{
		int min;

		min = arr[i];
		for (j = i; j < len; j ++)
		{
			if (min > arr[j])
			{
				int temp;
				
				temp = arr[j];
				arr[j] = min;
				min = temp;
			}
		}
		arr[i] = min;
	}
	
	ArrayShow(arr, len);
	printf("%s:Exit \n", __FUNCTION__);
}

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

typedef int DataType;

typedef struct node {	//结点类型定义
	DataType data;		//结点的数据域
	struct node *next;	//结点的指针域
} ListNode;

typedef ListNode *LinkList;

/**
 * 单链表
 * 双链表
 * 循环单链表
 * 循环双链表
 */

/**
 * 头结点
 * 头指针
 */

LinkList ListShow(LinkList l);
LinkList ListInit(void);
void ListFree(LinkList l);
LinkList ListAddTail(LinkList l, DataType data);
LinkList ListAddHead(LinkList l, DataType data);
LinkList ListDelTail(LinkList l);
LinkList ListDelHead(LinkList l);

#define NUM	9

void *my_malloc(int size);
void my_free(void *ptr);

int main()
{
	LinkList l_1;
	
	l_1 = ListInit();
	ListShow(l_1);
{
	int i;
	for (i = 0; i < NUM; i ++)
	{
		ListAddTail(l_1, i + 1);
	}

	ListShow(l_1);
}
{	
	int i;
	for (i = 0; i < NUM; i ++)
	{
		ListAddHead(l_1, i + 1);
	}

	ListShow(l_1);
}	
{	
	int i;
	for (i = 0; i < NUM; i ++)
	{
		ListDelTail(l_1);
	}

	ListShow(l_1);
}
{	
	int i;
	for (i = 0; i < NUM; i ++)
	{
		ListDelHead(l_1);
	}

	ListShow(l_1);
}

	ListFree(l_1);

	return 0;
}

LinkList ListShow(LinkList l)
{
	LinkList p = l;
	
	printf("%s(%2d):", __FUNCTION__, p->data);

	while (p)
	{
		p = p->next;
		
		if (p)
		{
			printf("%02d ", p->data);
		}
	}
	printf("\n");
	
	return l;
}

LinkList ListInit(void)
{
	ListNode *head = (ListNode *)my_malloc(sizeof(ListNode));
	
	head->data = 0;
	head->next = NULL;
	
	return head;
}

void ListFree(LinkList l)
{
	ListNode *p = l;
	
	if (p)
	{
		my_free(p);
	}
}

LinkList ListAddTail(LinkList l, DataType data)
{
	ListNode *p = l;

	while (p)
	{	
		if (p && (NULL == p->next))
		{
			ListNode *q = (ListNode *)my_malloc(sizeof(ListNode));
			
			q->data = data;
			p->next = q;
			p->next->next = NULL;
			l->data ++;
			
			break;
		}
		
		p = p->next;
	}
	
	return l;
}

LinkList ListAddHead(LinkList l, DataType data)
{
	ListNode *p = l;
	
	if (p)
	{
		ListNode *q = (ListNode *)my_malloc(sizeof(ListNode));
			
		q->data = data;
		q->next = p->next;
		p->next = q;

		l->data ++;
	}

	return l;
}

LinkList ListDelTail(LinkList l)
{
	ListNode *p = l;
	
	while (p)
	{
		p = p->next;
		
		if (p->next && (NULL == p->next->next))
		{
			my_free(p->next);
			p->next = NULL;
			
			l->data --;
			
			break;
		}
	}

	return l;
}

LinkList ListDelHead(LinkList l)
{
	ListNode *p = l;

	if (p->next)
	{
		ListNode *temp = p->next;
		
		if (p->next->next)
		{
			p->next = p->next->next;
		}
		else
		{
			p->next = NULL;
		}
		
		my_free(temp);
		
		l->data --;
	}

	return l;
}

void *my_malloc(int size)
{
	void *ptr;
	
	ptr = (void *)malloc(size);
	
	if (ptr)
	{
		printf("%s:%p\n", __FUNCTION__, ptr);
	}
	
	return ptr;
}
void my_free(void *ptr)
{
	if (ptr)
	{
		printf("%s:%p\n", __FUNCTION__, ptr);
		
		free(ptr);
		
		ptr = NULL;
	}
}

TARGET=list

all:
    gcc -g $(TARGET).c -o $(TARGET)
    ./$(TARGET)

clean:
    rm -rf $(TARGET)