链表

1. 熟悉什么是链表，链表的分类？ 

链表：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的

链表的分类：根据以下组合会有8中情况

（1）单向、双向

（2）带头、不带头

（3）循环、非循环
2. 熟悉链表带头结点和不带头结点的区别？

不带头结点的头插：将来改变头指针的指向

带头结点的头插：不需要改变头指针的指向

3.单链表的基本操作

slist.h

 

#pragma once

typedef int SDatatype;

//链表的结点
typedef struct SListnode
{
    SDatatype _data;
    struct SListnode* _pnext;

}Node,*PNode;

//链表
typedef struct SList
{
    PNode _PHead;
}SList;

//链表的基本操作

void SListinit(SList* s);//链表的初始化

void SListpushback(SList* s,SDatatype data);//尾插
void SListpopback(SList* s);//尾删

void SListpushfront(SList* s,SDatatype data);//头插
void SListpopfront(SList* s);//头删

void SListinsert(PNode pos,SDatatype data);//任意结点插
void SListerase(SList* s,PNode pos);//任意结点删

PNode SListfind(SList* s,SDatatype data);

size_t SListsize(SList* s);

int SListempty(SList* s);

void SListremove(SList* s,SDatatype data);

void SListremoveall(SList* s,SDatatype data);

 

 

test.c

#include<stdio.h>
#include<stdlib.h>
#include"Slist.h"
#include<assert.h>

//不带头结点的单链表

void SListinit(SList* s)//链表的初始化
{
    assert(s);
    s->_PHead=NULL;
}

PNode Buyslistnode(SDatatype data)
{
    PNode pnewnode=(PNode)malloc(sizeof(Node));
    if(NULL==pnewnode)
    {
        assert(0);
        return NULL;
    }
    pnewnode->_data=data;
    pnewnode->_pnext=NULL;
    return pnewnode;
}

//1找到链表中最后一个结点
//2让最后一个结点指向新结点
void SListpushback(SList* s,SDatatype data)//尾插
{
    assert(s);
    PNode pnewnode=Buyslistnode(data);
    if (NULL==s->_PHead)
    {
        //空链表
        s->_PHead=pnewnode;
    }
    else
    {
        //非空链表
        PNode Pcur=s->_PHead;
        while(Pcur->_pnext)
            Pcur=Pcur->_pnext;
        Pcur->_pnext=pnewnode;
    }

}

void SListpopback(SList* s)
{
    assert(s);
    if(NULL==s->_PHead)//空链表
    {
        return;
    }
    else if (NULL==s->_PHead->_pnext)//链表只有一个结点
    {
        free(s->_PHead);
        s->_PHead=NULL;
    }
    else//链表有两个结点以上
    {
        PNode ppre=NULL;
        PNode pcur=s->_PHead;
        while(pcur->_pnext)
        {
            ppre=pcur;
            pcur=pcur->_pnext;
        }
        free(pcur);
        ppre->_pnext=NULL;
    }
}

void SListpushfront(SList* s,SDatatype data)//头插
{
    assert(s);
    PNode pnewnode=Buyslistnode(data);
    pnewnode->_pnext=s->_PHead;
    s->_PHead=pnewnode;
}

void SListpopfront(SList* s)//头删
{
    assert(s);
    if(NULL==s->_PHead)
    {
        return;
    }
    else
    {
        PNode pdelnode=s->_PHead;
        s->_PHead=pdelnode->_pnext;
        free(pdelnode);
    }

}

void Printslist(SList* s)
{
    assert(s);
    PNode pcur=s->_PHead;
    while(pcur)
    {
        printf("%d--->",pcur->_data);
        pcur=pcur->_pnext;
    }
    printf("NULL\n");
}

void SListinsert(PNode pos,SDatatype data)//任意结点插
{
    if(NULL==pos)
    {
        return;
    }
    else
    {
    PNode pnewnode=Buyslistnode(data);
    pnewnode->_pnext=pos->_pnext;
    pos->_pnext=pnewnode;
    }

}

void SListerase(SList* s,PNode pos)//任意结点删
{
    assert(s);
    if(NULL==pos||NULL==s->_PHead)
    {
        s->_PHead=pos->_pnext;
    }
    else
    {
        PNode pprepos=s->_PHead;
        while(pprepos&&pprepos->_pnext!=pos)
            pprepos=pprepos->_pnext;
        if(pprepos)
        {
        pprepos->_pnext=pos->_pnext;
        }
    
    }
    free(pos);
}

PNode SListfind(SList* s,SDatatype data)
{
    assert(s);
    PNode pcur=s->_PHead;
    while(pcur)
    {
        if(pcur->_data==data)
            return pcur;
        pcur=pcur->_pnext;
    }
    return NULL;
}

size_t SListsize(SList* s)
{
    assert(s);
    PNode pcur=s->_PHead;
    size_t count=0;
    while(pcur)
    {
        count++;
        pcur=pcur->_pnext;
    }
    return count;
}

int SListempty(SList* s)
{
    assert(s);
    return NULL==s->_PHead;
}

void SListremove(SList* s,SDatatype data)
{
    assert(s);
    if(NULL==s->_PHead)
        return;

    PNode ppre=NULL;
    PNode pcur=s->_PHead;
    while(pcur)
    {
        if (pcur->_data==data)
        {
            if(pcur==s->_PHead)
            {
                s->_PHead=pcur->_pnext;
            }
            else
            {
                ppre->_pnext=pcur->_pnext;
            
            }
            free(pcur);
            return;
        }
        else
        {
            ppre=pcur;
            pcur=pcur->_pnext;
        }
    }
}

void SListremoveall(SList* s,SDatatype data)
{
    assert(s);
    if(NULL==s->_PHead)
        return;

    PNode ppre=NULL;
    PNode pcur=s->_PHead;
    while(pcur)
    {
        if (pcur->_data==data)
        {
            if(pcur==s->_PHead)
            {
                s->_PHead=pcur->_pnext;
            }
            else
            {
                ppre->_pnext=pcur->_pnext;
            
            }
            free(pcur);
        }
        else
        {
            ppre=pcur;
            pcur=pcur->_pnext;
        }
    }
}

void Testslist1()
{
    SList s;
    SListinit(&s);
    SListpushback(&s,1);
    SListpushback(&s,2);
    SListpushback(&s,3);
    SListpushback(&s,4);
    SListpushback(&s,5);
    Printslist(&s);

    SListpopback(&s);
    SListpopback(&s);
    SListpopback(&s);
    SListpopback(&s);
    SListpopback(&s);
    Printslist(&s);
}

void Testslist2()
{
    SList s;
    SListinit(&s);
    SListpushfront(&s,2);
    SListpushfront(&s,2);
    SListpushfront(&s,3);
    SListpushfront(&s,2);
    SListpushfront(&s,5);
    SListpushfront(&s,6);
    Printslist(&s);

    SListpopfront(&s);
    Printslist(&s);
    SListpopfront(&s);
    SListpopfront(&s);
    SListpopfront(&s);
    SListpopfront(&s);
    SListpopfront(&s);
    Printslist(&s);

    SListremoveall(&s,2);
    Printslist(&s);

    SListremove(&s,2);
    Printslist(&s);
}

void Testslist()
{
    //Testslist1();
    Testslist2();
}

int main()
{

    Testslist();
    system("pause");
    return 0;
}