实现一个算法，删除单链表中间的某个结点，假定你只能访问该结点

直接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. }