C++模板实现链表,顺序表

最新推荐文章于 2019-05-21 20:45:13 发布
最新推荐文章于 2019-05-21 20:45:13 发布
阅读量1.1k 收藏 4
点赞数 2
分类专栏： C++ 一起学习C/C++ 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26768741/article/details/52352812
版权

Seqlist.h

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<string>
#include<cassert>

using namespace std;

template<typename T>
class SeqList
{
public:
    SeqList();
    ~SeqList();
    SeqList(const SeqList& s);
    SeqList<T>& operator=(const SeqList<T> s);
    T& operator[](const int& n);

    void PushBack(const T& data);
    void Display();
    void PushFront(const T& data);
    void PopBack();
    void PopFront();
    void Insert(int pos,const T& data);

    void Remove(const T& data);
    void RemoveAll(const T& data);
    void Sort();
    void reserve(int n);
    void erase(int pos);
    void Size();
    void Capacity();
private:
    void CheckCapacity();
    void CheckCapacity(int n);
private:
    T* _data;
    int _sz;
    int _capacity;
};



template<typename T>
SeqList<T>::SeqList()
:_data(NULL)
, _sz(0)
, _capacity(3)
{
    _data = new T[3];
}

template<typename T>
SeqList<T>::~SeqList()
{
    if (_data != NULL)
    {
        delete[] _data;
        _data = NULL;
        _sz = 0;
        _capacity = 0;
    }
}

template<typename T>
void SeqList<T>::PushBack(const T& data)
{
    CheckCapacity();
    _data[_sz] = data;
    _sz++;
}

template<typename T>
void SeqList<T>::Display()
{
    for (int i = 0; i < _sz; i++)
    {
        cout << _data[i] << " ";
    }
    cout << endl;
}


template<typename T>
void SeqList<T>::CheckCapacity()
{
    if (_sz == _capacity)
    {
        int NewCapacity = 2 * _capacity;
        T* Tmp = new T[NewCapacity];
        //在这里不使用memcpy()函数，主要是因为对于非内置类型memcpy()函数会出现浅拷贝问题，比如string类型，
        //这个类型中有一个_buf与_ptr,当储存少于16个的时候这时会储存在_buf当中的，如果多于16个，那个会单独开辟空间
        //进行储存,这时拷贝的时候就是拷贝过去这个储存的地址而已，所以这样调用析构函数的时候，当增加容量的时候，
        //这个时候会把储存string的那块空间进行释放，这个时候最后得到的结果就是你新拷贝的所指向的内容变为了释放以后的内容

        for (int i = 0; i < _sz; i++)
        {
            Tmp[i] = _data[i];
        }

        delete[] _data;
        _data = Tmp;
        _capacity = NewCapacity;
    }
}

template<typename T>
void SeqList<T>::CheckCapacity(int n)
{
    int NewCapacity = n;
    T* Tmp = new T[n];
    //在这里不使用memcpy()函数，主要是因为对于非内置类型memcpy()函数会出现浅拷贝问题，比如string类型，
    //这个类型中有一个_buf与_ptr,当储存少于16个的时候这时会储存在_buf当中的，如果多于16个，那个会单独开辟空间
    //进行储存,这时拷贝的时候就是拷贝过去这个储存的地址而已，所以这样调用析构函数的时候，当增加容量的时候，
    //这个时候会把储存string的那块空间进行释放，这个时候最后得到的结果就是你新拷贝的所指向的内容变为了释放以后的内容

    for (int i = 0; i < _sz; i++)
    {
        Tmp[i] = _data[i];
    }

    delete[] _data;
    _data = Tmp;
    _capacity = n;
}

template<typename T>
void SeqList<T>::PushFront(const T& data)
{
    CheckCapacity();
    for (int i = _sz; i >0; i--)
    {
        _data[i] = _data[i-1];
    }
    _data[0] = data;
    _sz++;
}

template<typename T>
void SeqList<T>::PopBack()
{
    _sz--;
}

template<typename T>
void SeqList<T>::PopFront()
{
    for (int i = 0; i < _sz; i++)
    {
        _data[i] = _data[i + 1];
    }
    _sz--;
}

template<typename T>
void SeqList<T>::Insert(int pos, const T& data)
{
    assert(pos >= 0 && pos < _sz);
    for (int i = _sz; i >=pos-1; i--)
    {
        _data[i + 1] = _data[i];

    }
    _data[pos-1] = data;
    _sz++;
}

template<typename T>
void SeqList<T>::Size()
{
    cout << _sz << endl;;
}

template<typename T>
void SeqList<T>::Capacity()
{
    cout << _capacity << endl;
}


template<typename T>
void SeqList<T>::Remove(const T& data)
{
    if (_sz == 0)
    {
        return;
    }
    for (int i = 0; i < _sz; i++)
    {
        if (_data[i] == data)
        {
            for (int j = i; j < _sz; j++)
            {
                _data[j] = _data[j + 1];

            }
            break;
        }
    }
    _sz--;
}
template<typename T>
void SeqList<T>::RemoveAll(const T& data)
{
    if (_sz == 0)
    {
        return;
    }
    for (int i = 0; i < _sz; i++)
    {
        if (_data[i] == data)
        {
            for (int j = i; j < _sz; j++)
            {
                _data[j] = _data[j + 1];

            }
            _sz--;
        }
        if (_data[i] == data)
        {
            i--;
        }
    }

}
template<typename T>
void SeqList<T>::Sort()
{
    int flag = 0;
    for (int i = 0; i < _sz; i++)
    {
        int flag = 1;
        for (int j = 0; j < _sz - i - 1; j++)
        {
            if (_data[j]>_data[j + 1])
            {
                std::swap(_data[j], _data[j + 1]);
                flag = 0;
            }
        }
        if (flag)
        {
            break;
        }
    }
}
template<typename T>
void SeqList<T>::reserve(int n)
{
    if (_capacity < n)
    {
        CheckCapacity(n);
    }

}
template<typename T>
void SeqList<T>::erase(int pos)
{
    assert(pos >= 0 && pos < _sz);
    for (int i = pos; i < _sz; i++)
    {
        _data[i - 1] = _data[i];
    }
    _sz--;
}


template<typename T>
SeqList<T>& SeqList<T>::operator=( SeqList<T> s)
{
    if (_data != s._data)
    {
        std::swap(_data, s._data);
        std::swap(_capacity, s._capacity);
        std::swap(_sz, s._sz);
    }
    return *this;
}

template<typename T>
T& SeqList<T>::operator[](const int& n)
{
    assert(n >= 0 && n < _sz);
    return _data[n];
}

template<typename T>
SeqList<T>::SeqList(const SeqList& s)
:_sz(s._sz)
, _capacity(s._capacity)
, _data(new T[s._capacity])
{
    for (int i = 0; i < _sz; i++)
    {
        _data[i] = s._data[i];
    }

}

Linklist.h

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<string>
#include<cassert>

template<typename T>
struct Node
{
    Node()
    :_next(NULL)
    {}
    ~Node()
    {
    }
public:
    T _data;
    Node* _next;

};

template <typename T>
class LinkList
{
public:
    LinkList();
    ~LinkList();
    LinkList(const LinkList<T> & list);
    LinkList<T>& operator =(const LinkList<T> list);
    void PushBack(const T& data);
    void Display();
    void PushFront(const T& data);
    void PopBack();
    void PopFront();
    void Insert(Node<T> *pos, const T& data);

    void Remove(const T& data);
    void RemoveAll(const T& data);
    void Sort();
    void erase(Node<T>* pos);
    void Size();
    Node<T>* find(const T& data);

private:
    Node<T>* _head;
    Node<T>* _tail;
};

template<typename T>
LinkList<T>::LinkList()
:_head(NULL)
, _tail(NULL)
{

}

template<typename T>
LinkList<T>::~LinkList()
{
    Node <T>*cur = _head;
    while (cur)
    {
        Node<T>*del = cur;
        cur=cur->_next;
        delete del;
    }
}

template<typename T>
LinkList<T>::LinkList(const LinkList & list)
    :_head(NULL)
    , _tail(NULL)
{
    Node <T>*cur = list._head;
    while (cur != NULL)
    {
        PushBack(cur->_data);
        cur = cur->_next;
    }

}

template<typename T>
LinkList<T>& LinkList<T>::operator =( LinkList<T> list)
{
    std::swap(_head, list._head);
    std::swap(_tail, list._tail);
    return *this;
}

template<typename T>
void LinkList<T>::PushBack(const T& data)
{
    if (_head == NULL)
    {
        _head = new Node<T>;
        _head->_data = data;
        _tail = _head;
    }
    else
    {
        Node<T> *tmp = new Node<T>;
        tmp->_data = data;
        tmp->_next = NULL;
        _tail->_next = tmp;
        _tail = tmp;
    }
}

template<typename T>
void LinkList<T>::Display()
{
    Node<T>* cur = _head;
    while (cur)
    {
        cout << cur->_data << " ";
        cur = cur->_next;
    }
    cout << endl;
}

template<typename T>
void LinkList<T>::PushFront(const T& data)
{
    Node<T>*tmp = new Node<T>;
    tmp->_data = data;
    Node <T>*cur = _head;
    _head = tmp;
    tmp->_next = cur;
}


template<typename T>
void LinkList<T>::PopBack()
{
    Node <T>*cur = _head;
    Node <T>*del = NULL;
    if (_head == NULL)
    {
        return;
    }
    else if (_head == _tail)
    {
        del = _head;
        delete del;
        _head = _tail = NULL;
    }
    else
    {
        while (cur->_next != _tail)
        {
            cur = cur->_next;
        }
        delete _tail;
        _tail = cur;
        _tail->_next = NULL;

    }
}

template<typename T>
void LinkList<T>::PopFront()
{
    if (_head == NULL)
    {
        return;
    }
    else
    {
        Node<T>* cur = _head;
        Node<T>* del = NULL;
        del = _head;
        _head = _head->_next;
        delete del;
        del = NULL;
    }
}
template<typename T>
Node<T>* LinkList<T>::find(const T& data)
{
    Node<T>* cur = _head;
    while (cur)
    {
        if (cur->_data == data)
        {
            return cur;
        }
        cur = cur->_next;
    }
    return NULL;
}
template<typename T>
void LinkList<T>::Insert(Node<T>* pos, const T& data)
{
    if (pos == NULL)
    {
        return;
    }
    Node<T>* newnode = new Node<T>;
    newnode->_data = data;
    Node<T>* cur = _head;
    Node<T>* prev = NULL;
    while (cur != NULL)
    {
        if (pos == cur)
        {
            break;
        }
        prev = cur;
        cur = cur->_next;
    }
    if (prev == NULL)
    {
        _head->_next = newnode;
        newnode->_next = cur;
    }
    else
    {
        prev->_next = newnode;
        newnode->_next = cur;
    }
}

template<typename T>
void LinkList<T>::Remove(const T& data)
{
    if (_head == NULL)
    {
        return;
    }
    Node<T> *cur = _head;
    Node<T> *prev = NULL;
    Node<T> *del = NULL;
    while (cur != NULL)
    {
        if (cur->_data == data)
        {
            if (cur == _head)
            {
                del = cur;
                _head = cur->_next;
                delete del;
                del = NULL;
            }
            else
            {
                del = cur;
                prev->_next = cur->_next;
                delete del;
                del = NULL;
            }
            return;
        }
        else
        {
            prev = cur;
            cur = cur->_next;
        }
    }
}

template<typename T>
void LinkList<T>::RemoveAll(const T& data)
{
    if (_head == NULL)
    {
        return;
    }
    Node<T> *cur = _head;
    Node<T> *del = NULL;
    Node<T> *prev = cur;
    while (cur != NULL)
    {
        if (cur->_data == data)
        {
            if (cur == _head)
            {
                del = cur;
                prev = cur->_next;
                _head = cur->_next;
                delete del;
                del = NULL;
            }
            else
            {
                del = cur;
                prev->_next = cur->_next;
                delete del;
                del = NULL;
            }
            cur = prev;
        }
        else
        {
            prev = cur;
            cur = cur->_next;
        }
    }
}

template<typename T>
void LinkList<T>::Sort()
{
    if ((_head == NULL) || (_head->_next == NULL))
    {
        return;
    }
    Node<T>* cur = _head;
    Node<T>* tail = NULL;
    while (cur != tail)
    {
        while (cur->_next != tail)
        {
            if (cur->_data > cur->_next->_data)
            {
                std::swap(cur->_data, cur->_next->_data);
            }
            cur = cur->_next;
        }
        tail = cur;
        cur = _head;
    }
}

template<typename T>
void LinkList<T>::erase(Node<T>* pos)
{
    if (_head == NULL)
    {
        return;
    }
    Node<T> *cur = _head;
    Node<T> *del = NULL;
    Node<T> *prev = _head;
    while (cur != NULL)
    {
        if (pos == cur)
        {
            if (pos == _head)
            {
                del = pos;
                _head = cur->_next;
                delete del;

                del = NULL;
            }
            else
            {
                del = pos;
                prev->_next = cur->_next;
                delete del;
                del = NULL;
            }
            return;
        }
        else
        {
            prev = cur;
            cur = cur->_next;
        }


    }
}

template<typename T>
void LinkList<T>::Size()
{
    Node<T>*cur = _head;
    int count = 0;
    while (cur != NULL)
    {
        count++;
        cur = cur->_next;
    }
    cout<<count<<endl;
}
宇哲_安菲尔德
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++实现的单链表通用模板
Gifted2013
03-19 5793
这两天复习了一下单链表，决定用C++写一个单链表的统一模板，方便使用时可直接调用。所谓单链表，是指一串相同的结构体，其中，前一个结构体中存储了指向下一个结构体的指针，是数组的进化形式。单链表示意图如下：           链表的常见操作有：查询（Find）、插入（Insert）、删除（Delete）等。单链表在表的起始处一般为一个空的表头，该表头只存储一个指
C++链表的排序实现
suren_jun的博客
10-18 4646
对于链表的排序算法，除了希尔排序之外，且堆排序不建议，其他排序方法都是支持的，如下：冒泡排序，选择排序，插入排序，归并排序，快速排序，计数排序，桶排序和基数排序。下面废话不多说。
C++模版类实现顺序表、单链表、双链表
10-28
压缩包内为线性表的工程包；工程内包括顺序表、单链表、双链表的类的定义与实现；附适当注释；完全面向对象，类封装；测试类中用（纯）虚函数实现多态。
C++模板实现单链表基本操作
starzyh的博客
05-21 990
#ifndef LINKLIST_H #define LINKLIST_H #include <iostream> using namespace std; template <typename T> struct Node{ T data; struct Node* next; }; template <typename T> class...
链表排序算法
澈彻策的博客
10-16 3417
1）题目 对乱序的链表进行排序，要求空间复杂度为常数。（LeetCode 148 中等）   输入: 4-&gt;2-&gt;1-&gt;3 输出: 1-&gt;2-&gt;3-&gt;4   输入: -1-&gt;5-&gt;3-&gt;4-&gt;0 输出: -1-&gt;0-&gt;3-&gt;4-&gt;5   2）思路        对于这题我有两种解法，一种是时间复
C++实现数组和链表的排序算法
MSFollower的博客
08-23 1882
OK，我们经常会用到排序算法。那么，常用的排序算法，除了使用数组之外，用链表又该如何处理呢？下面我们来做个对比： //使用插入排序对数组进行排序 int *get_order(int *num, int length) { for(int eiter = 1; eiter &lt; length; eiter++) { int temp_value = num[...
c c++ 顺序表 链表 队 栈 树类模板实现 以及例子
01-27
c/c++ 顺序表 、链表 、队 、栈 、树、类模板实现 以及例子
C++模板实现顺序栈
12-20
由于栈顶元素是经常变动的，所以附设top指示栈顶元素在顺序表中的位置，同时也需要知道顺序栈存储空间的起始位置，因此还需设定一个base指针用来指示栈空间的起始位置。 一般约定top指针指向栈顶元素的下一个位置，...
实现一个模板类的链表（c++）
06-03
1. 请创建一个数据类型为T的链表类模板List，实现以下成员函数： 1） 默认构造函数List()，将该链表初始化为一个空链表（10分） 2） 拷贝构造函数List(const List<T>& list)，根据一个给定的链表构造当前链表（10...
数据结构　顺序链表（C++）
06-07
C++实现顺序链表类模板及测试
ShiYan1_单链表_C++_顺序表_数据结构_
09-29
（3）在顺序表类模板中增加成员函数max()和min()，它们分别返回顺序表中元素值最大的数据元素序号。 2．单链表的验证 （1）定义一个结构体，描述学生信息。学生信息包括：学号、姓名、性别、班级和电话号码等。用...
用C++实现的链表的排序：选择排序和冒泡排序
12-11
这是根据数据结构书上讲的线性表的排序方法改写成链表，上面有简单的测试程序。
顺序表和链表
03-26
数据结构 顺序表和链表的相关操作 vc++6.0
用c++类模板，实现的单链表基本操作
05-14
#include "stdafx.h" #include #include using namespace std; template struct LNode { T data; LNode *next; }; template class LinkList { public: LinkList(){L = 0;}//构造函数 ~LinkList();//析构函数，销毁单链表 void CreateList_L(int n);//构造单链表 bool IsEmpty() const{return L->next == 0;}//判断单链表是否为空 int GetElem_L(int i,T &e) const;//当第i个元素存在时，其值赋给e int ListInsert_L(int i,T &e);//在第i个位置插入元素e ……………………
数据结构C++单链表冒泡法排序
12-06
数据结构，单链表冒泡法排序数据结构，C++实现，可输入式程序
c/c++实现链表排序
11-07
简单实现链表排序，利用图形深入浅出的讲解，涵盖排序遇到很多问题，详细的很，助你轻松理解链表排序。
C++ 简单实现链表模板类
m0_37579906的博客
08-25 2759
目的在于熟悉 C++ 实现链表类、熟悉模板类 #include &lt;iostream&gt; #include &lt;stdio.h&gt; #include &lt;string.h&gt; using namespace std; //前置申明模板类 template &lt;class T&gt; class List; //定义节点模板类 template &lt;cl...
C++模板的实现（模板函数和模板类，附带模板实现顺序表和链表代码）
龙跃十二
05-05 3110
模板 一、模板函数 模板函数的格式： 模板参数隐式实例化 模板参数显示实例化 二、模板类 模板类的格式 模板类示例 模板  当我们实现一个交换函数时，我们可以写成如下。 void Swap(int&amp; x, int&amp; y) { int tmp = x; x = y; y = tmp; }  这里只能交换两个整数...
用C++实现目的：使用C++模板设计并逐步完善二叉树的抽象数据类型（ADT）。 内容：（1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。） 注意：二叉树ADT的基本操作的算法设计很多要用到递归的程序设计方法。 （2）基本操作：二叉树的二叉链表存储形式的建立，完成后将其加入到二叉树的ADT基本操作集中。 输入数据为层次次序，要求设计一个算法，将二叉树转化为二叉链表的存储形式。 初始条件：definition给出二叉树T的定义（自然输入顺序序列。无孩子或指针为空的情形，算法通过特殊分隔符识别（输入）），至少有1个根结点。 输出：按definition构造二叉树的二叉链表。 注意：由于测试数据的显示需建立在二叉树的遍历基础上。因此，请在设计好二叉树的三种遍历算法之后（基本操作2），再进行测试。求代码
最新发布
05-27
以下是一个简单的二叉树ADT模板： ```c++ template struct TreeNode { T data; TreeNode* left; TreeNode* right; }; template class BinaryTree { public: BinaryTree(); ~BinaryTree(); void insert...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值