List--C++模板类

最新推荐文章于 2024-03-12 19:46:10 发布
最新推荐文章于 2024-03-12 19:46:10 发布
阅读量259 收藏
点赞数
分类专栏： CodeOfDataStructure 文章标签： list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fktr_70/article/details/50433776
版权 
#ifndef _PACKAGE_H_
#define _PACKAGE_H_


//数组实现
namespace list_in_array
{
    template<typename T>
    class List
    {
    private:
        enum { bad = -1 };
        enum { MAX = 100 };
        T elements[MAX];
        int last;
    public:
        List() { last = -1; };
        ~List() {}
        void Insert(T x, int p);
        void Delete(int p);
        int Locate(T x)const;
        T Retrieve(int p)const;
        int Previous(int p)const;
        int Next(int)const;
        int MakeNull();
        int First()const;
        int End()const;
        void Travel()const;
    };
    template<typename T>
    void List<T>::Insert(T x, int p)
    {
        int q;
        if (last >= MAX - 1)
            cout << "FULL!\n";
        else if ((p > last + 1) || (p < 0))
            cout << "NOT EXIST!\n";
        else
        {
            for (q = last; q >= p; q--)
                elements[q + 1] = elements[q];
            elements[p] = x;
            last++;
        }
    }
    template<typename T>
    void List<T>::Delete(int p)
    {
        int q;
        if ((p > last) || (p < 0))
            cout << "NOT EXIST!\n";
        else
        {
            for (q = p; q < last; q++)
                elements[q] = elements[q + 1];
            last--;
        }
    }
    template<typename T>
    int List<T>::Locate(T x)const
    {
        int q;
        for (q = 0; q <= last; q++)
            if (elements[q] == x)
                return q;
        cout << "NOT EXIST!\n";
        return bad;
    }
    template<typename   T>
    T List<T>::Retrieve(int p)const
    {
        if (p > last)
            cout << "NOT EXIST!\n";
        else
            return elements[p];
        return bad;
    }
    template<typename T>
    int List<T>::Previous(int p)const
    {
        if (p<1 || p>last)
            cout << "NOT EXIST!\n";
        else
            return p - 1;
        return bad;
    }
    template<typename T>
    int List<T>::Next(int p)const
    {
        if (p<0 || p>last - 1)
            cout << "NOT EXIST!\n";
        else
            return p + 1;
        return bad;
    }
    template<typename T>
    int List<T>::MakeNull()
    {
        last = -1;
        return 0;
    }
    template<typename T>
    int List<T>::First()const
    {
        if (last < 0)
            cout << "EMPTY!\n";
        else
            return 0;
        return bad;
    }
    template<typename T>
    int List<T>::End()const
    {
        if (last < 0)
            cout << "EMPTY!\n";
        else
            return last;
        return -1;
    }
    template<typename T>
    void List<T>::Travel()const
    {
        for (int i = 0; i <= last; i++)
            cout << elements[i] << endl;
    }
}

//链表实现
namespace link_list
{
    template<typename T>
    class List
    {
    public:
        struct Node
        {
            T data;
            struct Node *next;
        };
        Node *head;
        int length;
    public:
        List()
        {
            length = 0;
            head = new Node{ 0,NULL };
        }
        ~List() { delete head; }
        void Insert(T x, Node *p);
        void Delete(Node *p);
        Node * Locate(T x)const;
        T Retrieve(Node *p)const;
        Node* Previous(Node *p)const;
        Node* Next(Node *p)const;
        Node* MakeNull();
        Node* First()const;
        Node* End()const;
        void Travel()const;
    };
    template<typename T>
    void List<T>::Travel()const
    {
        Node *t = head->next;
        while (t != NULL)
        {
            cout << t->data << endl;
            t = t->next;
        }
    }
    template<typename T>
    typename List<T>::Node* List<T>::End()const
    {
        Node *t = head;
        while (t->next != NULL)
            t = t->next;
        return t;
    }
    template<typename T>
    typename List<T>::Node* List<T>::First()const
    {
        return head;
    }
    template<typename T>
    typename List<T>::Node* List<T>::MakeNull()
    {
        Node *t = head->next;
        while (t != NULL)
        {
            Node *t2 = t;
            t = t->next;
            delete t2;
        }
        head->next = NULL;
        length = 0;
        return head;
    }
    template<typename T>
    typename List<T>::Node* List<T>::Next(Node*p)const
    {
        if (p->next != NULL)
            return p->next;
        else
            cout << "NOT EXIST!\n";
        return p->next;
    }
    template<typename T>
    typename List<T>::Node* List<T>::Previous(Node *p)const
    {
        Node *t;
        if (p == head)
            cout << "NOT EXIST!\n";
        else
        {
            t = head;
            while (t->next != p)
                t = t->next;
            return t;
        }
    }
    template<typename T>
    T List<T>::Retrieve(Node *p)const
    {
        return p->data;
    }
    template<typename T>
    typename List<T>::Node* List<T>::Locate(T x)const
    {
        Node *t = head;
        while (t != NULL)
            if (t->data == x)
                return t;
            else
                t = t->next;
        return t;
    }
    template<typename T>
    void List<T>::Delete(Node *p)
    {
        Node *t;
        if (p->next != NULL)
        {
            t = p->next;
            p->next = t->next;
            delete t;
        }
        else
        {
            t = head;
            while (t->next->next != NULL)
                t = t->next;
            delete t->next;
            t->next = NULL;
        }
        length--;
    }
    template<typename T>
    void List<T>::Insert(T x, Node *p)
    {
        Node *t = new Node;
        t->data = x;
        if (p->next != NULL)
        {
            t->next = p->next;
            p->next = t;
        }
        else
        {
            p->next = t;
            t->next = NULL;
        }
        length++;
    }
}

//静态链表
namespace static_link_list
{
    template<typename T>
    class List
    {
    private:
        struct Node
        {
            T data;
            int next;
        };
        enum { maxsize = 100 };
        Node space[maxsize];
        int avail;
        int GetNode();
        void FreeNode(int q);
    public:
        List() {}
        ~List() {}
        void Initialize();
        void Insert(T x, int p);
        void Delete(int p);
    };
    template<typename T>
    void List<T>::Delete(int p)
    {
        int q;
        if (space[p].next != -1)
        {
            q = space[p].next;
            space[p].next = space[q].next;
            FreeNode(q);
        }
        else
            cout << "NOT EXIST!\n";
    }
    template<typename T>
    void List<T>::Insert(T x, int p)
    {
        int q;
        q = GetNode();
        space[q].data = x;
        space[q].next = space[p].next;
        space[p].next = q;
    }
    template<typename T>
    void List<T>::FreeNode(int q)
    {
        space[q].next = space[avail].next;
        space[avail].next = q;
    }
    template<typename T>
    int List<T>::GetNode()
    {
        int p;
        if (space[avail].next == -1)
        {
            cout << "FULL!\n";
            p = -1;
        }
        else
        {
            p = space[avail].next;
            space[avail].next = space[p].next;
        }
        return p;
    }
    template<typename T>
    void List<T>::Initialize()
    {
        int i;
        for (i = 0; i < maxsize - 1; i++)
            space[i].next = i + 1;
        space[i].next = -1;
        avail = 0;
    }
}

//双向链表
namespace double_link_list
{
    template<typename T>
    class List
    {
    private:
        struct Node
        {
            T data;
            struct Node *next, *prior;
        };
        Node *head;
        int length;
    public:
        List() { head = new Node{ 0,NULL,NULL }; }
        ~List() {}
        void Insert(T x, Node*p);
        void Delete(Node *p);
    };
    template<typename T>
    void List<T>::Delete(Node *p)
    {
        if (p->prior != NULL)
            p->prior->next = p->next;
        if (p->next != NULL)
            p->next->prior = p->prior;
        delete p;
        length--;
    }
    template<typename T>
    void List<T>::Insert(T x, Node *p)
    {
        Node *s = new Node;
        s->data = x;
        s->prior = p;
        s->next = p->next;
        p->next->prior = s;
        p->next = s;
        length++;
    }
}

//循环链表
namespace ring_link_list
{
    template<typename T>
    class List
    {
    private:
        struct Node
        {
            T data;
            struct Node *next;
        };
        Node *head;
    public:
        void LInsert(T x);
        void RInsert(T x);
    };
    template<typename T>
    void List<T>::RInsert(T x)
    {
        LInsert(x);
        head = head->next;
    }
    template<typename T>
    void List<T>::LInsert(T x)
    {
        Node *p = new Node;
        p->data = x;
        if (head == NULL)
        {
            p->next = p;
            head = p;
        }
        else
        {
            p->next = head->next;
            head->next = p;
        }
    }
}

//广义表
namespace general_list
{
    template<typename T>
    class List
    {
    private:
        enum tag { ATOM, LIST };
        struct Node
        {
            struct Node *link;
            bool tag;
            union
            {
                T data;
                struct Node *dlink;
            };
        };
        Node *head;
    public:
        bool Eaqual(List<T> &t)const;
    };
    template<typename T>
    bool List<T>::Eaqual(List<T> &t)const
    {
        bool x, y;
        y = false;
        if (head == NULL && t.head == NULL)
            y = true;
        else if (head != NULL && t.head != NULL)
        {
            if (head->tag == t.head->tag)
            {
                if (head->tag == ATOM)
                {
                    if (head->data == t.head->data)
                        x = true;
                    else
                        x = false;
                    if (x == true)
                        y = head->link.Eaqual(t.head->link);
                }
                else
                {
                    x = head->dlink.Eaqual(t.head->dlink);
                    if (x == true)
                        y = head->link.Eaqual(t.head->link);
                }
            }
        }
        return y;
    }
}

#endif
fktr_70
关注
专栏目录
c++系列-泛型编程与模板-源码
05-24
除了模板函数，C++还提供了模板类，这使得我们可以创建泛型的容器，如标准模板库(STL)中的`vector`、`list`和`map`等。例如，`std::vector`可以存储任何类型的元素： ```cpp template class vector { // ... }; `...
C++模板与STL库介绍
03-18
C++模板和STL库是C++编程语言中的两个核心特性，它们极大地提高了代码的复用性和效率。本文将深入探讨这两个主题，并提供丰富的实践应用示例。 首先，我们来理解C++模板。模板是C++的一个强大工具，它允许程序员...
C++初阶：STL之list类模板
weixin_36194037的博客
01-19 1094
C++初阶：STL之list类模板
C++模版类List实现
17岁boy的博客
03-20 2930
模版类即使用模版的泛型方式来编写类似链表的链式物理结构，这篇文章我是以动态数组的方式实现的，所以是List线性物理结构！ 1.包含头文件 定义函数执行的正确与错误宏用来判断函数执行，其次在定义类型别名（个人的一个小习惯） 头文件 #include <stdio.h> #include <stdlib.h> #include <iostream> 宏与...
list 模板类的简单实现
zhangziyangup
12-11 504
最近学数据结构，于是尝试着去实现了一个 list 类，发现确实有很多问题，特别是类的继承这一块，有些问题搞不懂…… 这个 list 类只是一个简单的实现，只提供了基本的功能，也没有边界检测什么的，越界访问的问题由使用者自己把握…… 很多功能都是没有实现的，总得来说这是一个比较裸的 list 模板类，没有什么实用价值…… /* THE PROGRAM IS MADE BY PYY */ ...
c++模板 --- 类模板、自定义类型当做模板参数
weixin_60569662的博客
12-17 4176
生成一个类模板 用template修饰的类 ---> 类中用到了未知类型 多用于数据结构，忽略类型的问题 只要用template修饰，有没有用到未知类型都是模板类 template<class _Ty> class MM { public: protected: } //只要被template修饰就是一个模板类，用没用未知类型没关系 类模板调用 只要用template修饰，就是一个模板类，模板类必须采用显式调用 不存在隐式调用(必须要传参....
C++类模板实例化
热门推荐
jinzhu1911的专栏
09-04 1万+
C++类模板实例化 文章目录C++类模板实例化1. 简介2. 类模板实例化2.1 隐式实例化（Implicit instantiation）2.2 显示实例化（Explicit instantiation）2.3 类模板中的静态成员 1. 简介 该文章主要总结C++类模板实例化的方法。类模板的实例化包含两种： 隐式实例化（Implicit instantiation） 显示实例化（Explicit instantiation） 2. 类模板实例化 类模板本身不是类型、对象或任何其他实体。仅包含模板定义的
C++:STL--List
小青菜的博客
05-28 1511
C++list的学习
【C++ 】list 类
最新发布
2301_79789645的博客
03-12 1434
list 的使用和模拟实现
Microsoft Visual C++ 2015-2019 运行库合集，包含32位64位.zip
06-16
2. ATL（Active Template Library）：它是一组C++模板，主要用于创建COM（Component Object Model）组件，简化了COM对象的创建过程。 3. CRT（C Run-Time Library）：这是C++的基础运行库，包括标准库函数、内存管理...
Introduction-to-C++.pptx
09-02
C++ 由Bjarne Stroustrup于1979年开发，是对C语言的扩展，引入了类、模板、异常处理等概念，使其成为构建大型系统软件的理想选择。C++ 是一个静态类型的、编译式的、通用的、大小写敏感的、不仅支持过程化编程，也...
C++编程实例100篇-C/C++代码类资源
12-18
实例将展示模板函数和模板类的使用。 7. **异常处理**：C++的错误处理机制，通过try-catch块来捕获和处理运行时错误。 8. **STL（标准模板库）**：包括容器（如vector、list、set、map等）、迭代器、算法和函数...
C++中模板类list常用示例
刀刀脱靶的博客
05-31 4838
list是STL提供的一个线性链表的数据结构，其与vector的差异，类似于链表与数组的差异。 数组：可以随机读取访问，但是要插入和删除指定元素时不容易处理，因为在扩展或缩小数组空间时，对应的其他数组元素的位置会受到影响。 链表：不能够随机读取访问，但是插入和删除元素时较数组要方便很多，以双向线性链表为例，每个节点都通过前驱指针和后驱指针与前后元素保持访问关系，插入和删除元素时只涉及到最多三个
如何写模板类？（模板类的简单例子）
沧海一帆的专栏
10-31 5374
本文通过c++ primer plus中的例子来学习写模板类． 1.为什么需要模板类？ 为了满足代码重用的需求． 比如stack类，希望不同的类型都能用． 先看看用typedef 定义的stack类． // stack.h -- class definition for the stack ADT #ifndef STACK_H_ #define STACK_H_ typedef unsigne...
左式堆--C语言实现
fktr_70的博客
01-01 779
leftheap.h#ifndef _LEFTHEAP_H_ #define _LEFTHEAP_H_ #define Insert(X,H) (H=Insert1((X),H)) #define DeleteMin(H)(H=DeleteMin1(H))struct TreeNode; typedef struct TreeNode *PriorityQueue; typedef int Elem
二项队列--C语言实现
fktr_70的博客
01-01 644
binqueue.h#ifndef _BINQUEUE_H_ #define _BINQUEUE_H_ #define MaxTrees 100 #define Capacity 1000struct BinNode; struct Collection; typedef int ElementType; typedef struct BinNode *Position; typedef Posit
BST树--C语言实现
fktr_70的博客
12-30 643
bsttree.h#ifndef _BSTTREE_H_ #define _BSTTREE_H_struct BstNode; typedef int ElementType; typedef struct BstNode *Position; typedef struct BstNode *BstTree; BstTree MakeEmpty(BstTree T); Position Find(E
C++模板深入：TypeList应用与模板分类解析
"该资源是关于C++模板的讲解，特别是TypeList的使用，这是一个用于类型操作的工具，常在元编程中使用。" 在C++编程中，模板是一种强大的特性，允许我们创建泛型代码，即代码可以处理不同类型的数据。在给定的描述中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值