单链表的方方面面

定义

• 采用链式存储结构表示的线性表称为线性链表

• 每个节点只有一个地址域线性表成为单链表 节点（数据域，地址域）

java表示单链表的节点类

public class Node<T> {
    private T data;//数据域
    private Node<T> next;//地址域存放的时下一个节点的引用

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Node<T> getNext() {
        return next;
    }

    public void setNext(Node<T> next) {
        this.next = next;
    }
}

单链表的遍历

private static void printNode(Node<Integer> head) {
        if (head == null){
            System.out.println("null");
            return;
        }
        while (head!=null){
            System.out.print(" "+head.getData());
            head= head.getNext();
        }
        System.out.println();
    }

单链表的查找

 private static Node getIndex(Node<Integer> head, int i) {
        for (int j = 0; j < i && head.getNext() != null; j++) {
            head = head.getNext();
        }
        return head;
 }

单链表的插入

private static Node insertIndex(Node<Integer> head, int i,Node<Integer> insertNode) {
        if (i<=0){
            insertNode.setNext(head);
            return insertNode;
        }
        Node<Integer> front = head;
        for (int j = 0; j < i-1 && front.getNext() != null; j++) {
            front = front.getNext();
        }
        insertNode.setNext(front.getNext());
        front.setNext(insertNode);
        return head;
    }

单链表的删除

 private static Node removeIndex(Node<Integer> head, int i) {
        if(i<=0){
            return head.getNext();
        }
        Node<Integer> front = head;
        Node<Integer> pre= head;
        for (int j = 0; j < i-1 && front.getNext() != null; j++) {
            pre =front;
            front = front.getNext();
        }
        pre.setNext(pre.getNext().getNext());
        return head;
}

单链表的反转

 /**
     * 递归反转
     * @param head
     * @return
     */
    public static Node<Integer> reverseRecur(Node<Integer> head) {
        if (head == null || head.getNext() == null) {
            return head;
        }
        Node reversedNode = reverseRecur(head.getNext());
        head.getNext().setNext(head);
        head.setNext(null);

        return reversedNode;
    }

    /**
     * 非递归反转
     * @param head
     * @return
     */
    public static Node<Integer> reverse(Node<Integer> head) {
        if (head == null) {
            return head;
        }
        Node<Integer> pre = head;
        Node<Integer> cur = head.getNext();
        Node<Integer> temp;
        while (cur != null) {
            temp = cur.getNext();
            cur.setNext(pre);
            pre = cur;
            cur = temp;
        }
        head.setNext(null);
        return pre;
    }