3.2 模板双向排序链表

原创已于 2023-10-11 16:26:19 修改 · 473 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #数据结构 #c++ #开发语言 #算法

于 2023-08-31 10:43:56 首次发布

C++数据结构与算法实现专栏收录该内容

24 篇文章

订阅专栏

本文详细介绍了如何在C++中使用模板类创建双向排序链表，包括元素的插入、删除、顺序和逆序输出，以及模板参数的使用。

C++ 精简教程目录（必读）

本文素材来自于内华达大学拉斯维加斯分校

双向排序链表

双向排序链表是一个双链表

在插入元素的时候需要保持元素的大小顺序

如果是字符，字符串，就按照字母表顺序

如果是数值类型，就按照数值大小排序

双向链表的功能

（1）插入一个元素insert，保持元素升序排列

（2）删除指定值的所有元素 searchDelete

（3）顺序输出所有元素 print

（4）逆序输出所有元素 backwardsPrint

双链表模板类

我们的双链表类可以存储任意类型的元素。

比如，元素类型可以是 int类型；也可以是 string 类型；

定义双链表的时候只需要指定一个具体的类型，就会只存放这种类型的元素。

就像std::vector， std::list， std::map 这些标准库容器一样。

这种类在C++中可以定义成模板类。

创建双链表模板类

template<typename T>
class List
{
};

上面的 template<typename T> 表示List这个类是一个模板类。

其中， typename T 表示 List类内部可以声明 T 类型的变量。

当我们创建 List对象的时候，需要给T指定具体类型。

例如：

List<int> listInt;//定义一个存放int类型数据的双链表对象
List<string> listString;//定义一个存放 string 类型数据的双链表对象
List<Student> listStudent;//定义一个存放 Student 类型数据的双链表对象

在定义模板类的时候需要template<typename T>，在类外部定义模板类的成员函数时，也需要。见后文完整的代码和测试用例部分。

管理元素的成员变量

元素的存放需要通过成员变量来管理

添加头节点 head（其next指向第一个节点的指针，一开始其next设置为空指针）。

添加尾节点 tail（其next指向最后一个节点的指针，一开始其next设置为空指针）。

注意：为何是头结点，尾结点，而不是头指针呢？

这是因为为了代码好写。

例如，当我们希望在当前节点 p 的前面插入一个新节点 new_node 的时候，我们希望可以做下面的操作：

p->prev->next = new_node;

可以看出来，我们的 p->prev 这个节点必须要存在，只有存在才能访问。

但是我们不想去判断存在与否，这就必须要求 p->prev 这个节点一开始就存在。

为了做到这一点，我们只需要给 List 添加头节点 head 即可。

所以，一个空的链表就像下面这样：

class List
{
    Node m_head;//注意不是指针类型，所以可以直接访问该节点
    Node m_tail;//注意不是指针类型，所以可以直接访问该节点
};

其中，节点Node类型如下：

节点Node类型

struct Node
{
    Node() {}
	Node(T t):data(t){ }
	T data;
	Node* pre = nullptr;
	Node* next = nullptr;
};

添加一个元素

添加一个元素需要先找到插入位置，因为链表是有序的，所以需要先通过遍历查找到合适的插入位置。

假如这个位置是一个由Node* right指向的结点，我们需要把元素插入到这个节点之前。

查找 right 的过程如下：

Node* right = head.next;
while (right != &tail && right->data < p->data)
{
	right = right->next;
}

下面是具体的插入过程（用right表示上面的run）：

输出双链表的所有元素

输出双链表的所有元素，只需要创建一个指针变量，从指向第一个元素开始，循环指向下一个节点

每遇到一个节点就先输出这个节点的内容，并输出一个分隔符。

当移动到tail节点的时候，停止循环。

Node* p = head.next;
while (p != &tail)
{
	cout << p->data<<" ";
	p = p->next;
}

逆序输出双链表的所有元素

逆序输出的逻辑和正序输出的print很像。

只不过是从最后一个节点开始往前打印。

结束的条件是打印到了head，就不用打印了。

void List::backwardsPrint(void) const
{
    Node* p = tail.next;
    while (p != nullptr && p != &head)
    {
        cout  << p->data<< " ";
        //(1) your code

    }
    cout <<"." << endl;
}

删除给定值的元素

删除指定的元素，一般的情形如下图所示:

找到待删除的元素，用p指向；q 指向待删除元素的后继。

具体的删除过程：

删除元素的实现

（1）使用循环遍历每个节点，如果节点的值是要删除的值，就删除这个节点

（2）遍历节点的指针往后移动一个节点到下一个节点

template<typename T>
void DoublyLinkedList<T>::searchDeleteLoop(T t)
{
	Node* p = head.next;
	while (p)
	{
		if (p->data == t)
		{
			//p=p->next is finished inner
                        //(2) your code

		}
		else
		{
			p = p->next;
		}
	}
}

这其中删除一个节点的动作由deleteNode来完成，具体实现如下：

//------下面的代码是用来测试你的代码有没有问题的辅助代码，你无需关注------
#include <algorithm>
#include <cstdlib>
#include <iostream> 
#include <vector>
#include <utility>
using namespace std;
struct Record { Record(void* ptr1, size_t count1, const char* location1, int line1, bool is) :ptr(ptr1), count(count1), line(line1), is_array(is) { int i = 0; while ((location[i] = location1[i]) && i < 100) { ++i; } }void* ptr; size_t count; char location[100] = { 0 }; int line; bool is_array = false; bool not_use_right_delete = false; }; bool operator==(const Record& lhs, const Record& rhs) { return lhs.ptr == rhs.ptr; }std::vector<Record> myAllocStatistic; void* newFunctionImpl(std::size_t sz, char const* file, int line, bool is) { void* ptr = std::malloc(sz); myAllocStatistic.push_back({ ptr,sz, file, line , is }); return ptr; }void* operator new(std::size_t sz, char const* file, int line) { return newFunctionImpl(sz, file, line, false); }void* operator new [](std::size_t sz, char const* file, int line)
{
	return newFunctionImpl(sz, file, line, true);
}void operator delete(void* ptr) noexcept { Record item{ ptr, 0, "", 0, false }; auto itr = std::find(myAllocStatistic.begin(), myAllocStatistic.end(), item); if (itr != myAllocStatistic.end()) { auto ind = std::distance(myAllocStatistic.begin(), itr); myAllocStatistic[ind].ptr = nullptr; if (itr->is_array) { myAllocStatistic[ind].not_use_right_delete = true; } else { myAllocStatistic[ind].count = 0; }std::free(ptr); } }void operator delete[](void* ptr) noexcept { Record item{ ptr, 0, "", 0, true }; auto itr = std::find(myAllocStatistic.begin(), myAllocStatistic.end(), item); if (itr != myAllocStatistic.end()) { auto ind = std::distance(myAllocStatistic.begin(), itr); myAllocStatistic[ind].ptr = nullptr; if (!itr->is_array) { myAllocStatistic[ind].not_use_right_delete = true; } else { myAllocStatistic[ind].count = 0; }std::free(ptr); } }
#define new new(__FILE__, __LINE__)
struct MyStruct { void ReportMemoryLeak() { std::cout << "Memory leak report: " << std::endl; bool leak = false; for (auto& i : myAllocStatistic) { if (i.count != 0) { leak = true; std::cout << "leak count " << i.count << " Byte" << ", file " << i.location << ", line " << i.line; if (i.not_use_right_delete) { cout << ", not use right delete. "; }	cout << std::endl; } }if (!leak) { cout << "No memory leak." << endl; } }~MyStruct() { ReportMemoryLeak(); } }; static MyStruct my; void check_do(bool b, int line = __LINE__) { if (b) { cout << "line:" << line << " Pass" << endl; } else { cout << "line:" << line << " Ohh! not passed!!!!!!!!!!!!!!!!!!!!!!!!!!!" << " " << endl; exit(0); } }
#define check(msg)  check_do(msg, __LINE__);
//------上面的代码是用来测试你的代码有没有问题的辅助代码，你无需关注------

#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <cassert>
using namespace std;

template<typename T>
class DoublyLinkedList
{
	struct Node
	{
		Node() {}
		Node(T t) :data(t) {}
		T data;
		Node* prev = nullptr;
		Node* next = nullptr;
	};
public:
	DoublyLinkedList();
	~DoublyLinkedList();
	void insert(T t);
	string print(void) const;
	void backwardsPrint(void) const;

	void searchDelete(T t);
private:
	//当前类不支持复制，仅限于单个对象独立使用，主要是用于降低难度
	DoublyLinkedList<T>(const DoublyLinkedList<T>& from) = delete;
	//当前类不支持复制，仅限于单个对象独立使用，主要是用于降低难度
	DoublyLinkedList<T>& operator=(const DoublyLinkedList<T>& from) = delete;

	void searchDeleteLoop(T t);
	void deleteNode(Node*& p);

	Node m_head;
	Node m_tail;
};

template<typename T>
void DoublyLinkedList<T>::deleteNode(Node*& p)
{
	//p is not nullptr
	assert(p);
	Node* q = p->next;
	//1 inner node
	/*(1)*/ p->prev->next = p->next;
	/*(2)*/ p->next->prev = p->prev;
	delete p;
	p = q;//p指向被删除节点的下一个节点
}
template<typename T>
void DoublyLinkedList<T>::backwardsPrint(void) const
{
	Node* p = m_tail.prev;
	while (p != nullptr && p != &m_head)
	{
		cout << p->data << " ";
		//(1) your code


	}
	cout << endl;
}
template<typename T>
void DoublyLinkedList<T>::searchDeleteLoop(T t)
{
	Node* p = m_head.next;
	while (p)
	{
		if (p->data == t)
		{
			//p=p->next is finished inner
			//(2) your code

		}
		else
		{
			p = p->next;
		}
	}
}

template<typename T>
void DoublyLinkedList<T>::searchDelete(T t)
{
	searchDeleteLoop(t);
}
template<typename T>
inline DoublyLinkedList<T>::DoublyLinkedList()
{
	//(3) your code


}
template<typename T>
DoublyLinkedList<T>::~DoublyLinkedList()
{
	Node* p = m_head.next;
	while (p != &m_tail)
	{
		Node* q = p;
		p = p->next;
		delete q;
	}
	m_head.next = &m_tail;
	m_tail.prev = &m_head;
}
template<typename T>
void DoublyLinkedList<T>::insert(T t)
{
	Node* p = new Node(t);

	Node* right = m_head.next;
	while (right != &m_tail && right->data < p->data)
	{
		right = right->next;
	}
	//inner insert
	/*(1)*/ right->prev->next = p;
	/*(2)*/ p->prev = right->prev;
	/*(3)*/ p->next = right;
	//(4) your code

}

template<typename T>
string DoublyLinkedList<T>::print(void) const
{
	ostringstream oss;
	Node* p = m_head.next;
	while (p != &m_tail)
	{
		oss << p->data << " ";
		p = p->next;
	}
	string result = oss.str();
	return result;
}


int main()
{
	DoublyLinkedList<int> dlist;
	dlist.insert(5);
	check(dlist.print() == "5 ");
	dlist.insert(2);
	check(dlist.print() == "2 5 ");
	dlist.insert(8);
	check(dlist.print() == "2 5 8 ");
	dlist.insert(7);
	check(dlist.print() == "2 5 7 8 ");
	dlist.insert(7);
	check(dlist.print() == "2 5 7 7 8 ");
	dlist.insert(8);
	check(dlist.print() == "2 5 7 7 8 8 ");
	dlist.insert(9);
	check(dlist.print() == "2 5 7 7 8 8 9 ");
	dlist.backwardsPrint();
	dlist.searchDelete(2);
	check(dlist.print() == "5 7 7 8 8 9 ");
	dlist.backwardsPrint();
	dlist.searchDelete(9);
	check(dlist.print() == "5 7 7 8 8 ");
	dlist.backwardsPrint();
	dlist.searchDelete(7);
	check(dlist.print() == "5 8 8 ");
	dlist.insert(7);
	check(dlist.print() == "5 7 8 8 ");
	dlist.searchDelete(7);
	check(dlist.print() == "5 8 8 ");
	dlist.searchDelete(5);
	check(dlist.print() == "8 8 ");
	dlist.searchDelete(8);
	check(dlist.print() == "");
	dlist.insert(7);
	check(dlist.print() == "7 ");
	dlist.backwardsPrint();
	return 0;
}

预期输出：