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

原创 2016年08月29日 14:26:30

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;
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

c++链表(用类加模板)

上周学的c的链表,我想用c++中的模板加类来提高链表的可扩展性。 自己的一些拙见,望见谅。话不多说,贴代码才是王道 (为了方便指针倒置加了一下小插曲)#include #include temp...
  • lingxian55
  • lingxian55
  • 2017年12月25日 15:38
  • 76

用C++模板技术写的单链表

第一段应用C++类模板技术写的东西,并且用在现在的系统中,效果还不错,感觉代码还不够精简。//单链表模板类using namespace std;template class ElemType>cla...
  • NextLeap
  • NextLeap
  • 2006年07月27日 14:57
  • 1162

C++模板实现简单的链表和顺序表

从最初学习C语言到C++,就有一个认识就是作为一个优秀的程序猿一定要学会 ”偷懒“ ,用程序员的话来说就是复用,在C的基础上开发的C++就深刻阐明了这一道理,因为这样有太多的好处,增加了代码的可移植性...
  • blight_888
  • blight_888
  • 2017年04月11日 11:39
  • 216

C++模版类实现顺序表、单链表、双链表

  • 2012年10月28日 10:16
  • 526KB
  • 下载

线性表的两种实现 -- 顺序表和链表(C++)

线性表两种实现方法的比较 空间方面: 顺序表的缺点:大小事先固定。虽然便于分配空间,但是元素只有少数的几个时造成空间的浪费。 链表的优点:只有实际在链表中的对象需要空间,只要存在可用的内存空间分...
  • y396397735
  • y396397735
  • 2016年05月27日 10:57
  • 1780

C++数据结构 顺序表的实现(模板类的实现)

利用模板类实现顺序表的操作 实现的功能:  1.尾插,2.头插,3.显示,4.尾删,5.头删,6.按位置,7.插按值插,8.按位置删,9.按值删,10.按值查,11.求表长,12.清除数据,13.摧毁...
  • ZhongQi0808
  • ZhongQi0808
  • 2015年05月24日 15:12
  • 2348

c++模板链表实现

简介:主要是利用模板实现链表的操作。模板的使用,使得程序的开发量大大地减少。 可以先定义一个链表LinkList,之后可以定义自己的类了(例如:Student类),使用时就可以这样调用了 LinkLi...
  • invisible_sky
  • invisible_sky
  • 2016年03月24日 17:48
  • 927

链表——用C++模板实现

LinkedList.h//单向链表的实现 //查找、插入和移除某个元素、复制、清空单向链表的时间复杂度均为O(n) //设计类时,应尽量减少类的成员函数之间的依赖关系 #ifndef LINK...
  • Microsues
  • Microsues
  • 2010年12月29日 20:02
  • 12420

【C++】模板类顺序表

1.什么是模板     模板是泛型编程的基础。所谓泛型编程就是编写与类型无关的逻辑代码,是一种复用的方式。如果我们写一个普通的顺序表,那它只能满足一种数据存储类型,之后如果想把这个顺序表改成其他数据类...
  • pointer_y
  • pointer_y
  • 2016年08月29日 09:01
  • 714

C++模板类实现单链表

c++模板类实现单链表#include using namespace std; #include #include template struct LinkNode { LinkNode*...
  • Nou_Camp
  • Nou_Camp
  • 2017年04月08日 17:15
  • 852
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++模板实现链表,顺序表
举报原因:
原因补充:

(最多只允许输入30个字)