1. #pragma once
  2. #ifndef _CLIST_H_
  3. #define _CLIST_H_
  4.  
  5. #include <iostream>
  6. #include <assert.h>
  7. using namespace std;
  8.  
  9. template<class Type> class List;
  10.  
  11. typedef enum { FALSE, TRUE }Status;
  12.  
  13. template<class Type>
  14. class ListNode
  15. {
  16. 	friend class List<Type>;
  17. public:
  18. 	ListNode() :data(Type()), next(NULL)
  19. 	{}
  20. 	ListNode(Type d, ListNode<Type> *n = NULL)
  21. 		: data(d), next(n)
  22. 	{}
  23. 	~ListNode()
  24. 	{}
  25. 	void setData(const Type &d)
  26. 	{
  27. 		data = d;
  28. 	}
  29. 	Type GetData()
  30. 	{
  31. 		return data;
  32. 	}
  33. private:
  34. 	Type data;
  35. 	ListNode<Type> *next;
  36. };
  37.  
  38. template<class Type>
  39. class List
  40. {
  41. public:
  42. 	List()
  43. 	{
  44. 		ListNode<Type> *s = new ListNode<Type>(0);
  45. 		assert(s != NULL);
  46. 		last = first = s;
  47. 		size = 0;
  48. 	}
  49. 	~List()
  50. 	{}
  51. public:
  52. 	Status push_back(const Type &x)
  53. 	{
  54. 		ListNode<Type> *s = new ListNode<Type>(x);
  55. 		last->next = s;
  56. 		last = s;
  57. 		size++;
  58. 		return TRUE;
  59. 	}
  60. 	Status push_front(const Type &x)
  61. 	{
  62. 		ListNode<Type> *s = new ListNode<Type>(x);
  63. 		s->next = first->next;
  64. 		first->next = s;
  65. 		if (size == 0)
  66. 		{
  67. 			last = s;
  68. 		}
  69. 		size++;
  70. 		return TRUE;
  71. 	}
  72. 	Status pop_back()
  73. 	{
  74. 		if (size == 0)
  75. 		{
  76. 			return FALSE;
  77. 		}
  78. 		ListNode<Type> *p = first;
  79. 		while (p->next != last)
  80. 		{
  81. 			p = p->next;
  82. 		}
  83. 		delete last;
  84. 		last = p;
  85. 		last->next = NULL;
  86. 		size--;
  87. 		return TRUE;
  88. 	}
  89. 	Status pop_front()
  90. 	{
  91. 		if (size == 0)
  92. 		{
  93. 			return FALSE;
  94. 		}
  95. 		ListNode<Type> *p = first->next;
  96. 		first->next = p->next;
  97. 		delete p;
  98. 		if (size == 1)
  99. 		{
  100. 			last = first;
  101. 		}
  102. 		size--;
  103. 		return TRUE;
  104. 	}
  105. 	void show_List()
  106. 	{
  107. 		ListNode<Type> *p = first->next;
  108. 		while (p != NULL)
  109. 		{
  110. 			cout << p->data << "->";
  111. 			p = p->next;
  112. 		}
  113. 		cout << "NULL" << endl;
  114. 	}
  115. 	Status insert_val(const Type &x)
  116. 	{
  117. 		ListNode<Type> *p = first;
  118. 		while (p->next != NULL && p->next->data < x)
  119. 		{
  120. 			p = p->next;
  121. 		}
  122. 		if (p->next == NULL)
  123. 		{
  124. 			push_back(x);
  125. 		}
  126. 		else
  127. 		{
  128. 			ListNode<Type> *s = new ListNode<Type>(x);
  129. 			s->next = p->next;
  130. 			p->next = s;
  131. 			size++;
  132. 		}
  133. 		/*
  134. 		ListNode<Type> *s = new ListNode<Type>(x);
  135. 		ListNode<Type> *q = p->next;
  136. 		if(last->data > x)
  137. 		{
  138. 		while(q->data < x )
  139. 		{
  140. 		p = p->next;
  141. 		q = q->next;
  142. 		}
  143. 		p->next = s;
  144. 		s->next = q;
  145. 		size++;
  146. 		}
  147. 		else
  148. 		{
  149. 		push_back();
  150. 		}*/
  151.  
  152. 		return TRUE;
  153. 	}
  154. 	ListNode<Type>* find(const Type &key) const
  155. 	{
  156. 		if (size == 0)
  157. 		{
  158. 			return NULL;
  159. 		}
  160. 		ListNode<Type> *p = first->next;
  161. 		while(p != NULL && p->data != key)
  162. 		{
  163. 		p = p->next;
  164. 		}
  165. 		return p;
  166. // 		while (p != NULL)
  167. // 		{
  168. // 			if (p->data == key)
  169. // 			{
  170. // 				return p;
  171. // 			}
  172. // 			p = p->next;
  173. // 		}
  174. // 		return NULL;
  175. 	}
  176. 	Status delete_val(const Type &x)
  177. 	{
  178. 		if (size == 0)
  179. 		{
  180. 			return FALSE;
  181. 		}
  182. 		ListNode<Type> *p = find(x);
  183. 		if (p == NULL)
  184. 		{
  185. 			return FALSE;
  186. 		}
  187. 		if (p == last)
  188. 		{
  189. 			pop_back();
  190. 		}
  191. 		else
  192. 		{
  193. 			ListNode<Type> *q = p->next;
  194. 			p->data = q->data;
  195. 			p->next = q->next;
  196. 			delete q;
  197. 			size--;
  198. 			return TRUE;
  199. 		}
  200. 		return FALSE;
  201. 		/*	ListNode<Type> *p = first;
  202. 		ListNode<Type> *q = p->next;
  203. 		if(last->data == x)
  204. 		{
  205. 		pop_back();
  206. 		}
  207. 		while(q->data != x)
  208. 		{
  209. 		p = p->next;
  210. 		q = q->next;
  211. 		}
  212. 		p->next = q->next;
  213. 		return TRUE;*/
  214. 	}
  215. 	Status modify_val(const Type &x, const Type &y)
  216. 	{
  217. 		ListNode<Type> *p = find(x);
  218. 		if (p == NULL)
  219. 		{
  220. 			return FALSE;
  221. 		}
  222. 		p->data = y;
  223. 		return TRUE;
  224. 	}
  225. 	int length()
  226. 	{
  227. 		return size;
  228. 	}
  229. 	void clear()
  230. 	{
  231. 		ListNode<Type> *p = first->next;
  232. 		while (p != NULL)
  233. 		{
  234. 			first->next = p->next;
  235. 			delete p;
  236. 			p = first->next;
  237. 		}
  238. 		last = first;
  239. 		size = 0;
  240. 	}
  241. 	void destroy()
  242. 	{
  243. 		clear();
  244. 		delete first;
  245. 		first = last = NULL;
  246. 	}
  247. 	void sort()
  248. 	{
  249. 		if (size==0 || size==1)
  250. 		{
  251. 			return;
  252. 		}
  253. 		ListNode<Type> *p = first->next;
  254. 		ListNode<Type> *q = p->next;
  255. 		last = p;
  256. 		last->next = NULL;
  257. 		while (q != NULL)
  258. 		{
  259. 			p = q;
  260. 			q = q->next;
  261.  
  262. 			ListNode<Type> *s = first;
  263. 			while (p->data > s->next->data && s->next != NULL)
  264. 			{
  265. 				s = s->next;
  266. 			}
  267. 			if (s->next == NULL)
  268. 			{
  269. 				p->next = NULL;
  270. 				last->next = p;
  271. 				last = p;
  272. 			}
  273. 			else
  274. 			{
  275. 				p->next = s->next;
  276. 				s->next = p;
  277. 			}
  278. 		}
  279. 	}
  280.  
  281. 	void resver()
  282. 	{
  283. 		if (size==0 || size==1)
  284. 		{
  285. 			return;
  286. 		}
  287. 		ListNode<Type> *p = first->next;
  288. 		ListNode<Type> *q = p->next;
  289. 		last = p;
  290. 		last->next = NULL;
  291. 		while (q != NULL)
  292. 		{
  293. 			p = q;
  294. 			q = q->next;
  295. 			p->next = first->next;
  296. 			first->next = p;
  297. 		}
  298. 	}
  299. 	Status merge(List<Type> <1, List<Type> <2)
  300. 	{
  301. 		ListNode<Type> *p = lt1.first->next;
  302. 		ListNode<Type> *q = lt2.first->next;
  303. 		ListNode<Type> *s = first;
  304. 		while (p != NULL && q != NULL)
  305. 		{
  306. 			if (p->data < q->data)
  307. 			{
  308. 				s->next = p;
  309. 				p = p->next;
  310. 				s = s->next;
  311. 			}
  312. 			else
  313. 			{
  314. 				s->next = q;
  315. 				q = q->next;
  316. 				s = s->next;
  317. 			}
  318. 		}
  319. 		while (p != NULL)
  320. 		{
  321. 			s->next = p;
  322. 			p = p->next;
  323. 			s = s->next;
  324. 		}
  325. 		while (q != NULL)
  326. 		{
  327. 			s->next = q;
  328. 			q = q->next;
  329. 			s = s->next;
  330. 		}
  331. 		size = lt1.size + lt2.size;
  332. 		return TRUE;
  333. 	}
  334. 	ListNode<Type> *prio(ListNode<Type> *p) const
  335. 	{
  336. 		if (p == NULL || p == first->next)
  337. 		{
  338. 			return NULL;
  339. 		}
  340. 		ListNode<Type> *pr = first;
  341. 		while (pr->next != p)
  342. 		{
  343. 			pr = pr->next;
  344. 		}
  345. 		return pr;
  346. 	}
  347. 	ListNode<Type> *next(ListNode<Type> *p) const
  348. 	{
  349. 		if (p == NULL || p->next == NULL)
  350. 		{
  351. 			return NULL;
  352. 		}
  353. 		ListNode<Type> *q = first;
  354. 		while (q->next != p)
  355. 		{
  356. 			q = q->next;
  357. 		}
  358. 		return q;
  359. 	}
  360. 	ListNode<Type> *Next(const Type &x) const
  361. 	{
  362. 		if (size==0 || size==1)
  363. 		{
  364. 			return NULL;
  365. 		}
  366. 		ListNode<Type> *q = find(x);
  367. 		if (q == NULL)
  368. 		{
  369. 			return NULL;
  370. 		}
  371. 		return q->next;
  372. 	}
  373. 	ListNode<Type> *Prio(const Type &x) const
  374. 	{
  375. 		if(size==0 || size==1)
  376. 		{
  377. 			return NULL;
  378. 		}
  379. 		ListNode<Type> *p = first;
  380. 		ListNode<Type> *q = p->next;
  381. 		while (q != NULL)
  382. 		{
  383. 			if (q->data == x)
  384. 			{
  385. 				return p;
  386. 			}
  387. 			p = p->next;
  388. 			q = q->next;
  389. 		}
  390. 		return NULL;
  391. 	}
  392. private:
  393. 	ListNode<Type> *first;
  394. 	ListNode<Type> *last;
  395. 	size_t         size;
  396. };
  397.  
  398. #endif  

  1. #include "CList.h"
  2.  
  3. void main()
  4. {
  5. 	List<int> mylist;
  6. 	List<int> youlist;
  7. 	List<int> mergelist;
  8.  
  9. 	int select = 1;
  10. 	int pos;
  11. 	int item;
  12. 	system("Color 0d");
  13. 	while (select)
  14. 	{
  15. 		cout << "************************************" << endl;
  16. 		cout << "* [0]  quit_system [1] push_back   *" << endl;
  17. 		cout << "* [2]  push_front  [3] show_list   *" << endl;
  18. 		cout << "* [4]  pop_back    [5] pop_front   *" << endl;
  19. 		cout << "* [6]  insert_val  [7] delete_val  *" << endl;
  20. 		cout << "* [8]  merge       [9] next        *" << endl;
  21. 		cout << "* [10] find       [11] sort        *" << endl;
  22. 		cout << "* [12] resver     [13] length      *" << endl;
  23. 		cout << "* [14] clear      [15] destroy     *" << endl;
  24. 		cout << "* [16] modify_val [17] prio        *" << endl;
  25. 		cout << "************************************" << endl;
  26. 		cout << "请选择:>";
  27. 		cin >> select;
  28. 		switch (select)
  29. 		{
  30. 		case 1:
  31. 			cout << "请输入要插入的数据(-1结束):>";
  32. 			while (cin >> item, item != -1)
  33. 			{
  34. 				mylist.push_back(item);
  35. 			}
  36. 			break;
  37. 		case 2:
  38. 			cout << "请输入要插入的数据(-1结束):>";
  39. 			while (cin >> item, item != -1)
  40. 			{
  41. 				mylist.push_front(item);
  42. 			}
  43. 			break;
  44. 		case 3:
  45. 			system("cls");
  46. 			mylist.show_List();
  47. 			system("pause");
  48. 			break;
  49. 		case 4:
  50. 			mylist.pop_back();
  51. 			break;
  52. 		case 5:
  53. 			mylist.pop_front();
  54. 			break;
  55. 		case 6:
  56. 			cout << "请输入要插入的值:>";
  57. 			cin >> item;
  58. 			mylist.insert_val(item);
  59. 			break;
  60. 		case 7:
  61. 			cout << "请输入要删除的值:>";
  62. 			cin >> item;
  63. 			mylist.delete_val(item);
  64. 			break;
  65. 		case 8:
  66. 			for (int i = 1; i < 10; i+=2)
  67. 			{
  68. 				mylist.push_back(i);
  69. 			}
  70. 			for (int i = 2; i < 10; i += 2)
  71. 			{
  72. 				youlist.push_back(i);
  73. 			}
  74. 			mergelist.merge(mylist, youlist);
  75. 			mergelist.show_List();
  76. 			break;
  77. 		case 9:
  78. 			cout << "请输入要查找的值:>";
  79. 			cin >> item;
  80. 			cout << "所在查找值的后继为:" << mylist.Next(item) << endl;
  81. 			break;
  82. 		case 10:
  83. 			cout << "请输入要查找的值:>";
  84. 			cin >> item;
  85. 			cout << "该值指针为:" << mylist.find(item) << endl;
  86. 			break;
  87. 		case 11:
  88. 			mylist.sort();
  89. 			break;
  90. 		case 12:
  91. 			mylist.resver();
  92. 			break;
  93. 		case 13:
  94. 			cout << "线性表的长度为：" << mylist.length() << endl;
  95. 			break;
  96. 		case 14:
  97. 			mylist.clear();
  98. 			break;
  99. 		case 15:
  100. 			mylist.destroy();
  101. 			break;
  102. 		case 16:
  103. 			cout << "请输入要改动的值:>";
  104. 			cin >> item;
  105. 			cout << "请输入改动后的值:>";
  106. 			cin >> pos;
  107. 			mylist.modify_val(item, pos);
  108. 			break;
  109. 		case 17:
  110. 			cout << "请输入要查找的值:>";
  111. 			cin >> item;
  112. 			cout << "所在查找值的前驱为:" << mylist.Prio(item) << endl;
  113. 			break;
  114. 		default:
  115. 			break;
  116. 		}
  117. 	}
  118. }

执行界面例如以下：

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

【C++/数据结构】单链表的基本操作的更多相关文章

  1. PHP单链表的基本操作

    链表的实现 数据结构第一个就是链表了,链表分为两种有直接的数组形式的顺序链,这里不讨论,什么array_push(),array_pop(),函数基本能满足日常的需求,但报告老板,我就是想装个X 上代 ...

  2. python实现数据结构单链表

    #python实现数据结构单链表 # -*- coding: utf-8 -*- class Node(object): """节点""" ...

  3. C语言数据结构-单链表的实现-初始化、销毁、长度、查找、前驱、后继、插入、删除、显示操作

    1.数据结构-单链表的实现-C语言 typedef struct LNode { int data; struct LNode* next; } LNode,*LinkList; //这两者等价.Li ...

  4. 数据结构——单链表java简易实现

    巩固数据结构 单链表java实现 单链表除了表尾 每个几点都有一个后继 结点有数据和后继指针组成  通过构建表头和表尾(尾部追加需要)两个特殊几点 实现单链表的一些操作,代码如下 package co ...

  5. 用Java实现单链表的基本操作

    笔试题中经常遇到单链表的考题,下面用java总结一下单链表的基本操作,包括添加删除节点,以及链表转置. package mars; //单链表添加,删除节点 public class ListNode ...

  6. C# 数据结构--单链表

    什么是单链表 这两天看到很多有关单链表的面试题,对单链表都不知道是啥的我.经过学习和整理来分享一下啥是单链表和单链表的一些基本使用方法.最后看些网上有关单链表的面试题代码实例. 啥是单链表? 单链表是 ...

  7. 数据结构-------单链表（C++）

    相关信息: /** * @subject 数据结构 实验2 * @author 信管1142班 201411671210 赖俊杰 * @project 单链表 * @time 2015年10月29日1 ...

  8. C# 数据结构 - 单链表 双链表 环形链表

    链表特点(单链表 双链表) 优点:插入和删除非常快.因为单链表只需要修改Next指向的节点,双链表只需要指向Next和Prev的节点就可以完成插入和删除操作. 缺点:当需要查找某一个节点的时候就需要一 ...

  9. 数据结构—单链表（类C语言描写叙述）

    单链表 1.链接存储方法 链接方式存储的线性表简称为链表(Linked List). 链表的详细存储表示为: ① 用一组随意的存储单元来存放线性表的结点(这组存储单元既能够是连续的.也能够是不连续的) ...

  10. python算法与数据结构-单链表(38)

    一.链表 链表是一种物理存储单元上非连续.非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的.链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成.每个结点包括 ...

随机推荐

  1. CentOS 6.4 linux下编译安装MySQL5.6.14

    CentOS 6.4下通过yum安装的MySQL是5.1版的,比较老,所以就想通过源代码安装高版本的5.6.14. 正文: 一:卸载旧版本 使用下面的命令检查是否安装有MySQL Server rpm ...

  2. 使用VC++编写QQ群发器,MFC做UI

    由于公司业务需要,QQ群发器经常被用来发送QQ广告,购买的QQ群发器不好用不说,而且是按机器收费的,有些功能还不能修改. 所以公司派我来开发一款自己的QQ群发器,我给群发器取名叫做飞速群发器,用来给软 ...

  3. Swift 性能相关

    起初的疑问源自于「在 Swift 中的, Struct:Protocol 比 抽象类 好在哪里?」.但是找来找去都是 Swift 性能相关的东西.整理了点笔记,供大家可以参考一下. 一些疑问 在正题开 ...

  4. bootparam - 介绍Linux核心的启动参数

    描叙 Linux 核心在启动的时候可以接受指定的"命令行参数"或"启动参数"．在通常情况下,由于核心有可能无法识别某些硬件,或可能将某些硬件识别为不正确的配置, ...

  5. sysbench下载安装

    涉及到sysbench源码的配置和编译,首先确认系统安装了gcc gcc-c++编译器:确认安装了autoconf .automake.libtool等:[root@PC download]# rpm ...

  6. 多线程下单例模式的实现_ThreadLocal_ReentrantLock

    package threadStudy; public class MultiThreadSingleInstance { // volatile 防止指令重排 private static vola ...

  7. Timer时钟（之一）

    using System.Timers; static void Main(string[] args) { ThreadingTimer(); DateTime a = DateTime.Now; ...

  8. rem怎么算

    * rem : html根标签的 font-size决定* em 相对于父标签的font-size 决定的* 设计稿的宽一般都是 750px ---> 20px* 750px 1rem = 10 ...

  9. DTD DOCTYPE

    总结: DOCTYPE是什么 ? 文档类型声明,告诉解析器用什么样的文档类型定义来解析此文档.DOCTYPE不存在或格式不正确会导致文档以兼容模式呈现.   标准模式与兼容模式各有什么区别? 如果页面 ...

  10. IDEA使用properties配置文件进行mysql数据路连接

    1. 新建一个web项目(过程不需要教了吧,所以就省略啦) 2. 右键点击新建的项目名,选择创建文件目录(Directory),一般properties文件夹命名应为resoures; 3.右键点击新 ...