List(C++模版实现的带哨兵的双向链表）

最新推荐文章于 2024-06-03 22:50:30 发布
最新推荐文章于 2024-06-03 22:50:30 发布
阅读量193 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x402596250/article/details/118650481
版权

List(C++模版实现的带哨兵的双向链表）

//
// Created by 许加权 on 2021/7/10.
//

#ifndef C11LEARN_LIST_H
#define C11LEARN_LIST_H
template<typename T>
class List
{
protected:
    class Node
    {
    public:
        Node *pre;
        Node *next;
        T key;
        Node(){}
        Node(const T key):key(key){}
    };

private:
    Node* Nil;
    int size;
public:
    List();
    virtual ~List();
    List(const List<T> & list);
    const List<T> & operator=(const List<T> & list);
    const List<T> & operator+(const List<T> & list);
    const List<T> & operator-(const List<T> & list);
    List<T> merge(const List<T> & list);
    List<T> except(const List<T> & list);
    List<T> intersect(const List<T> & list);
    void add(const T key);
    void insert(const T key,int position);
    bool remove(const T key);
    bool remove_all(const T key);
    bool remove_at(int index);
    bool contain(const T &key);
    T operator[](int index) const;
    T & operator[] (int index);
    bool empty();
    void clear();
    int length() const;
    int length();
    void sort(bool ascending = true);
    void sort(void(*f)(T *array,int length));
    const List<T> & distinct();
private:
    Node* search(const T & key);
//    Node* search01(const T & key);
    Node* get(int index)const;
    void add(Node* node);
    bool remove(Node* node);
    void quick_sort(T*array,int start,int end,bool ascending = true);
    int partition(T*array,int start,int end,bool ascending);
};

template<typename T>
List<T>::List()
{
    Nil = new Node();
    Nil->next = Nil;
    Nil->pre = Nil;
    size = 0;
}
template<typename T>
List<T>::~List(){
    clear();
    delete Nil;
}
template<typename T>
List<T>::List(const List<T> & list)
{
    Nil = new Node();
    Nil->next = Nil;
    Nil->pre = Nil;
    size = 0;
    Node * current = list.Nil->next;
    while (current != list.Nil)
    {
        add(current->key);
        current = current->next;
    }
}
template<typename T>
const List<T>& List<T>::operator=(const List<T> & list){
    if(&list == this)return *this;
    clear();
    Node * current = list.Nil->next;
    while (current != list.Nil)
    {
        add(current->key);
        current = current->next;
    }
    return *this;
}
template<typename T>
List<T> List<T>::merge(const List<T> & list)
{
    List<T> temp(*this);
    temp.distinct();
    Node* current = list.Nil->next;
    while (current!=list.Nil)
    {
        if(!temp.contain(current->key))
        {
            temp.add(current->key);
        }
        current = current->next;
    }
    return temp;
}
template<typename T>
List<T> List<T>::except(const List<T> & list){
    List<T> temp(*this);
    temp.distinct();
    Node* current = list.Nil->next;
    while (current!=list.Nil)
    {
        if(temp.contain(current->key))
        {
            temp.remove(current->key);
        }
        current = current->next;
    }
    return temp;
}
template<typename T>
List<T> List<T>::intersect(const List<T> & list){
    List<T> temp;
    Node* current = list.Nil->next;
    while (current!=list.Nil)
    {
        if(contain(current->key))
        {
            temp.add(current->key);
        }
        current = current->next;
    }
    temp.distinct();
    return temp;
}
template<typename T>
const List<T> & List<T>::distinct(){
    if(size == 0) return *this;
    T* array = new T[size];
    int index = 0;
    Node* current = Nil->next;
    while (current!=Nil)
    {
        array[index] = current->key;
        current =current->next;
        index++;
    }
    quick_sort(array,0,size-1);
    T current_key = array[0];
    for (int i = 1; i < size; ++i) {
        if(current_key == array[i])
        {
            remove(current_key);
        }
        else
        {
            current_key = array[i];
        }
    }
    delete[] array;
    return *this;
}
template<typename T>
void List<T>::add(const T key)
{
    Node* node = new Node(key);
    size++;
    add(node);
}
template<typename T>
void List<T>::add(Node* node){
    if(Nil->next == Nil)
    {
        Nil->pre = node;
        Nil->next = node;
        node->pre = Nil;
        node->next = Nil;
    }
    else
    {
        Nil->pre->next = node;
        node->pre = Nil->pre;
        node->next = Nil;
        Nil->pre = node;
    }
}
template<typename T>
void List<T>::insert(const T key,int position)
{
    if(position<0 || position>size)
        throw "out of bound";
    if(position == size || size == 0)
    {
        add(key);
    }
    else
    {
        Node* node = new Node(key);
        Node* current = get(position);
        current->pre->next = node;
        node->pre = current->pre;
        node->next = current;
        current->pre = node;
        size++;
        if(position == 0)
        {
            Nil->next = node;
        }
    }
}
template<typename T>
bool List<T>::remove(const T key){
    Node *result =  search(key);
    if(result!= Nil)
    {
        remove(result);
        return true;
    }
    return false;
}
template<typename T>
bool List<T>::contain(const T& key){
    return search(key) != Nil;
}
template<typename T>
bool List<T>::empty(){
    return Nil->next == Nil;
}
template<typename T>
typename List<T>::Node* List<T>::search(const T &key) {
    Node * current = Nil->next;
    while (current != Nil && current->key!=key)
    {
        current = current->next;
    }
    return current;
}
//template<typename T>
//typename List<T>::Node* List<T>::search01(const T &key) {
//    Nil->key = key;
//    Node * current = Nil->next;
//    while (current->key!=key)
//    {
//        current = current->next;
//    }
//    return current;
//}
template<typename T>
bool List<T>::remove(Node* node){
    if(empty()) return false;
    node->pre->next = node->next;
    node->next->pre = node->pre;
    size --;
    delete node;
    return true;
}
template<typename T>
void List<T>::clear(){
    Node* current = Nil->next;
    while (current!= Nil)
    {
        Node * temp = current;
        current = current->next;
        delete temp;
    }
    Nil->next = Nil;
    Nil->pre = Nil;
    size = 0;
}
template<typename T>
int List<T>::length() const  {
    return size;
}
template<typename T>
int List<T>::length()  {
    return size;
}
template<typename T>
T List<T>::operator[](int index) const{
    return get(index)->key;
}
template<typename T>
T & List<T>::operator[] (int index){
    return get(index)->key;
}
template<typename T>
typename List<T>::Node* List<T>::get(int index) const{
    if(index>=size || index < 0) throw "Index out of bounds";
    Node * current;
    if(index>=size/2)
    {
        index = size - index - 1;
        current = Nil->pre;
        while (index-->0)
        {
            current = current->pre;
        }
    }
    else
    {
        current = Nil->next;
        while (index-->0)
        {
            current = current->next;
        }
    }
    return current;
}
template<typename T>
bool List<T>::remove_at(int index){
    if(index>=size) return false;
    return remove(get(index));
}
template<typename T>
void List<T>::quick_sort(T*array,int start,int end,bool ascending){
    if(start<end)
    {
        int k = partition(array,start,end,ascending);
        quick_sort(array,start,k-1,ascending);
        quick_sort(array,k+1,end,ascending);
    }
}
template<typename T>
int List<T>::partition(T*array,int start,int end,bool ascending){
    T key = array[end];
    int p = start - 1;
    T temp;
    for (int i = start; i < end; ++i) {
        if((array[i] <= key && ascending) ||(array[i] >= key && !ascending) )
        {
            p++;
            temp = array[p];
            array[p] = array[i];
            array[i] = temp;
        }
    }
    array[end] = array[p+1];
    array[p+1] = key;
    return p+1;
}
template<typename T>
void List<T>::sort(bool ascending){
    if(size == 0) return;
    T*array = new T[size];
    Node* current = Nil->next;
    int index = 0;
    while (current!=Nil)
    {
        array[index] = current->key;
        current = current->next;
        index++;
    }
    quick_sort(array,0,size - 1,ascending);
    int length = size;
    clear();
    for (int i = 0; i < length; ++i) {
        add(array[i]);
    }
    delete[] array;
}
template<typename T>
void List<T>::sort(void(*f)(T *array,int length)){
    if(size == 0) return;
    T*array = new T[size];
    Node* current = Nil->next;
    int index = 0;
    while (current!=Nil)
    {
        array[index] = current->key;
        current = current->next;
        index++;
    }
    f(array,size);
    int length = size;
    clear();
    for (int i = 0; i < length; ++i) {
        add(array[i]);
    }
    delete[] array;
}
template<typename T>
const List<T> & List<T>::operator+(const List<T> & list){
    Node* current =  list.Nil->next;
    while (current!=list.Nil)
    {
        add(current->key);
        current = current->next;
    }
    return *this;
}
template<typename T>
const List<T> & List<T>::operator-(const List<T> & list){
    Node* current =  list.Nil->next;
    while (current!=list.Nil)
    {
        remove_all(current->key);
        current = current->next;
    }
    return *this;
}
template<typename T>
bool List<T>::remove_all(const T key){
    Node* current = Nil->next;
    bool success = false;
    while (current!=Nil)
    {
        if(current->key == key)
        {
            success = true;
            Node* node = current;
            current = current->next;
            node->pre->next = node->next;
            node->next->pre = node->pre;
            size --;
            delete node;
        }
        else
        {
            current = current->next;
        }
    }
    return success;
}
#endif //C11LEARN_LIST_H
外太空の神
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
带哨兵的双向链表
yuanjianchuan的专栏
08-15 1325
//带哨兵的双向链表 #include #include typedef struct NODE{ struct NODE*prev;char key;struct NODE*next; }NODE; NODE*NIL=NULL;//双链表L的哨兵结点。 NODE*search(char key)//每次循环省略对p!=NULL的检查 {/*查找双链表L中第一个关键字为key的元素，并返回
C++ 实现双向链表的实例
12-31
双向链表C++ 的实现   本文是通过C++ 的知识实现数据结构中的双向链表，这里不多说 了，代码注释很清楚， 实现代码： //double LinkList implement with C++ template #include using namespace std; /*template...
C++实现有哨兵的双向循环链表
01-20
C++实现有哨兵的双向循环链表：   #include<iostream> #include<stack> using namespace std; template<class> class Node { private: T data; Node<T>* next; public: Node() { Node=NULL; } Node(T d) { data=d; next=NULL;
合并两个有序数组（哨兵）
Howzit
12-07 671
讲两个有有序的数组合并成一个数组，合并后数组仍然是排好序的。 private static int[] mergeList(int[] AList, int[] BList) { int pivotA = 0;//数组AList 哨兵 int pivotB = 0;//数组BList 哨兵 int aLength = AList.length;//数...
Redis哨兵（Sentinel）模式
larance的挨踢生活
12-01 455
主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。 一、哨兵模式概述 哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。 Redis哨兵 这里的哨兵有两个作用 通过发送命令，让Redis服务器返回监控.
C++实现双向链表（List）
08-19
主要为大家详细介绍了C++实现双向链表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
深入解析C++的循环链表与双向链表设计的API实现
09-02
主要介绍了C++的循环链表与双向链表设计的API实现,文中的示例对于链表结点的操作起到了很好的说明作用,需要的朋友可以参考下
【算法】8 图文搭配诠释三种链表及其哨兵
weixin_33670713的博客
06-28 178
三种链表的介绍 原谅我拙劣的绘图能力，花了半天终于还是决定从网上找来了这三张图，因为环形链表的弧形箭头难以完美的展现出来。 以下3张图片来自Wikipedia。 大家看着图片应该也都知道这分别是哪种链表了。那么链表到底是什么呢？ 它和前面的栈和队列一般，都是基本的数据结构，其中的各个对象按线性顺序排列。大家应该注意到...
list的模拟实现(万字解读+由浅入深）
qq_68926231的博客
12-04 926
日拱一卒，功不唐捐！一起进步~
数据结构——哨兵
m0_53846409的博客
09-14 2698
1、哨兵的定义 哨兵，是用来简化边界条件的一个参数，可以减少循环中的判断，使代码更加高效 在链表中，哨兵可以作为一个头节点（称为哨兵节点），为了操作的方便而引入 简单来说，哨兵是在循环或迭代算法中用来标志终止条件的值 2、哨兵的代码实现 int SequentialSearch(List Tb1, ElemType K){ //在Elem[1]~Elem[n]中查找关键字为K的数据元素 int i; Tb1->Elem[0] = K; //使其第一项为K，作为哨兵 for(
数据结构: 链表中哨兵(头结点)的作用
【黑键】
01-01 1万+
数据结构: 链表中哨兵(头结点)的作用 单链表的实现中,常有 带头结点 和 不带头结点 两种实现方式. 笔者在做算法与数据结构题目时,非常喜欢使用带头结点的实现方式.可以简化一些边界的处理. 哨兵节点 哨兵节点,也是头结点,是一个 dummy node. 可以用来简化边界条件. 是一个附加的链表节点.该节点作为第一个节点,它的值域不存储任何东西. 只是为了操作的方便而引入的. 如果一个链表有哨...
学习C/C++语言系列（1）双向循环带哨兵位链表
roseisbule的博客
03-24 2433
虽然双向循环比单链表和循序表结构要复杂，但在我目前看来，它比单链表，顺序表都要好用，都更实用。所以我想在单链表和顺序表之前先讲解一下我学到的双向循环带哨兵位链表。 首先来讲一讲什么是哨兵位。 如图，哨兵位其实是一个在头节点之前的节点，这个节点并不存放有效值，只存放头节点的地址和尾节点的地址。 哨兵位 为什么要有哨兵位呢？ 1.对于一个已经创建和初始化的链表来讲，可以没有数据，即头节点，尾节点等，但是不能没有哨兵位，...
带哨兵节点和不带哨兵节点的单链表操作的对比
热门推荐
bg2wlj的博客
08-24 1万+
哨兵节点（sentinel）是一个哑元节点（dummy node），可以简化边界条件。
【数据结构】关于链表中哨兵结点(sentinel)问题的深入剖析
m0_45406092的博客
02-01 3418
文章目录1. 概述2. 什么是哨兵结点2.1 单链表中的哨兵结点2.2 双链表中的哨兵结点2.2.1 Version 1: 双哨兵2.2.2 Version 2：循环双链表 1. 概述 最近正在学习UC Berkeley的CS61B这门课，主要是采用Java语言去实现一些数据结构以及运用数据结构去做一些project。这门课不仅告诉你这个东西怎么做，而且一步一步探寻为什么要这样做以及为什么会有这些功能。我们有时在接触某段代码或功能的实现时，可能直接就看到了它最终的面貌，而不知道如何一步步演化而来，其实每一个
【数据结构】链表与顺序表的比较
SWsunlight的博客
06-01 915
顺序表和链表比较
数据结构-哈希表
weixin_42035282的博客
06-01 413
哈希表是一种高效的数据结构，它可以提供快速的插入、删除和查找操作。哈希表的基本思想是将键通过一个哈希函数映射到一个连续的地址空间上，然后在这个地址空间上进行查找、插入和删除操作。下面将详细介绍哈希表的相关概念和实现方法。
day2数据结构
m0_62438849的博客
05-31 278
L 因为L会发生变化 & 引用在 C 语言中，参数传递不支持引用（&）的方式，应该使用指针来传递参数数组的赋值不能使用 = 直接赋值整个数组。需要逐个赋值数组的元素，或者使用循环来初始化数组//定义线性表的最大长度int length;}SqList;return -1;i < 5;i++){\n");return 0;
数据结构：链式队列
最新发布
weixin_67035108的博客
06-03 539
链式队列，指的是使用链表实现的队列，是一种常见的数据结构。队列遵循先进先出（FIFO）的原则，即最先进入队列的元素将是最先被移除的元素。链式队列通过链表的动态特性来实现队列的插入和删除操作，提供了比静态数组实现的队列更高的灵活性。： 链式队列需要维护两个指针：队首指针（指向队列的第一个元素）和队尾指针（指向队列的最后一个元素）。： 由于链式队列的元素是动态添加的，因此需要使用动态内存分配来创建新的节点。： 链式队列由一系列节点组成，每个节点通常包含两个部分：数据部分和指向下一个节点的指针
用C++语言实现一个双向循环链表
05-25
在C++语言中，可以通过定义一个双向循环链表类来实现该数据结构。 以下是一个简单的双向循环链表类的实现： ```cpp class Node { public: int value; Node* prev; Node* next; Node(int v) : value(v), prev...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值