链表基本操作伪代码

链式结构体

typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;

//声明变量
LinkList L;

头插法创建

Initial(LinkList &L)
{
    L = (LinkList)malloc(sizeof(LinkList));
    L->next = NULL;
    int x;
    LNode *p;
    while (true) //输入9999结束输入
    {
        scanf("%d", x);
        if (x == 9999)
            break;
        p = (LNode *)malloc(sizeof(LNode));
        p->data = x;
        p->next = L->next;
        L->next = p;
    }
    return true;
}

尾插法

Initial(LinkList &L)
{
    L = (LinkList)malloc(sizeof(LinkList));
    int x;
    LNode *p, *r = L; //需添加尾指针,以便进行插入
    while (true)      //输入9999结束输入
    {
        scanf("%d", x);
        if (x == 9999)
            break;
        p = (LNode *)malloc(sizeof(LNode));
        p->data = x;
        p->next = NULL;
        r->next = p;
        r = p; //尾指针恒指向最后一个结点
    }
    return true;
}

求表长

Length(L)
{
    int i = 0;
    while (L != NULL)
    {
        i++;
        L = L->next;
    }
    return i;
}

按值查找

LocateElem(L, e)
{
    LNode *p;
    p = L->next;
    int i = 1;
    while (p->data != e && p != NULL)
    {
        p = p->next;
        i++;
    }
    if (p->data != e || p == NULL)
        return false;
    return i;
}

按位查找

GetElem(L, i)
{
    LNode *p;
    p = L->next;
    int j = 1;
    while (j < i && p != NULL)
    {
        p = p->next;
        j++;
    }
    if (j > i || p == NULL)
        return false;
    return p->data;
}

插入

ListInsert(&L, i, e)
{
    LNode *p, *q;
    p = L->next;
    int j = 1;
    while (j < i - 1 && p != NULL)
    {
        p = p->next;
        j++;
    }
    if (j > i - 1 || p == NULL)
        return false;
    q->data = e;
    q->next = p->next;
    p->next = q;
    return true;
}

删除

ListDelete(&L, i, &e)
{
    LNode *p, *q;
    p = L->next;
    int j = 1;
    while (j < i - 1 && p != NULL)
    {
        p = p->next;
        j++;
    }
    if (j > i - 1 || p == NULL)
        return false;
    q = p->next;
    e = q->data;
    p->next = q->next;
    free(q);
    return true;
}

按值删除(first)

ListDelete(&L, e)
{
    LNode *p, *q;
    p = L;
    q = L->next;
    while (q->data != e && q != NULL)
    {
        p = q;
        q = q->next;
    }
    if (q->data != e || q == NULL)
        return false;
    p->next = q->next;
    free(q);
}

按值删除(all)

ListDelete(&L, e)
{
    LNode *p, *q;
    p = L;
    q = L->next;

    while (q != NULL)
    {
        if (q->data == e)
        {
            p->next = q->next;
            free(q);
            q=p->next;
        }
        else
        {
            p = q;
            q = q->next;
        }
        
    }
    if (q == NULL)
        return false;
}

有序表的合并

MergeList(A,B,&C)
{
    LNode *r;
    r=C;
    a=A->next;
    b=B->next;
    while(a!=NULL&&b!=NULL)
    {
        if(a->data>b->data)
        {
            r->next=b;
            r=b;
            b=b->next;
        }
        else
        {
            r->next=a;
            r=a;
            a=a->next;
        }
    }
/*  
    if(a!=NULL)
    {
        while(a!=NULL)
        {
            r->next=a;
            r=a;
            a=a->next;
        }
    }
    if(b!=NULL)
    {
        while(b!=NULL)
        {
            r->next=b;
            r=b;
            b=b->next;
        }
    }
*/
    if(a!=NULL)
        r->next=a;
    else
        r->next=b;
}

循环链表

/*
判空:p!=L
判表尾：p->next!=L
*/
//有头结点且有尾指针的循环链表的合并
ConnectList(A,B)//A,B是尾指针
{
    LNode *p;
    p=A->next;
    A->next=B->next->next; //越过B的头结点
    free(B->next);
    B->next=p;
}

双向链表

//结构体
typedef struct DulNode
{
    ElemType data;
    struct DulNode *prior,*next;
}DulNode,*DulList;
//删除
q->prior->next=q->next;
q->next->prior=q->prior;
free(p);
//插入
q->next=p->next;
p->next->prior=q;
q->prior=p;
p->next=q;
//插入时如果只给出前驱节点，那么勾链时要注意先右后左，如果同时给出了前驱后继，那么勾链无所谓次序

静态链表

//结构体
typedef struct 
{
    ElemType data;
    int next;
}SLinst[MaxSize];