线性表之链式存储

链表的存储结构

typedef int ElementType;
typedef struct Node
{
	ElementType data;
	struct Node* next;
}LNode;

链表的基本运算

1. 链表的初始化
   没有头结点的链表

LNode* init()
{
	LNode* List=(LNode*)malloc(sizeof(Node*));
	List=NULL;
	return List;	
}

2. 求表长

int length(LNode* List)
{
	LNode* L=List;
	int len=0;
	while(L){
		L=L->next;
		len++;
	}
	return len;
}

3. 查找
   按位置查找

LNode* find(LNode* List,int k)
{
	LNode* L=List;
	int i=1;
	while(L!=NULL && i<k)
	{
		L=L->next;
		i++;
	}
	if(i==k)	return L;
	return NULL;	
}

按值查找

LNode* Find(LNode* List,ElementType value)
{
	LNode* L=List;
	while(L!=NULL && L->data!=value){
		L=L->next;
	}
	return L;
}

4. 头插法

//有返回值的头插
LNode* head_insert(LNode* List,ElementType value)
{
	//LNode* p=List;
	LNode* L=(LNode*)malloc(sizeof(Node));
	L->data=value;
	L->next=List;
	printf("-------------\n");
	return L;
}
//返回值为void的头插
void head_insert(LNode** List,ElementType value)
{
	//LNode* p=List;
	LNode* L=(LNode*)malloc(sizeof(Node));
	L->data=value;
	L->next=*List;
	*List=L;
}

5. 尾插法

void foot_insert(LNode** List,ElementType value)
{
	LNode* L=*List;
	LNode* p=(LNode*)malloc(sizeof(Node));
	p->data=value;
	p->next=NULL;
	if(*List==NULL){
		*List=p;
	} 
	else{
		while(L->next){
			L=L->next;
		}
		L->next=p;
	}
}

6. 从某一位置插入（包括头尾）

void i_insert(LNode** List,int i,ElementType value)
{
	LNode* p=(LNode*)malloc(sizeof(Node));
	p->data=value;
	if(i==1){
		p->next=*List;	
		*List=p;
		return;
	}
	else{
		//LNode* L=*List;
		LNode* pre=find(*List,i-1);
		if(pre==NULL)
		{
			printf("位置错误");
			return; 
		}
		p->next=pre->next;
		pre->next=p;
	}
}

7. 从某一位置删除

void i_delete(LNode** List,int i)
{
	if(i==1){
		LNode* p=*List;
		*List=p->next;
		free(p);
		
	}
	else{
		//LNode* L=*List;
		LNode* pre=find(*List,i-1);
		if(pre==NULL)
		{
			printf("位置错误");
			return; 
		}
		LNode* p=pre->next;
		pre->next=p->next;
		free(p);
	}	
}

8. 单链表的倒置

void reverse(LNode** List) 
{
	//LNode* L=*List;
	LNode* p,*q;
	p=*List;
	*List=NULL;
	while(p!=NULL){
		q=p;
		p=p->next;
		q->next=*List;
		*List=q;
	}
}

9. 删除链表中重复的元素

void del_repeat(LNode** List)
{
	LNode* L=*List;
	LNode* q,*p,*r;
	p=L;
	while(p!=NULL)
	{
		q=p;
		while(q->next)
		{
			if(q->next->data==p->data){
			r=q->next;
			q->next=r->next;
			free(r);
			}
			else
				q=q->next;
		}
		p=p->next;
	}
}

10.找出A链表中属于链表A但不属于链表B的元素

void difference(LNode** LA,LNode* LB)
{
	LNode* p,*q,*pre,*r;
	p=*LA;
	pre=p;
	while(p!=NULL)
	{
		q=LB;
		if(p==*LA && p->data==q->data){
			r=p;
			*LA=p->next;
			p=p->next;
			pre=p;
			free(r);
		}
		else{
			while(q!=NULL && q->data!=p->data)	q=q->next;
			if(q!=NULL){
				r=p;
				pre->next=p->next;
				p=p->next;
				free(r);
			}
			else{
				pre=p;
				p=p->next;
			}
		}
	}
}

11. 输出链表中的元素

void print(LNode* List)
{
	LNode* L=List;
	while(L!=NULL){
		printf("%d*****\n",L->data);
		L=L->next;
	}
}