题目：给定单向链表的头指针和一个结点指针，定义一个函数在O(1)时间删除该结点。

思路：如果按常规思路来
删除一个结点需要找到该结点的前一个结点，将这个节点的_next指向被删除节点的 _next,找到这个该结点的前一个结点就需要遍历链表，此时就不是O(1)时间。
删除结点我们不需要找到前一个结点，我们可以很方便的找到后一个节点，我们可以把后一个节点的值给前一个结点，删除后一个结点。
但是，如果我们删除的是尾结点呢？我们必须遍历链表了。
还需要考虑如果链表只有一个节点的问题。删除结点之后，需要把链表头结点置为空。

时间复杂度：1. O(n) 2. [(n-1 )*O(1)+O(n)]/n

但是是否要判断链表是否有这一删除的结点呢？
判断了时间复杂度又要加O(n)。

代码如下：

template<class T>
struct ListNode
{
    T _value;
    ListNode<T>* _next;

    ListNode(const T& value)
        :_value(value),_next(NULL)
    {}
};

template<class T>
class List
{
public:
    List()
        :_head(NULL)
    {}
    bool PushBack();
   bool DelListNode(ListNode<T>* node)//在O(1)时间删除链表节点 head mid tail
    {
        if(_head == NULL)
            return false;

        if(node == NULL)
        {
            cout<<"该节点不存在"<<endl;
            return false;
        }
        if(_head == node)//head
        {
            if(_head->_next == NULL)
            {
                delete _head;
                return true;
            }
            else
            {
                ListNode<T>* del = _head;
                _head = _head->_next;
                delete del;
                return true;
            }
        }
        else if(node->_next == NULL)//tail
        {
            ListNode<T>* node = _head;
            ListNode<T>* prev = NULL;
            while(node->_next != NULL)
            {
                prev = node;
                node = node->_next;
            }
            delete node;
            prev->_next = NULL;
            return true;
        }
        else//mid
        {
            ListNode<T>* del = node->_next;
            node->_value = del->_value;
            if(del->_next == NULL)
            {
                delete del;
                node->_next = NULL;
            }
            else
            {
                node->_next = del->_next;
                delete del;
            }
            return true;
        }
    }
private:
    ListNode<T>* _head;
};