数据结构-单链表

一、单链表基本定义

线性表的链式存储：线性表采用链式方式将结点链接起来的存储结构称之链表。单链表结构，分前后两个域，date数据域：存放结点的值，next指针域：存放数据元素后继的位置。附设头结点的目的：为方便统一空表或非空表的运算处理。其中的基本概念：

（1）头结点：数据域无要求，其指针域指向第一个结点，

（2）首结点：链表中第一个元素结点，

（3）头指针：指向链表开始。

单链表C语言定义

typeddef struct Node    //结点类型定义
{
    ElemType data;
    struct Node *Next;
}Node *LinkList;    //LinkList为结构指针类型
LinkList L;    //L为单链表的头指针，也称为单链表L

LinkList和Node*同为结构指针类型，LinkList定义指针变量，Node*定义单链表中的结点类型。

二、单链表基本运算

1、求单链表长度

思路：沿带头结点单链表L的首元结点计数统计长度

int ListLength(LinkList L)
{
    Node *p;
    p=L->next;
    j=0;    //计数器，存放单链表长度
    while(p!=Null)
    {
        p=p->next;
        j++;
    }
    return j;
}

2、建立单链表

（1）建立空表

LnitList(LinkList Ｌ)
{
    L=(LinkList)malloc(sizeof(Node));   //建立头结点
    L->next=Null;   //建立空的单链表
}

（2）头插法建表

算法描述：已知空链表L，一次读入结点数据头插入，直到读入结束标志$为止。每插入一个结点到表头的步骤，先生成新结点s，再将s插入到首元结点之前，即表头结点之后。

LinkList CreateFromHead(LinkList L)
{
    Node *s;
    char c;
    int flag=1;
    while(flag)
    {
        c=getchar();
        if(c!='$')
        {
            s=(Node*)malloc(sizeof(Node));
            s->data=c;
            s->next=L->next;
            L->next=s;
        }
        else flag=0;
    }
}

（3）尾插法建表

算法描述：空链表L，设置尾指针r指向当前表尾，每插入一个结点到表尾的步骤，先生成新结点s，将s插入r之后该结点作为当前表尾结点。

LinkList CreateFromeTail(LinkList L)
{
    LinkList L;
    Node *r,*s;
    int flag=1;//设置一个标志，初值为0，当输入‘$’，flag=0，建表结束。
    r=L;//*r指针始终动态指向链表的当前表尾，以便表尾插入，其初值指向头结点。
    while(flag)
    {
        c=getchar();
        if(c!='$')
        {
            s=(Node*)malloc(sizeof(Node));
            s->data=c;
            r->next=s;
            r=s;
        }
        else
        {
            flag=0;
            r->next=Null;//将最后一个结点的next置空，表示链表结束。
        }
    }
}

3、单链表查找

（1）按序号查找，从头查找，顺链计数，结果判断。

Node* Get(LinkList L,int i)
{
    //在带头结点的单链表L中查找第i个结点，若找到（1<=i<=n）,则返回该结点的存储位置。
    int j;
    Node *p;
    p=L;
    j=0;
    while((p->next!=Null)&&(j<i))
    {
        p=p->next;  //扫描下一个结点
        j++;
    }
    if(i==j) return p;
    else return Null;
}

（2）按值查找

在单链表中查找是否有节点值等于key的结点。算法描述：从表头开始，p指向链表L首元结点p=L->next，当表未查完，当前结点值不为key，指针p后移返回p位置。

Node *Locate(LinkList L,ElemType key)
{
    Node *p;
    p=L->next;    //从表中第一个结点比较
    while(p!=Null)
    {
        if(p->data!=key)
            p=p->next;
        else break;
    }
    return p;
}

4、单链表插入

算法描述：先确定第i-1个结点的位置（同按序号查找），再申请新结点s，并插入挂链，s插入第i-1个结点之后（s->next=pre->next，pre->next=s）

void InsertList(LinkList L,int i,ElemType e)
{
    Node *pre,*s;
    int k;
    pre =L;
    k=0;
    //在第i个元素之前插入，则先找到第i-1个数据元素的存储位置，是指针pre指向它。
    while(pre!=Null&&k<i-1)
    {
        pre=pre->next;
        k=k+1;
    }
    if(!pre)
    {
        printf("插入位置不合法");
        return(ERROR);
    }
    s=(Node*)malloc(sizeof(Node));
    s->data=e;
    pre->next=s;//将待插入结点的值e赋给s的数据域
    return OK;
}

5、单链表删除

算法描述：先确定第i-1个结点的位置p，再删除并释放第i个结点（r=p->next，p->next=r->next，free(r)）

void DelList(LinkList L,int i,ElemType *e)
{
    //将删除的元素保存到变量*e中
    Node *p,*r;
    int k;
    p=L;
    k=0;
    while(p->next!=Null&&k<i-1)
    {
        p=p->next;  //寻找被删除结点i的前驱结点i-1使p指向它
        k=k+1;
    }
    if(k!=i-1)  //即while循环是因为p->next=Null而跳出
    {
        printf("删除结点的位置i不合法");
        return;
    }
    r=p->next;
    p->next=p->next->next;
    *e=r->data;
    free(r);
}

6、求两集合的差A-B

算法思路：A-B中包含所有属于A而不属于B的元素，逐个读取A中的元素，在B中进行差按照，存在相同的从A中删除。

void Difference(LinkList LA,LinkList LB)
{
    Next *pre,*p,*q,*r;
    pre=LA;
    p=LA->next;
    while(p!=Null)  //逐个确定A表的中每一个元素
    {
        q=LB->next;
        while(q!=Null&&q->data!=p->data)
        {
            //查是否属于B表
            q=q->next;
        }
        if(q!=Null)
        {
            r=p;
            pre->next=p->next;
            p=p->next;
            free(r);
        }
        else
        {
            pre=p;
            p=p->next;
        }
    }
}

 

 

关注我吧

关注「前端一起学」公众号 ，看着项目进阶学习，让我们一起学前端，一起进步。