数据结构(3)-从零开始实现一个java链表

数据集合是编程中常用的逻辑，链表是在数据结构中经常被用到和考察，JDK util 包中提供了Queue 接口，
LinkedList、LinkedHashSet、LinkedHashMap<K,V>实现。
显而易见，linkedHashSet 是以LinkedHashMap<K,V> 为基础来实现的。

 /**
     * Constructs a new, empty linked hash set.  (This package private
     * constructor is only used by LinkedHashSet.) The backing
     * HashMap instance is a LinkedHashMap with the specified initial
     * capacity and the specified load factor.
     *
     * @param      initialCapacity   the initial capacity of the hash map
     * @param      loadFactor        the load factor of the hash map
     * @param      dummy             ignored (distinguishes this
     *             constructor from other int, float constructor.)
     * @throws     IllegalArgumentException if the initial capacity is less
     *             than zero, or if the load factor is nonpositive
     */
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

之前在做数据采集的时候，自己动手写了一个采集程序，虽然过程曲折，但对于后期对于开源爬虫的使用很有帮助，当你自己实现了一个算法，简单引擎，再去看同类就有一种俯视的视角， 不要迷信权威 ，毕竟计算机行业发展还处于起步阶段。

什么是链表

接下来 先大概说一下链表，链表顾名思义，是由一个一个节点组成的一个数据链 ，前一个节点next 指向后一个节点，遍历的时候，根据头节点顺序找到尾节点。
链表示意图：

链表的实现在不同开发语言中细节不同 (),但链表的定义有一个通用的标准，引用《算法导论》中的定义

链表 linked list 是一种这样的数据结构， 其中的各对象an线性顺序排列，数组的线性顺序是由数组的下标决定，然而与数组不同的是，链表的顺序是由各个对象的指针决定的，链表为动态集合提供一种简单而灵活的表示方法。

支持 insert 、delete、pop 常用操作方法

链表节点

链表节点 首先能保存数据，这里简单选择了object 对象

然后节点中需要指向另一个节点

class Node {


    private String name;

    private Object data;

    private Node next;


    public Node(String name, Object data, Node next) {
        this.name = name;
        this.data = data;
        this.next = next;
    }

    public boolean hasNext() {
        if (null == next) {
            return false;
        } else {
            return true;
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Object getData() {
        return data;
    }

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

    public Node getNext() {
        return next;
    }

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


}

这里我选择了inner class

链表的简单实现

public class LinkedList {

    /**
     * 头节点
     */
    private Node head;

    /**
     * 判断链表是否为空
     *
     * @return
     */

    private Boolean isEmpty() {
        if (null == head) {
            return true;
        } else {
            return false;
        }

    }

    /**
     * 获取头节点
     *
     * @return
     */
    public Object getHead() {
        if (null == head) {
            return null;
        } else {
            return head.getData();
        }

    }

    /**
     * 增加节点
     */
    public boolean insertData(Object data) {

        if (isEmpty()) {
            head = new Node("first", data, null);
        } else {
            Node temp=head;
            while (temp.hasNext()) {
                temp = temp.getNext();
            }
            temp.setNext(new Node("last", data, null));
        }
        return true;

    }

    /**
     * 删除节点
     */

    public boolean deleteData(Object data) {

        if (isEmpty()) {
            return false;
        } else {
            /**
             * 如果是头节点 直接删除返回
             */
            if (head.getData() == data) {
                head = head.getNext();
                return true;
            } else {
                while (head.hasNext()) {
                    Node temp = head.getNext();
                    if (temp.getData() == data) {
                        head.setNext(temp.getNext());
                        break;
                    }
                }
                return true;
            }
        }


    }
}

链表翻转

链表翻转是一道常见的算法题目，比较简单

下班给出一种简单的解题思路：

链表由于只能指向后续节点，没有下标所以要遍历链表 截断，所有你需要 借用三个新的节点

起名为：
航行节点，用于遍历链表
head 节点 用户找到新的翻转节点
rail 节点 用户找到原来的节点

a->b->c->d

sail
head
tail

sail->a->b->c->d

head->a sial->b-c-d
tail=b
head->b->a sial-c-d

   Node fake = new Node("fake", 0, null);
        Node sail = new Node("sail", 0, d);
        while (sail.hasNext()) {
            Node temp = sail.getNext();
            sail.setNext(sail.getNext().getNext());
            if (fake.hasNext()) {
                temp.setNext(fake.getNext());
                fake.setNext(temp);
            } else {
                fake.setNext(temp);
                temp.setNext(null);
            }
        }

        while (fake.hasNext()) {
            System.out.println(fake.getNext().getData());
            fake = fake.getNext();
        }