存储int数据单链表的实现

单链表特点
1）链表是以结点的方式来存储
2）每个节点包含data域和next域，next域：指向下一个节点
3）链表的各个节点不一定是连续存放的
4）链表分带头节点的和不带头节点的，根据实际需求确定

package linkedlist;

/**
 * @author litianfu
 * @version 1.0
 * @email 1035869369@qq.com
 * @date 2020-03-25 18:10
 */
public class SingleLinkedList {
    public static void main(String[] args) {
        //创建节点
        IntegerNode i1 = new IntegerNode(1);
        IntegerNode i2 = new IntegerNode(2);
        IntegerNode i3 = new IntegerNode(3);
        IntegerNode i4 = new IntegerNode(4);
        IntegerNode i5 = new IntegerNode(5);
        IntegerNode i6 = new IntegerNode(99);

        //创建链表
        SingleLinkedList4IntegerNode list = new SingleLinkedList4IntegerNode();
        list.add(i1);
        list.add(i2);
        list.add(i3);
        list.add(i4);
        list.list();
        System.out.println("*****按指定位置插入数据******");
        list.add(2, i5);
        list.list();
        System.out.println("*****按指定位置修改数据******");
        list.update(2, 110);
        list.list();
        System.out.println("*****删除指定位置节点******");
        list.delete(2);
        list.list();
        System.out.println("list.size() = " + list.size());
        System.out.println("*****按指定位置修改数据******");
        list.update(0, 110);
        list.list();
        System.out.println("*****按指定位置添加数据******");
        list.add(10, i6);
        list.list();
        System.out.println("*****获取指定的数据******");
        System.out.println("list.getIntegerNum(0) = " + list.getIntegerNum(0));
        System.out.println("*****获取指定的数据******");
        System.out.println("list.getReverseIntegerNum(1) = " + list.getReverseIntegerNum(1));
        System.out.println("***********反转单链表*********");
        list.reverseLinkedList();
        list.list();
        System.out.println("*****清空所有数据******");
        list.makeEmpty();
        list.list();


    }
}

/**
 * 管理链表节点
 */
class SingleLinkedList4IntegerNode {
    /**
     * 先初始化头节点，并且不存放数据
     */
    private IntegerNode head = new IntegerNode(-1);

    /**
     * 在链表尾部添加节点
     *
     * @param node
     */
    public void add(IntegerNode node) {
        //1.找到当前链表的最后节点
        IntegerNode temp = head;
        while (true) {
            //找到链表的最后
            if (temp.next == null) {
                break;
            }
            //如果没有找到,将temp后移
            temp = temp.next;
        }
        //2.将最后节点的next指向新节点

        temp.next = node;
    }

    /**
     * 按照指定位置添加数据节点
     *
     * @param index
     * @param node
     */
    public void add(Integer index, IntegerNode node) {
        IntegerNode temp = head;
        //如果索引大于当前链表长度，则在链表最后添加节点
        if (index > this.size()) {
            this.add(node);
            return;
        }
        if (index < 0) {
            System.out.println("非法值");
            return;
        }
        //1.找到新添加节点的位置
        for (int i = 0; i < index; i++) {
            if (temp.next == null) {
                System.out.println("该链表为空 ");
                break;
            }
            temp = temp.next;
        }
        //2.新节点.next = temp.next
        node.next = temp.next;
        //3.将temp.next = node
        temp.next = node;

    }

    /**
     * 更新指定节点的数据
     *
     * @param index
     * @param data
     */
    public void update(Integer index, Integer data) {
        IntegerNode temp = head;
        //如果索引大于当前链表长度，或为负数
        if (index > this.size() || index < 0) {
            System.out.println("非法值");
            return;
        }
        //1.找到要修改节点的位置
        for (int i = 0; i < index; i++) {
            if (temp.next == null) {
                System.out.println("该链表为空");
                break;
            }
            temp = temp.next;
        }
        //temp是指定节点的上一个节点
        //temp.next就是指定节点
        //直接修改值
        temp.next.data = data;

    }

    /**
     * 删除指定节点
     *
     * @param index
     */
    public void delete(Integer index) {
        IntegerNode temp = head;
        //如果索引大于当前链表长度，或为负数
        if (index > this.size() || index < 0) {
            System.out.println("非法值");
            return;
        }
        //1.找到要修改节点的位置
        for (int i = 0; i < index; i++) {
            if (temp.next == null) {
                System.out.println("该链表为空~");
                break;
            }
            temp = temp.next;
        }
        //2.temp就是指定节点的前一个，只需要temp指向下一个的下一个的地址就可以删除指定节点
        temp.next = temp.next.next;
    }

    /**
     * 获取第几个节点
     *
     * @param index
     * @return
     */
    public IntegerNode getIntegerNum(Integer index) {
        IntegerNode temp = head;
        //如果索引大于当前链表长度，或为负数
        if (index > this.size() || index < 0) {
            System.out.println("非法值");
            return null;
        }
        for (int i = 0; i < index; i++) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        return temp.next;
    }

    /**
     * 获取倒数第几个节点
     *
     * @param index
     * @return
     */
    public IntegerNode getReverseIntegerNum(Integer index) {
        IntegerNode temp = head;
        //如果索引大于当前链表长度，或为负数
        if (index > this.size() || index < 0) {
            System.out.println("非法值~");
            return null;
        }
        for (int i = 0; i < this.size() - index; i++) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        return temp.next;
    }

    /**
     * 反转单链表
     */
    public void reverseLinkedList() {
        IntegerNode cur = head.next;
        IntegerNode next = null;
        IntegerNode reverseHead = new IntegerNode(-1);
        while (true) {
            if (cur == null) {
                break;
            }
            //先保存当前节点的下个节点
            next = cur.next;
            //将cur的下个节点指向新链表的最前端
            //非常重要
            cur.next = reverseHead.next;
            //将cur连接到新的链表上
            reverseHead.next = cur;
            //让cur后移
            cur = next;
        }
        head.next = reverseHead.next;
    }

    /**
     * 清空所有数据
     */
    public void makeEmpty() {
        head.next = null;
    }


    /**
     * 遍历链表
     */
    public void list() {
        if (isEmpty()) {
            System.out.println("链表为空");
            return;
        }
        //创建临时变量
        IntegerNode temp = head.next;
        while (true) {
            if (temp == null) {
                break;
            }
            //输出节点信息
            System.out.println(temp.data);
            temp = temp.next;
        }
    }

    /**
     * 判空
     */
    public Boolean isEmpty() {
        return head.next == null;
    }

    /**
     * 统计节点个数
     *
     * @return
     */
    public Integer size() {
        Integer count = 0;
        if (isEmpty()) {
            return 0;
        }
        //创建临时变量
        IntegerNode temp = head.next;
        while (true) {
            if (temp == null) {
                break;
            }
            //统计节点个数
            count++;
            temp = temp.next;
        }
        return count;
    }

}

/**
 * 定义节点
 */
class IntegerNode {
    /**
     * 存储数据
     */
    public Integer data;
    /**
     * 指向下一个结点
     */
    public IntegerNode next;

    public IntegerNode(Integer data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "IntegerNode{" +
                "data=" + data +
                '}';
    }
}