Java链表基本操作小总结

工作以来一直都忽略Java链表的简单编程，在自己简单的书写后，发现其实链表也蛮好理解的。再简单的数据结构也要自己手动敲敲，不然会反应迟钝的~

package com.study.list;

/**
 * @program: TwoReverseLinedList
 * @description: 两个节点反转
 * @author: 
 * @create: 2018-11-14 11:10
 **/
public class TwoReverseLinedList<T> {

    private int size;

    private LinkNode<T> head;

    private LinkNode<T> tail;

    public static void main(String[] args) {

        TwoReverseLinedList<Integer> twoReverseLinedList = new TwoReverseLinedList<Integer>();

        for (int i = 0; i < 10; i++) {
            twoReverseLinedList.addByTail(i);
        }

        twoReverseLinedList.printLinkList();

        System.out.println();

        System.out.println("获取元素是：" + twoReverseLinedList.get(0));

        System.out.println("该链表长度：" + twoReverseLinedList.size());

        twoReverseLinedList.reverse();

        System.out.println("方法一反转后的链表");

        twoReverseLinedList.printLinkList();

        System.out.println();

        twoReverseLinedList.reverse1();

        System.out.println("方法二反转后的链表");

        twoReverseLinedList.printLinkList();

        System.out.println();

        System.out.println("删除指点节点后的链表");

        twoReverseLinedList.delete(0);

        twoReverseLinedList.printLinkList();

        System.out.println();

        System.out.println("添加指点节点后的链表");

        twoReverseLinedList.insert(0, 100);

        twoReverseLinedList.printLinkList();
    }

    /**
     * 增加节点 头插法，head总是指向最新节点
     *
     * @param data
     */
    public void addByHead(T data) {
        if (null == this.head) {
            this.head = new LinkNode<T>();
        }

        LinkNode<T> newNode = new LinkNode<T>();
        newNode.setData(data);
        newNode.setNext(head);
        head = newNode;
        size++;
    }

    /**
     * 增加节点
     *
     * @param data
     */
    public void addByTail(T data) {
        if (null == this.head) {
            this.head = new LinkNode<T>();
            this.tail = this.head;
        }

        LinkNode<T> newNode = new LinkNode<T>();
        newNode.setData(data);
        tail.setNext(newNode);
        tail = newNode;
        size++;
    }

    /**
     * 打印链表
     */
    public void printLinkList() {
        if (null == head) {
            return;
        }

        LinkNode<T> tmp = head.getNext();
        System.out.print("链表如下: ");
        while (null != tmp) {
            System.out.print(tmp.getData() + "->");
            tmp = tmp.getNext();
        }
    }

    /**
     * 获取数据
     *
     * @param index
     * @return
     */
    public T get(int index) {

        if (null == head) {
            throw new IllegalArgumentException("链表不存在");
        }

        if (-1 > index || index > size - 1) {
            throw new IllegalArgumentException("获取位置异常");
        }

        if (-1 == index) {
            return null;
        }

        LinkNode<T> tmp = head.getNext();
        int count = 0;
        while (null != tmp) {
            if (count++ == index) {
                return tmp.getData();
            }
            tmp = tmp.getNext();
        }

        return null;
    }

    /**
     * 获取指定节点
     *
     * @param index
     * @return
     */
    public LinkNode<T> getNode(int index) {

        if (null == head) {
            throw new IllegalArgumentException("链表不存在");
        }

        if (-1 > index || index > size - 1) {
            throw new IllegalArgumentException("获取位置异常");
        }

        if (-1 == index) {
            return head;
        }

        LinkNode<T> tmp = head.getNext();
        int count = 0;
        while (null != tmp) {
            if (count++ == index) {
                return tmp;
            }
            tmp = tmp.getNext();
        }

        return null;
    }

    /**
     * 返回列表的长度
     *
     * @return
     */
    public int size() {
        return this.size;
    }

    /**
     * 反转-值交换
     */
    public void reverse() {

        if (null == head) {
            return;
        }

        LinkNode<T> first = head.getNext();
        LinkNode<T> tmp;
        // 交换值实现
        while (null != first && null != first.getNext()) {
            tmp = first.getNext();
            T tmpData = first.getData();
            first.setData(tmp.getData());
            tmp.setData(tmpData);
            first = tmp.getNext();
        }
    }

    /**
     * 反转-节点交换
     */
    public void reverse1() {

        if (null == head) {
            return;
        }

        LinkNode<T> first = head.getNext();
        LinkNode<T> base = head;
        LinkNode<T> second;
        // 交换值实现
        while (null != first && null != first.getNext()) {
            second = first.getNext();
            base.setNext(second);
            first.setNext(second.getNext());
            second.setNext(first);

            base = first;
            first = first.getNext();
        }
    }

    /**
     * 删除指点的节点
     *
     * @param i
     */
    public void delete(int i) {

        LinkNode<T> node = getNode(i);
        if (null == node) {
            throw new IllegalArgumentException("删除的目标节点不存在");
        }

        LinkNode<T> pre = getNode(i - 1);

        pre.setNext(node.getNext());

        size--;
    }

    /**
     * 指定位置插入
     *
     * @param data
     */
    public void insert(int index, T data) {

        if (null == head) {
            return;
        }

        LinkNode<T> node = getNode(index - 1);
        if (null == node) {
            throw new IllegalArgumentException("插入位置有误");
        }

        LinkNode<T> tmp = new LinkNode<T>();
        tmp.setData(data);

        tmp.setNext(node.getNext());
        node.setNext(tmp);

        size++;
    }

    /**
     * 节点
     *
     * @param <T>
     */
    class LinkNode<T> {

        /**
         * 数据域
         */
        private T data;

        /**
         * 指针域
         */
        private LinkNode next;

        public LinkNode() {

        }

        public LinkNode(T data) {
            this.data = data;
        }

        public T getData() {
            return data;
        }

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

        public LinkNode getNext() {
            return next;
        }

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

运行结果:

链表如下: 0->1->2->3->4->5->6->7->8->9->
获取元素是：0
该链表长度：10
方法一反转后的链表
链表如下: 1->0->3->2->5->4->7->6->9->8->
方法二反转后的链表
链表如下: 0->1->2->3->4->5->6->7->8->9->
删除指点节点后的链表
链表如下: 1->2->3->4->5->6->7->8->9->
添加指点节点后的链表
链表如下: 100->1->2->3->4->5->6->7->8->9->