单链表简单实现c++

首先定义一个类，相关数据，函数封装，在头文件中

#pragma once
class SingleList
{
public:
    typedef struct _NODE{
        int nData;      //数据域
        _NODE *pNext;   //指向下一个节点

    }NODE,*PNODE;
private:
    NODE * m_pHandNode;
    int m_nCount;
public:
    SingleList();
    ~SingleList();
    bool   InitList();                          //初始化操作
    bool   ListEmpty();                         //判断链表是否为空
    bool   ListInsert(int Data);                //插入数据(末尾)
    bool   ListInsert(int nPos, int Data);      //在指定位置插入数据
    int    GetElem(int nPos);                   //返回指定位置元素值
    int    LocateElem(int Data);                //查找与给定值相等的元素
    bool   ListDelete(int nPos, int &ValueData);//删除指定位置的元素，并返回其值
    int    ListLength();                        //返回元素个数
    bool   ClearList();                         //清空链表

};

实现具体的代码，在cpp

#include "stdafx.h"
#include "SingleList.h"
#include<iostream>
SingleList::SingleList(){
}
SingleList::~SingleList(){
}
//初始化链表
bool  SingleList::InitList(){
      m_nCount = 0;                          //链表长度为0
      m_pHandNode = new NODE;                //给头结点分配空间
      memset(m_pHandNode, 0, sizeof(NODE));  //头结点初始化
      return true;
}
//插入数据
bool   SingleList::ListInsert(int Data){
    PNODE pTemNode = m_pHandNode;
    while (true){
        if (!pTemNode->pNext){                     //如果节点指针为空，插入
            PNODE pNewNode = new NODE;             //建立临时节点
            pNewNode->nData = Data;                //临时节点数据赋值
            pNewNode->pNext = nullptr;             //临时节点下指针域置空
            pTemNode ->pNext= pNewNode;            //将插入节点地址给指向        
            m_nCount++;                            //将链表长度增加1
            return true;
        }
        pTemNode = pTemNode->pNext;                //如果非空，指向下一节点
    }
}
//插入指定位置，插入数据
bool   SingleList::ListInsert(int nPos, int Data){
    PNODE pTemNode = m_pHandNode;           //将头结点给一个变量，用于遍历
    if (nPos > m_nCount+1){                 //插入位置大于元素个数
        ListInsert(Data);                   //插入末尾
        return true;
    }
    else{
        PNODE pNewNode = new NODE;          //建立临时节点
        pNewNode->nData = Data;             //临时节点数据赋值
        pNewNode->pNext = nullptr;          //临时节点下指针域置空
        for (int i = 0; i < nPos - 1; i++){ //遍历到要插入节点上一节点处
            pTemNode = pTemNode->pNext;     
        }
        pNewNode->pNext = pTemNode->pNext;  //将上一节点的next给新节点的next
        pTemNode->pNext = pNewNode;         //将新节点的地址给上一节点的next
        m_nCount++;                         //链表长度加1
        return true;
    }
}

//非空判定
bool   SingleList::ListEmpty(){
    if (m_pHandNode->pNext){                //头节点的next有值，则非空
        return false;
    }
    return true;
}
//返回指定位置元素值
int    SingleList::GetElem(int nPos){      //传入坐标
    PNODE pTemp = new NODE;                //建立新节点接收链表
    pTemp = m_pHandNode;                      
    for (int i = 0; i < nPos; i++){        //遍历到坐标位置
        pTemp = pTemp->pNext;
    }
    return pTemp->nData;                   //返回坐标值
}
//寻找指定元素，返回位置
int    SingleList::LocateElem(int Data){   
    if (ListEmpty()){                      //如果为空，返回-1
        return -1;
    }
    else{
        int count = 1;                     //计数初始化
        PNODE Temp = new NODE;             //建立接收链表指针
        Temp = m_pHandNode->pNext;         //接收链表的指针指向第一个元素
        for (int i = 0; i < m_nCount; i++){//循环遍历找到元素
            if ((Temp->nData) == Data){    //找到元素，返回下标
                return count;
            }
            Temp = Temp->pNext;            //没找到指向下一个元素
            count++;                       //记数值加1
        }
    
    }
    return false;                          //遍历后还未找到，返回错误
}
//删除指定位置元素
bool   SingleList::ListDelete(int nPos, int &ValueData){
    if (ListEmpty()||nPos>m_nCount){     //如果链表为空，或指定位置大于链表长度
        return false;
    }
    PNODE pStart = m_pHandNode;
    for (int i = 0; i < nPos - 1; i++){
        pStart = pStart->pNext;             //指针指向要删除元素前一个位置
    }
    PNODE TempNode = new NODE;              //建立新节点
    TempNode = pStart->pNext;               //新节点记录要删除的节点信息
    ValueData = TempNode->nData;            //将要删除的信息保存传出外界
    pStart->pNext = TempNode->pNext;        //将删除后的两端链接
    delete TempNode;                        //释放掉建立的空间
    m_nCount--;                             //将链表个数减一
    return true;
}

//返回链表长度
int    SingleList::ListLength(){
    return m_nCount;
}
//销毁指针
bool   SingleList::ClearList(){
    PNODE pTemNode = m_pHandNode->pNext;   //保存头结点指针
    PNODE pTemNextNode;                    
    while (pTemNode)                       //当头节点指向不为空
    {
        pTemNextNode = pTemNode->pNext;    //头结点下一个指向给临时指针
        delete pTemNode;                   //删除头节点临时
        pTemNode = pTemNextNode;           //临时头节点指向下一个
    }
    m_nCount = 0;                          //将链表元素个数置0
    m_pHandNode->pNext = nullptr;          //将头结点next置空
    ///////////////////////////////////////////
    return true;
}

测试主函数

#include "stdafx.h"
#include"SingleList.h"
int _tmain(int argc, _TCHAR* argv[])
{

    SingleList a;                  //测试单链表
    a.InitList();                  //初始化
    a.ListInsert(23);              //插入几个数据
    a.ListInsert(24);
    a.ListInsert(25);
    a.ListInsert(26);
    a.ListInsert(27);
    a.ListInsert(28);
    int c;                         //定义变量接收要删除的值
    a.ListDelete(2, c);            //删除第二个元素，用c来接收，此时c作为引用传进去
    a.GetElem(3);                  //获取第三个元素
    a.ListInsert(3, 49);           //在第三个位置插入49
    int f=a.ListLength();          //获取长度
    int d=a.LocateElem(27);        //获取某个值所在位置
    a.ClearList();                 //销毁链表
    return 0;
}