重学数据结构 - 链表

链表的基本概念

最基本的动态数据结构，与数组，栈，队列依赖于静态数组封装而来的实现不同，链表底层实现了真正的动态数组。
链表一种线性的数据结构,通过指针将一个个零散的内存块连接起来,链表的每个内存块称为结点。

• 最简单的动态数据结构
• 链表更重要的作用（引用/指针） - 涉及到内存管理
• 有清晰的递归结构和性质

链表 Linked List

• 数据存储在节点中（Node）

	//一个Node节点中一般来说只包含两个属性
    class Node {
        //当前位置的实际数据
        E e;
        //指向下一个节点的引用，如果节点是最后一个，那么该节点的next值为NULL
        Node next;
    }

例如火车，每一节车厢都可以看成一个Node节点，中间的链接锁可以看成是next，如图所示

优点

• 真正的动态数据结构，不需要处理固定容量的问题

缺点

• 不能随机访问，数组通过索引访问，且在内存中开辟空间是连续分布的。但是链表是靠next链接，计算机底层每个节点所在内存的位置是不同的，只能依靠next去进行顺序查找。

实现一个简单的链表

实现一个链表的几个关键元素

• Node节点对象
• 头节点
• 链表长度

package com.yunhuxi.cloudeyes.util.data.structure.linked.list;

public class LinkedList<E> {

    //使用private保证节点只允许在链表内部访问，对于用户来说，不需要了解底层实现，不关注节点的实现细节，所以该类应该基于封装的思想进行隐藏。
    private class Node {
        public E e;
        public Node next;

        //构造方法，需要考虑多个情况对构造进行方法重载
        public Node() {
            this(null, null);
        }

        public Node(E e) {
            this(e, null);
        }

        public Node(E e, Node node) {
            this.e = e;
            this.next = node;
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    //定义头节点
    private Node head;

    //定义链表长度
    private int size;

    public LinkedList(){
        head = null;
        size = 0;
    }

    // 获取链表中的元素个数
    public int getSize(){
        return size;
    }

    // 返回链表是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    // 在链表头添加新的元素e
    public void addFirst(E e){
        add(0, e);
    }

    // 在链表的index位置添加新的元素e,如果是0，代表没有前节点
    public void add(int index, E e){

        if(index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Illegal index.");
        }

        if (index != 0) {
            Node prev = head;
            int i = 0 ;
            while (i < index - 1) {
                prev = prev.next;
                i++;
            }
            prev.next = new Node(e, prev.next);
            size ++;
        } else {
            addFirst(e);
        }
    }

    // 在链表末尾添加新的元素e
    public void addLast(E e){
        add(size, e);
    }
}

上面的代码存在问题

头插入的特殊处理

由于链表头部和在其他位置添加逻辑上会有差别，因为头部插入时要找到待添加前的一个节点，链表头并没有前面的节点。所以头插是比较特殊的。

统一处理这种特殊节点

目前的核心问题是链表头并没有前面的节点。那么是否可以添加一个虚拟的头节点来解决这个问题。

将链表头设置为null，不存储为任何元素，将这个节点称之为head node.

改后的代码

核心改动点就是在初始化head时，不再赋值为null而是初始化一个无参的node对象。

原代码

	public LinkedList(){
        head = null;
        size = 0;
    }

新代码

	public LinkedList(){
        //改动位置
        head = new Node();
        size = 0;
    }


	// 在链表的index位置添加新的元素e,如果是0，代表没有前节点
    public void add(int index, E e){

        if(index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Illegal index.");
        }

        //改动位置
        Node prev = head;
        int i = 0 ;
        while (i < index) {
            prev = prev.next;
            i++;
        }

        prev.next = new Node(e, prev.next);
        size ++;
    }

链表的查询

	// 获得链表的第index个位置的元素
    public E get(int index){
    
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Get failed. Illegal index.");
        }
     
		//由于这里是为了查询元素，所以应该从虚拟节点head的下一个实际数据的节点来开始查找，这是Node cur = head.next在这里的的原因
        Node cur = head.next;
        int i = 0 ;
        while (i < index) {
            cur = cur.next;
            i++;
        }
        return cur.e;
    }

	// 获得链表的第一个元素
    public E getFirst(){
        return get(0);
    }

    // 获得链表的最后一个元素
    public E getLast(){
        return get(size - 1);
    }
    
	// 查找链表中是包含元素
    public boolean contains(E e){
        Node cur = head.next;
        if (cur != null) {
            do {
                if (cur.e.equals(e)) {
                    return true;
                }
                cur = cur.next;
            } while (cur != null);
        }
        return false;
    }

链表的修改

 	// 修改链表的第index个位置的元素,
    public void set(int index, E e){
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Set failed. Illegal index.");
        }
		
		//这个位置需要不断遍历这个链表，查询是否包含元素，不包含返回false，包含返回true
        Node cur = head.next;
        int i = 0 ;
        while (i < index) {
            cur = cur.next;
            i++;
        }
        cur.e = e;
    }
    
	//重写toString，处理一下返回值格式
	@Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        Node cur = head.next ;
        while (cur != null) {
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL");
        return res.toString();
    }

链表的删除

	// 从链表中删除第一个元素, 返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

    // 从链表中删除最后一个元素, 返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }

    // 从链表中删除元素e
    public void removeElement(E e){
		
		//断开头节点
        Node prev = head;
        while(prev.next != null){
            if(prev.next.e.equals(e)) {
                break;
            }
            prev = prev.next;
        }
		
		//断开尾节点
        if(prev.next != null){
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size --;
        }
    }

链表的扩展性分析

使用链表实现一个栈

基于之前的Stack接口实现一个栈，可以去看前面的博客

package com.yunhuxi.cloudeyes.util.data.structure.linked.list;

import com.yunhuxi.cloudeyes.util.data.structure.stack.Stack;
import java.util.stream.IntStream;

public class LinkedListStack<E> implements Stack<E> {

    private LinkedList<E> list;

    public LinkedListStack(){
        list = new LinkedList<>();
    }

    @Override
    public int getSize(){
        return list.getSize();
    }

    @Override
    public boolean isEmpty(){
        return list.isEmpty();
    }

    @Override
    public void push(E e){
        list.addFirst(e);
    }

    @Override
    public E pop(){
        return list.removeFirst();
    }

    @Override
    public E peek(){
        return list.getFirst();
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Stack: top ");
        res.append(list);
        return res.toString();
    }

    public static void main(String[] args) {

        LinkedListStack<Integer> stack = new LinkedListStack<>();

        IntStream.range(0, 5).forEach(i -> {
            stack.push(i);
            System.out.println(stack);
        });

        stack.pop();
        System.out.println(stack);
    }
}