链表的快速入门（基本操作）

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

//对于形参，改变链表就用&L，不改变就用L
//原理：“地址” 
//Lnode => 节点  
//*LinkList => 指向这种结构的指针
typedef struct{
    char num[10];
    char name[10];
    int score;
}ElemType;

typedef struct Lnode{
	ElemType data;
	struct Lnode *next;
}Lnode,*LinkList;

typedef struct DulNode
{
    ElemType data;
    struct DuleNode *prior,*next;
}DuleNode,*DuLinkList;



//单链表的初始化
void initList(LinkList &L)
{
    L = new Lnode;
    L->next = NULL;
}


//判断链表是否为空
int isEmpty(LinkList L)
{
    if(L->next == NULL)
    {
        return 0;
    }
    return 1;
}

//单链表的销毁
void destroyLinkList(LinkList &L)
{
    Lnode *p;//或者LinkList p;
    while(L)//L非空
    {
        p = L;
        L = L->next;
        free(p);//delete p;
    }
}

//单链表的清空
void clearList(LinkList &L)
{
    Lnode *p,*q;
    p = L->next;
	while(p){
		q = p->next;
		delete p;
		p = q;
	}
	L->next = NULL;//头结点指针域设为空 
}

//求单链表的表长
int ListLength(LinkList L)
{
	LinkList p;
	p = L->next;
	int length = 0;
	while(p){
		length++;
		p = p->next;
	}
	return length;
}

//取第i个元素的内容
int GetElem_L(LinkList L,int i,ElemType &e)
{
	LinkList p;

	p = L->next;
	int j = 1;
    //或者
    // p =L;
    // int j = 0;
	while(p && j < i){
		p = p->next;
		++j;
	}
	if(!p || j > i){
		return 0;
	}
	e = p->data;
	return 1;
}

//在第i个节点前插入一个值为e的新节点
int InsertList_L(LinkList &L,int i,ElemType e)
{
    LinkList p;

    p = L;
    int j = 0;
    while(p && j < i-1){
        p = p->next;
        ++j;
    }
    if(!p || j > i-1){
        return 0;
    }
    LinkList s;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return 1;
} 

//删除第i个节点
int DeleteList_L(LinkList &L,int i,ElemType &e)
{
    LinkList p;
    p = L;
    int j = 0;
    while (p->next && j < i-1)
    {
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i-1)
    {
        return 0;
    }
    Lnode q = new Lnode;
    q = p->next;
    p->next = q->next;
    e = q->data;
    delete q;
    return 1;
}

//单链表的建立 ——> 头插法
void CreateList_H(LinkList &L,int n)
{
    Lnode L = new Lnode;
    L->next = NULL;
    for(int i = n;i > 0;--i){
        Lnode p = new Lnode;
        cin>>p.data;
        p.next = L->next;
        L->next = p;
    }
}

//单链表的建立 ——> 尾插法
void CreateList_R(LinkList &L,int n)
{
    Lnode L = new Lnode;
    L->next = NULL;
    Lnode r = new Lnode;
    r = L;//尾指针指向头结点
    for(int i = 0;i < n;++i){
        Lnode p = new Lnode;
        cin>>p.data;
        p->next = NULL;
        r->next = p;
        r = p;
    }
}

//带尾指针的循环链表合并
LinkList Connect(LinkList Ta,LinkList Tb)
{
    p = Ta->next; //p存放Ta表头节点
    Ta->next = Tb->next->next; //Ta表尾连接Tb表头
    delete Tb->next; //释放Tb表头
    Tb->next = p; //Tb表尾连接Ta表头
    return Tb;
}

//双向链表的插入
int InsertList_DuL(DuLinkList &L,int i,ElemType &e)
{
    if(!(p = GetElemP_DuL(L,i))){
        return 0;
    }
    DuleNode s = new DuleNode;
    s->data = e;
    s->prior = p->prior;
    p->prior->next = s;
    s->next = p;
    p->prior = s;
    return 1;
}

//双向链表的删除,删除的元素用e返回
int DeleteList_DuL(DuLinkList &L,int i,ElemType &e)
{
    if(!(p = GetElemP_DuL(L,i))){
        return 0;
    }
    e = p->data;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    delete p;
    return 1;
}

//合并两个线性表
void unionList(List &La,List Lb)
{
    La_Len = ListLength(La);
    Lb_Len = ListLength(Lb);
    for(int i = 0;i < Lb_Len;i++){
        GetElem(Lb,i,e);
        if(!LocateElem(La,e)){ //找到了返回位置 => 假
            ListInsert(&La,++La_Len,e);
        }
    }
}

//有序表的合并 ———— 链表实现
void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc)
{
    pa = La->next;
    pb = Lb->next;
    pc = Lc = La; //用La的头结点作为Lc的头结点
    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; //释放Lb的头结点
    }
}