c++实现线性表和双向链表

c++实现线性表
SeqList.h

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string>
#include<assert.h>
using namespace std;

typedef int DataType;
class SeqList
{
public:
    SeqList()
        : _pData(new DataType[3])
        , _capacity(3)
        , _size(0)
    {}
    SeqList(size_t n, DataType value);
    // 浅拷贝 三大big 
    SeqList(const SeqList& s);
    SeqList& operator=(const SeqList& s);
    ~SeqList();
    void PushBack(const DataType& data);
    void PopBack();
    void Insert(size_t pos, const DataType& data);
    void Erase(size_t pos);
    int Find(const DataType& data);
    size_t Size()const;
    size_t Capacity()const;
    bool Empty()const;
    void Clear();
    // 把顺序表中的有效元素改变到size个 
    void Resize(size_t size, const DataType& data);
    DataType& operator[](size_t index);
    const DataType& operator[](size_t index)const;
    DataType& Front();
    const DataType& Front()const;
    DataType& Back();
    const DataType& Back()const;
    void DisPlay()
    {
        int i = 0;
        for (i; i < _size; i++)
        {
            cout << _pData[i] << " ";
        }
        cout << endl;
    }

private:
    void _CheckCapacity()
    {
            DataType* pTemp = new DataType[_capacity * 2];
            for (size_t idx = 0; idx < _size; ++idx)
                pTemp[idx] = _pData[idx];
            delete[] _pData;
            _pData = pTemp;
            _capacity *= 2;
    }
private:
    DataType* _pData;
    size_t _capacity;
    size_t _size;
};

SeqList.cpp

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

SeqList::SeqList(size_t n, DataType value)
    : _pData(new DataType[3])
    , _capacity(3)
    , _size(0)
{
    while (n > _capacity)
    {
        _CheckCapacity();
    }
    int i = 0;
    for (i; i < n; i++)
    {
        _pData[i] = value;
    }
    _size = n;
}
SeqList::SeqList(const SeqList& s)
{
    _pData = new DataType[s._capacity];
    _capacity = s._capacity;
    _size = s._size;
    //拷贝数据
    //方法1
    int i = 0;
    for (i; i < s._size; i++)
    {
        _pData[i] = s._pData[i];
    }
    //方法2
    //memcpy(_pData, s._pData, s._size);
}
SeqList& SeqList::operator=(const SeqList& s)
{
    int i = 0;
    if (this == &s)
    {
        return *this;
    }
    DataType* pTemp = new DataType[s._capacity];
    for (i; i < s._size; i++)
    {
        pTemp[i] = s._pData[i];
    }
    delete[] _pData;
    _pData = pTemp;
    _size = s._size;
    _capacity = s._capacity;
}
SeqList::~SeqList()
{
    if (_pData != NULL)
    {
        delete[] _pData;
        _pData = NULL;
        _size = 0;
    }
}
void SeqList::PushBack(const DataType& data)
{
    if (_size == _capacity)
    {
        _CheckCapacity();
    }
    _pData[_size] = data;
    _size += 1;
}
void SeqList::PopBack()
{
    if (_size == 0)
    {
        return;
    }
    _size -= 1;
}
void SeqList::Insert(size_t pos, const DataType& data)
{
    int i;
    assert(pos > 0 && pos <= _size);

    for (i = _size; i >= pos; i--)
    {
        _pData[i] = _pData[i - 1];
    }
    _pData[pos] = data;
    _size += 1;
}
void SeqList::Erase(size_t pos)
{
    int i;
    assert(pos > 0 && pos < _size);
    for (i = pos; i < _size; i++)
    {
        _pData[i-1] = _pData[i];
    }
    _size -= 1;
}
//找到返回下标，否则返回-1
int SeqList::Find(const DataType& data)
{
    int i = 0;

    for (i; i < _size; i++)
    {
        if (_pData[i] == data)
        {
            return i;
        }
    }
    return -1;
}
size_t SeqList::Size()const
{
    return _size;
}
size_t SeqList::Capacity()const
{
    return _capacity;
}
bool SeqList::Empty()const
{
    if (_size == 0)
    {
        return true;
    }
    return false;
}
void SeqList::Clear()
{
    if (_pData != NULL)
    {
        delete[] _pData;
        _size = 0;
    }
}
// 把顺序表中的有效元素改变到size个 
void SeqList::Resize(size_t size, const DataType& data)
{
    int i = 0;
    if (_size >= size)
    {
        _size = size;
    }
    else
    {
        if (size > _capacity)
        {
            _CheckCapacity();
        }
        for (i = _size; i < size; i++)
        {
            _pData[i] = data;
        }
        _size = size;
    }
}
DataType& SeqList::operator[](size_t index)
{
    return _pData[index];
}
const DataType& SeqList::operator[](size_t index)const
{
    return _pData[index];
}
DataType& SeqList::Front()
{
    return _pData[0];
}
const DataType& SeqList::Front()const
{
    return _pData[0];
}
DataType& SeqList::Back()
{
    return _pData[_size - 1];
}
const DataType& SeqList::Back()const
{
    return _pData[_size - 1];
}

---

双向链表
LinkList.h

#define _CRT_SECURE_NO_WARNINGS
#pragma once 
#include<iostream>
#include<assert.h>
using namespace std;

typedef int DataType;
struct Node
{
    Node(const DataType& data)
    : _pNext(NULL)
    , _pPre(NULL)
    , _data(data)
    {}

    Node* _pNext;
    Node* _pPre;
    DataType _data;
};

class List
{
public:
    List()
        : _pHead(NULL)
    {}
    List(size_t n, DataType data);
    void PushBack(const DataType& data);
    void PopBack();
    void PushFront(const DataType& data);
    void PopFront();
    Node* Find(const DataType& data);
    void Insert(Node* pos, const DataType& data);
    void Erase(Node* pos);
    size_t Size();
    bool Empty()const;
    List(const List& l);
    List& operator=(const List& l);
    void Display()
    {
        Node* tmp = _pHead;
        while (tmp)
        {
            cout << tmp->_data << " ";
            tmp = tmp->_pNext;
        }
        cout << endl;
    }
    ~List();
private:
    Node* BuyNode(const DataType& data)
    {
        Node* tmp=new Node(data);
        tmp->_pNext = NULL;
        tmp->_pPre = NULL;

        return tmp;
    }
private:
    Node* _pHead;
};

LinkList.cpp

#define _CRT_SECURE_NO_WARNINGS
#include"LinkList.h"

List::List(size_t n, DataType data)
{
    while (n--)
    {
        PushBack(data);
    }
}
void List::PushBack(const DataType& data)
{
    Node* tmp = _pHead;
    Node* NewNode = BuyNode(data);
    if (_pHead == NULL)
    {
        _pHead=NewNode;
        //NewNode->_pPre = _pHead;
    }
    else
    {
        while (tmp->_pNext != NULL)
        {
            tmp = tmp->_pNext;
        }
        tmp->_pNext = NewNode;
        NewNode->_pPre = tmp;
    }
}
void List::PopBack()
{
    Node* tmp = _pHead;
    if (_pHead == NULL)
    {
        return;
    }
    else
    {
        while (tmp->_pNext)
        {
            tmp = tmp->_pNext;
        }
        tmp->_pPre->_pNext = NULL;
        delete tmp;
    }

}
void List::PushFront(const DataType& data)
{
    Node* tmp = _pHead;
    Node* NewNode = BuyNode(data);
    if (_pHead == NULL)
    {
        _pHead = NewNode;
    }
    else
    {
        NewNode->_pNext = _pHead;
        _pHead->_pPre = NewNode;
        _pHead = NewNode;
    }
}
void List::PopFront()
{
    if (_pHead == NULL)
    {
        return;
    }
    else if (_pHead->_pNext==NULL)
    {
        _pHead = NULL;
    }
    else
    {
        _pHead = _pHead->_pNext;
    }
}
Node* List::Find(const DataType& data)
{
    Node* tmp = _pHead;
    while (tmp)
    {
        if (tmp->_data == data)
        {
            return tmp;
        }
        tmp = tmp->_pNext;
    }
    return NULL;
}
void List::Insert(Node* pos, const DataType& data)
{
    Node* NewNode = BuyNode(data);
    assert(pos);
    if (pos == _pHead)
    {
        PushFront(data);
    }
    else
    {
        NewNode->_pNext = pos->_pPre->_pNext;
        pos->_pPre->_pNext = NewNode;
        NewNode->_pPre = pos->_pPre;
        pos->_pPre = NewNode;
    }
}
void List::Erase(Node* pos)   //不能删除最后一个
{
    assert(pos);
    if (_pHead == NULL)
    {
        return;
    }
    else if (_pHead==pos)
    {
        PopFront();
    }
    else
    {
        pos->_pPre->_pNext=pos->_pNext;
        pos->_pNext->_pPre=pos->_pPre;
    }
}
size_t List::Size()
{
    Node* tmp = _pHead;
    size_t len = 0;
    while (tmp)
    {
        len++;
        tmp = tmp->_pNext;
    }
    return len;
}
bool List::Empty()const
{
    if (_pHead == NULL)
    {
        return true;
    }
    return false;
}
List::List(const List& l)
{

}
List& List::operator=(const List& l)
{
    if (this == &l)
    {
        return *this;
    }
}
List::~List()
{
    if (_pHead != NULL)
    {
        delete _pHead;
        _pHead = NULL;
    }

}

小面给出了双向链表的任意位置插入和删除原理图
任意位置插入
下图为除去在第一节点差插入

任意位置删除
除去删除第一个位置