不带头结点的单链表

//.h

#pragma once
typedef int DataType;
typedef struct Node
{
 struct Node* _pNext;
 DataType _data;
}Node,*pNode;
void SListInit(pNode* pHead);// 链表初始化
pNode BuySListNode(DataType data); //创建新结点
void SListPushBack(pNode* pHead, DataType data);// 尾插
void printSList(pNode pHead);//打印单链表
void SListPopBack(pNode* pHead);//尾删
void SListPushFront(pNode* pHead, DataType data);//头插
void SListPopFront(pNode* pHead);//头删
pNode SListFind(pNode pHead, DataType data); //查找值为data的结点，返回该结点在链表中的位置
void SListInsert(pNode* pHead, pNode pos, DataType data);// 在链表pos位置后插入结点data
void SListErase(pNode* pHead, pNode pos);// 删除链表pos位置上的结点
void SListDestroy(pNode* pHead);// 销毁单链表
int SListSize(pNode pHead);// 求链表中结点的个数 
void SListClear(pNode* pHead);// 将链表中的结点清空
pNode SListBack(pNode pHead);// 获取链表中的最后一个结点，返回该结点的地址

//.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SListNode.h"
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

//初始化
void SListInit(pNode* pHead)
{
 assert(pHead);
 *pHead = NULL;
}
//创建新结点
pNode BuySListNode(DataType data)
{
 pNode pNewNode = (pNode*)malloc(sizeof(Node));
 if (NULL==pNewNode)
 {
  return NULL;
 }
 else
 {
  pNewNode->_data = data;
  pNewNode->_pNext = NULL;
 }
 return pNewNode;
}
//尾插
void SListPushBack(pNode* pHead, DataType data)
{
 assert(pHead);
 //pNode pNewNode = NULL;
 pNode pNewNode = BuySListNode(data);
 pNode pCur = *pHead;
 if (NULL==pCur)
 {
  *pHead = pNewNode;
  return;
 }
 while (pCur->_pNext)
 {
  pCur = pCur->_pNext;
 }
 pCur->_pNext = pNewNode;
}
void printSList(pNode pHead)//打印单链表
{
 pNode pCur = pHead;
 while (pCur)
 {
  printf("%d->", pCur->_data);

  pCur = pCur->_pNext;
 }
 printf("NULL\n");
}
//尾删
void SListPopBack(pNode* pHead)
{
 assert(pHead);
 pNode pCur = *pHead;
 if (NULL==pCur)
 {
  return;
 }
 //一个节点
 if (NULL==pCur->_pNext)
 {
  pCur = NULL;
  free(pCur);
  return;
 }
 //多个节点
 while (pCur->_pNext->_pNext)
 {
  pCur = pCur->_pNext;
 }
 free(pCur->_pNext);
 pCur->_pNext = NULL;
}
//头插
void SListPushFront(pNode* pHead, DataType data)
{
 assert(pHead);
 pNode pNewNode = BuySListNode(data);
  if (NULL==pNewNode)
 {
  return;
 }
 pNewNode->_pNext = *pHead;
 *pHead = pNewNode;
}
//头删
void SListPopFront(pNode* pHead)
{
 assert(pHead);
 pNode pCur = *pHead;
 if (NULL==*pHead)
 {
  return;
 }
 else
 {
  *pHead = pCur->_pNext;
  free(pCur);
 }
}
// 查找值为data的结点，返回该结点在链表中的位置
pNode SListFind(pNode pHead, DataType data)
{
 assert(pHead);
 pNode pCur = pHead;
 while (pCur)
 {
  if (pCur->_data == data)
  {
   return pCur;
  }
  pCur = pCur->_pNext;
 }
 return NULL;
}
// 在链表pos位置后插入结点data
void SListInsert(pNode* pHead, pNode pos, DataType data)
{
 assert(pHead);
 pNode pCur = *pHead;
 pNode pNewNode = BuySListNode(data);
 if (NULL==pHead || NULL==pos)
 {
  return;
 }
 while (pCur)
 {
  if (pCur == pos)
  {
   pNewNode->_pNext = pos->_pNext;
   pos->_pNext = pNewNode;
  }
  pCur = pCur->_pNext;
 }
}
 //删除链表pos位置上的结点
void SListErase(pNode* pHead, pNode pos)
{
 assert(pHead);
 pNode pCur = *pHead;
 if (*pHead == NULL)
 {
  return;
 }
  if (pCur == pos)//一个结点
  {
   *pHead = pos->_pNext;
   free(pos);
   pos= NULL;
  }
  else
  {
   while (pCur && pCur->_pNext != pos)
   {
    pCur = pCur->_pNext;
   }
   if (pCur != NULL)
   {
    pCur->_pNext = pos->_pNext;
    free(pos);
    pos = NULL;
   }
  }
}
// 销毁单链表
void SListDestroy(pNode* pHead)
{
 assert(pHead);
 pNode pCur = *pHead;
 while (pCur)
 {
  pCur = pCur->_pNext;
  free(pCur);
  pCur = NULL;
 }
 *pHead = NULL;
}
// 求链表中结点的个数
int SListSize(pNode pHead)
{
 assert(pHead);
 int count = 0;
 pNode pCur = pHead;
 while (pCur)
 {
  count++;
  pCur = pCur->_pNext;
 }
 return count;
}
// 将链表中的结点清空
void SListClear(pNode* pHead)
{
 assert(pHead);
 pNode pCur = *pHead;
 while (pCur)
 {
  pCur->_pNext = *pHead;
  free(pCur);
 }
 free(*pHead);
}
//void SListClear(pNode* pHead)
//{
// assert(pHead);
// SListDestoy(pHead);
//}
// 获取链表中的最后一个结点，返回该结点的地址
pNode SListBack(pNode pHead)
{
 assert(pHead);
 pNode pCur = pHead;
 if (NULL == pHead)
 {
  return;
 }
 while (pCur->_pNext)
 {
  pCur = pCur->_pNext;
 }
 return pCur;
}

//test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SListNode.h"
#include<stdio.h>
#include<stdlib.h>
void test1()
{
 pNode pHead;
 SListInit(&pHead);
 SListPushBack(&pHead, 1);//尾插
 SListPushBack(&pHead, 2);
 SListPushBack(&pHead, 3);
 SListPushBack(&pHead, 4);
 SListPushBack(&pHead, 5);
 printSList(pHead);
 SListPopBack(&pHead);//尾删
 printSList(pHead);
 SListPopBack(&pHead);
 printSList(pHead);
 SListPopBack(&pHead);
 printSList(pHead);
 SListPopBack(&pHead);
 printSList(pHead);
}
void test2()
{
 pNode pHead;
 SListInit(&pHead);
 SListPushFront(&pHead, 1);//头插
 SListPushFront(&pHead, 2);
 SListPushFront(&pHead, 3);
 SListPushFront(&pHead, 4);
 SListPushFront(&pHead, 5);
 printSList(pHead);
 SListPopFront(&pHead);//头删
 printSList(pHead);
 SListPopFront(&pHead);
 printSList(pHead);
 SListPopFront(&pHead);
 printSList(pHead);
 SListPopFront(&pHead);
 printSList(pHead);
}
void test3()
{
 pNode pHead;
 pNode pos = NULL;
 SListInit(&pHead);
 SListPushFront(&pHead, 1);//头插
 SListPushFront(&pHead, 2);
 SListPushFront(&pHead, 3);
 SListPushFront(&pHead, 4);
 SListPushFront(&pHead, 5);
 printSList(pHead);
 pos = SListFind(pHead, 3);//找到3的位置
 printf("%d\n", pos->_data);
 SListInsert(&pHead,pos,6);//在3元素的位置处插入元素6
 printSList(pHead);
 SListErase(&pHead,pos);//删除3元素位置处的元素
 printSList(pHead);
 SListDestroy(&pHead);
 printSList(pHead);
}


int main()
{
 //test1();
 //test2();
 //test3();

 system("pause");
 return 0;
}