链表(C语言）

1.顺序表与链表区别辨析

	顺序表	链表
存储方式	顺序存储	随机存储
存取方式	随机存取	顺序存取

解释：顺序表按照一定顺序一次存储元素，通过下标索引查找元素

链表随机存储元素，从头结点按照地址顺序依次查找元素

2.具体算法

单链表结构：

typedef Struct{
	char num[8];
	char name[8];
	int score;
}Elemtype;//数据域 
typedef struct Lnode{
	Elemtype data;//数据域 
	struct Lnode* next;//指针域 
}Lnode,*Linklist;

（1）创建空链表

Status init(Linklist &L){
    L=new Lnode;
    L->next=NULL;
    return OK;
}

（2）判断链表是否为空

int isempty(Linklist L){
    if(L->next)
        return 0;
    else
        return 1;
}

（3）销毁链表

Status destroy(Linklist &L){
    Lnode *p;
    while(L){
        p=L;
        L=L->next;
        delete p;
    }
    return OK;
}

（4）清空链表

Status clear(Linklist &L){
    Lnode *p,*q;
    p=L->next;
    while(p){
        q=p->next;
        delete p;
        p=q;
    }
    L->next=NULL;
    return OK;
}

​​​​​（5）计算链表长度

int length(Linklist &L){
    int cnt=0;
    Lnode* p;
    p=L->next;
    while(p){
        p=p->next;
        cnt++;
    }
    return cnt;
}

（6）读取第i个元素

Status get(Linklist L,int i,Elemtype &x){
	Lnode* p=L->next;
	int j=1; 
	while(p&&j<i){
		p=p->next;
		++j;
	}
	if(i>cnt){
		return ERROR;
	}///cnt为链表长度
	x=p->data;
	return x;
}

（7）输入数据，返回对应指针

Lnode* locate(Linklist L,Elemtype x){
	Lnode* p=L->next;
	while(p&&p->data!=x){
		p=p->next;
	}
	return p;
}

（8）输入数据，返回对应序号

int locate(Linklist L,Elemtype x){
	Lnode* p=L->next;
	int j=1;
	while(p&&p->data!=x){
		p=p->next;
		j++;
	}
	if(p){
		return j;
	}
	else{
		return 0;
	}
}

（9）在第i个元素前插入数据元素x

Status insert(Linklist &L,int i,Elemtype x){
	Lnode* p=L;
	int j=0;
	while(p&&j<i-1){
		p=p->next;
		++j;
	}
	if(!p||j>i){
		return ERROR;
	}
	s=new Lnode;
	s->data=x;
	s->next=p->next;
	p->next=s;
}

（10）头插法

void create(Linklist &L,int n){
	L=new Lnode;
	L->next=NULL;
	for(int i=n;i>0;--i){
		p=new Lnode;
		cin>>p->data;
		p->next=L->next;
		L->next=p;
	}
} 

（11）尾插法

Linklist insert(Linklist &L,int x){
	Linklist p=(Linklist)malloc(sizeof(LNode));
	p->data=x;
	p->next=NULL;
	if(!L->next){
		L->next=p;
	}
	else{
		Linklist q=L;
		while(q->next){
			q=q->next;
		}
		q->next=p;
	}
}

（12）删除第i个元素

Linklist insert(Linklist &L,int x){
	Linklist p=(Linklist)malloc(sizeof(LNode));
	p->data=x;
	p->next=NULL;
	if(!L->next){
		L->next=p;
	}
	else{
		Linklist q=L;
		while(q->next){
			q=q->next;
		}
		q->next=p;
	}
}

（13）合并链表，去除重复元素（通用算法，线性表也可）

void union(SeqList&La,SeqList Lb){
	al=Length(La);
	bl=Length(Lb);
	for(int i=1;i<=bl;i++){
		Get(Lb,i,x);
		if(!Locate(La,e))Insert(&La,++al,e);
	}
}//将Lb接到La后

（14）有序表的合并

void merge(Linklist& La, Linklist& Lb, Linklist& Lc) {
	Linklist pa = La->next;
	Linklist pb = Lb->next;
	Linklist pc = Lc = La;
	while (pa && pb) {
		if (pa->data < pb->data) {
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else {
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
	}
	pc->next = pa ? pa : pb;
	delete Lb;
}

（15）输出单链表

void PrintLinkNode(Linklist& L)
{
	Linklist* s=L->next;
	while (s != NULL) {
		cout<< s->data;
		s =s->next;
	}
	cout<<endl;
}

（16）逆转单链表

LNoode reverse(Lnode L){
	Linklist old_head,new_head,temp;
	new_head=NULL;
	old_head=L->next;
	while(old_head){
		temp=old_head->next;
		old_head->next=new_head;
		new_head=old_head;
		old_head=temp;
	}
	L->next=new_head;
	return L;

循环链表

（1）初始化

Linklist init(){
	Linklist p=(Linklist)malloc(sizeof(LNode));
	p->next=p;
	p->data=-1;
	return p;

（2）将数值为x的节点插到第n位

int insert(Linklist L,int x,int n){
	if(L==NULL||n<1){
		return -1;
	}
	Linklist p=L;
	int i=0;
	while(p->next!=p&&i<(n-1)){
		p=p->next;
		i++;
	}
	if(p->next==L&&i!=(n-1)){
		return -1;		
	}
	Linklist q=(Linklist)malloc(sizeof(LNode));
	q->data=x;
	q->next=p->next;
	p->next=q;
	return 0;
} 

（3）删除数据

int Delete(Linklist L,int n){
	if(L==NULL||n<1){
		return -1;
	}
	Linklist p=L;
	int i=0;
	while(p->next!=L&&i<(n-1)){
		p=p->next;
		i++;
	}
	if(p->next==L){
		return -1;
	}
	Linklist q=p->next;
	p->next=q->next;
	return 0;
}

（4）查找数据

int find(Linklist L,int *x,int n){
	if(p=NULL||x=NULL||n<1){
		return -1;
	}
	Linklist p=L->next;
	int i=1;
	if(p==L){
		return -1;
	}
	while(p->next!=L&&i<n){
		p=p->next;
		i++;
	}
	if(p->next==L){
		if(i!=n){
			return -1;
		}
	}
	*x=p->data;
	printf("%d",*x);
	return 0;
}

（5）链接两个带尾指针的循环链表

Linklist connect(Linklist Ta,Linklist Tb){
	Linklist p=Ta->next;
	Ta->next=Tb->next->next;
	delete Tb->next;
	Tb->next=p;
	return Tb;
} 

（6）尾插

void push(Linklist L,int x){
	Linklist p=(Linklist)malloc(sizeof(LNode));
	p->data=x;
	p->next=L;
	Linklist q=L;
	while(q->next!=L){
		q=q->next;
	}
	q->next=p;
}

双向链表结构：

typedef struct Lnode{
	Elemtype data;//数据域 
	struct Lnode* next,* prior;//指针域 
}Lnode,*Linklist;

（1）插入

void insert(Linklist &L,int i,Elemtype x){
	if(!(p=get(L,i))){
		return ERROR;
	}
	s=new Lnode;
	s->date=x;
	s->prior=p->prior;
	p->prior->next=s;
	s->next=p;
	p->prior=s;
	return OK;
}//需要引用get函数

（2）删除

void deletelist(Linklist &L,int i,Elemtype &x){
	if(!(p=get(L,i))){
		return ERROR;
	}
	x=p->data;
	p->prior->next=p->next;
	p->next->prior=p->prior;
	delete(p);
	return OK;
}