单链表

什么是单链表

单链表是一种莲链式存取的数据结构，用一组地址任意的存储单元存放线性的数据元素。其单个存储节点单元是由当前单元的值与下一个节点的位置组成的，所以一个单链表的节点可以如下表示。

class ListNode {
    private Integer value;
    private ListNode nextNode;
}

单链表的特性

1. 存储空间不连续
2. 长度不确定

优点

1. 指定指点下的插入和删除比较方便，只要改变指定节点的下一个指针指向就可以了

缺点

1. 查找不方便，查找节点需要遍历单链表，时间复杂度为o(n)

单链表的考察点

删除单链表的节点

    ListNode delete(ListNode head, ListNode node){
        if (head==null){
            return null;
        }
        ListNode current = head;
        if (node==head){
            head= head.nextNode;
            return head;
        }else if (node.nextNode==null){
            while (head.nextNode!=node){
                head = head.nextNode;
            }
            head.nextNode = null;
        }else {
            node.value = node.nextNode.value;
            node.nextNode = node.nextNode.nextNode;
        }
        return current;
    }

从尾到头打印链表

1. 用递归实现

void reversePrint(ListNode head){
        if (head==null){
            System.out.println((Object) null);
        }else {
            if (head.nextNode!=null){
                reversePrint(head.nextNode);
            }
            System.out.println(head.value);
        }
    }

2. 用栈实现

 void reversePrintByStack(ListNode head){
        Stack<Integer> stack = new Stack<Integer>();
        if (head!=null){
            stack.push(head.value);
            while (head.nextNode!=null){
                head = head.nextNode;
                stack.push(head.value);
            }
        }
        while (!stack.isEmpty()){
            System.out.println(stack.pop());
        }
    }

链表中倒数k个节点

     ListNode FindKthToTail(int k,ListNode head){
        if (k<1||head==null){
            return null;
        }
        int n = 1;
        ListNode n1 = head;
        ListNode n2 = head;
        while (n!=k){
            if (n1.nextNode!=null){
                n1 = n1.nextNode;
                n++;
            }else {
                return null;
            }

        }
        while (n1.nextNode!=null){
            n2 = n2.nextNode;
            n1 = n1.nextNode;
        }
        return n2;
    }

反转单链表

1. 使用迭代法

 ListNode reverse(ListNode head){
        if (head==null){
            return null;
        }
        ListNode now = head;
        ListNode pre = null;
        while (now!=null){
            ListNode next = now.nextNode;
            now.nextNode = pre;
            pre = now;
            now = next;
        }
        return pre;
    }

2. 使用递归

ListNode reverse2(ListNode head){
        if (head == null){
            return null;
        }
        if (head.nextNode!=null){
            ListNode next = head.nextNode;
            head.nextNode = null;
            ListNode pre = reverse2(next);
            next.nextNode = head;
            return pre;
        }else {
            return head;
        }
    }

合并两个排序的链表

ListNode merge(ListNode head1,ListNode head2){
        ListNode head = null;
        if (head1==null){
            return head2;
        }
        if (head2==null){
            return head1;
        }

        if (head1.value <= head2.value){
            head = head1;
            head.nextNode = merge(head1.nextNode,head2);

        }else {
            head = head2;
            head.nextNode = merge(head1,head2.nextNode);

        }
        return head;
    }

6. 两个链表的第一个公共节点