链表操作 -- 链表自身的处理问题

问题：

　　删除链表中的某个给定点。 

解答：

　　1）可以借助于节点的前一个节点来删除。

　　　　要花费O(n)的时间来查找节点的前继节点。时间复杂度O(n)，空间复杂度O(1).

　　2）将后一个节点的内容复制到本节点，然后删除后一个节点。时间复杂度O(1),空间复杂度O(1)

　　　　这样就省略了查找上一个节点的时间。注意要删除的节点为尾节点的情况！　　　　　　

Node* DelNode(Node* node,Node* head)
{
    if(node->next == NULL)//尾节点要特殊处理
    {
        while(head->next != node)
            head = head->next;

        head->next = NULL;
        return NULL;
    }else
    {
        *node = *(node->next);
        node->next = node->next->next;
        return node;
    }
}

问题：　　

　　单链表的区间反转（reverse）

　　题目：Swap Nodes in Pairs   Reverse Linked List II  

解答：　　

　　1）每次取得两个相邻的三个节点，反转前两个节点的指针，记录第三个节点。依次往后移动。

　　时间复杂度：O(n)     空间复杂度：O(1)　 

　　

//We reverse the node in (prev,end] { prev != end , end != NULL}
//When solving particular problems,
 //a guard head can be generated to eliminate special verdict for head node.
 void reverse(ListNode* prev,ListNode* end)
 {
    ListNode* l = prev->next;//A head for new reversed list
    ListNode* n = l->next;//Old remained list
    ListNode* nn;

    ListNode* nend = end->next;
    while(l != end)
    {
        nn = n->next;

        n->next = l;//n became the new head

        l = n;
        n = nn;
    }

    prev->next->next = nend;
    prev->next = end;
}

　　2)使用两个指针，一直指向最左端，一个指向最右端。交换两个指针指向对象的内容，之后左端指针右移，右端指针左移。

　　耗时操作在于右端指针移动时定位其前一节点的动作。  总体时间复杂度为：O(n²)；空间复杂度为：O(1)

　　

　　更新：　　

　　　　3)递归

　　　　4)一直插在新链表头部后面（头插法）

问题：

　　找出链表中的倒数第n个元素。

 　  类似题目：Remove Nth Node from End of List

解答：

　　更新：

　　0）使用递归回溯解决。

　　1）两个遍历解决。注意：n大于链表长度的情况。

　　时间复杂度：O(n)，空间复杂度：O(1)

　　如何一次遍历就解决问题？

　　2）使用连个指针【又是双指针！】。选择一个指针向前先走n步，然后两个指针同时移动。当先移动的指针到达链表尾部的时候，另一个指针就指在倒数第n个位置。

　　时间复杂度：O(n)，空间复杂度：O(1)

Node* find_backwark_n(Node* head,int n)
{
    if(n <= 0)
        return NULL;

    Node* frontNPtr = head;
    while(n-- && frontNPtr)//这里要注意一点：当最后退出时会判断到n==0,虽然此时会退出while循环，但是n--操作还是会执行，n的值变为了-1
        frontNPtr = frontNPtr->next;

    //对于n大于链表长度的情况我们返回NULL！
    //如果head == NULL的情况，也会在这里返回
    if(n >= 0)
        return NULL;

    Node* backNPtr = head;

    while(frontNPtr)
    {
        frontNPtr = frontNPtr->next;
        backNPtr = backNPtr->next;
    }

    return backNPtr;
}

　　3）借助一个数组来模拟的滑动窗口。窗口的大小为n，窗口在滑动的时候，剔除链表左端的元素，加入右端新元素。

　　这样当遍历完数组后，窗口中记录的链表中最左端元素即为所求。

　　时间复杂度：O(n)，空间复杂度：O(m)

Node* find_backwark_n(Node* head,int n)
{
    if(n <= 0 || head == NULL)
        return NULL;

    Node** window = new Node*[n];
    if(window==NULL)
        return NULL;

    Node* curr = head;
    int pos = 0;
    while(curr)
    {
        window[pos % n] = curr;

        pos++;
        curr = curr->next;
    }

    if(pos < n)
        return NULL;

    Node* res = window[pos % n];
    delete window;

    return res;
}

问题：

　　寻找链表的中间元素。

解答：

　　1）两次遍历。

　　2）快+慢指针。

　　寻找链表的中间元素，也就是寻找链表中位于1/2位置的元素。我们考虑下，寻找链表中1/n位置的元素。

　　此时仍用快慢指针来处理。只不过快指针每次向前移动n步。

　　时间复杂度：O(n)，空间复杂度：O(1)

Node* get_position(Node* node,int n)
{
    while(n-- && node)
        node = node->next;
    if(n >=0)
        return NULL;

    return node;
}
Node* find_Node(Node* head,int n)
{
    if(n <= 1)
        return NULL;

    Node* fast = get_position(head,n);
    if(fast == NULL)
        return NULL;

    Node* slow = head->next;
    while(fast = get_position(fast,n))
    {
        slow = slow->next;
    }

    return slow;
}

问题：

　　交换链表中”相邻“的节点。只能通过操作节点的next指针来实现。

　　题目：Leetcode -- Swap Nodes in Pairs

解答：

　　可以申请使用newHead节点来减少边界判断！

ListNode* swapPairs(ListNode *head)
{
    //可以通过使用一个新头来减少对左边界情况的判断
    ListNode newHead(0);
    ListNode* p = &newHead;
    p->next = head;

    //我们在代码中为新的nnext节点连向了nnnext节点
    //所以不需要处理只剩下单个节点的情况了。
    while(p->next && p->next->next)
    {
        ListNode* n = p->next;
        ListNode* nnn = p->next->next->next;

        p->next = p->next->next;
        p->next->next = n;
        p->next->next->next = nnn;

        p = p->next->next;
    }

    return newHead.next;
}

问题：

　　旋转链表n位。  题目： Leetcode -- Rotate List

解答：

　　遍历一遍后，将链表收尾相连，可以减少边界判断！

　　1）参考动态窗口的思路。注意窗口为1的情况需要特别处理。

    int get_length(ListNode* head)
    {
        int len = 0;
        while(head)
        {
            len++;
            head = head->next;
        }
        return len;
    }
    
    //使用k的数组存储后[k+1 ~ 2]个值
    //思路来自“寻找单链表中的倒数第n个数”
    ListNode *rotateRight(ListNode *head, int k)
    {
        if(head == NULL)
            return NULL;
    
        k = k % get_length(head);//在使用get_length之前，得确认链表是否为空
        if(k==0)
            return head;
    
        ListNode** window = new ListNode*[k];
    
        ListNode* curr = head;
        int pos = 0;
        while(curr->next)
        {
            window[pos % k] = curr;
            curr = curr->next;
            pos ++ ;
        }
    
        //倒数第k+1个节点被存储在window[pos % (k+1)]中
        //最后一个节点位于curr中
    
        curr->next = head;
        window[pos % k]->next = NULL;
        
        if(k == 1)
            return curr;
        else
            return window[(pos+1) % k];
    }

　　2）既然归根到底是定位的问题，当然可以用块+慢指针啦　　

//快+慢指针啦 ~
ListNode *rotateRight(ListNode *head, int k)
{
    if(head == NULL || k<=0)
        return head;

    ListNode* frontPtr = head;
    int pos = 0;
    while(pos < k)
    {
        pos++;
        frontPtr = frontPtr->next;
        if(frontPtr == NULL)
            break;
    }

    if(frontPtr == NULL)
        return rotateRight(head,k%pos);//可以通过先移动，后判断的方法来减少不必要的就按链表长度。

    ListNode* backPtr = head;
    while(frontPtr->next)
    {
        frontPtr = frontPtr->next;
        backPtr = backPtr->next;
    }//最终停止时，frontPtr指向最后一个节点，backPtr指向倒数第k+1个节点。

    frontPtr->next = head;

    head = backPtr->next;
    backPtr->next = NULL;

    return head;
}

问题：

　　Partition List

解答：

ListNode *partition(ListNode *head, int x)
{
    if(head == NULL || head->next == NULL)
        return head;

    ListNode lNode(0),* l;
    l = &lNode;

    ListNode ulNode(0),*ul;
    ul = &ulNode;

    ListNode* curr = head;
    while(curr)
    {
        if(curr->val < x)
        {
            l->next = curr;
            l = l->next;
        }else
        {
            ul->next = curr;
            ul = ul->next;
        }

        curr = curr->next;
    }

    l->next = ulNode.next;
    ul->next = NULL;//We need to assure the last elem of list point to NULL

    return lNode.next;
}

问题：

　　Reorder List

解答：

　　本问题可以思考为将原链表从中间拆为两份，reverse后一份链表后，重新合并。

　　

参考：

　　http://blog.csdn.net/huangxy10/article/category/1244320这位博友的链表专题

　　和别人的leetcode代码，在此致谢。