一个完整链表的实现

【linearlist.h】：

 1 #include<iostream>
 2 using namespace std;
 3 template <class T>
 4 class LinearList
 5 {
 6 public:
 7     virtual bool IsEmpty() const = 0;
 8     virtual int Length() const = 0;
 9     virtual bool Find(int i, T& x)const = 0;
10     virtual int Search(T x) const = 0;
11     virtual bool Insert(int i, T x) = 0;
12     virtual bool Delete(int i) = 0;
13     virtual bool Update(int i, T x) = 0;
14     virtual void Output(ostream & out) const = 0;
15 protected:
16     int n;
17 };

【singlelist.h】：

  1 #include"linearlist.h"
  2 template <class T>
  3 class SingleList;
  4 template <class T>
  5 class Node
  6 {
  7 private:
  8     T element;
  9     Node<T> *link;
 10     friend class SingleList<T>;
 11 };
 12 template <class T>
 13 class SingleList:public LinearList<T>
 14 {
 15 public:
 16     SingleList()
 17     {
 18         first = NULL;
 19         n = 0;
 20     }
 21     ~SingleList();
 22     bool IsEmpty() const;
 23     int Length() const;
 24     bool Find(int i, T& x) const;
 25     int Search(T x) const;
 26     bool Insert(int i, T x);
 27     bool Delete(int i);
 28     bool Update(int i, T x);
 29     void Clear();
 30     void Output(ostream& out) const;
 31 private:
 32     Node<T>* first;
 33 };
 34
 35 template<class T>
 36 SingleList<T>::~SingleList()
 37 {
 38     Node<T> *p;
 39     while (first)
 40     {
 41         p = first->link;
 42         delete first;
 43         first = p;
 44     }
 45 }
 46 template <class T>
 47 int SingleList<T>::Length() const
 48 {
 49     return n;
 50 }
 51 template <class T>
 52 bool SingleList<T>::IsEmpty() const
 53 {
 54     return n == 0;
 55 }
 56 template <class T>
 57 bool SingleList<T>::Find(int i, T& x) const
 58 {
 59     if (i<-1 || i>n - 1)
 60     {
 61         cout << "out of bounds";
 62         return false;
 63     }
 64     Node<T> *p = first;
 65     for (int j = 0; j < i; j++)
 66         p = p->link;
 67     x = p->element;
 68     return true;
 69 }
 70 template <class T>
 71 int SingleList<T>::Search(T x) const
 72 {
 73     int j ;
 74     Node<T> *p = first;
 75     for ( j = 0;  p&&p->element!=x; j++)
 76         p = p->link;
 77     if (p)
 78         return j;
 79     return -1;
 80 }
 81 template <class T>
 82 bool SingleList<T>::Insert(int i, T x)
 83 {
 84     if (i<-1 || i>n - 1)
 85     {
 86         cout << "out of bounds";
 87         return false;
 88     }
 89     Node<T> *q = new Node<T>;
 90     q->element = x;
 91     Node<T> *p = first;
 92     for (int j = 0; j < i; j++)
 93         p = p->link;
 94     if (i>-1)
 95     {
 96         q->link = p->link;
 97         p->link = q;
 98     }
 99     else
100     {
101         q->link = first;
102         first = q;
103     }
104     n++;
105     return true;
106 }
107 template<class T>
108 bool SingleList<T>::Delete(int i)
109 {
110     if (!n)
111     {
112         cout << "underflow" << endl;
113         return false;
114     }
115     if (i<0 || i>n - 1)
116     {
117         cout << "out of bounds"<<endl;
118         return false;
119     }
120     Node<T> *p = first, *q = first;
121     for (int j = 0; j < i - 1; j++)
122         q = q->link;
123     if (i == 0)
124         first = first->link;
125     else
126     {
127         p = q->link;
128         q->link = p->link;
129     }
130     delete p;
131     n--;
132     return true;
133 }
134 template<class T>
135 bool SingleList<T>::Update(int i, T x)
136 {
137     if (i<0 || i>n - 1)
138     {
139         cout << "out of bounds" << endl;
140         return false;
141     }
142     Node<T> *p = first;
143     for (int j = 0; j < i; j++)
144         p = p->link;
145     p->element = x;
146     return true;
147 }
148 template <class T>
149 void SingleList<T>::Output(ostream& out) const
150 {
151     Node<T> *p = first;
152     while (p)
153     {
154         out << p->element << " ";
155         p = p->link;
156     }
157     out << endl;
158 }

【singlelist_temp.h】：

  1 #include"linearlist.h"
  2 template <class T>
  3 class SingleList;
  4 template <class T>
  5 class Node
  6 {
  7 private:
  8     T element;
  9     Node<T> *link;
 10     friend class SingleList<T>;
 11 };
 12 template <class T>
 13 class SingleList :public LinearList<T>
 14 {
 15 public:
 16     SingleList()
 17     {
 18         first = NULL;
 19         n = 0;
 20     }
 21     ~SingleList();
 22     bool IsEmpty() const;
 23     int Length() const;
 24     bool Find(int i, T& x) const;
 25     int Search(T x) const;
 26     bool Insert(int i, T x);
 27     bool Delete(int i);
 28     bool Update(int i, T x);
 29     void Clear();
 30     void Output(ostream& out) const;
 31     void Upstream();
 32     bool SM_Delete(T x);
 33 private:
 34     Node<T>* first;
 35 };
 36
 37 template<class T>
 38 SingleList<T>::~SingleList()
 39 {
 40     Node<T> *p;
 41     while (first)
 42     {
 43         p = first->link;
 44         delete first;
 45         first = p;
 46     }
 47 }
 48 template <class T>
 49 int SingleList<T>::Length() const
 50 {
 51     return n;
 52 }
 53 template <class T>
 54 bool SingleList<T>::IsEmpty() const
 55 {
 56     return n == 0;
 57 }
 58 template <class T>
 59 bool SingleList<T>::Find(int i, T& x) const
 60 {
 61     if (i<-1 || i>n - 1)
 62     {
 63         cout << "out of bounds";
 64         return false;
 65     }
 66     Node<T> *p = first;
 67     for (int j = 0; j < i; j++)
 68         p = p->link;
 69     x = p->element;
 70     return true;
 71 }
 72 template <class T>
 73 int SingleList<T>::Search(T x) const
 74 {
 75     int j;
 76     Node<T> *p = first;
 77     for (j = 0; p&&p->element != x; j++)
 78         p = p->link;
 79     if (p)
 80         return j;
 81     return -1;
 82 }
 83 template <class T>
 84 bool SingleList<T>::Insert(int i, T x)
 85 {
 86     if (i<-1 || i>n - 1)
 87     {
 88         cout << "out of bounds";
 89         return false;
 90     }
 91     Node<T> *q = new Node<T>;
 92     q->element = x;
 93     Node<T> *p = first;
 94     for (int j = 0; j < i; j++)
 95         p = p->link;
 96     if (i>-1)
 97     {
 98         q->link = p->link;
 99         p->link = q;
100     }
101     else
102     {
103         q->link = first;
104         first = q;
105     }
106     n++;
107     return true;
108 }
109 template<class T>
110 bool SingleList<T>::Delete(int i)
111 {
112     if (!n)
113     {
114         cout << "underflow" << endl;
115         return false;
116     }
117     if (i<0 || i>n - 1)
118     {
119         cout << "out of bounds" << endl;
120         return false;
121     }
122     Node<T> *p = first, *q = first;
123     for (int j = 0; j < i - 1; j++)
124         q = q->link;
125     if (i == 0)
126         first = first->link;
127     else
128     {
129         p = q->link;
130         q->link = p->link;
131     }
132     delete p;
133     n--;
134     return true;
135 }
136 template<class T>
137 bool SingleList<T>::Update(int i, T x)
138 {
139     if (i<0 || i>n - 1)
140     {
141         cout << "out of bounds" << endl;
142         return false;
143     }
144     Node<T> *p = first;
145     for (int j = 0; j < i; j++)
146         p = p->link;
147     p->element = x;
148     return true;
149 }
150 template <class T>
151 void SingleList<T>::Output(ostream& out) const
152 {
153     Node<T> *p = first;
154     while (p)
155     {
156         out << p->element << " ";
157         p = p->link;
158     }
159     out << endl;
160 }
161 template<class T>
162 void SingleList<T>::Upstream()
163 {
164     Node<T> *p = first;
165     Node<T> *curr = p->link;
166     Node<T> *tmp = NULL;
167
168     p->link = NULL;
169     while (curr)
170     {
171         tmp = curr->link;
172         curr->link = p;
173         p = curr;
174         curr = tmp;
175
176     }
177
178     first->link = NULL;
179     first = p;
180 }
181
182 template<class T>
183 bool  SingleList<T>::SM_Delete(T x)
184 {
185     /*
186     for (Node<T>** cur = &first; *cur;)
187     {
188         Node<T>* entry = *cur;
189         if (entryement == x)
190         {
191             *cur = entry->link;
192             free(entry);
193         }
194         else
195             cur = &entry->link;
196     }
197     */
198     Node<T> *p;
199     int j = 0;
200     p = first;
201     while (p)
202     {
203         for (j = 0; p&&p->element != x; j++)
204             p = p->link;
205         if (p)
206         {
207             Delete(j);
208             p = first;
209         }
210         else
211             return false;
212     }
213     return true;
214 }

【SingleList.cpp（测试用）】：

 1 #include"singlelist_temp.h"
 2 template<class T>
 3 void Intersection(SingleList<T> &LA, SingleList<T> &LB)
 4 {
 5     T x;
 6     int i = 0;
 7     while (i < LA.Length())
 8     {
 9         LA.Find(i, x);
10         if (LB.Search(x) == -1)
11             LA.Delete(i);
12         else i++;
13     }
14 }
15 int main()
16 {
17     SingleList<int> LA;
18     //SingleList<int> LB;
19     /*
20     for (int i = 0; i < 10; i++)
21          LA.Insert(i-1, i);
22         */
23          LA.Insert(-1, 1);
24          LA.Insert(0, 2);
25          LA.Insert(1, 3);
26          LA.Insert(2, 2);
27          LA.Insert(3, 4);
28          LA.Insert(4, 2);
29
30          LA.Insert(5, 5);
31
32     LA.Output(cout);
33     /*
34     for (int i = 5; i < 10; i++)
35          LB.Insert(i - 6, i);
36     LB.Output(cout);
37     LB.Insert(-1, 0);
38     LB.Output(cout);
39     LB.Insert(3, 2);
40     LB.Output(cout);
41     Intersection(LA, LB);
42     */
43     LA.Upstream();
44     LA.SM_Delete(2);
45     LA.Output(cout);
46     system("pause");
47 }

时间： 2024-12-06 04:40:21

一个完整链表的实现的相关文章

【LeetCode-面试算法经典-Java实现】【206-Reverse Linked List（反转一个单链表）】

[206-Reverse Linked List(反转一个单链表)] [LeetCode-面试算法经典-Java实现][所有题目目录索引] 代码下载[https://github.com/Wang-Jun-Chao] 原题 Reverse a singly linked list. 题目大意反转单链表. 解题思路使用头插法. 代码实现结点类 public class ListNode { int val; ListNode next; ListNode(int x) { val = x;

让我们一起来实现一个完整的内存管理工具（线程，内存池，萃取）

//让我们开始一个完整的内存管理工具的实现吧. ///准备做一个完整的内存管理工具 //涉及线程,内存池,萃取,不仅仅是new跟delete的重载(或者说是函数重载),这是我的一个雏形,大家谁有什么好的指正谢谢提出,一起学习. #include <iostream> #include <string.h> #include <stdlib.h> #include <stdio.h> #include <list> #include <mal

13输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针。

转载请注明出处:http://www.cnblogs.com/wuzetiandaren/p/4250795.html 声明:现大部分文章为寻找问题时在网上相互转载,此博是为自己做个记录记录,方便自己也方便有类似问题的朋友,本文的思想也许有所借鉴,但源码均为本人实现,如有侵权,请发邮件表明文章和原出处地址,我一定在文章中注明.谢谢. 题目:输入一个单向链表,输出该链表中倒数第k个结点.链表的倒数第0个结点为链表的尾指针. 题目分析: 1.链表的倒数第0个结点为链表的尾指针,设为r,则r指向最后一

【如何快速的开发一个完整的iOS直播app】(原理篇)

一.个人见解(直播难与易) 直播难:个人认为要想把直播从零开始做出来,绝对是牛逼中的牛逼,大牛中的大牛,因为直播中运用到的技术难点非常之多,视频/音频处理,图形处理,视频/音频压缩,CDN分发,即时通讯等技术,每一个技术都够你学几年的. 直播易:已经有各个领域的大牛,封装好了许多牛逼的框架,我们只需要用别人写好的框架,就能快速的搭建一个直播app,也就是传说中的站在大牛肩膀上编程. 二.了解直播热门直播产品映客,斗鱼,熊猫,虎牙,花椒等等直播效果图直播效果.jpeg 1.一个完整直播ap

【如何快速的开发一个完整的iOS直播app】(播放篇)

前言在看这篇之前,如果您还不了解直播原理,请查看上篇文章如何快速的开发一个完整的iOS直播app(原理篇) 开发一款直播app,集成ijkplayer成功后,就算完成直播功能一半的工程了,只要有拉流url,就能播放直播啦本篇主要讲解的是直播app中,需要用到的一个很重要的开源框架ijkplayer,然后集成这个框架可能对大多数初学者还是比较有难度的,所以本篇主要教你解决集成[ijkplayer]遇见的各种坑. 很多文章,可能讲解的是如何做,我比较注重讲解为什么这样做,大家有什么不明白,还可以

c语言：编写一个输出链表的函数print

编写一个输出链表的函数print. 解:程序: #include<stdio.h> #include<stdlib.h> #define LEN sizeof(struct Student) struct Student { long num; float score; struct Student *next; }; int n; struct Student *creat()//建立链表的函数 { struct Student *head; struct Student *p1

【转载】串口中怎样接收一个完整数据包的解析

这里以串口作为传输媒介,介绍下怎样来发送接收一个完整的数据包.过程涉及到封包与解包.设计一个良好的包传输机制很有利于数据传输的稳定性以及正确性.串口只是一种传输媒介,这种包机制同时也可以用于SPI,I2C的总线下的数据传输.在单片机通信系统(多机通信以及PC与单片机通信)中,是很常见的问题. 一.根据帧头帧尾或者帧长检测一个数据帧 1.帧头+数据+校验+帧尾这是一个典型的方案,但是对帧头与帧尾在设计的时候都要注意,也就是说帧头.帧尾不能在所传输的数据域中出现,一旦出现可能就被误判.如果用中断来

如何快速搭建一个完整的移动直播系统？

移动直播行业的火热会在很长一段时间内持续,通过和各行业的整合,从而成为具有无限可能性的行业.主要因为以下三个原因: 第一,移动直播的UGC生产模式比PC端的直播更明显,人人都有设备,随时随地开播,完全顺应了互联网时代的开放性原则,能刺激更多人去创造和传播优质内容. 第二,网络带宽和速度在逐渐提高,网络成本在逐渐下降,为移动直播提供一个极佳的发展环境.文字.声音.视频.游戏等都会在移动直播中呈现,创造出更加丰富的用户体验.直播可以以SDK的形式接入到自己的应用中,比如,教育领域中的课后辅导完全可以

两个有序链表合成一个有序链表

RT.... 无聊帮朋友撸个 C++ 作业.. ＝＝ 1 /* 2 无聊帮朋友撸个作业...... \ = v = / 3 4 两个有序链表合成为一个有序链表. 5 要求: 6 1. 每个链表元素里的值不超过int范围. 7 2. 两个链表要求为升序(从小到大). 8 9 10 2016.1.5 author : 加德满都的猫会爬树 11 12 */ 13 14 #include <iostream> 15 using namespace std; 16 const int MAX = 10