list 相关

• 相关接口

size() //容器的大小即节点数量
resize() //更改容器的大小，多删少补。
remove() //传入一个参数，删除列表中所有与该参数相同的元素。
erase() //传入迭代器，删除，并返回下一个迭代器。
push_back() //尾部插入元素
emplace_back() //右值引用的尾部插入元素

• list填充随机1-100之间的数，再删除可以被5整除的。

#include<list>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<cstdlib>
using namespace std;
int main()
{
    list<int>l;
    srand((int)time(0));
    for (int i = 0; i < 100; i++)
    {
        int value = rand() % 100;
        l.push_back(value);
    }

    for (auto it = l.begin(); it != l.end();)
    {
        if (*it % 5 == 0)
        {
            it = l.erase(it);
        }
        else
        {
            ++it;
        }
    }
    for (auto it : l)
    {
        cout << it << endl;
    }
    system("pause");
    return 0;
}

• list实现部分接口

#ifndef _MY_LIST
#define _MY_LIST
#include<iostream>
typedef unsigned int UINT32;
template<class T>
class NodeStruct {
public:
    T data;
    NodeStruct* next;
    NodeStruct* prev;
    NodeStruct(T x) :next(nullptr),
        prev(nullptr),
        data(x)
    {
    }
};

template<class T>
class MyList
{
    typedef NodeStruct<T>Node;
private:
    Node* head;
    Node* tail;
    UINT32 m_dwsize;
public:
    MyList() :head(nullptr),
        tail(nullptr),
        m_dwsize(0)
    {
    }

    ~MyList()
    {
        while (head != nullptr)
        {
            Node* delete_node = head;
            head = head->next;
            delete delete_node;
        }
        head = nullptr;
        tail = nullptr;
        m_dwsize = 0;
    }

    UINT32 size()
    {
        return m_dwsize;
    }

    bool empty()
    {
        return head == nullptr ? true : false;  
    }

    void remove(const T& value)
    {
        Node *current_node = head;
        while (current_node != nullptr)
        {
            if (current_node->data == value)
            {
                Node* delete_node = current_node;
                if (current_node == head)
                {
                    current_node = current_node->next;
                    head = head->next;
                    delete delete_node;
                    head->prev = nullptr;
                }
                else if (current_node == tail)
                {
                    tail = tail->prev;
                    current_node = nullptr;
                    delete delete_node;
                    tail->next = nullptr;
                }
                else
                {
                    current_node->next->prev = current_node->prev;
                    current_node->prev->next = current_node->next;
                    current_node = current_node->next;
                    delete delete_node;
                }
                m_dwsize--;
            }
            else
            {
                current_node = current_node->next;
            }
        }
    }

    void push_back(const T& value)
    {
        Node* node = new Node(value);
        if (head != nullptr)
        {
            if (head->next == nullptr)
            {
                head->next = node;
            }
            Node* prev_node = tail;
            tail = node;
            tail->prev = prev_node;
            prev_node->next = tail;
        }
        else
        {
            head = node;
            tail = node;
        }
        m_dwsize++;
    }
public:
    void testshow()
    {
        Node* current_node = head;
        while (current_node)
        {
            std::cout << current_node->data << std::endl;
            current_node = current_node->next;
        }
        std::cout << "size is " << m_dwsize << std::endl;
    }
};

#endif
/*
X X
*/