實現一個算法，刪除單鏈表中間的某個結點，假定你只能訪問該結點

直接free(p)，這樣行不通，由於咱們不能訪問其餘結點；

若是咱們只能訪問該結點，能夠嘗試將該結點的後繼結點的數據複製到當前結點，而後刪除後繼結點

 

1. public static boolean deleteNode (LinkListNode n) {  
2.     if( null == n || null == n.next ) return false;  
3.     LinkListNode next = n.next;  
4.     n.data = next.data;  
5.     n.next = next.next;  
6.     return true;  
7. }  

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Remove {
    public boolean removeNode(ListNode pNode) {
        // write code here
        if(pNode.next == null){
            return false;
        }else{
            pNode.val = pNode.next.val;
            pNode.next = pNode.next.next;
            return true;
        }
    }
}

可是這樣作有一個問題，若是咱們要刪除的是尾結點，這個算法就失效了，若是是尾結點，能夠考慮將這個結點置爲假的

 

題目：刪除帶頭結點的單鏈表L中的結點p，p不是最後一個結點，要求時間複雜度爲O(1)。

解題思路：
若是不要求時間複雜度爲O(1)，咱們能夠找出p的前驅結點，而後很容易就刪除p。

如今要求時間複雜度爲O(1)，由於p不是最後一個結點，知道結點p咱們能夠刪除p的後繼結點，那麼咱們能夠把p的後繼結點元素的值賦給p結點元素的值。

 

1. //單鏈表的結點類  
2. class LNode{  
3.     //爲了簡化訪問單鏈表,結點中的數據項的訪問權限都設爲public  
4.     public int data;  
5.     public LNode next;  
6. }  

 

1. public class LinkListUtli {  
2.     public static void deleteNode(LNode p)  
3.     {  
4.         if(p==null||p.next==null) return;//若是p爲空或爲單鏈表中最後一個結點不符合題意，直接返回  
5.         LNode q=p.next;//q爲p的後繼結點  
6.         p.data=q.data;  
7.         p.next=q.next;//從單鏈表中刪除結點q  
8.     }  
9. }  

拓展：若是刪除的結點p多是最後一個結點，怎麼辦。

解題思路：此時只能保證刪除結點的平均時間複雜度爲O(1)，當p不是最後一個結點，時時間複雜度爲O(1)，當p是最後一個結點時，時間複雜度爲O(n)。

算法實現：

 

1. public class LinkListUtli {  
2.     public static void deleteNode(LNode L,LNode p)  
3.     {  
4.         if(p==null||L==null) return;//若是p爲空或單鏈表L爲空不符合題意，直接返回  
5.         if(p.next != null) //若是p不是最後一個結點  
6.         {  
7.             LNode q=p.next;//q爲p的後繼結點  
8.             p.data=q.data;  
9.             p.next=q.next;//從單鏈表中刪除結點q  
10.         }  
11.         else //若是p是最後一個結點  
12.         {  
13.             LNode pre=L;//用pre表示p的前驅結點  
14.             while(pre.next != null) //保持pre有後繼結點  
15.             {  
16.                 if(pre.next==p)//若是pre是p的前驅結點  
17.                 {  
18.                     pre.next=p.next;//將結點p從單鏈表中刪除  
19.                 }  
20.             }  
21.         }  
22.           
23.     }  
24. }