【殷人昆数据结构】第二章2.4 双向链表代码的调试

最新推荐文章于 2021-09-26 01:19:06 发布
最新推荐文章于 2021-09-26 01:19:06 发布
阅读量154 收藏
点赞数
分类专栏： 数据结构笔记 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianty1121/article/details/108159503
版权

Circular List双向链表

主函数

#include "DblList.h"
#include <fstream>
#include <cassert>
using namespace std;
int main()
{
	DblList<int> list(-1);
	ifstream fin("list.txt");
	assert(fin);
	fin >> list;
	cout << "The initial list in the file is:\n" << list << endl;

	cout << "========================================\n";
	int i, elem, d;
	cout << "Test the Insert, Remove and Search function:\n";
	cout << "Each test will terminate by an invaid input.";
	cout << "\n----------------------------------------\n";

	cout << "1. Test the Insert(int i, T &elem, int d):\n";
	while (1){
		cout << "Input the index i and data elem and the direction(0/1) to insert: ";
		cin >> i >> elem >> d;
		if (!cin){
			cin.clear();
			cin.ignore(100,'\n');
			break;
		}
		if (i < 0)	break;
		if (list.Insert(i, elem, d))	cout << "Insert successful!\n";
		else	cout << "Insert failed!\n";
	}
	cout << "\nAfter inserted\n" << list << endl;

	cout << "----------------------------------------\n";
	cout << "2. Test the Remove(int i, T &elem, int d):\n";
	while (1){
		cout << "Input the index i and the direction(0/1) in which you want to remove: ";
		cin >> i >> d;
		if (!cin){
			cin.clear();
			cin.ignore(100,'\n');
			break;
		}
		if (i < 0)	break;
		if (list.Remove(i, elem, d)) cout << "The element " << elem << " has been removed!\n";
		else	cout << "Remove failed!\n";
	}
	cout << "\nAfter removed\n" << list << endl;

	cout << "----------------------------------------\n";
	cout << "3. Test the Search(T &elem):\n";
	while (1){
		cout << "Input the element and the search direction(1/0) you want to search: ";
		cin >> elem >> d;
		if (!cin){
			cin.clear();
			cin.ignore(100,'\n');
			break;
		}
		if (elem < 0)	break;
		DblNode<int> *p = list.Search(elem, d);
		if (p)	cout << "The element " << elem << " is in the list.\n";
		else	cout << "The element is not exist!\n";
	}
	cout << "\n----------------------------------------\n";
	cout << "End test!" << endl;
	return 0;
}

双向结点类定义

template <typename T>struct DblNode{
	T data;
	DblNode<T> *rLink, *lLink;  //前后指针
	DblNode(DblNode<T> *l = NULL, DblNode<T> *r = NULL){
		lLink = l;
		rLink = r;
	}
	DblNode(T value, DblNode<T> *l = NULL, DblNode<T> *r = NULL){
		data = value;
		lLink = l;
		rLink = r;
	}
};

双向链表类定义

template <typename T>class DblList{
public:
	DblList(T uniqueVal){
		first = new DblNode<T>(uniqueVal);
		assert(first); 
		first->rLink = first->lLink = first;  
	}
	~DblList()	{
		makeEmpty();
		delete first;
	}
	void makeEmpty(){
		DblNode<T> *q;
		while (first->rLink != first){   //后向指针是rLink
			q = first->rLink;  
			first->rLink = q->rLink;
			delete q;
		}
		first->lLink=first; //最后只剩下头结点
	}
	DblNode<T> *getFirst()const{
		return first;
	}
	DblNode<T> *Search(const T &x, int d = 1);
	DblNode<T> *Locate(int i, int d = 1);
	bool Insert(int i, const T &x, int d = 1);
	bool Remove(int i, T &x, int d);
	bool IsEmpty(){
		return first->rlink == first;  //当后向指针指向首节点时
	}
	bool IsFull(){
		return false;
	}
	friend istream& operator >> (istream& in, DblList<T> &dbl){
		int i = 0;
		T data;
		dbl.makeEmpty(); //在输入开始时缓存区清空？
		while (!in.eof()){
			in >> data;
			dbl.Insert(i, data, 1);  //调用Insert函数，按从头输入的方式输入
			i++;
		}
		return in;
	}

	friend ostream & operator << (ostream &out, DblList <T> &dbl)	{
		DblNode <T> *p= dbl.first->rLink;
		while ( p!=dbl.first ){
			out << p->data <<'\t';
			p = p->rLink;
		}
		cout << endl;
		return out;
	}
private:
	DblNode<T> *first;
};

提问1：assert什么时候用？
assert是用来避免显而易见的错误的，而不是处理异常的。错误和异常是不一样的，错误是不应该出现的，异常是不可避免的。c语言异常可以通过条件判断来处理，其它语言有各自的异常处理机制。
一个非常简单的使用assert的规律就是，在方法或者函数的最开始使用，如果在方法的中间使用则需要慎重考虑是否是应该的。方法的最开始还没开始一个功能过程，在一个功能过程执行中出现的问题几乎都是异常。

提问2：为什么在输入函数定义operator>>中需要dbl.makeEmpty()？

Locate和Search函数

template <typename T>DblNode<T> *DblList<T>::Locate(int i, int d){
	if (first->rLink == first || i==0){
		return first;
	}
	DblNode<T> *current = (d == 0)?first->lLink:first->rLink;
	while (current != first && --i > 0){ 
		current = (d == 0)?current->lLink:current->rLink;
	}
	return (current == first)?NULL:current;
}

template <typename T>DblNode<T> *DblList<T>::Search(const T &x, int d){
	DblNode<T> *current = (d == 0)?first->lLink:first->rLink;
	while (current != first && current->data != x)	{
		current = (d == 0)?current->lLink:current->rLink;
	}
	return (current == first)?NULL:current;
}

Insert函数

template <typename T>bool DblList<T>::Insert(int i, const T &x, int d){
	DblNode<T> *current = Locate(i, d);
	if (current == NULL){
		return false;    
	}
	DblNode<T> *newNode = new DblNode<T>(x);
	assert(newNode);
	if (d == 0){		
		newNode->lLink = current->lLink;
		current->lLink = newNode;
		newNode->lLink->rLink = newNode;
		newNode->rLink = current;
	}
	else{			
		newNode->rLink = current->rLink;
		current->rLink = newNode;
		newNode->rLink->lLink = newNode;
		newNode->lLink = current;
	}
	return true;
}

Remove函数

template <typename T>
bool DblList<T>::Remove(int i, T &x, int d){
	DblNode<T> *current = Locate(i, d);
	if (current == NULL)
	{
		return false; 	    
	}
	current->rLink->lLink = current->lLink;
	current->lLink->rLink = current->rLink;	
	x = current->data;
	delete current;
	return true;
}

整一个头文件：

#ifndef DBLLIST_H
#define DBLLIST_H
#include <iostream>
#include <cassert>
using namespace std;

template <typename T>struct DblNode{
	T data;
	DblNode<T> *rLink, *lLink;
	DblNode(DblNode<T> *l = NULL, DblNode<T> *r = NULL){
		lLink = l;
		rLink = r;
	}
	DblNode(T value, DblNode<T> *l = NULL, DblNode<T> *r = NULL){
		data = value;
		lLink = l;
		rLink = r;
	}
};

template <typename T>class DblList{
public:
	DblList(T uniqueVal){
		first = new DblNode<T>(uniqueVal);
		assert(first);
		first->rLink = first->lLink = first;
	}
	~DblList()	{//Îö¹¹º¯Êý²»¿ÉÉÙ
		makeEmpty();
		delete first;//ÊͷŸ½¼ÓÍ·½áµã
	}
	void makeEmpty(){//Ìí
		DblNode<T> *q;
		while (first->rLink != first){//½öÓ฽¼ÓÍ·½áµã
			q = first->rLink;//ÏȲ»¹Ü×óÖ¸Õë
			first->rLink = q->rLink;
			delete q;
		}
		first->lLink=first;//×îºó´¦Àí
	}
	DblNode<T> *getFirst()const{
		return first;
	}
	DblNode<T> *Search(const T &x, int d = 1);
	DblNode<T> *Locate(int i, int d = 1);
	//ÔÚÁ´±íÖж¨Î»ÐòºÅΪi(¡Ý0)µÄ½áµã, d=0°´Ç°Çý·½
	//Ïò,d¡Ù0°´ºó¼Ì·½Ïò
	bool Insert(int i, const T &x, int d = 1);
	//ÔÚµÚi¸ö½áµãºó²åÈëÒ»¸ö°üº¬ÓÐÖµxµÄнáµã,d=0
	//°´Ç°Çý·½Ïò,d¡Ù0°´ºó¼Ì·½Ïò
	bool Remove(int i, T &x, int d);
	bool IsEmpty(){
		return first->rlink == first;
	}
	bool IsFull(){
		return false;
	}
	friend istream& operator >> (istream& in, DblList<T> &dbl){//¸Ä
		int i = 0;
		T data;
		dbl.makeEmpty();
		while (!in.eof()){
			in >> data;
			dbl.Insert(i, data, 1);
			i++;
		}
		return in;
	}

	friend ostream & operator << (ostream &out, DblList <T> &dbl)	{
		DblNode <T> *p= dbl.first->rLink;
		while ( p!=dbl.first ){
			out << p->data <<'\t';
			p = p->rLink;
		}
		cout << endl;
		return out;
	}
private:
	DblNode<T> *first;
};

template <typename T>DblNode<T> *DblList<T>::Locate(int i, int d){//d==1ÏòÓÒ
	if (first->rLink == first || i==0){
		return first;
	}
	DblNode<T> *current = (d == 0)?first->lLink:first->rLink;
	while (current != first && --i > 0){
		current = (d == 0)?current->lLink:current->rLink;
	}
	return (current == first)?NULL:current;
}

template <typename T>DblNode<T> *DblList<T>::Search(const T &x, int d){//´Ëº¯ÊýÏò×óÏòÓÒÎÞËùν
	DblNode<T> *current = (d == 0)?first->lLink:first->rLink;
	while (current != first && current->data != x)	{
		current = (d == 0)?current->lLink:current->rLink;
	}
	return (current == first)?NULL:current;
}

template <typename T>bool DblList<T>::Insert(int i, const T &x, int d){
	//½¨Á¢Ò»¸ö°üº¬ÓÐÖµxµÄнáµã, ²¢½«Æä°´ d Ö¸¶¨µÄ·½Ïò²åÈëµ½µÚi¸ö½áµãÖ®ºó¡£
	DblNode<T> *current = Locate(i, d);
	if (current == NULL){
		return false;    //²åÈëʧ°Ü
	}
	DblNode<T> *newNode = new DblNode<T>(x);
	assert(newNode);
	if (d == 0){		//Ç°Çý·½Ïò:²åÔÚµÚi¸ö½áµã×ó²à	
		newNode->lLink = current->lLink;
		current->lLink = newNode;
		newNode->lLink->rLink = newNode;
		newNode->rLink = current;
	}
	else{			//ºó¼Ì·½Ïò:²åÔÚµÚi¸ö½áµãºóÃæ	
		newNode->rLink = current->rLink;
		current->rLink = newNode;
		newNode->rLink->lLink = newNode;
		newNode->lLink = current;
	}
	return true;
}

template <typename T>
bool DblList<T>::Remove(int i, T &x, int d){
	//ÔÚË«ÏòÑ­»·Á´±íÖа´dËùÖ¸·½Ïòɾ³ýµÚi¸ö½áµã¡£
	DblNode<T> *current = Locate(i, d);
	if (current == NULL)
	{
		return false; 	      //ɾ³ýʧ°Ü
	}
	current->rLink->lLink = current->lLink;
	current->lLink->rLink = current->rLink;	
	x = current->data;
	delete current;
	return true;
}
#endif
率真的瓜子
关注
专栏目录
看殷人昆《数据结构》
hi
08-03 1万+
以前没学过数据结构，找人要了本黄皮的殷人昆《数据结构》。原因有三：一来和严蔚敏的C语言实现版本（没考虑过外文书，主要英文功底差，不想被语言描述打乱思路）比，C++的面向对象编程确实要方便直观许多；二来以前没用C++编过程（学点皮毛，没动过手），打算利用学数据结构的时候过一遍最基本的C++知识点；三来这本书久经中国学生考验，遇到问题网上应该能（我猜的）找到对应的答案。对我这样自己啃的人（
【殷人昆数据结构】第二章2.2 单链表代码的调试
tianty1121的博客
08-21 368
Single Linked List单链表 文件： 主函数： #include <fstream> //调用文件输入输出流类 #include "LinkedList.h" //调用单链表头文件 using namespace std; //声明命名空间 int main(){ List<int> list; //实例化类List ifstream fin("list.txt"); //这里将输入文件设为ifstream类型 assert(fin);
C# 实现双向链表
RoySummy的博客
09-08 1332
双向链表 目录双向链表节点代码代码框架思路遍历直接添加到链表末尾依据编号顺序添加修改删除 节点代码 class Node { public int ID { get; set; } public string Name { get; set; } public string NickName { get; set; } public Node Next { get; set; } public Node Pre
uva12657 双向链表的实现与痛苦的调试
liuzheng_yong的博客
03-25 469
题目You have n boxes in a line on the table numbered 1 … n from left to right. Your task is to simulate 4 kinds of commands: • 1 X Y : move box X to the left to Y (ignore this if X is already the left
数据结构与算法--005-双向链表实现--Java
qq_44236958的博客
11-17 381
双向链表应用实例 目录双向链表应用实例操作**遍历****添加**头部插入尾部插入指定的位置插入修改删除 管理单链表的缺点分析 单向链表,查找的方向只能是一个方向,而双链表可以向前或者后查找 单向链表不能自我删除,需要辅助结点,而双向链表,可进行自我删除,所以我们单链表删除节点时,总是找到temp(待删除结点的前一个结点) 操作 遍历 方向和单链表一样,可以向前也可以向后查找 添加 头部插入 要插入放入的节点 Link newNode = new Link(data); 将还没插入新结点之前链
单链表的逆置（C++实现）
weixin_30732487的博客
12-10 1620
  单链表以及逆置是什么就不说了，就简单说一下思想： 链表的初始状态： 具体的方法就是将头节点后面的节点，依次通过指针指向，插入head头节点之后，即可完成逆置过程．　 示意图(这里我写一下中间处理流程，因为这样比较直观．第一次的处理与正常处理雷同)： 需要注意的主要有两点： 1.　逆置之后的链表的尾部要NULL．在这里就是刚开始的时候的pHea...
殷人昆 数据结构C++第二版源代码（参考）
最新发布
09-05
《殷人昆 数据结构C++第二版源代码》是一份宝贵的教学参考资料，它涵盖了数据结构在C++编程语言中的实现，对于学习C++和数据结构的程序员来说极具价值。数据结构是计算机科学的基础，它是研究如何高效存储和组织数据...
殷人昆数据结构用面向对象方法与C++语言描述第二版扫描版
02-16
《殷人昆数据结构用面向对象方法与C++语言描述》是数据结构领域一本重要的教材，尤其对于学习C++编程的计算机科学和技术专业的学生来说，它提供了深入理解数据结构和算法的基础。本书的第二版在第一版的基础上进行了...
考研-数据结构-殷人昆.zip
09-09
1.1 针对考研数据结构的代码书写规范以及C 与C 语言基础1 1.1.1 考研综合应用题中算法设计部分的代码书写规范1 1.1.2 考研中的C 与C 语言基础3 1.2 算法的时间复杂度与空间复杂度分析基础 12 1.2.1 考研中的算法时间...
殷人昆《数据结构》电子源代码
07-16
这份压缩包文件包含了该教材第二版的类库源代码，经东南大学吴乃陵老师修订，对于学习和理解数据结构有极大的帮助。 源代码是理解算法和数据结构实现的关键，通过阅读这些源代码，我们可以深入探究各种数据结构（如...
【殷人昆数据结构】第二章2.3 循环链表代码的调试
tianty1121的博客
08-21 304
Circular List循环链表 ????文件： 主函数： #include <fstream> #include "CircList.h" using namespace std; int main(){ CircList<int> list; ifstream fin("list.txt"); assert(fin); fin >> list; cout << "The initial list in the file is:\n" &
C++实现单向循环链表
wanglelelihuanhuan的专栏
09-10 449
#include #include using namespace std; typedef int DataType; struct LinkNode { DataType _data; LinkNode* _next; LinkNode(const DataType& x) :_data(x) ,_next(NULL) {} }; class Slist { publi
【殷人昆数据结构】第二章2.1 顺序表代码的调试
tianty1121的博客
08-20 534
SeqList 文件： 程序功能：输入 #include "SeqList.h" #include <fstream> #include <cassert> using namespace std; int main(){ SeqList<int> list(10); //实例化SeqList类为int型，分配10个动态结点给list ifstream fin("list.txt"); //调用文件输入流ifstream，将txt输入缓存区fin
PTA 7-1 顺序表的建立及遍历 (30 分)
weixin_44996854的博客
10-01 5431
PTA 7-1 顺序表的建立及遍历 (30 分) #include <iostream> #include <cassert> #include <cstdlib> #include <ctime> using namespace std; typedef int T; const int defaultSize = 100; class SeqL...
数据结构--双链表的c/c++实现（超详细注释/实验报告）
池塘春草梦的博客
09-26 2960
如果希望从表中快速确定某一个结点的前去，其中一个解决方法就是在单链表的每个结点再增加一个指向其前去的指针域prior。这样形成的链表中就有两条方向不同的链，称之为双向链表(Double Linked List)。
java实现双向链表的操作
架构设计
04-25 97
单向链表只能单方向的查找链表中的节点，并且在插入或者删除某一个节点的时候，必须知道其的前一个节点。当单向链表的前一个节点指向这个链表的第一个节点的时候称为循环链表。 双向链表的每个结构分为三个部分，一个左指针 llink , 一个数据data ,一个右指针 rlink,其手llink存放当前节点的前一个节点，rlink指向当前节点的后一个节点。因此构造java节点类型如下 public cl...
【数据结构】多项式加法与乘法
tianty1121的博客
07-26 1760
人类对于多项式相加的思维是这样的： P1=3X5+4X4−X3+2X−1P1 = 3X^5+4X^4-X^3\quad\quad\quad +2X-1P1=3X5+4X4−X3+2X−1 P2=2X4+X3−7X2+XP2 = \quad\quad\quad2X^4 +X^3-7X^2+XP2=2X4+X3−7X2+X ----------------------------------------------------------------- P=3X5+6X4−7X2+3X−1P = 3X^5 +
【数据结构】堆栈基本原理
tianty1121的博客
07-24 1670
什么是堆栈 计算机如何进行表达式求值？ 这个地方前缀表达式比较容易搞混，来几个???? a+b∗c−d/ea+b*c-d/ea+b∗c−d/e 的前缀表达式：−+a∗bc/de-+a*bc/de−+a∗bc/de 1+((2+3)∗4)−51+((2+3)*4)-51+((2+3)∗4)−5 的前缀表达式：−+1∗+2345- + 1 * + 2 3 4 5−+1∗+2345 这个有一个简单的方法： 如：我要将 a+b∗c+(d∗e+f)∗ga+b*c+(d*e+f)*ga+b∗c+(d∗e+f)∗g 变成
C语言版清华殷人昆数据结构第一讲：概念与表格示例
在清华大学计算机系殷人昆教授的《C语言版》数据结构教材中，第一章主要介绍了数据结构的基本概念。首先，章节以探讨数据结构的定义为起点，强调数据结构是组织和存储数据的方式，使得数据的访问和操作更为高效。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值