链表知识梳理

1. 熟悉什么是链表，链表的分类？
   答：链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序来实现的。
2. 熟悉链表带头结点和不带头结点的区别？
   答：在结构上：带头结点的单链表，不管链表是否为空，均含有一个头结点，不带头结点的单链表不含头结点。
   在操作上：带头结点的单链表的初始化为申请一个头结点。无论插入或删除的位置是第一个结点还是其他结点，算法步骤都相同。不带头结点的单链表，其算法步骤要分别考虑插入或删除的位置是第一个结点还是其他结点。
3. 完成单链表的以下基本操作：

typedef int SDataType;

// 链表的节点
typedef struct SListNode
{
SDataType _data;
struct SListNode* _pNext;
}Node, *PNode;

// 链表的结构，给一个头指针保存链表第一个节点的地址
typedef struct SList
{
PNode _pHead; // 指向链表中的第一个节点
}SList, *PSList;

// 链表的初始化
void SListInit(SList* s);
{
asser(s);
s->_pHead = NULL;
pNode BuySListlnit(SData Type data)
{
pNode pNewNode=(pNode)malloc(sizeof(Node));
if(NULL==pNewNode)
{
assert(0);
return NULL;
}
pNewNode->_data=data;
pNewNode->_pNext=NULL;
return pNewNode;
}
}

// 在链表s最后一个节点后插入值为data的节点
void SListPushBack(SList* s, SDataType data);
{
asssert(s);
pNode pNewNode=BuySListNode(data);
if(NULL==s->_pHead)
{
s->_pHead=pNewNode;
pNewNode->_pNext=NULL;
}
else
{
pNode pCur=s->_pHead;
while(pCur->_pNext)
pCur=pCur->_pNext;
pCur->_pNext=pNewNode;
pNewNode->_pNext=NULL;
}
}

// 删除链表s最后一个节点
void SListPopBack(SList* s);
{
assert(s);
if(NULLs->_pHead)
return;
else if(NULLs->_pHead->_pNext)
{
free(s->_pHead);
s->_pHead=NULL;}
else{
pNode pPre=NULL;
pNode pCur=s->_pHead;
while(pCur=s->_pHead)
{
pPre=pCur;
pCur=pCur->_pNext;
}
free(pCur);
pPre->_pNext=NULL;
}
}

// 在链表s第一个节点前插入值为data的节点
void SListPushFront(SList* s, SDataType data);
{
assert(s);
pNode pNewNode=BuySListNode(data);
pNewNode->_pNext=s->_pHead;
s->_pHead=pNewNode;
}

// 删除链表s的第一个节点
void SListPopFront(SList* s);
{
assert(s);
if(NULL==s->_pHead)
return;
pNode pDelNode=s->_pHead;
s->_Head=pDelNode->_Next;
free(pDelNode);

}
// 在链表的pos位置后插入值为data的节点
void SListInsert(PNode pos, SDataType data);
{
assert(s);
if(NULL==pos)
return;
pNode pNewNode=BuySListNode(data);
pNewNode->_pNext=pos->_pNext;
pos->_pNext=pNewNode;
}

// 删除链表s中pos位置的节点
void SListErase(SList* s, PNode pos);
{
assert(s);
if(NULL==pos)
return;
pNode pos=pos->_pNext;
free(pos);
}

// 在链表中查找值为data的节点，找到返回该节点的地址，否则返回NULL
PNode SListFind(SList* s, SDataType data);
{
assert(s);
if(NULL==data)
return NULL;
pNode pCur=s->_pHead;
while(pCur->_pNext)
{pCur=pCur->_pNext;

return pNode

}

// 获取链表中有效节点的个数
size_t SListSize(SList* s);
{
assert(s);
int count=o;
pNode pCur=s->_pHead;
while(pCur->_pNext)
{conut++;
pcur=pCur->_pNext;}
printf("%d\n",count);
}

// 检测链表是否为空
int SListEmpty(SList* s);
{
assert(s);
pNode pCur=s->_pHead;
return pCur;
}

// 将链表中有效节点清空
void SListClear(SList* s);
{
pNode pCur=pHead->_pNext;
while(pCur!=pHead)
{
pHead->_pNext=pCur->_pNext;
free(pCur);
pCur=pHead->_pNext;}
pHead->_pNext=pHead;
pHead->_pPre=pHead;
}
}

// 销毁链表
void SListDestroy(SList* s);
{
SListClear(*s);
free(*s);
*s=NULL;}