在时间复杂度为O(1)、空间复杂度为O(1)的情况下，删除单向链表中节点。

大众思维：找到给出要删除节点的前一个节点，将前一个节点指向要删除节点的下一个节点，再释放删除节点的空间。但是，时间复杂度O(n),空间复杂度O(1)。

逆向思维：将给出的待删除节点指向待删除节点的下一个的下一个节点，并将下一个节点中的数据复制到待删除节点中，再释放待删除节点的下一个节点。变相的等于删除了待删除节点的下一个节点。满足时间复杂度和空间复杂度。

代码如下：

//Node Class

package LinkList;

public class Node {
    public int val;
    public Node next;
    
    public Node() {
        // TODO Auto-generated constructor stub
        this.val = new Integer(-1);
        this.next = null;
    }
    
}

//main
package LinkList;

import org.omg.CORBA.FREE_MEM;

public class DeleteNode {
    public void deleteNode(Node deleteNode) {
        deleteNode.val = deleteNode.next.val;
        deleteNode.next = deleteNode.next.next;
        //释放多余节点
        
    }
    public static void main(String[] args) {
        Node node[];
        node = new Node[10];
        for (int i = 0; i < node.length; i++) {
            node[i] = new Node();
        }
        for(int i=0;i<9;i++){
            node[i].val = i;
            node[i].next = node[i+1];
        }
        node[9].next = node[7];
        node[9].val = 9;
        
        for (int i = 0; i < node.length; i++) {
                System.out.println(node[i].val + ":" + node[i].next.val);
        }
        
        new DeleteNode().deleteNode(node[7]);
        
        for (int i = 0; i < node.length; i++) {
            System.out.println(node[i].val + ":" + node[i].next.val);
        }
        
    }
}