LeetCode | 707. lista de diseños

Implementar la lista de diseño. Usted puede optar por utilizar una lista única o doble ligado. de un solo nodo en la lista debe tener dos propiedades: valy next. valEs el valor actual del nodo, nextes un puntero que apunta al siguiente nodo / referencia. Para utilizar una lista doblemente enlazada, también se requiere un atributo prevpara indicar un nodo en la lista enlazada. Suponiendo que todos los nodos de la lista están 0-indexen.

La implementación de estas características en la clase de lista:

get(index): Obtiene el valor de la lista de nodos de índice. Si el índice no es válido, se devuelve -1.
addAtHead(val): Adición de un valor antes de que el primer elemento de una lista enlazada valde nodos. Después de la inserción, el nuevo nodo será el primer nodo de la lista.
addAtTail(val): El nodo a val adjuntas al último elemento de la lista.
addAtIndex(index,val): Adición de valor antes de la lista de índices primer nodo de enlaces valnodos. Si el índice es igual a la longitud de la lista, a continuación, el nodo se añade al final de la lista. Si el índice es mayor que la longitud de la lista, no se insertará el nodo. Si el índice es menor que 0, entonces el nodo se inserta en la cabeza.
deleteAtIndex(index): Si el índice de índice es válido, borrar la lista de nodos de índice.

Ejemplo:

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

consejos:

• Todos los valvalores están en el $ [1, 1000] de $.
• El número de operaciones en los $ [1, 1000] $ dentro.
• No utilizar el incorporado en la LinkedListbiblioteca.

Código

struct myListNode
{
    int val;
    myListNode* next;
    myListNode() :val(-1), next(nullptr) {}
};


class MyLinkedList {
public:
    int m_size;
    myListNode* m_head;
    myListNode* m_tail;
    
public:
    /** Initialize your data structure here. */
    MyLinkedList() :m_size(0)
    {
        m_head = new myListNode();
    }

    /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
    int get(int index)
    {
        if (index > m_size - 1 || index < 0)
        {
            return -1;
        }
        myListNode* p = m_head->next;
        while (index != 0)
        {
            p = p->next;
            --index;
        }
        //std::cout << p->val;
        return p->val;
    }

    /** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
    void addAtHead(int val)
    {
        myListNode* newNode = new myListNode();
        newNode->next = m_head->next;
        m_head->next = newNode;
        newNode->val = val;
        m_size += 1;
    }

    /** Append a node of value val to the last element of the linked list. */
    void addAtTail(int val)
    {
        myListNode* lastNode = new myListNode();
        lastNode->val = val;
        myListNode* p = m_head;
        int len = m_size;
        while (len != 0)
        {
            p = p->next;
            --len;
        }
        p->next = lastNode;
        lastNode->next = NULL;
        m_size += 1;
    }

    /** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
    void addAtIndex(int index, int val)
    {
        if (index > m_size) return;
        if (index == m_size)
        {
            addAtTail(val);
            return;
        }
        if (index < 0)
        {
            addAtHead(val);
            return;
        }
        myListNode* newNode = new myListNode();
        myListNode* p = m_head;
        while (index != 0)
        {
            p = p->next;
            --index;
        }
        newNode->next = p->next;
        p->next = newNode;
        newNode->val = val;
        m_size += 1;
    }

    /** Delete the index-th node in the linked list, if the index is valid. */
    void deleteAtIndex(int index)
    {
        if (index > m_size - 1 || index < 0) return;
        myListNode* p = m_head;
        while (index != 0)
        {
            p = p->next;
            --index;
        }
        myListNode* delNode = p->next;;
        p->next = p->next->next;
        m_size -= 1;
        delete delNode;
    }
};