实现单链表的基础操作

单链表

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

下面我们来看看单链表的实现：

list.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>

// 1、无头单向非循环链表增删查改实现 
typedef int SLTDataType;
typedef struct SListNode
{
 SLTDataType _data;
 struct SListNode* _next;
}SListNode;

typedef struct SList
{
 SListNode* _head;
}SList;

void SListInit(SList* plist);
void SListDestory(SList* plist);
SListNode* BuySListNode(SLTDataType x); //创建节点
void SListPushFront(SList* plist, SLTDataType x);
void SListPopFront(SList* plist);
SListNode* SListFind(SList* plist, SLTDataType x);

// 在pos的后面进行插入 
void SListInsertAfter(SListNode* pos, SLTDataType x);
void SListEraseAfter(SList* plist, SListNode* pos);
// 在pos的前面进行插入 
void SListInsertFront(SList* plist, SListNode* pos, SLTDataType x);
void SListRemove(SList* plist, SLTDataType x);
void SListPrint(SList* plist);
void Test();

list.c

#include "list.h"

SListNode* BuySListNode(SLTDataType x)
{
 SListNode* pnode = (SListNode*)malloc(sizeof(SListNode));
 pnode->_data = x;
 pnode->_next = NULL;
 return pnode;
}

void SListInit(SList* plist)
{
 assert(plist);
 plist->_head = NULL;
}

void SListDestory(SList* plist)
{
 assert(plist);
 SListNode* cur = plist->_head;
 while (cur)
 {
  SListNode* next = cur->_next; 
  free(cur);
  cur = next;
 }
 plist->_head = NULL;
}

void SListPrint(SList* plist)
{
 assert(plist);
 SListNode* cur = plist->_head;
 while (cur)
 {
  printf("%d ", cur->_data);
  cur = cur->_next;
 }
}

void SListPushFront(SList* plist, SLTDataType x)
{
 SListNode* newnode = BuySListNode(x);
 assert(plist);
 newnode->_next = plist->_head;
 plist->_head = newnode; 
}

void SListPopFront(SList* plist)
{
 assert(plist);
 SListNode* next = plist->_head->_next;
 free(plist->_head);
 plist->_head = next;
}

SListNode* SListFind(SList* plist, SLTDataType x)
{
 assert(plist);
 SListNode* pos = plist->_head;
 while (pos)
 {
  if (pos->_data == x)
   return pos;
  pos = pos->_next;
 }
 return pos;
}

void SListInsertAfter(SListNode* pos, SLTDataType x)
{
 SListNode* newnode = BuySListNode(x);
 newnode->_next = pos->_next;
 pos->_next = newnode;
}

void SListEraseAfter(SList* plist, SListNode* pos)
{
 SListNode* cur = plist->_head;
 if (pos == plist->_head)
 {
  cur = cur->_next;
  free(pos);
  plist->_head = cur;
  return;
 }
 while (cur->_next != pos)
 {
  cur = cur->_next;
 }
 cur->_next = pos->_next;
 free(pos);
}

void SListInsertFront(SList* plist, SListNode* pos, SLTDataType x)
{
 if(pos == NULL)
 {
      pritnf("输入有误\n");
      return;
 }
 SListNode* cur = plist->_head;
 SListNode* newnode = BuySListNode(x);
 if (pos == plist->_head)
 {
  cur = cur->_next;
  plist->_head = newnode;
  plist->_head->_next = cur;
  return;
 }
 while (cur->_next != pos)
 {
  cur = cur->_next;
 }
 cur->_next = newnode;
 newnode->_next = pos;
}

void SListRemove(SList* plist, SLTDataType x)
{
 assert(plist);
 SListNode* temp = NULL;
 SListNode* cur = NULL;
 cur = temp = plist->_head;
 while (cur)
 {
  if (x == cur->_data)
  {
   if (x == plist->_head->_data)
   {
    plist->_head = plist->_head->_next;
    free(cur);
    cur = plist->_head;
   }
   else
   {
    temp->_next = cur->_next;
    free(cur);
    cur = temp;
   }
  }
  else
  {
   temp = cur;
   cur = cur->_next;
  }
 }
}

void Test()
{
 SList plist;
 SListNode* pos = NULL;
 SListInit(&plist);
 SListPushFront(&plist, 1);
 SListPushFront(&plist, 2);
 SListPushFront(&plist, 3);
 SListPushFront(&plist, 4);
 //SListPopFront(&plist);
 //SListPopFront(&plist);
 //SListPopFront(&plist);
 pos = SListFind(&plist, 2);
 //SListInsertAfter(pos, 5);
 //SListEraseAfter(&plist, pos);
 SListRemove(&plist, 3); 
 pos = SListFind(&plist, 2);
 SListInsertFront(&plist, pos, 4);
 SListPrint(&plist);
 SListDestory(&plist);
}

main.c

#include "list.h"

int main()
{
 Test();
 system("pause");
 return 0;
}