数据结构---链表ADT C++实现

最近在学习数据结构,刚开始一直在看书,但是总是感觉似懂非懂,心想还不如自己操练一波,势必有所收获。现将实现代码发表此地,以备日后复习,同时由于本人C++基础薄弱,若有错误或者建议,欢迎告知本人!

1. 节点类

1 class Node {
2 public:
3     int data;
4     Node *next;
5     Node(int da):
6         data(da), next(NULL){}
7 };

这里节点类的定义采用大多数刷题网站的模版(当然,也可以使用 struct )

2. 链表类ADT

 1 class List{
 2 private:
 3     Node *head;
 4 public:
 5     List(): head(NULL){}
 6     ~List(){
 7         delete head;
 8         cout<<"The list is deleted."<<endl;
 9     };
10     int size(); // 链表长度
11     bool isEmpty(); // 是否为空
12     void printList(); // 打印链表
13     void insert(int position, int value); // 指定位置插入
14     void insertHead(int value); // 插入到最前
15     void insertTail(int value); // 插入到最后
16     int getValue(int position); // 查找指定位置的值
17     int search(int value); // 查找指定元素的位置
18     void update(int position, int value); // 更新指定位置的值
19     int erase(int position); // 删除指定位置的节点
20     void reverse(); // 反转链表
21     //void clearList() // 清空链表
22 };

3. 完整代码


  1 #include<iostream>
  2 using namespace std;
  3
  4 class Node {
  5 public:
  6     int data;
  7     Node *next;
  8     Node(int da):
  9         data(da), next(NULL){}
 10 };
 11
 12 class List{
 13 private:
 14     Node *head;
 15 public:
 16     List(): head(NULL){}
 17     ~List(){
 18         delete head;
 19         cout<<"The list is deleted."<<endl;
 20     };
 21     int size(); // 链表长度
 22     bool isEmpty(); // 是否为空
 23     void printList(); // 打印链表
 24     void insert(int position, int value); // 指定位置插入
 25     void insertHead(int value); // 插入到最前
 26     void insertTail(int value); // 插入到最后
 27     int getValue(int position); // 查找指定位置的值
 28     int search(int value); // 查找指定元素的位置
 29     void update(int position, int value); // 更新指定位置的值
 30     int erase(int position); // 删除指定位置的节点
 31     void reverse(); // 反转链表
 32     //void clearList() // 清空链表
 33 };
 34
 35 // 返回链表大小
 36 int List::size(){
 37     Node *p = head;
 38     int index = 0;
 39     while(p != NULL){
 40         index++;
 41         p = p->next;
 42     }
 43     return index;
 44 }
 45
 46 // 判断链表是否为空
 47 bool List::isEmpty(){
 48     if(List::size() == 0)
 49         return true;
 50     else
 51         return false;
 52 }
 53
 54 // 打印链表
 55 void List::printList(){
 56     Node *p = head;
 57     while(p != NULL){
 58         cout<<p->data<<" ";
 59         p = p->next;
 60     }
 61     cout<<endl;
 62     cout<<endl;
 63 }
 64
 65 // 在position位置插入value
 66 void List::insert(int position, int value){
 67     if(position<0 || position>List::size()){
 68         cout<<"position error, please check."<<endl;
 69         return ;
 70     }
 71     Node *s = new Node(value); // new node
 72     Node *p = head;
 73     if(head == NULL){ // isEmpty = true
 74         head = s;
 75     }
 76     else{ // isEmpty = false
 77         if(position == 0){
 78             s->next = p;
 79             head = s;
 80         }
 81         else{
 82             int index = 0;
 83             while(index != position-1){
 84                 p = p->next;
 85                 index++;
 86             }
 87             s->next = p->next;
 88             p->next = s;
 89         }
 90     }
 91     if (position == 0)
 92         cout<<"insert "<<value<<" at the first."<<endl;
 93     else if (position == List::size())
 94         cout<<"insert "<<value<<" at the tail."<<endl;
 95     else
 96         cout<<"insert "<<value<<" at position "<<position<<endl;
 97 }
 98
 99 // 头部插入
100 void List::insertHead(int value){
101     List::insert(0, value);
102 }
103
104 // 尾部插入
105 void List::insertTail(int value){
106     List::insert(List::size(), value);
107 }
108
109 // 搜索数据value,并返回位置
110 int List::search(int value){
111     Node *p = head;
112     int index = 0;
113     while(p != NULL && p->data != value){
114         index++;
115         p = p->next;
116     }
117     if(p == NULL){
118         cout<<"the value is not in the list, please check."<<endl;
119         return -1;
120     }
121     else{
122         cout<<value<<" at position "<<index<<endl;
123         return index;
124     }
125 }
126
127 // 将position位置的数据更新为value
128 void List::update(int position, int value){
129     if(position<0 || position>(List::size()-1)){
130         cout<<"position error, please check."<<endl;
131         return ;
132     }
133     Node *p = head;
134     int index = 0;
135     while(index != position){
136         p = p->next;
137         index++;
138     }
139     p->data = value;
140     cout<<"update "<<value<<" at position "<<position<<endl;
141 }
142
143 // 删除position位置的数据,并返回
144 int List::erase(int position){
145     if(position<0 || position>(List::size()-1)){
146         cout<<"position error, please check."<<endl;
147         return -1;
148     }
149     int res = List::getValue(position);
150     Node *p = head;
151     int index = 0;
152     cout<<"erase data at position "<<position<<endl;
153     if(position == 0){
154         head = p->next;
155         return res;
156     }
157     else{
158         while(index != position-1){
159             p = p->next;
160             index++;
161         }
162         Node *temp = p->next;
163         p->next = temp->next;
164         return res;
165     }
166 }
167
168 // 反转链表
169 void List::reverse(){
170     if (head == NULL || head->next == NULL)
171         return ;
172     Node *prev = head;
173     Node *cur = head->next;
174     Node *temp = head->next->next;
175     while(cur){
176         temp = cur->next;
177         cur->next = prev;
178         prev = cur;
179         cur = temp;
180     }
181     head->next = NULL; // 更新末尾元素的指针
182     head = prev; // 更新头结点
183     cout<<"reverse the list."<<endl;
184 }
185
186 // 返回position位置的数据
187 int List::getValue(int position){
188     if(position<0 || position>(List::size()-1)){
189         cout<<"position error, please check."<<endl;
190         return -1;
191     }
192     Node *p = head;
193     int index = 0;
194     while(index != position){
195         p = p->next;
196         index++;
197     }
198     cout<<"position "<<position<<" is "<<p->data<<endl;
199     return p->data;
200 }
201 /*
202 void List::clearList(){
203     Node *p = head;
204     while(p){
205         Node *temp = p->next;
206         delete p;
207         p = temp;
208     }
209 }
210 */
211 int main() {
212     List l1;
213     l1.insertTail(6);l1.printList();
214     l1.insertHead(7);l1.printList();
215     l1.insert(1, 5);l1.printList();
216     l1.insert(0, 16);l1.printList();
217     l1.insert(2, 56);l1.printList();
218     l1.insert(0, 169);l1.printList();
219     l1.insert(6, 16);l1.printList();
220     l1.search(16);
221     l1.getValue(5);
222     l1.update(1, 666);l1.printList();
223     l1.erase(0);l1.printList();
224     l1.reverse(); l1.printList();
225     cout<<"The size of the list: "<<l1.size()<<endl;
226     return 0;
227 }


4. 运行结果

insert 6 at the first.
6 

insert 7 at the first.
7 6 

insert 5 at position 1
7 5 6 

insert 16 at the first.
16 7 5 6 

insert 56 at position 2
16 7 56 5 6 

insert 169 at the first.
169 16 7 56 5 6 

insert 16 at position 6
169 16 7 56 5 6 16 

16 at position 1
position 5 is 6
update 666 at position 1
169 666 7 56 5 6 16 

position 0 is 169
erase data at position 0
666 7 56 5 6 16 

reverse the list.
16 6 5 56 7 666 

The size of the list: 6
The list is deleted.
[Finished in 2.0s]

关于每一部分的详解会继续补充。

原文地址:https://www.cnblogs.com/iwangzhengchao/p/9769768.html

时间: 2024-10-25 14:22:20

数据结构---链表ADT C++实现的相关文章

《数据结构与算法分析》学习笔记(三)——链表ADT

今天简单学习了下链表,待后续,会附上一些简单经典的题目的解析作为学习的巩固 首先要了解链表,链表其实就是由一个个结点构成的,然后每一个结点含有一个数据域和一个指针域,数据域用来存放数据,而指针域则用来存放下一个结点的地址. 1.先给出结点的定义. typedef struct Node *PtrToNode; typedef PtrToNode List; typedef PtrToNode Position; struct Node { ElementType Element; Positio

基础数据结构 链表、栈、队列

数据结构是程序设计中一个非常重要的部分,基本的数据结构包括链表.栈和队列,当然高级一点的还有树.图等,实际上链表.栈和队列都是线性表,只是在操作和表示方式上有所不同,线性表用顺序结构表示就是顺序表,用链结构表示就是链表,如果对线性表的操作加以限制,只能有在表尾进行插入和删除元素,这就变成栈了,如果只能允许元素从表尾插入,表头删除,这就变成队列了. 链表 /* * 数据结构 链表 * 链式结构 */ #include <iostream> using namespace std; enum St

数据结构链表学习

今天初步学习数据结构链表,学习过程中感觉对于指针的理解还差很多,而且对于VS的调试也不会使用,调查问题只能靠一遍一遍的梳理逻辑,效率不是一般的低下..接下来得赶紧学习下VS的使用.. 今天链表只是初步学习,写的例子也比较简单,如下: 定义链表的数据结构,只简单的定义了一个数据和一个指向后继的指针 1 struct List { 2 int num; 3 List *next; 4 }; 接下来就是链表的创建,返回一个指针地址赋给主函数中的头指针,用于之后的增删改查等等 1 List *creat

数据结构——链表的封装

链表是数据结构中最基本的线性结构,在编程中使用的频率最高,那么如何用封装思想来编写一个完整的链表操作呢?且看以下代码的实例. /*功能:演示链表的操作方法 */              /*作者: james */              /*时间: 2014.7.16 */              /*版本: v1.0 */              /*说明:使用面向对象思想封装一个链表*/ #include <stdio.h>              #include <s

数据结构与算法分析 - 1 - 链表ADT

1.描述:不连续存储的表,可以把链表看成一个数组,数组元素是一个个结构体,这些结构体之间通过指针连接 2.优点: 利用不连续的存储空间,提高内存使用效率 避免删除和插入的线性开销 对比数组,大小不固定,可以扩展 3. 缺点:查找效率低 4. 定义一个单向链表 1 struct Node 2 { 3 ElementType value; 4 Node *next; //next指针,指向下一个节点 5 }; 5.检测链表是否为空 对于一个单向链表,链表为空即头节点为空 1 int IsEmpty(

Linux内核数据结构——链表

目录 目录 简介 单向链表 双向链表 环形链表 Linux内核中的链表实现 offsetof container_of container_of 第一部分 container_of 第二部分 链表初始化 向链表中增加一个节点 删除节点 移动节点 判断链表是否为空 遍历链表 Demo测试 mlisth mlistc 执行结果 简介 最近在学习Android Binder驱动程序实现的时候,发现里面的数据结构用到了struct list_head.而我google发现struct list_head

第十章 基本数据结构——链表

 链表 链表与数组的区别是链表中的元素顺序是有各对象中的指针决定的,相邻元素之间在物理内存上不一定相邻.采用链表可以灵活地表示动态集合.链表有单链表和双链表及循环链表.书中着重介绍了双链表的概念及操作,双链表L的每一个元素是一个对象,每个对象包含一个关键字和两个指针:next和prev.链表的操作包括插入一个节点.删除一个节点和查找一个节点,重点来说一下双向链表的插入和删除节点操作,图例如下: 链表是最基本的数据结构,凡是学计算机的必须的掌握的,在面试的时候经常被问到,关于链表的实现,百度一下就

数据结构-链表

今天写抽象数据类型的表 抽象数据类型(ADT)是个啥? 就是定义了一块数学模型和对这块数学模型的操作. 现在就讲下今天的大头,LIST ADT 从最表的最简单格式讲 数组 数组的数学模型就是arr=[1,2,3]; 数组的操作就是打印数组,查找元素,这些操作可以自己添加,比如找previous或者next. 数组有个啥问题呢?就是删除和添加的时候,需要对整个数组大动干戈. 比如,在数组最前面添加一个元素,要把所有元素都向后移动. 比如,在数组最前面删除一个元素,要把所有元素都向前移动. 为了解决

delphi.数据结构.链表

链表作为一种基础的数据结构,用途甚广,估计大家都用过.链表有几种,常用的是:单链表及双链表,还有N链表,本文着重单/双链表,至于N链表...不经常用,没法说出一二三来. 在D里面,可能会用Contnrs.pas.TStack/TQueue相关类,进行操作,不过里面的实现,并非使用的是链表实现,只是用TList,然后...实现的. 呵,TList怎么实现那些不是重点,本文着重是说一下自己使用链表的一些心得. 一:单链表: 单链表的用途,主要一个场景:队列(stack/queue),两者区别在于:s