手写单链表-并实现单链表元素逆置

数组作为数据存储有一定的缺陷，在无序数组中，搜索是低效的；在有序数组中，插入效率低，不管在哪一种数组中，删除效率都很低，数组创建后它的大小是不可改变的。

链表：在内存中不是连续的，添加删除效率高，不支持高效随机访问
自己手写单链表 实现 链表元素逆制

元素逆制：

    // 逆置
    public void inverse1() {

        // 判断个数 如果size 是0 或者1 不需要逆置
        if (size == 0 || size == 1) {
            return;
        }
        if (size == 2) {
            // 2个首尾逆置
            Node<E> temp = first;
            first = last;
            last = temp;
            first.next = last;
            last.next = null;

            return;
        } else {
            // 如果大于2数
            Node<E> node0 = null;
            Node<E> tempLast = null;// 尾部节点
            int tempsize = size;
            for (int i = 0; i < tempsize; i++) {

                if (i == 0) {
                    node0 = findNodeByIndex(0);
                    remove(0);
                    tempLast = node0;
                    tempLast.next = null;
                } else {
                    Node<E> node = findNodeByIndex(0);
                    remove(0);
                    node.next = node0;
                    node0 = node;

                }

            }
            first = node0;
            last = tempLast;
            size = tempsize;
        }
    }

单链表实现：增删改查

public class SingleLinkedList<E> {

    private Node<E> first;// 首部节点
    private Node<E> last;// 尾部节点
    int size;// 容量大小

    // 添加一个数据在数据链表 尾部
    public boolean add(E e) {

        LinkedLast(e);
        return true;

    }

    // 在链最后端添加节点
    private void LinkedLast(E e) {
        Node<E> data = new Node<E>(e, null);

        if (size == 0) {
            // 如果添加第一个

            this.first = data;
            this.last = data;
        } else {
            // 依次往后添加
            this.last.next = data;
            this.last = data;// 设置最后一个节点
        }

        size++;
    }

    // 随机添加一个数据
    public boolean add(int index, E e) {
        // 判断插入位置错误
        if (index < 0 || index > size) {
            return false;
        }
        // 如果插入的位置是最后一个
        if (index == size) {
            LinkedLast(e);

            return true;
            // 如果插入的位置是第一个
        } else if (index == 0) {

            Node<E> data = new Node<E>(e, this.first);

            this.first = data;
            size++;
            return true;
        } else {
            // 插入位置为链表中间位置
            // 第一步查找到要插入位置的数据
            Node<E> fiNode = findNodeByIndex(index - 1);
            // 第二步 中间插入数据
            Node<E> data = new Node<E>(e, fiNode.next);
            fiNode.next = data;
            size++;
            return true;
        }

    }

    // 查找指定位置的Node
    private Node<E> findNodeByIndex(int index) {
        if (index < 0 || index > size) {
            return null;
        }

        Node<E> target = this.first;
        for (int i = 0; i < index; i++) {
            target = target.next;
        }
        return target;

    };

    // 删除随机数据
    public boolean remove(int index) {

        if (index < 0 || index >= size) {
            return false;
        }

        if (index == 0) {
            // 当删除第一个数据时

            first = first.next;

            size--;
        } else {
            // 获取删除node 的前一个节点
            Node<E> pre = findNodeByIndex(index - 1);
            // 获取节点后一个节点
            Node<E> target = pre.next;
            // 将前一个节点的next 指向下后一个节点
            pre.next = target.next;
            // 删除当前节点
            if (!target.hasNext()) {
                // 删除的就是最后一个节点
                last = pre;
            }
            target = null;
            size--;
        }

        return true;

    }

    public E find(int index) {
        if (index < 0 || index > size) {
            return null;
        }
        return findNodeByIndex(index).item;
    }

    // 设置第一个first
    public void setFirst(E e) {
        add(0, e);
    }

    public void setLast(E e) {
        add(size, e);
    }

    boolean hasNext(Node node) {

        if (node.next != null) {
            return true;
        }
        return false;
    };

    // 打印single Linked list 数据 优化查找 带来的多次循环
    @Override
    public String toString() {

        Node<E> eNode = first;
        StringBuffer sbBuffer = new StringBuffer();

        if (size == 0) {
            sbBuffer.append("没有数据");

        } else {

            for (int i = 0; i < size; i++) {

                sbBuffer.append(i + "--->" + eNode.item + " \t");

                if (eNode.hasNext()) {
                    eNode = eNode.next;
                }
            }

        }

        // for (int i = 0; i < size; i++) {
        // System.out.print(i + "--->" + findNodeByIndex(i).item + " \t");
        // }

        return sbBuffer.toString();
    }

    // 逆置
    public void inverse() {

        // 判断个数 如果size 是0 或者1 不需要逆置

        if (size == 0 || size == 1) {
            return;
        }

        // 替换item
        for (int i = 0; i < size / 2; i++) {
            Node<E> node1 = findNodeByIndex(i);
            Node<E> node2 = findNodeByIndex(size - 1 - i);
            E e = node1.item;
            node1.item = node2.item;
            node2.item = e;

        }
        //

    }

    // 逆置
    public void inverse1() {

        // 判断个数 如果size 是0 或者1 不需要逆置
        if (size == 0 || size == 1) {
            return;
        }
        if (size == 2) {
            // 2个首尾逆置
            Node<E> temp = first;
            first = last;
            last = temp;
            first.next = last;
            last.next = null;

            return;
        } else {
            // 如果大于2数
            Node<E> node0 = null;
            Node<E> tempLast = null;// 尾部节点
            int tempsize = size;
            for (int i = 0; i < tempsize; i++) {

                if (i == 0) {
                    node0 = findNodeByIndex(0);
                    remove(0);
                    tempLast = node0;
                    tempLast.next = null;
                } else {
                    Node<E> node = findNodeByIndex(0);
                    remove(0);
                    node.next = node0;
                    node0 = node;

                }

            }
            first = node0;
            last = tempLast;
            size = tempsize;
        }
    }

    private static class Node<E> {
        E item;
        Node<E> next;

        public Node(E e, Node<E> next) {
            this.item = e;
            this.next = next;
        }

        boolean hasNext() {

            if (next != null) {
                return true;
            }
            return false;
        };
    }
}