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++ Primer 仔细的读了读。看完运算符重载那一章时,就想到写个复数类来练一练手。 实际上 C++ 中是有复数类的,而且还是个模版类,...

匿名对象与非匿名对象的区别

类封装完以后就可以通过使用new关键字和类的构造方法来创建对象,这种对象分为两种:匿名对象与非匿名对象。何为匿名对象,何为非匿名对象呢?举个例子:假如有如下类:     package com.hei...

c++实现单链表,双向链表,顺序表的接口(非模板)

在以前使用c实现单链表的时候,没有使用函数的复用去完成相应的接口操作,这次使用尽量多的复用去完成链表和顺序表的操作(包括故意使用insert()去复用pushback()这个逻辑是错的,只是为了 ...

(C++模板类)顺序表、双向链表

C++模板类实现顺序表和双向循环带头节点链表
  • JS_Evey
  • JS_Evey
  • 2017年07月29日 20:15
  • 223

顺序链表C++实现

  • 2014年09月06日 22:02
  • 7KB
  • 下载

顺序链表类模板的实现

编写的顺序链表类模板存放元素Node,类模板定义了一下成员: 成员变量: 表示链表表头的指针:Node *head 链表长度:length 链表大小:size_ 成员函数 默认构造函数 接受迭代器...

c++顺序表与双向链表实现

之前实现过c语言版本的顺序表和单向链表,现在实现c++版本的顺序表和双向链表: 再来看一下顺序表,单链表和双向链表的区别: 顺序表的c++实现: #define _CRT_SECURE_...

双向循环链表的头插、中插、尾插、删除、逆序顺序显示(C++实现)

我们在单链表中,有了next指针,这就使得我们要查找下一个结点的时间复杂度为O(1),可是如果我们要查找的是上一个结点的话,那么最坏的时间复杂度为O(n)。因为我们每次都要从头开始遍历。为了克服单向性...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++模板实现链表,顺序表
举报原因:
原因补充:

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