线性链表

与顺序表的不同与优势：

     顺序存储结构对于插入删除操作，当插入第i个元素时，每次需要移动n-i个元素，复杂度为O(n) 。而单链表，我们只需要在第一次时找到第i个位置的指针，此时复杂度也是O(n)，接下来只是简单地通过移动指针而已，时间复杂度为O(1)。故当插入与删除操作频繁时，单链表的效率较高。  

线性链表的基本操作：

 

     InitList (*L );    初始化操作，建立一个空的线性表L。

     ListEmpty（L）: 若线性表为空，返回true，否则返回false

     ClearList（*L）: 将线性表清空

     GetElem(L,i,*e): 将线性表中第i个元素的值返回给e

     LocateElem（L，e）:在线性表L中查找与给定值e相等的元素，如果查找成功，返回该元素在表中的序号表示成功，否则返回0表示失败。

       ListInsert(*L,i,e) :在线性表L中的第i个位置插入新元素e

     ListDelete（*L，i，e）: 删除线性表L中第i个位置元素，并用e返回其值

     ListLength（L）: 返回线性表L的元素个数

 

基本操作代码：

#include "iostream"
#include <time.h>

using namespace std;

typedef int ElemType;
typedef struct Node
{
	ElemType data;
	struct Node *next;
}Node;

typedef struct Node *LinkList;

/*********************
带头结点的链表
**********************/

ElemType GetElem(LinkList L,int i,ElemType *e)//获取第i个元素的值;复杂度为O(n)
{
	int j;
	LinkList p; 
	p =  L->next;//让p指向链表L的第一个结点
	j = 1;
	while ( p && j < i )//*p不为空或者计数器j还没有等于i时，循环继续
	{
		p = p->next;
		j++;
	}
	if( p == NULL || j > i )
	{
		cout<<"超出了链表的长度";
		return 0;
	}
	*e = p->data;
	return *e;
}

bool ListInsert( LinkList *L, int i,ElemType e	)// 在链表中第i个位置插入元素，由于有头结点
{
	int j;
	LinkList p,s;
	p = *L;
	j = 1;
	while(p && j < i )  //寻找第i个结点
	{ 
		p = p->next;
		++j;
	}
	if (!p || j > i )
	{
		cout<<"超过链表的长度";
		return false;
	}

	s = (LinkList)malloc(sizeof(Node));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;    //其实这里的*L可以全部用L代替
}


bool ListDelete( LinkList *L, int i,ElemType *e	)//删除第i个结点的元素
{
	int j;
	LinkList p,q;
	p = *L;
	j = 1;
	while(p->next && j < i )  //寻找第i个结点
	{ 
		p = p->next;
		++j;
	}
	if (!(p->next) || j > i )
	{
		cout<<"超过链表的长度";
		return false;
	}

	q = p->next;
	p->next = q->next;
	*e = q->data; //将删除结点的数据给e
	free(q);
	return true;    //其实这里的*L可以全部用L代替
}

//单链表的创建,头插法
void CreateListHead( LinkList *L,int n)
{
	LinkList p;
	int i;
	srand (time(0));//随机初始化种子
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;
	for ( i = 0; i<n;i++ )
	{
		p = (LinkList)malloc(sizeof(Node));//生成新结点
		p->data = rand()%100 + 1;
		p->next = (*L)->next;
		(*L)->next = p;//插入到表头
	}
}

//删除整条链表
bool ClearList(LinkList *L)
{
	LinkList p,q;
	p = (*L)->next;//指向第一个结点
	while(p)
	{
		q = p->next;
		free(p);
		p = q;
	}
	(*L)->next = NULL;
	return true;
}

//输出链表
void ListPrintf(LinkList *L)
{
	LinkList p;
	p = (*L)->next;
	while(p != NULL)
	{
		cout<<p->data<<"   ";
		p = p->next;
	}
}

//测试程序
void main()
{
	int n = 10;
	LinkList L = (LinkList)malloc(sizeof(Node));
	CreateListHead(&L,n); //随机插入10个数字
	ListPrintf(&L);

	getchar();
}

    

    对于静态链表，只是对于那些无指针的高级设计语言的一种处理方法，用数组来代替指针来描述链表。