무 두 결점 단일 체인 테이블 기본 조작

linklist.h
#pragma once

#include <stdio.h>
#include <assert.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>

typedef int DataType;

typedef struct ListNode
{
    struct ListNode* pNext;
    DataType _data;
}Node,*PNode;

//       
void SListInit(PNode* pHead);

//      
PNode BuyListNode(DataType data);

//   
void SListPushBack(PNode* pHead, DataType data);

//   
void SListPopBack(PNode* pHead);

//   
void SListPushFront(PNode* pHead, DataType data);

//   
void SListPopFront(PNode* pHead);

//         data   ，       data   
PNode SListFind(PNode pHead, DataType data);

//  pos      data   
void SListInsert(PNode* pHead, PNode pos, DataType data);

//   pos     
void SListErase(PNode* pHead, PNode pos);

//       
int SListSize(PNode pHead);

//         
int SListEmpty(PNode pHead);

//     
void SListDestroy(PNode* pHead); 

//    
void print(PNode pHead);


linklist.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "linklist.h"

//   
void SListInit(PNode* pHead)
{
    assert(pHead);        //  pHead        ,      ,          ,     
                          //   NULL         ,   assert     
    *pHead = NULL;
}

//  
void SListPushBack(PNode* pHead, DataType data)
{
    assert(pHead);
    if(*pHead == NULL)
        *pHead = BuyListNode(data);
    else 
    {
        PNode pCur = *pHead;
#if 1
        while(pCur->pNext)        //     pNext     ，   pCur->pNext          
            pCur = pCur->pNext;    
#else
        PNode pPre = NULL;
        while(pCur)
        {
            pPre = pCur;
            pCur = pCur->pNext;  //     ,  pCur          
                               //      ,      pCur->pNext    
        }
        pCur = pPre;
#endif
        pCur->pNext = BuyListNode(data);  //     pCur->pNext         ,   pCur->pNext     
    }
}

//  
void SListPopBack(PNode* pHead)
{
    //    1、0  2、1  3、  
    PNode pCur = *pHead;  
    PNode pPre = NULL;
     assert(pHead);
    if(*pHead == NULL)
    {
        printf("     !
");
        return;
    }
    else if((*pHead)->pNext == NULL)
    {
        free(*pHead);
        *pHead = NULL;
        return;
    }
    while(pCur->pNext != NULL)
    {
        pPre = pCur;
        pCur = pCur->pNext;
    }
    free(pCur); 
    pPre->pNext = NULL;
}


//  
void SListPushFront(PNode* pHead, DataType data)
{
    PNode pCur;
    assert(pHead);
    if(*pHead == NULL)
    {
        *pHead = BuyListNode(data);
    } 
    else 
        pCur = BuyListNode(data);
    pCur->pNext = *pHead;
    *pHead = pCur;
}

//  
void SListPopFront(PNode* pHead)
{
    PNode next;
    assert(pHead);
    if(*pHead == NULL)
    {
        printf("     !
");
        return;
    }
    else
    {
        next = (*pHead)->pNext;
        free(*pHead);
        *pHead = next;
    }
}

//  
PNode SListFind(PNode pHead, DataType data)
{
    if(pHead == NULL)
        return NULL;
    while(pHead)
    {
        if(pHead->_data == data)
            return pHead;
        pHead = pHead->pNext;
    }
    return NULL;
}

//  pos      data   
void SListInsert(PNode* pHead, PNode pos, DataType data)
{
    assert(pHead);
    if(*pHead == NULL || pos == NULL)
        return ;
    if(*pHead == pos)
    {
        PNode pCur =BuyListNode(data);
        pCur->pNext = *pHead;
        *pHead = pCur;
    }
    else
    {
        PNode pCur = *pHead;
        PNode pPre = NULL;
        while( pCur != pos && pCur )
        {
            pPre = pCur;
            pCur = pCur->pNext;
        }
        if(pCur)
        {
            PNode pNew = BuyListNode(data);
            pNew->pNext = pCur;
            pPre->pNext = pNew;
        }
    }
}

//   pos     
void SListErase(PNode* pHead, PNode pos)
{
    assert(pHead);
    if(*pHead == NULL || pos == NULL)
        return;
    else  if(pos == *pHead)
    {
        PNode  pDel = *pHead;
        *pHead = (*pHead)->pNext;
        free(pDel);
    }
    else
    {
        PNode pCur = *pHead;
        PNode pPre = NULL;
        while(pCur!=pos && pCur)
        {
            pPre = pCur;
            pCur = pCur->pNext;
        }
        if(pCur)
        {
            pPre->pNext = pCur->pNext;
            free(pCur);
        }
    }
}

//      
int SListSize(PNode pHead)
{
    int count = 0;
    if(pHead == NULL)
        return 0;
    else
    {
        while(pHead)
        {
            count++;
            pHead = pHead->pNext;
        }
    }
    return count;

}
//    
int SListEmpty(PNode pHead)
{
    return pHead?1:0;
    //if(pHead == NULL)
    //{
    //  printf("    !
");
    //  return 0;
    //}
    //else 
    //  printf("     !
");
    //return 0;
}

//    
void SListDestroy(PNode* pHead)
{
    PNode pCur = *pHead;
    PNode pNext = NULL;
    assert(pHead);
    if(*pHead == NULL)
            return;
    else
    {
        *pHead = NULL;
        while(pCur)
        {
            pNext = pCur->pNext;
            free(pCur);
            pCur = pNext;
        }
    }
}

//      
PNode BuyListNode(DataType data)
{
    PNode pNewNode = (PNode)malloc(sizeof(Node));
    if(pNewNode == NULL)
    {
        assert(0);
        return NULL;
    }
    pNewNode->_data = data;
    pNewNode->pNext = NULL;
    return pNewNode;
}

//    
void print(PNode pHead)
{
    if(pHead == NULL)
    {
        printf("NULL
");
        return;
    }
    while(pHead)   
    {
        printf("%d->",pHead->_data);
        pHead = pHead->pNext;
    }
    printf("NULL
");
}


test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "linklist.h"
void test();
void test1();

int main()
{
    test();
    return 0;
}

//  
//  、   、   、  、  
void test1()
{
    PNode pHead = NULL;        
    SListInit(&pHead);         //   
    SListPushBack(&pHead,54);  //  
    SListPushBack(&pHead,465);
    SListPushBack(&pHead,8);
    SListPushBack(&pHead,78);

    printf("%p
",SListFind(pHead,465));        //  465   (465     )
    printf("%d
",SListFind(pHead,465)->_data); //  465      

    SListInsert(&pHead,SListFind(pHead,54),100);// 54         100
    print(pHead);

    SListErase(&pHead,SListFind(pHead,100));    //        100   
    print(pHead);

    printf("      :%d
",SListSize(pHead)); //       

    printf("%d
",SListEmpty(pHead));             //          1   0  

    SListDestroy(&pHead);                           //    
    print(pHead);
}
//  
//  、  、  、  
void test()
{
    PNode pHead = NULL;        //        
    SListInit(&pHead);         //   
    SListPushBack(&pHead,3);   //  
    SListPushBack(&pHead,4);   //  
    print(pHead);

    SListPushFront(&pHead,6);  //  
    SListPushFront(&pHead,34);
    SListPushFront(&pHead,54);
    print(pHead);

    SListPopBack(&pHead);       //  
    SListPopFront(&pHead);      //  

    print(pHead);
    SListDestroy(&pHead); 
}