Java实现单向链表以及简单功能

最近在看数据结构,看到了链表.

单向链表每个节点都有一个指向下一个元素的指针,最后一个节点的后继节点为null表示链表的结束.

链表的遍历是从表头开始,直到下个节点为空结束遍历.

放一个toString方法,演示下遍历.

@Override
public String toString() {
    if (headerNode == null) {
        return "[]";
    } else {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        sb.append(headerNode.element);
        ListNode<E> firstNode = headerNode;
        ListNode<E> iterator = firstNode.next;
        while (iterator != null) {
            sb.append(",").append(iterator.element);
            iterator = iterator.next;
        }
        return sb.append("]").toString();
    }
}

链表的插入分为三种情况

• 向表头插入节点

将新节点的后继节点指向原来的表头,然后将表头设置为新节点

 /**
  * 向表头增加元素
  * @param element 需要增加的元素
  */
 public void addFirst(E element) {
     ListNode<E> newFirstNode = new ListNode<>(element);
     newFirstNode.next = headerNode;
     headerNode = newFirstNode;
 }

• 向指定位置插入节点

将新节点的后继节点更新为目标节点的后继节点,然后将目标节点的后继节点更新为新节点.

/**
 * 在指定元素后添加元素
 *
 * @param previousElement 先前的元素
 * @param newElement      插入的元素
 */
public void add(E previousElement, E newElement) {
    if (headerNode == null) {
        throw new RuntimeException("链表中没有元素");
    }
    ListNode<E> firstNode = headerNode;
    ListNode<E> targetNode = null;
    if (firstNode.element.equals(previousElement)) {
        targetNode = firstNode;
    }
    ListNode<E> iterator = firstNode.next;
    while (iterator != null) {
        if (iterator.element.equals(previousElement)) {
            targetNode = iterator;
            break;
        }
        iterator = iterator.next;
    }
    if (targetNode == null) {
        throw new RuntimeException("链表中无法查找到指定元素所处的位置");
    } else {
        ListNode<E> newListNode = new ListNode<>(newElement);
        newListNode.next = targetNode.next;
        targetNode.next = newListNode;
    }
}

• 向表尾插入节点

将表尾节点的后继节点更新为新节点,新节点的后继节点为null.

/**
 * 向链表末尾添加元素
 *
 * @param element 需要添加的元素
 */
public void add(E element) {
    if (headerNode == null) {
        headerNode = new ListNode<>(element);
        return;
    }
    //获取首节点
    ListNode<E> firstNode = headerNode;
    //遍历到尾节点,并将新节点的地址(指针)赋值给next
    while (firstNode.next != null) {
        firstNode = firstNode.next;
    }
    firstNode.next = new ListNode<>(element);
}

删除也分三种情况

• 删除表头

将表头元素的后继节点设置为新的表头,然后将原表头的后继节点设置为null

• 删除中间的指定位置

将指定节点的前驱节点 指向后继节点.然后指定节点的后继节点设置为null

• 删除表尾

将表尾的前驱节点的后继节点设置为null即可.

/**
 * 移除链表中的某个元素
 *
 * @param element 需要移除的元素
 */
public boolean remove(E element) {
    if (headerNode == null) {
        throw new RuntimeException("链表中没有元素");
    }
    ListNode<E> firstNode = headerNode;
    ListNode<E> iterator = firstNode.next;
    if (firstNode.element.equals(element)) {
        headerNode = iterator;
        firstNode.next = null;
        return true;
    }
    ListNode<E> preIterator = firstNode;
    while (iterator != null) {
        if (iterator.element.equals(element)) {
            preIterator.next = iterator.next;
            iterator.next = null;
            return true;
        }
        preIterator = iterator;
        iterator = iterator.next;
    }
    return false;
}

放个整体代码.

package com.relic.linkedlist;


/**
 * 单向链表的简单实现
 *
 * @author Relic
 */
public class MyLinkedList<E> {

    /**
     * 链表的表头节点
     */
    private ListNode<E> headerNode;

    public MyLinkedList(E element) {
        headerNode = new ListNode<>(element);
        headerNode.next = null;
    }

    public MyLinkedList() {
        headerNode = null;
    }

    public static void main(String[] args) {
        MyLinkedList<String> list = new MyLinkedList<>();
        list.add("test1");
        list.add("test2");
        list.add("test3");
        list.add("test2", "test4");
        list.addFirst("test0");
        System.out.println(list);
        System.out.println(list.indexOf(7));
        System.out.println(list.lastIndexOf(2));
        System.out.println(list.size());
        System.out.println(list.contains("test1"));
        System.out.println(list.remove("test3"));
        System.out.println(list);
    }

    /**
     * 向链表末尾添加元素
     *
     * @param element 需要添加的元素
     */
    public void add(E element) {
        if (headerNode == null) {
            headerNode = new ListNode<>(element);
            return;
        }
        //获取首节点
        ListNode<E> firstNode = headerNode;
        //遍历到尾节点,并将新节点的地址(指针)赋值给next
        while (firstNode.next != null) {
            firstNode = firstNode.next;
        }
        firstNode.next = new ListNode<>(element);
    }

    /**
     * 在指定元素后添加元素
     *
     * @param previousElement 先前的元素
     * @param newElement      插入的元素
     */
    public void add(E previousElement, E newElement) {
        if (headerNode == null) {
            throw new RuntimeException("链表中没有元素");
        }
        ListNode<E> firstNode = headerNode;
        ListNode<E> targetNode = null;
        if (firstNode.element.equals(previousElement)) {
            targetNode = firstNode;
        }
        ListNode<E> iterator = firstNode.next;
        while (iterator != null) {
            if (iterator.element.equals(previousElement)) {
                targetNode = iterator;
                break;
            }
            iterator = iterator.next;
        }
        if (targetNode == null) {
            throw new RuntimeException("链表中无法查找到指定元素所处的位置");
        } else {
            ListNode<E> newListNode = new ListNode<>(newElement);
            newListNode.next = targetNode.next;
            targetNode.next = newListNode;
        }
    }

    /**
     * 向表头增加元素
     *
     * @param element 需要增加的元素
     */
    public void addFirst(E element) {
        ListNode<E> newFirstNode = new ListNode<>(element);
        newFirstNode.next = headerNode;
        headerNode = newFirstNode;
    }

    /**
     * 移除链表中的某个元素
     *
     * @param element 需要移除的元素
     */
    public boolean remove(E element) {
        if (headerNode == null) {
            throw new RuntimeException("链表中没有元素");
        }
        ListNode<E> firstNode = headerNode;
        ListNode<E> iterator = firstNode.next;
        if (firstNode.element.equals(element)) {
            headerNode = iterator;
            firstNode.next = null;
            return true;
        }
        ListNode<E> preIterator = firstNode;
        while (iterator != null) {
            if (iterator.element.equals(element)) {
                preIterator.next = iterator.next;
                iterator.next = null;
                return true;
            }
            preIterator = iterator;
            iterator = iterator.next;
        }
        return false;
    }

    /**
     * 返回链表中是否包括某个元素
     *
     * @param element 查找的元素
     * @return 的布尔值
     */
    public boolean contains(E element) {
        ListNode<E> iterator = headerNode;
        do {
            if (iterator.element.equals(element)) {
                return true;
            }
            iterator = iterator.next;
        } while (iterator != null);
        return false;
    }

    /**
     * @return int 链表的长度
     */
    public int size() {
        int length = 0;
        ListNode<E> firstNode = headerNode;
        if (firstNode == null) {
            return 0;
        }
        ListNode<E> iterator = firstNode.next;
        while (iterator != null) {
            length++;
            iterator = iterator.next;
        }
        //加上首节点
        return length + 1;
    }

    /**
     * 根据角标返回链表中的元素
     *
     * @param index 链表中的位置
     * @return 指定的元素
     */
    public E indexOf(int index) {
        ListNode<E> iterator = headerNode;
        for (int i = 1; i < index; i++) {
            if (iterator.next == null) {
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
            }
            iterator = iterator.next;
        }
        return iterator.element;
    }

    /**
     * 返回从末尾开始计数指定角标的元素
     *
     * @param index 从末尾开始的位置
     * @return 指定的元素
     */
    public E lastIndexOf(int index) {
        ListNode<E> pre = headerNode;
        ListNode<E> later = headerNode;
        //pre指针先移动index个长度
        for (int i = 1; i < index; i++) {
            //超出链表长度,
            if (pre.next == null) {
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
            }
            pre = pre.next;
        }
        //同时移动两个指针,直到pre指针到达尾端,此时later指针的位置即为所求位置
        while (pre.next != null) {
            pre = pre.next;
            later = later.next;
        }
        return later.element;
    }

    @Override
    public String toString() {
        if (headerNode == null) {
            return "[]";
        } else {
            StringBuilder sb = new StringBuilder();
            sb.append("[");
            sb.append(headerNode.element);
            ListNode<E> firstNode = headerNode;
            ListNode<E> iterator = firstNode.next;
            while (iterator != null) {
                sb.append(",").append(iterator.element);
                iterator = iterator.next;
            }
            return sb.append("]").toString();
        }
    }

    static class ListNode<E> {
        private E element;
        private ListNode<E> next;

        ListNode(E element) {
            this.element = element;
            next = null;
        }

        ListNode() {
        }
    }

    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+ size();
    }

}