编程导航算法通关村（一） | 链表基本操作

单链表

注意

• 一个单链表（Node）是值+节点（指针，链接后面的节点）构成

• 单链表无论什么操作都要从头向后逐个访问，所以表头很重要！切记不要直接操作表头

插入

插入操作要考虑三种情况：头部、中部、尾部

• 头部（head==null就是空链表，直接head=newNode）

  1. newNode.next=head

  2. head=newNode

• 中部

  1. 单链表无法访问前节点，所以要在插入位置的前一个节点停下（比如A、B中间插入C）

  2. 要先链接后面的节点（C➡B）（newNode.next = node(A).next），再连接前面（A➡C）（node(A).next = newNode）。顺序乱了就链接不到后节点了

• 尾部

  • 将尾结点指向新结点就行

删除

• 头部

  • head = head.next

• 中部

  • 找到要删除的前驱节点，node.next = node.next.next即可

• 尾部

  • 找到要删除的前驱节点，node.next = null即可

双向链表

注意

• 双向链表是值+前节点+后节点构成

• 控制好头节点和尾节点的操作！

插入

• 头部（head==null，则将头尾节点赋给newNode）

  newNode.next = head;
  head.prev = newNode;
  head = newNode;

• 中部

  • 遍历到插入位置的前一个节点，注意节点衔接顺序。（比如A、B中间插入C）

    1. B.pre=C

    2. C.next=B

    3. A.next=B

    4. B.pre=A

  • preNode.next.prev = newNode;
    newNode.next = preNode.next;
    preNode.next = newNode;
    newNode.prev = preNode;

• 尾部

  last.next = newNode;
  newNode.prev = last;
  last = newNode;

双向链表代码示例：

package chapter01_linkList;

public class DoublyLinkedList {
    private Node head;
    private Node last;

    public static void main(String[] args) {
        DoublyLinkedList doublyLinkedList = new DoublyLinkedList();
        doublyLinkedList.insert("a", 0);
        doublyLinkedList.insert("b", 1);
        doublyLinkedList.insert("c", 2);
        doublyLinkedList.insert("d", 3);
        doublyLinkedList.insert("e", 4);
        doublyLinkedList.insertFirst("head");
        doublyLinkedList.insertLast("last");
        System.out.println("前序输出："+doublyLinkedList.headOutPut());
        System.out.println("后序输出："+doublyLinkedList.lastOutPut());
        System.out.println("------------------------删除后------------------------");
        doublyLinkedList.removeByValue("head");
        doublyLinkedList.removeByValue("d");
        doublyLinkedList.removeByValue("last");
        System.out.println("前序输出："+doublyLinkedList.headOutPut());
        System.out.println("后序输出："+doublyLinkedList.lastOutPut());
    }
    /**
     * 插入头部
     * @param data
     * @return
     * @throws Exception
     */
    public Node insertFirst(Object data){
        if (data == null) {
            throw new RuntimeException("插入值不能为空！");
        }
        Node newNode = new Node(data);
        if (head == null){
            head = newNode;
            last = newNode;
        }else {
            newNode.next = head;
            head.prev = newNode;
            head = newNode;
        }
        return head;
    }

    /**
     * 插入尾部
     * @param data
     * @return
     */
    public Node insertLast(Object data) {
        if (data == null) {
            throw new RuntimeException("插入值不能为空！");
        }
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            last = newNode;
        }else {
            last.next = newNode;
            newNode.prev = last;
            last = newNode;
        }
        return head;
    }

    /**
     * 插入
     * @param data 值
     * @param index 位置
     * @return
     * @throws Exception
     */
    public Node insert(Object data, int index) {
        int size = getSize();
        if (data == null || size < index || index < 0) {
            throw new RuntimeException("输入参数有误！");
        }
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            last = newNode;
        } else if (index == 0) {
            newNode.next = head;
            head.prev = newNode;
            head = newNode;
        } else if (size == index){
            last.next = newNode;
            newNode.prev = last;
            last = newNode;
        }else {
            Node preNode = head;
            //遍历到插入位置的前一个
            for (int i = 0; i < index - 1; i++) {
                preNode = preNode.next;
            }
            preNode.next.prev = newNode;
            newNode.next = preNode.next;
            preNode.next = newNode;
            newNode.prev = preNode;
        }
        return head;
    }

    /**
     * 根据值删除节点
     * @param data
     * @return
     */
    public Node removeByValue(Object data) {
        Node node = head;
        if (node == null || data == null) {
            throw new RuntimeException("输入不能为空&表中无数据！");
        }
        //遍历拿到传入值所在节点
        while (node.data != data) {
            node = node.next;
        }
        if (node == null) {
            throw new RuntimeException("节点不存在");
        }
        if (node == head) {
            head =node.next;
            node.next.prev = null;
        }else if (node == last) {
            last = node.prev;
            node.prev.next = null;
        }else {
            node.next.prev = node.prev;
            node.prev.next = node.next;
        }
        return head;
    }

    /**
     * 获取链表长度
     * @return
     */
    public int getSize(){
        Node node = head;
        int count = 0;
        while (node != null) {
            count++;
            node = node.next;
        }
        return count;
    }
    /**
     * 正序输出
     */
    public String headOutPut() {
        StringBuilder sb = new StringBuilder();
        Node node = head;
        while (node != null) {
            sb.append(node.data).append("\t");
            node = node.next;
        }
        return sb.toString();
    }

    /**
     * 倒序输出
     */
    public String lastOutPut() {
        StringBuilder sb = new StringBuilder();
        Node node = last;
        while (node != null) {
            sb.append(node.data).append("\t");
            node = node.prev;
        }
        return sb.toString();
    }
    /**
     * 双向链表
     */
    class Node {
        public Object data;
        public Node next;
        public Node prev;

        public Node(Object data) {
            this.data = data;
        }
    }
}