链表系列文章(一)

参考 http://www.cnblogs.com/skywang12345/p/3561803.html在此致谢！

采用C++，实现了单链表和双向循环链表：

1. 单链表

  1 #ifndef SINGLE_LIST_H
  2 #define SINGLE_LIST_H
  3
  4 #ifndef INT_MAX
  5 #define INT_MAX 2147483647
  6 #define INT_MIN (-INT_MAX - 1)
  7 #endif
  8 #define ERROR INT_MIN
  9 #define OK 0
 10 #ifndef NULL
 11 #define NULL 0
 12 #endif
 13 template<class T>
 14 struct ListNode {
 15     T var;
 16     ListNode<T> *next;
 17     ListNode() : next(NULL) { }
 18     ListNode(T v, ListNode<T> *p = NULL) {
 19         var = v;
 20         next = p;
 21     }
 22 };
 23
 24 template<class T>
 25 class Mylist {
 26 public:
 27     Mylist();
 28     ~Mylist();
 29
 30     int size();
 31     bool empty();
 32
 33     int insert(int i, T t);
 34     int append(T t);
 35     int insert_first(T t);
 36
 37     T get(int i);
 38
 39     int erase(int i);
 40
 41 private:
 42     ListNode<T> *head;
 43     int len;
 44 };
 45 template<class T>
 46 Mylist<T>::Mylist() {
 47     len = 0;
 48     head = new ListNode<T>();
 49 }
 50 template<class T>
 51 Mylist<T>::~Mylist() {
 52     if(head) {
 53         int i = 0;
 54         ListNode<T> *p = NULL;
 55         while(i++ < len) {
 56             p = head->next;
 57             head->next = p->next;
 58             delete p;
 59         }
 60     }
 61     delete head;
 62 }
 63 template<class T>
 64 int Mylist<T>::size() {
 65     return len;
 66 }
 67 template<class T>
 68 bool Mylist<T>::empty() {
 69     return 0 == len;
 70 }
 71 template<class T>
 72 int Mylist<T>::insert(int i, T t) {
 73     if(i < 1 || i > len && len) return ERROR;
 74
 75     ListNode<T> *p = head;
 76     int j = 1;
 77     while(p && j++ < i) { p = p->next; }
 78
 79     ListNode<T> *s = p->next;
 80     p->next = new ListNode<T>(t);
 81     p->next->next = s;
 82
 83     len++;
 84     return OK;
 85 }
 86 template<class T>
 87 int Mylist<T>::append(T t) {
 88     ListNode<T> *p = head;
 89     int j = 0;
 90     while(p && j++ < len) { p = p->next; }
 91     p->next = new ListNode<T>(t);
 92     len++;
 93     return OK;
 94 }
 95 template<class T>
 96 int Mylist<T>::insert_first(T t) {
 97     return insert(1, t);
 98 }
 99 template<class T>
100 T Mylist<T>::get(int i) {
101     if(i < 1 || i > len) return ERROR;
102     ListNode<T> *p = head->next;
103     int j = 1;
104     while(p && j < i) { p = p->next; j++; }
105     return p->var;
106 }
107 template<class T>
108 int Mylist<T>::erase(int i) {
109     if(i < 1 || i > len) return ERROR;
110     ListNode<T> *p = head;
111     int j = 1;
112     while(p && j < i) { p = p->next; j++; }
113
114     ListNode<T> *s = p->next;
115     p->next = s->next;
116     delete s;
117
118     len--;
119     return OK;
120 }
121
122 #endif

2. 双向循环链表

  1 #ifndef BI_LINK_H
  2 #define BI_LINK_H
  3
  4 #ifndef INT_MAX
  5 #define INT_MAX 0x8fffffff
  6 #define INT_MIN (-INT_MAX - 1)
  7 #endif
  8 #define ERROR INT_MIN
  9 #define OK 0
 10 #ifndef NULL
 11 #define NULL 0
 12 #endif
 13
 14 template<class T>
 15 struct BLinkNode {
 16     T var;
 17     BLinkNode<T> *prev;
 18     BLinkNode<T> *next;
 19     BLinkNode() : prev(NULL), next(NULL) { }
 20     BLinkNode(T v, BLinkNode<T> *p = NULL, BLinkNode<T> *n = NULL) : var(v), prev(p), next(n) { }
 21 };
 22
 23 template<class T>
 24 class Bilink {
 25 public:
 26     Bilink();
 27     ~Bilink();
 28
 29     int size();
 30     bool empty();
 31
 32     T get(int index);
 33     T get_first();
 34     T get_last();
 35
 36     int insert(int index, T t);
 37     int insert_first(T t);
 38     int append_last(T t);
 39
 40     int erase(int index);
 41     int erase_first();
 42     int erase_last();
 43 private:
 44     int len;
 45     BLinkNode<T> *head;
 46 };
 47
 48 template<class T>
 49 Bilink<T>::Bilink():len(0) {
 50     head = new BLinkNode<T>();
 51     head->prev = head->next = head;
 52 }
 53 template<class T>
 54 Bilink<T>::~Bilink() {
 55     BLinkNode<T> *p = NULL;
 56     int i = 0;
 57     while(i++ < len) {
 58         p = head->next;
 59         head->next = p->next;
 60         delete p;
 61     }
 62     delete head;
 63 }
 64 template<class T>
 65 int Bilink<T>::size() {
 66     return len;
 67 }
 68 template<class T>
 69 bool Bilink<T>::empty() {
 70     return 0 == len;
 71 }
 72 template<class T>
 73 T Bilink<T>::get(int index) {
 74     if(index < 1 || index > len) return head->var;
 75     int i = 0;
 76     BLinkNode<T> *p = head;
 77     while(i++ < index) {
 78         p = p->next;
 79     }
 80     return p->var;
 81 }
 82 template<class T>
 83 T Bilink<T>::get_first() {
 84     if(len) {
 85         return head->next->var;
 86     }
 87     return head->var;
 88 }
 89 template<class T>
 90 T Bilink<T>::get_last() {
 91     if(len) {
 92         return head->prev->var;
 93     }
 94     return head->var;
 95 }
 96 template<class T>
 97 int Bilink<T>::insert(int index, T t) {
 98     if(index < 1 || index > len && len) return ERROR;
 99     if(index == 1) return insert_first(t);
100     int mid = (len + 1) >> 1;
101     BLinkNode<T> *p = head;
102     BLinkNode<T> *s = new BLinkNode<T>(t);
103     int i = 1;
104     if(index <= mid) {
105         while(i++ < index) { p = p->next; }
106         s->prev = p;
107         s->next = p->next;
108         p->next->prev = s;
109         p->next = s;
110     }
111     else {
112         while(i++ <= index) { p = p->prev; }
113         s->next = p;
114         s->prev = p->prev;
115         p->prev->next = s;
116         p->prev = s;
117     }
118     len++;
119     return OK;
120 }
121 template<class T>
122 int Bilink<T>::insert_first(T t) {
123     BLinkNode<T> *s = new BLinkNode<T>(t);
124     BLinkNode<T> *p = head;
125     s->prev = p;
126     s->next = p->next;
127     p->next->prev = s;
128     p->next = s;
129     len++;
130     return OK;
131 }
132 template<class T>
133 int Bilink<T>::append_last(T t) {
134     BLinkNode<T> *s = new BLinkNode<T>(t);
135     BLinkNode<T> *p = head;
136     s->prev = p->prev;
137     s->next = p;
138     p->prev->next = s;
139     p->prev = s;
140     len++;
141     return OK;
142 }
143 template<class T>
144 int Bilink<T>::erase(int index) {
145     if(index < 1 || index > len) { return ERROR; }
146     BLinkNode<T> *p = head;
147     int mid = len >> 1;
148     int i = 1;
149     if(index <= len) {
150         while(i++ < index) { p = p->next; }
151         BLinkNode<T> *s = p->next;
152         s->next->prev = p;
153         p->next = s->next;
154         delete s;
155     }
156     else {
157         while(i++ < index) { p = p->prev; }
158         BLinkNode<T> *s = p->prev;
159         s->prev->next = p;
160         p->prev = s->prev;
161         delete s;
162     }
163     len--;
164     return OK;
165 }
166 template<class T>
167 int Bilink<T>::erase_first() {
168     if(!len) return ERROR;
169     BLinkNode<T> *p = head;
170     BLinkNode<T> *s = p->next;
171     s->next->prev = p;
172     p->next = s->next;
173     len--;
174     return OK;
175 }
176 template<class T>
177 int Bilink<T>::erase_last() {
178     if(!len) return ERROR;
179     BLinkNode<T> *p = head;
180     BLinkNode<T> *s = p->prev;
181     s->prev->next = p;
182     p->prev = s->prev;
183     len--;
184     return OK;
185 }
186
187 #endif

由于本人水平有限，文章中难免有不当和错误之处，欢迎大家批评指正，愿共同进步！！！

时间： 2024-10-09 21:38:23

链表系列文章(一)的相关文章

链表系列文章(三)

上一篇讨论了链表相关的几个有趣的问题,这一篇主要讨论与反转链表有关的问题基本数据结构: struct ListNode { int var; ListNode *next; ListNode( int v = 0 ) : var(v), next(NULL) { } }; 1. 反转链表方法一:堆栈法,利用栈后进先出的特性,将链表节点依次入栈,然后弹出并修改next指针时间复杂度O(n),空间复杂度O(n) 1 ListNode *reverseList(ListNode *head)

链表系列文章(四)

上一篇讨论了链表的反转问题,这一篇讨论链表排序的问题 1. 排序两个有序链表比较简单,属于归并排序,不再赘述时间复杂度O(n), 空间复杂度O(1) 1 ListNode *mergeList( ListNode *list1, ListNode *list2 ) { 2 if(!list1 || !list2) return list1 ? list1 : list2; 3 ListNode res(-1), *phead = &res; 4 while(list1 && l

【系列文章】数据结构与算法——图

---恢复内容开始--- 接触C语言是很早以前的事了,大概是在初中二年级.后来发现只学语言,不学算法根本没用,于是乎萌发了学习数据结构和算法的想法,但一直没有什么实际进展.直到今天,才决定好好研究一番(ps:今年大一,甚是惭愧),顺便把学习过程记录在这一系列文章之中.好了,废话不多说,开始我这一系列的文章.文中可能有错误,如果你发现了,我恳请你帮我指出.谢谢. 图——图能很方便的描述一些实际问题,常用于寻找最优解类型的问题.其他相关概念,百度百科说的很清楚了. 学习图大概有以下几个过程. 一.创

《PHP内核探索系列文章》系列技术文章整理收藏

<PHP内核探索系列文章>系列技术文章整理收藏 PHP内核探索系列文章收藏夹收藏有关PHP内核方面的知识的文章,对PHP高级进阶的朋友提供PHP内核方面的知识点探讨 1PHP内核探索:从SAPI接口开始 2PHP内核探索:一次请求的开始与结束 3PHP内核探索:再次探讨SAPI 4PHP内核探索:Apache模块介绍 5PHP内核探索:Zend引擎 6PHP内核探索:多进程/线程的SAPI生命周期 7PHP内核探索:单进程SAPI生命周期 8PHP内核探索:一次请求生命周期 9PHP内核探索:

C#泛型专题系列文章目录导航

[C#泛型系列文章] 目录导航第一部分:O'Reilly 出版的<C# Cookbook>泛型部分翻译第一回:理解泛型第二回:获取泛型类型和使用相应的泛型版本替换ArrayList 第三回:使用相应的泛型版本替换Stack和Queue 第四回:链表的实现和可空类型第五回:反转SortedList里的内容第六回:使用泛型创建只读集合及使用相应的泛型版本替换Hashtable 第七回:在泛型字典类中使用foreach及泛型约束第八回:初始化泛型类型变量为它们的默认值第二部分:O'Re

数据结构:单向链表系列6--交换相邻两个节点1（交换数据域）

给定一个单向链表,编写函数交换相邻两个元素输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 输出: 2 -> 1 -> 4 -> 3 -> 6 -> 5 -> 7 输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6 输出: 2 -> 1 -> 4 -> 3 -> 6 -> 5 通过观察发现:当输入的与元素个数是单数的时候,最后一位不参与交换

《深入理解Java集合框架》系列文章

Introduction 关于C++标准模板库(Standard Template Library, STL)的书籍和资料有很多,关于Java集合框架(Java Collections Framework, JCF)的资料却很少,甚至很难找到一本专门介绍它的书籍,这给Java学习者们带来不小的麻烦.我深深的不解其中的原因.虽然JCF设计参考了STL,但其定位不是Java版的STL,而是要实现一个精简紧凑的容器框架,对STL的介绍自然不能替代对JCF的介绍. 本系列文章主要从数据结构和算法层面分析

Jenkins pipeline 入门到精通系列文章

Jenkins2 入门到精通系列文章. Jenkins2 下载与启动jenkins2 插件安装jenkins2 hellopipelinejenkins2 pipeline介绍jenkins2 javahelloworldjenkins2 groovy入门jenkins2 pipeline入门jenkins2 pipeline高级jenkins2 Jenkinsfilejenkins2 multibranchjenkins2 Jenkinsfile和loadjenkins2 groovy脚本参考

saltstack之基础入门系列文章简介

使用saltstack已有一段时间,最近由于各种原因,特来整理了saltstack基础入门系列文章,已备后续不断查阅(俗话说好记性不如烂笔头),也算是使用此工具的一个总结.saltstack的前六篇文章主要讲述了saltstack的安装.远程执行.配置管理.数据系统以及jinjia模板等知识点,从第七篇往后的文章是一些使用saltstack的案例,包括系统初始化,rpm包以及源码安装等. 博客中saltstack系列的文章,适合初学者从零开始学习直到逐渐熟练使用.文章具有一定的连贯性,如果没有任