反转单向链表

上次做查找单向链表的倒数第K个元素的时候还直接把这种反转单向链表的方案干掉了，就是嫌麻烦，结果报应不爽，还是要反转。罢了罢了，还是做做吧。

首先，我们需要先想通怎么反转一个单向链表。这个画图非我所长，草稿实在难看，所以反转的核心代码如下:

Node *p = pHead;
Node *p_next = p->next;
p->next = NULL;
while(q)
{
    Node *p_next_next = p_next->next;
    p_next->next = p;
    p = p_next;
    p_next = p_next_next;
}
pHead = p;

相信大家都能看懂，实在代码不好理解的话请一定要在草稿纸上画一下。我把整个程序的代码都贴在下面：

#include <iostream>
using namespace std;

template <typename T>
class List
{
private:
    struct Node
    {
        T val;
        Node *next;
        Node(T const& data) : val(data), next(NULL) {}
    };
    Node *pHead;
public:
    List(T const *arr,int n) : pHead(NULL)
    {
        for(size_t i = 0; i < n; ++i)
        {
            push_back(*(arr+i));
        }
    }
    void push_back(T const& data)
    {
        Node *node = new Node(data);
        if(pHead == NULL)
        {
            pHead = node;
            return ;
        }
        Node *p = pHead;
        while(p->next) p = p->next;
        p->next = node;
    }
    void rotate_list()
    {
        if(pHead == NULL) return ;
        Node *p = pHead;
        Node *p_next = p->next;
        p->next = NULL;
        while(q)
        {
            Node *p_next_next = p_next->next;
            p_next->next = p;
            p = p_next;
            p_next = p_next_next;
        }
        pHead = p;
    }
    friend ostream& operator<<(ostream& os, List const& myList)
    {
        List::Node *p = myList.pHead;
        while(p)
        {
            os << p->val << ' ';
            p = p->next;
        }
        return os;
    }
};
int main()
{
    char arr[10] = "abcdefghi";
    arr[9] = 'j';
    List<char> myList(arr,sizeof(arr)/sizeof(char));
    myList.rotate_list();
    cout << myList << endl;
    return 0;
}