单向链表C++版

LList.h

 1 #pragma once
 2 
 3 // 节点结构体
 4 struct LinkNode
 5 {
 6     void* data;    //数据域
 7     struct LinkNode* next;    //下一节点指针
 8 };
 9 
10 class LList
11 {
12 private:
13     struct LinkNode* pHeader;    //链表的头节点
14     int m_Size;    //链表长度
15 public:
16     LList();
17     virtual ~LList();
18     // 插入节点
19     void insert_LinkList(void* data, int pos=-1);
20     // 遍历
21     void foreach_LinkList(void(*myPrint)(void*));
22     // 获取链表长度
23     int GetLength();
24     // 删除链表节点，按位置删除
25     void removeByPos_LinkList(int pos);
26     // 删除链表节点，按值删除
27     void removeByValue_LinkList(void* data, int(myCompare)(void*, void*));
28     // 清空列表
29     void clear_LinkList();
30 };

LList.cpp

  1 #include <iostream>
  2 #include "LList.h"
  3 
  4 LList::LList()
  5 {
  6     pHeader = new LinkNode();
  7     if (pHeader == NULL)
  8     {
  9         return;
 10     }
 11     pHeader->data = NULL;
 12     pHeader->next = NULL;
 13     m_Size = 0;
 14 }
 15 
 16 
 17 LList::~LList()
 18 {
 19     clear_LinkList();
 20     delete pHeader;
 21     pHeader = NULL;
 22 }
 23 
 24 // 插入节点
 25 void LList::insert_LinkList(void* data, int pos)
 26 {
 27     if (data == NULL)
 28     {
 29         return;
 30     }
 31     if (pos < 0 || pos > m_Size)
 32     {
 33         pos = m_Size;    //pos数据异常，改为尾插
 34     }
 35     // 创建临时节点，通过循环找到待插入位置的前驱节点位置
 36     struct LinkNode* pCurrent = pHeader;
 37     for (int i = 0; i < pos; i++)
 38     {
 39         pCurrent = pCurrent->next;
 40     }
 41     struct LinkNode* pNewNode = new LinkNode();
 42     pNewNode->data = data;
 43     // 建立节点之前的关系
 44     pNewNode->next = pCurrent->next;
 45     pCurrent->next = pNewNode;
 46     // 更新链表长度
 47     m_Size++;
 48     return;
 49 }
 50 
 51 
 52 // 遍历，需要要回调函数
 53 void LList::foreach_LinkList(void(*myPrint)(void*))
 54 {
 55     struct LinkNode* pCurrent = pHeader->next;
 56     for (int i = 0; i < m_Size; i++)
 57     {
 58         myPrint(pCurrent->data);
 59         pCurrent = pCurrent->next;
 60     }
 61 }
 62 
 63 
 64 // 获取链表长度
 65 int LList::GetLength()
 66 {
 67     return m_Size;
 68 }
 69 
 70 
 71 // 删除链表节点，按位置删除
 72 void LList::removeByPos_LinkList(int pos)
 73 {
 74     if (pos < 0 || pos > m_Size - 1)
 75     {
 76         return;
 77     }
 78     // 找到待删除位置的前驱节点位置
 79     struct LinkNode* pCurrent = pHeader;
 80     for (int i = 0; i < pos; i++)
 81     {
 82         pCurrent = pCurrent->next;
 83     }
 84     // 利用指针记录待删除节点
 85     struct LinkNode* pDelNode = pCurrent->next;
 86     pCurrent->next = pDelNode->next;
 87     delete pDelNode;
 88     m_Size--;
 89     return;
 90 }
 91 
 92 
 93 // 删除链表节点，按值删除
 94 void LList::removeByValue_LinkList(void* data, int(myCompare)(void*, void*))
 95 {
 96     if (data == NULL)
 97     {
 98         return;
 99     }
100     struct LinkNode* pPrevNode = pHeader;
101     struct LinkNode* pDelNode = pHeader->next;
102     for (int i = 0; i < m_Size; i++)
103     {
104         // 找到节点，开始删除
105         if (myCompare(data, pDelNode->data))
106         {
107             // 更改指针指向
108             pPrevNode->next = pDelNode->next;
109             // 释放节点
110             delete pDelNode;
111             // 更新链表长度
112             m_Size--;
113             break;
114         }
115         pPrevNode = pPrevNode->next;
116         pDelNode = pDelNode->next;
117     }
118     return;
119 }
120 
121 
122 // 清空列表
123 void LList::clear_LinkList()
124 {
125     struct LinkNode* pCurrent = pHeader->next;
126     while (pCurrent != NULL)
127     {
128         struct LinkNode* pNextNode = pCurrent->next;
129         delete pCurrent;
130         pCurrent = pNextNode;
131     }
132     m_Size = 0;
133 }

main.cpp（这个是测试模块）

 1 #include <iostream>
 2 #include<stdlib.h>
 3 #include "LList.h"
 4 using namespace std;
 5 
 6 struct Person
 7 {
 8     char name[64];
 9     int age;
10 };
11 // 自定义输出的回调函数
12 void printPerson(void * data)
13 {
14     struct Person* person = (struct Person*)data;
15     cout << "姓名：" << person->name << "，年龄：" << person->age << endl;
16 }
17 // 自定义比较的回调函数
18 int Compare(void* data1, void* data2)
19 {
20     struct Person* p1 = (struct Person*)data1;
21     struct Person* p2 = (struct Person*)data2;
22     return (p1->age == p2->age && !strcmp(p1->name, p2->name));
23 }
24 int main()
25 {
26     struct Person p1 = { "张三", 18 };
27     struct Person p2 = { "李四", 19 };
28     struct Person p3 = { "王五", 20 };
29 
30     LList* mList = new LList();
31     mList->insert_LinkList(&p1);
32     mList->insert_LinkList(&p2);
33     mList->insert_LinkList(&p3,1);
34     cout << mList->GetLength() << endl;
35     mList->foreach_LinkList(printPerson);
36     cout << "------------------------" << endl;
37     mList->removeByPos_LinkList(1);
38     cout << mList->GetLength() << endl;
39     mList->foreach_LinkList(printPerson);
40     cout << "------------------------" << endl;
41     mList->removeByValue_LinkList(&p2, Compare);
42     cout << mList->GetLength() << endl;
43     mList->foreach_LinkList(printPerson);
44     delete mList;
45     system("pause");
46     return 0;
47 }

posted on 2019-12-19 01:06 王浩的博客阅读(92) 评论(0) 收藏举报