数据结构-单链表

一、单链表基本定义

线性表的链式存储:线性表采用链式方式将结点链接起来的存储结构称之链表。单链表结构,分前后两个域,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)
{
    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;
        }
    }
}

 

展开阅读全文

没有更多推荐了,返回首页