单链表的java实现

线性表的接口定义

/**
 * 线性表（列表）的接口定义
 */
public interface MyList {

    /**
     * 新增一个元素
     *
     * @param element 要新增的那个元素
     */
    public void add(Object element);

    /**
     * 删除相同元素
     *
     * @param element 要删除的那个元素
     */
    void delete(Object element);

    /**
     * 根据索引删除元素
     *
     * @param index 要删除元素的索引
     */
    void delete(int index);

    /**
     * 将指定索引位置的元素替换成新元素
     *
     * @param index 被替换元素的索引
     * @param newElement 替换成的新元素
     */
    void update(int index, Object newElement);

    /**
     * 当前列表中是否含有target这个元素
     *
     * @param target 要查找的元素
     * @return 返回是否含有这个元素
     */
    boolean contains(Object target);

    /**
     * 返回指定索引处的元素
     *
     * @param index 要返回元素的索引
     * @return 返回这个元素对象
     */
    Object elementAt(int index);

    /**
     * 查找element所在的索引，如果没有返回-1
     * @param element 要查找的元素
     * @return 返回元素索引
     */
    int indexOf(Object element);
}

 

单链表的节点定义

public class ListNode {
    Object data;
    ListNode next;

    public ListNode(Object data) {
        this.data = data;
    }
}

 

单链表的实现类

public class SingleLinkedList implements MyList {
    private ListNode first;
    private ListNode last;
    private int size;

    /**
     * 新增一个元素
     *
     * @param element 要新增的那个元素
     */
    @Override
    public void add(Object element) {
        if (first == null) {
            first = new ListNode(element);
            last = first;
        } else {
            last.next = new ListNode(element);
            last = last.next;
        }
        ++size;
    }

    /**
     * 删除相同元素
     *
     * @param element 要删除的那个元素
     */
    @Override
    public void delete(Object element) {
        ListNode p = first;
        ListNode pre = null;

        while (p != null) {
            if (p.data.equals(element)) {
                //如果要删除头结点，因为此时头结点的前驱节点为空，
                //所以可直接用头结点的下一个节点作为新的头结点
                if (p == first) {
                    first = first.next;
                } else {
                    pre.next = p.next;
                }
                --size;
                break;
            }
            pre = p;
            p = p.next;
        }
    }

    /**
     * 根据索引删除元素
     *
     * @param index 要删除元素的索引
     */
    @Override
    public void delete(int index) {
        if (index < 0 || index >= size) {
            //下标越界，啥也不干
            return;
        }
        //指针指向的节点索引
        int i = 0;
        ListNode p = first;
        ListNode pre = null;

        while (p != null) {
            if (i == index) {
                //删除p结点
                if (p == first) {
                    first = first.next;
                } else {
                    pre.next = p.next;
                }
                --size;
                break;
            }
            pre = p;
            p = p.next;
            ++i;
        }
    }

    /**
     * 将指定索引位置的元素替换成新元素
     *
     * @param index      被替换元素的索引
     * @param newElement 替换成的新元素
     */
    @Override
    public void update(int index, Object newElement) {
        if (index < 0 || index >= size) {
            //下标越界，啥也不干
            return;
        }
        //指针指向的节点索引
        int i = 0;
        ListNode p = first;

        while (p != null) {
            if (i == index) {
                p.data = newElement;
                break;
            }
            p = p.next;
            ++i;
        }
    }

    /**
     * 当前列表中是否含有target这个元素
     *
     * @param target 要查找的元素
     * @return 返回是否含有这个元素
     */
    @Override
    public boolean contains(Object target) {
        ListNode p = first;

        while (p != null) {
            if (p.data.equals(target)) {
                return true;
            }
            p = p.next;
        }
        return false;
    }

    /**
     * 返回指定索引处的元素
     *
     * @param index 要返回元素的索引
     * @return 返回这个元素对象
     */
    @Override
    public Object elementAt(int index) {
        if (index < 0 || index >= size) {
            //下标越界，啥也不干
            return null;
        }
        //指针指向的节点索引
        int i = 0;
        ListNode p = first;

        while (p != null) {
            if (i == index) {
                return p.data;
            }
            p = p.next;
            ++i;
        }
        return null;
    }

    /**
     * 查找element所在的索引，如果没有返回-1
     *
     * @param element 要查找的元素
     * @return 返回元素索引
     */
    @Override
    public int indexOf(Object element) {

        //指针指向的节点索引
        int i = 0;
        ListNode p = first;

        while (p != null) {
            if (p.data.equals(element)) {
                return i;
            }
            p = p.next;
            ++i;
        }
        return -1;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        ListNode p = first;
        while (p != null) {
            sb.append(p.data);
            if (p.next != null) {
                sb.append(", ");
            }
            p = p.next;
        }
        sb.append("]");
        return sb.toString();
    }
}

 

测试演示

import org.junit.jupiter.api.Test;

class SingleLinkedListTest {

    @Test
    void delete() {
        SingleLinkedList list = new SingleLinkedList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");

        //删除操作之前输出链表元素
        System.out.println("删除操作之前输出链表元素: " + list);

        list.delete("b");
        //删除元素"b"之后输出链表元素
        System.out.println("删除元素\"b\"之后输出链表元素: " + list);

        //删除下标为0的元素之后输出链表元素
        list.delete(0);
        System.out.println("删除下标为0的元素之后输出链表元素: " + list);
    }
}

 

运行结果截图