数据结构---线性表(链式存储)

/*
	链表 链式存储
*/

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

#define ElemType int
#define ERROR -1
#define OK 0

typedef struct Node
{
	ElemType value;
	struct Node *next;
}Node, *LinkList;


Node* createNode(int value)
{
	Node *node = (Node *)malloc(sizeof(Node));
	node->value = value;
	node->next = NULL;
	return node;
}

void createListHead(LinkList *list, int n)
{
	*list = createNode(n);
	srand(time(0));
	printf("head:");
	for (int i = 0; i < n; i++)
	{
		int value = rand() % 100 + 1;
		printf("%d\n", value);
		Node *node = createNode(value);
		node->next = (*list)->next;
		(*list)->next = node;
	}
}

void createListTail(LinkList *list, int n)
{
	*list = createNode(n);
	srand(time(0));
	printf("tail:");
	Node *r = (*list);
	for (int i = 0; i < n; i++)
	{
		int value = rand() % 100 + 1;
		printf("%d ", value);
		Node *node = createNode(value);
		node->next = r->next;
		r->next = node;
		r = node;
	}
}

void dump(Node *list)
{
	printf("\ndump:");
	Node *p = list->next;
	for (int i =0;i<list->value;i++)
	{
		printf("%d ", p->value);
		p = p->next;
	}
	printf("\n");
}

/*
  1 =< i <= list->value
*/
int getElem(Node *list, int pos, ElemType *data)
{
	assert(list);
	if (pos > list->value)
	{
		return ERROR;
	}
	int i = 0;
	Node *p = list;
	while (p && i < pos)
	{
		p = p->next;
		++i;
	}
	if (!p || i > pos)
	{
		return ERROR;
	}
	*data = p->value;
	return OK;
}

/*
	1 =< pos <= list->value
*/
int insert(Node *list,int pos,ElemType value)
{
	assert(list);
	if (pos > list->value)
	{
		return ERROR;
	}
	Node *p = list;
	int i = 0;
	while (p && i < pos)
	{
		p = p->next;
		++i;
	}
	if (!p || i > pos)
	{
		return ERROR;
	}

	Node *node = createNode(value);
	node->next = p->next;
	p->next = node;
	list->value++;
}

/*
1 =< pos <= list->value
*/
int del(Node *list, int pos, ElemType *value)
{
	assert(list);
	if (pos > list->value)
	{
		return ERROR;
	}
	Node *p = list;
	Node *pre = NULL;
	int i = 0;
	while (p && i < pos)
	{
		pre = p;
		p = p->next;
		++i;
	}
	if (!p || i > pos)
	{
		return ERROR;
	}
	*value = p->value;
	pre->next = p->next;
	list->value--;
	free(p);
	return OK;
}

void clearList(Node *list)
{
	assert(list);
	while (list->next)
	{
		Node *p = list->next;
		list->next = p->next;
		free(p);
		list->value--;
	}
	list->next = NULL;
	list->value = 0;
}

int main()
{
	Node *linklist = NULL;
	createListTail(&linklist, 10);
	dump(linklist);
	ElemType data;
	int ret = getElem(linklist, 3, &data);
	insert(linklist, 2, 100);
	dump(linklist);
	del(linklist, 5, &data);
	dump(linklist);
	clearList(linklist);
    dump(linklist);
	return 0;
}

顺序和链式坐一下简单对比：

存储分配方式:顺序必须一块连续的内存  链式不必连续用一组任意的存储单元存放

时间性能：查找             顺序o(1)  单链表o(n) 

                 插入和删除  顺序需要平均移动表长的一半 o(n)  单链表在查找到插入位置后 o(1)

                 空间性能     顺序需要预分配空间，大了浪费小不够   单链表不需要提前分配，用到了在分配。。。。。。