本文素材来自于 内华达大学拉斯维加斯分校
双向排序链表
双向排序链表是一个双链表
在插入元素的时候需要保持元素的大小顺序
如果是字符,字符串,就按照字母表顺序
如果是数值类型, 就按照数值大小排序
双向链表的功能
(1)插入一个元素insert,保持元素升序排列
(2)删除指定值的所有元素 searchDelete
(3)顺序输出所有元素 print
(4)逆序输出所有元素 backwardsPrint
双链表模板类
我们的双链表类可以存储任意类型的元素。
比如,元素类型可以是 int类型;也可以是 string 类型;
定义双链表的时候只需要指定一个具体的类型,就会只存放这种类型的元素。
就像std::vector, std::list, std::map 这些标准库容器一样。
这种类在C++中可以定义成模板类。
创建双链表模板类
template<typename T>
class List
{
};
![](https://i-blog.csdnimg.cn/blog_migrate/a61d3448a9e0732e33513ab0c565fa6f.png)
上面的 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;//注意不是指针类型,所以可以直接访问该节点
};
![](https://i-blog.csdnimg.cn/blog_migrate/134d6e69d6ccb03131b4bb428359d1f4.png)
其中,节点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;
}
![](https://i-blog.csdnimg.cn/blog_migrate/f3e7e0cd2159562081773deed3329a55.webp?x-image-process=image/format,png)
下面是具体的插入过程(用right表示上面的run):
![](https://i-blog.csdnimg.cn/blog_migrate/85bf17c7e84e39e2a795498e90c1225b.png)
输出双链表的所有元素
输出双链表的所有元素,只需要创建一个指针变量,从指向第一个元素开始,循环指向下一个节点
每遇到一个节点就先输出这个节点的内容,并输出一个分隔符。
当移动到tail节点的时候,停止循环。
![](https://i-blog.csdnimg.cn/blog_migrate/8c7630ab37b3bc5a6116779beb691134.png)
Node* p = head.next;
while (p != &tail)
{
cout << p->data<<" ";
p = p->next;
}
逆序输出双链表的所有元素
逆序输出的逻辑和正序输出的print很像。
只不过是从最后一个节点开始往前打印。
结束的条件是打印到了head,就不用打印了。
![](https://i-blog.csdnimg.cn/blog_migrate/5f79a8eac79c6078c5ca1772252a0162.png)
void List::backwardsPrint(void) const
{
Node* p = tail.next;
while (p != nullptr && p != &head)
{
cout << p->data<< " ";
//(1) your code
}
cout <<"." << endl;
}
删除给定值的元素
删除指定的元素,一般的情形如下图所示:
找到待删除的元素,用p指向;q 指向 待删除元素的后继。
![](https://i-blog.csdnimg.cn/blog_migrate/8bd19720ba94c98d298e8567d3f63fb5.png)
具体的删除过程:
![](https://i-blog.csdnimg.cn/blog_migrate/dd80b0e12a801839aa7922b4d7d4976a.png)
删除元素的实现
(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;
}
预期输出:
加油吧!祝你好运!