链表系列三：操作单链表

template<class T>
void swap(myList<T> list, ListNode<T>* node1, ListNode<T>* node2)
{
    if(node1 == node2)
        return;
    if(node1->next == node2)
    {
        ListNode<T>* prev = list.FindPrev(node1);
        node1->next = node2->next;
        node2->next = node1;
        prev->next = node2;
    }
    else if(node2->next == node1)
    {
        ListNode<T>* prev = list.FindPrev(node2);
        node2->next = node1->next;
        node1->next = node2;
        prev->next = node1;
    }
    else
    {
        ListNode<T>* prev1 = list.FindPrev(node1);
        ListNode<T>* prev2 = list.FindPrev(node2);
        ListNode<T>* temp = node1->next;
        node1->next = node2->next;
        node2->next = temp;
        prev1->next = node2;
        prev2->next = node1;
    }
}

（1）找出单链表倒数第k个元素

笨方法：先遍历整个单链表获得链表的长度n，然后再遍历第二次获得链表的第n-(k-1)个元素即得到单链表的倒数第k个元素，这样一来就需要遍历两次链表。

改进的方法：遍历一次单链表，单在一次遍历中使用两个指针，其差距为k，这样一来当第一个指针达到最后一个元素时，第二个指针就刚好指向倒数第k个元素，具体的实现如下：

template<class T>
ListNode<T>* FindKthNode(myList<T> list, int k)
{
    ListNode<T>* ptr1 = list.head;
    ListNode<T>* ptr2 = list.head;

    for(int i = 0; i < k; i++)
    {
        ptr1 = ptr1->next;
        if(ptr1 == NULL)
            return NULL;
    }

    while(ptr1 != NULL)
    {
        ptr1 = ptr1->next;
        ptr2 = ptr2->next;
    }
    return ptr2;
}

 （2）单链表反转

单链表反转就是将每一个结点中指向下一个元素的指针改为指向下一个元素，最后头结点指向原链表中最后一个结点。

template<class T>
void ReverseList(myList<T> list)
{
    if(list.isEmpty())
        return;

    //只有一个结点时不需要反转
    if(list.head->next->next != NULL)
    {
        ListNode<T>* prev = list.head->next;
        ListNode<T>* curr = prev->next;
        ListNode<T>* pnext = NULL;
        prev->next = NULL;

        while(curr->next != NULL)
        {
            pnext = curr->next;
            curr->next = prev;

            prev = curr;
            curr = pnext;
        }
        curr->next = prev;
        list.head->next = curr;
    }
}

还可以减少局部变量，用更简单的方法实现：

void reverse(test* head)
{
test* pe = head;
test* ps = head->next;
while(ps)
{ 
pe->next = ps->next;
ps->next = head;
head = ps;
ps = pe->next;
}
}

（3）从头到尾输出单链表

对此问题，有两种比较直接的方法：反转单链表和压栈。反转单链表使得原来的单链表发生了改变，操作比较多；压栈需要额外的维护栈操作。一个至少在代码量少比较简洁的方法是利用递归：

template<class T>
void ReversePrintRecu(ListNode<T>* node)
{
    if(node->next != NULL)
    {
        ReversePrintRecu(node->next);
    }
    cout<<node->data<<endl;
}

template<class T>
void ReversePrint(myList<T> list)
{
    if(!list.isEmpty())
    {
        ListNode<T>* node = list.head->next;
        ReversePrintRecu(node);
    }
}

引申：如果要求定义一个函数不适用任何变量求一个字符串的长度，那么也可以使用递归的方式实现：

int RecuStrLength(char* str)
{
    return ((*str) != '' ? 1 + RecuStrLength(++str) : 0);
}

 （4）寻找单链表的中间结点

如果链表的长度已知，那么只需要遍历一半的结点就找到了中间结点。在长度未知的情况下，可以通过两个指针来避免两次遍历链表：第一个指针一次走两步，第二个指针则一次走一步，分别称为快指针和慢指针，那么当快指针遍历到最后一个结点时，慢指针刚好遍历到中间结点：

template<class T>
void FindMidNode(myList<T> list)
{
    if(!list.isEmpty())
    {
        ListNode<T>* ptr1 = list.head->next;
        ListNode<T>* ptr2 = list.head->next;
        while(ptr1->next != NULL && ptr1->next->next != NULL)
        {
            ptr1 = ptr1->next->next;
            ptr2 = ptr2->next;
        }

        if(ptr1->next != NULL)//偶数个结点 中间结点有两个
        {
            ptr2->PrintNode();
            ptr2->next->PrintNode();
        }
        else //奇数个结点 中间结点有一个
            ptr2->PrintNode();
    }
}

 （5）单链表排序

a. 冒泡排序：比较相邻两个结点的数据大小，小的往上冒，大的往下沉，一趟比较下来，会有一个大的数据沉到正确的位置，若链表长度为n，那么n-1趟下来后各个元素都会在正确的位置。由于链表不能像数组那样可以随机访问，所以每一趟的比较都是n-1次，总共的比较次数为(n-1)*(n-1):

template<class T>
void BubbleSort(myList<T> list)
{
    if(!list.isEmpty())
    {        
        ListNode<T>* curr = list.head->next;
        ListNode<T>* node = list.head->next->next;
        for(; node != NULL; node = node->next)
        {
            for(curr = list.head->next; curr->next != NULL; curr = curr->next)
            {
                if(curr->data > curr->next->data)
                {
                    T temp = curr->next->data;
                    curr->next->data = curr->data;
                    curr->data = temp;
                }
            }
        }
    }
}

（6）交换单链表中的任意两个结点

交换单链表中的任意两个结点需要修改两个结点前驱结点的指针以及它们自身的指针，但是如果两个结点为相邻结点则需要特殊处理：

template<class T>
void swap(myList<T> list, ListNode<T>* node1, ListNode<T>* node2)
{
    if(node1 == node2)
        return;
    if(node1->next == node2)
    {
        ListNode<T>* prev = list.FindPrev(node1);
        node1->next = node2->next;
        node2->next = node1;
        prev->next = node2;
    }
    else if(node2->next == node1)
    {
        ListNode<T>* prev = list.FindPrev(node2);
        node2->next = node1->next;
        node1->next = node2;
        prev->next = node1;
    }
    else
    {
        ListNode<T>* prev1 = list.FindPrev(node1);
        ListNode<T>* prev2 = list.FindPrev(node2);
        ListNode<T>* temp = node1->next;
        node1->next = node2->next;
        node2->next = temp;
        prev1->next = node2;
        prev2->next = node1;
    }
}