C++链表简单实现

C++并没有像C#一样的List类,需要手动实现一个链表。 首先声明一个数据结点模板类:

1  template<class T>
2 class LinkNode {
3  public:
4    linkNode() {
5         next = NULL;
6 }
7   T data;
8 linkNode* next;
9  }; 

data:存放T类型数据,next:存放下一节点指针,初始化next为NULL。

声明链表主体模板:

 1 template<class T>
 2 class Link {
 3         private:
 4             unsigned int  listLength;
 5             linkNode<T> * tempNode;
 6             linkNode<T> * headNode;
 7             linkNode<T> * lastNode;
 8         public:
 9             Link();//init this list
10             unsigned int length();
11             void add(T x);
12             bool isEmpty();
13             linkNode<T> * findNode(T x);
14             void deleteNode(T x);
15             void deleteNode(linkNode<T>* x);
16             void insert(T x,linkNode<T> * p);
17             void insertHead(T x);
18             linkNode<T> * firstOrDefault();
19             linkNode<T>* lastOrDefault();
20             linkNode<T>* removeAll();
21 }; 

对链表进行初始化操作;

1 template<class T>
2 Link<T>::Link(){
3   listLength = 0;
4   tempNode = NULL;
5   headNode = NULL;
6   lastNode =  NULL;
7 }

实现各方法:

  1 template<class T>
  2 linkNode<T> *Link<T>::removeAll(){
  3   linkNode<T>* p1,*p2;
  4   for(p1=headNode;p1!=NULL;p1=p2){
  5       p2 = p1->next;
  6       delete p1;
  7       p1=NULL;
  8     }
  9   tempNode = headNode = lastNode = p2 = NULL;
 10   listLength = 0;
 11   return NULL;
 12 }
 13
 14 //获取链表中的第一个节点  默认为NULL
 15 template<class T>
 16 linkNode<T>* Link<T>::firstOrDefault(){
 17   return headNode;
 18 }
 19
 20 //获取链表中的最后一个节点  默认为NULL
 21 template<class T>
 22 linkNode<T>* Link<T>::lastOrDefault(){
 23   return lastNode;
 24 }
 25
 26 //返回LIST长度
 27 template<class T>
 28 unsigned int Link<T>::length(){
 29   return listLength;
 30 }
 31
 32
 33 //向链表添加一个元素
 34 template<class T>
 35 void Link<T>::add(T x){
 36   tempNode = new linkNode<T>();
 37   tempNode->data = x;
 38   if(lastNode == NULL){
 39       headNode = tempNode;
 40       lastNode = tempNode;
 41     }else
 42     {
 43       lastNode->next = tempNode;
 44       lastNode = tempNode;
 45     }
 46   ++listLength;
 47 }
 48
 49
 50 //判断LIST是否为空
 51 template<class T>
 52 bool Link<T>::isEmpty(){
 53   return listLength == 0;
 54 }
 55
 56 //在LIST中查找某个节点
 57 template<class T>
 58 linkNode<T>* Link<T>::findNode(T x){
 59   tempNode = headNode;
 60   while (tempNode!=NULL&&tempNode->data!=x) {
 61       tempNode = tempNode->next;
 62     }
 63   return tempNode;
 64 }
 65
 66 //删除LIST中的某个节点
 67 template<class T>
 68 void Link<T>::deleteNode(linkNode<T> *x){
 69   linkNode<T>* _temp = headNode;
 70   if(_temp == NULL){ return ;}
 71   if(_temp == x){
 72       headNode = _temp->next;
 73       if(headNode == NULL){ lastNode = NULL; }
 74       delete _temp;
 75       if(listLength>0){
 76           --listLength;
 77         }
 78       return;
 79     }
 80   while (_temp->next!=NULL && _temp->next!=x) {
 81       _temp = _temp->next;
 82     }
 83   if(_temp->next == NULL ){return;}
 84   if(_temp->next == lastNode){
 85       delete _temp->next;
 86       _temp->next =NULL;
 87       lastNode = _temp;
 88     }else{
 89       tempNode = _temp->next;
 90       _temp->next = tempNode->next;
 91       delete tempNode;
 92       tempNode =NULL;
 93     }
 94   if(listLength>0){--listLength;}
 95 }
 96
 97 //删除LIST中的某个节点
 98 template<class T>
 99 void Link<T>::deleteNode(T x){
100   linkNode<T>* _temp = headNode;
101   if(_temp == NULL){ return ;}
102   if((_temp->data) == x){
103       headNode = _temp->next;
104       if(_temp->next == NULL){ lastNode = NULL;}
105       delete(_temp);
106       if(listLength>0){
107           --listLength;
108         }
109       return ;
110     }
111   while (_temp->next!=NULL&&_temp->next->data!=x) {
112       _temp = _temp->next;
113     }
114   if(_temp->next ==NULL){return;}
115   if(_temp->next == lastNode){
116       lastNode = _temp;
117       delete(_temp->next);
118       _temp->next = NULL;
119     }else{
120       tempNode = _temp->next;
121       _temp->next  = tempNode->next;
122       delete(tempNode);
123       tempNode = NULL;
124     }
125   if(listLength>0){
126       --listLength;
127     }
128 }
129
130 //在P元素后添加X
131 template<class T>
132 void Link<T>::insert(T x ,linkNode<T> *p){
133   if(p == NULL){return;}
134   tempNode = new linkNode<T>();
135   tempNode->data = x;
136   tempNode->next = p->next;
137   p->next = tempNode;
138   if(tempNode->next == NULL){lastNode = tempNode;}
139   ++listLength;
140 }
141
142 //在LIST头添加元素X
143 template<class T>
144 void Link<T>::insertHead(T x){
145   tempNode = new linkNode<T>();
146   tempNode->data = x;
147   tempNode->next = headNode;
148   headNode = tempNode;
149   ++listLength;
150 }
时间: 2024-10-28 23:32:57

C++链表简单实现的相关文章

合并两个有序链表---简单

题目: 将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两个链表的所有节点组成的. 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 思路: 感冒加上鼻炎,又有点头晕,30分钟才做完.这道简单题其实就是分类讨论,还要注意保留头节点的指针保留可以返回. /** * Definition for singly-linked list. * struct ListNode { * int val; *

单链表简单实现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

Java 单链表简单实现

实现功能并不完全,只有添加,删除,和遍历功能,后续还会继续添加 定义节点属性 class Node{ //定义节点属性 public int Data; public Node next = null; public Node(int Data){ this.Data = Data; } } 定义节点方法 class ListMe { Node head = null;//头结点为空 void addNode(int data){ //添加节点 Node newNode = new Node(d

Leetcode题解 - 链表简单部分题目代码+思路(21、83、203、206、24、19、876)

??本次部分没有带题目,因为链表系列的题目有的非常直观,从名字中就能知道到底需要做什么. 21. 合并两个有序链表 """ (用中间链表的方法)可以想象为双指针,分别指向两个链表,比较指针当前指向的值(因为是比较当前的值所以不需要判断next是否为空),拥有较小值的链表指针后移. """ class Solution: def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNo

栈的简单实现(2)-单链表实现

引言 栈(stack)是一种被广泛使用的线性数据结构,它只允许在表的一端进行插入或删除操作,因而栈也可以被称作为操作受限的线性表 .在栈中,允许插入或删除的一端称作栈顶(top)不允许插入和删除的另一端称作栈底(bottom); 示意图如下: 此文借助单链表简单地实现栈及其基本操作. 代码如下: typedef struct stack{ int data; struct stack* next; }ListStack; 注:这里假设栈中储存的是整型 (int) 的数据 基本操作 1.栈的初始化

等式转换(熟悉一下链表,指针引用)

1 /***************************************************************************** 2 *输入一个正整数X,在下面的等式左边的数字之间添加 + 号或者 - 号,使得等式成立. 3 *1 2 3 4 5 6 7 8 9 = X 4 *比如: 5 *12 - 34 + 5 - 67 + 89 = 5 6 *1 + 23 + 4 - 5 + 6 - 7 - 8 - 9 = 5 7 *请编写程序,统计满足输入整数的所有整数个数

4.9链表&amp;状态机与多线程

4.9.1链表的引入 4.9.1.1.从数组的缺陷说起 (1)数组由两个缺陷.一个是数组中所有元素的类型必须一致.数组的元素个数必须事先指定,并且一旦指定后不能更改. (2)如何解决数组的2个缺陷:数组的第一个缺陷考结构体解决.结构体允许其中的元素类型不相同,因此解决了数组的第一个缺陷.因此结构体是因为数组不能解决某些问题而被发明出来的 (3)如何解决数组的第二个缺陷?我们希望数组的大小能够实时扩展, 比如一开始我们定义了元素个数是10,后来程序运行时觉得不够因此扩展为20.普通的数组显然不行,

单链表判断公共节点

单链表判断有无公共节点是个比较有趣的问题.这里所说的公共节点指的是完全相同的节点,不同与一般意义上的节点元素相同.相交单链表简单的都会是如下形式(有环除外): 粗略分析,容易想到就是暴力法,双重循环寻找公共节点. 关于单链表的判断有无公共节点,除了暴力法之外,还有很多方法可以尝试.下面简单列举几种. 可以尝试hash,如果两个节点的首地址相同,则该节点必定相同,可以以空间换取时间,先处理其中一个单链表,建立hash表,然后处理另外一个判断有无公共节点,时间复杂度为O(max(n,m)),空间复杂

C++链表与键值对

<算法>一书中,在算法3.1中提到了Map的实现,这里根据书上的思想,用单向链表简单写了写. #ifndef SEQUENTIAL_H #define SEQUENTIAL_H template<class K, class V> class Link { private: class Node { public: K key=0; V value=0; Node *next=nullptr; public: Node(K, V, Node*); Node(){}; }; priv