单链表数据增删改查

定义一个接口：

/*
 * 线性表（列表）的接口定义
 * 
 */
public interface MyArrayList {
    /*新增一个元素*/
    void add(Object element);
    
    /*删除相同元素*/
    void delete(Object element);
    
    /*根据索引删除元素*/
    void delete(int index);
    
    /*
     * 将指定索引位置的元素替换成新元素
     */
    void update(int index,Object newElment);
    
    /*
     * 当前列表中是否含有target这个元素
     */
    boolean contains(Object target);
    
    /*
     * 返回指定索引处的元素
     */
    Object at(int index); 
    
    /*
     * 根据元素查找对应索引
     */
    int indexof(Object element);
}

定义单链表元素属性：

public class ListNode {
    private Object data;//真实的元素数据
    private ListNode next;//元素的后继（即指的是当前元素指向后一个元素）
    
    public ListNode(Object data) {
        super();
        this.data = data;
    }

    public Object getData() {
        return data;
    }

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

    public ListNode getNext() {
        return next;
    }

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

单链表实现类：

public class SingleLinkedList implements MyArrayList{
    private ListNode first;
    private ListNode last;
    private int size;
    
    @Override
    public void add(Object element) {
        if(first==null) {
            first = new ListNode(element);
            last = first;
        }else {
            last.setNext(new ListNode(element)) ;
            last = last.getNext();
        }
        size++;
    }

    @Override
    public void delete(Object element) {
         ListNode p = first;//把头节点复制一下
         ListNode pre = null;//记录上一个的节点
         while(p != null) {
             if(p.getData().equals(element)) {
                 if (p==first) 
                     first=first.getNext();
                else
                 pre.setNext(p.getNext());
                 size--;
                 break;//注意
             }
             
             pre = p; //一个一个节点往后移动
             p=p.getNext();
         }
        
    }

    /*
     * 根据索引删除元素
     */
    @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) {
                if(p == first)
                    first = first.getNext();
                else
                pre.setNext(p.getNext());
                size--;
                break;//注意这里
            }
            pre = p;
            p = p.getNext();
            i++;
        }
        
    }

    @Override
    public void update(int index, Object newElment) {
        int i=0;
        ListNode p = first;
        ListNode pre = null;
        
        while (p != null) {
            if (i==index) {
                p.setData(newElment);
            }
            pre = p;
            p = p.getNext();
            i++;
        }
        
    }

    @Override
    public boolean contains(Object target) {
        int i = 0;
        ListNode p = first;
        
        while (p != null) {
            if (p.getData().equals(target)) {
                return true;
            }
            p = p.getNext();
            i++;
        }
        return false;
    }

    @Override
    public Object at(int index) { 
        if (index<0||index>=size) {
            return null;
        }
        int i=0;
        ListNode p = first;
        
        while (p != null) {
            if (i==index) {
                return p.getData();
            }
            p = p.getNext();
            i++;
        }
        return null;
    }

    @Override
    public int indexof(Object element) {
        int i=0;
        ListNode p = first;
        
        while (p != null) {
            if (p.getData().equals(element)) {
                return i;
            }
            p = p.getNext();
            i++;
        }
        return -1;
    }

    public String toString() {
        StringBuilder sBuilder = new StringBuilder("[");
        ListNode p = first; 
        while(p != null) {
            sBuilder.append(p.getData());
            if (p.getNext() != null) 
                sBuilder.append(",");
                p = p.getNext();
        }
        sBuilder.append("]");
        return sBuilder.toString();
        
    }
}

单元测试类：

class SingleLinkedListTest {
    SingleLinkedList list = new SingleLinkedList();
    

    
    @BeforeEach
//    @Test
    void testAdd() {
        
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
        System.out.println(list);
        list.add("g");
        list.add("h");
        list.add("i");
        System.out.println(list);
    }

    @Test
    void testDeleteObject() {
        list.delete("b");
        System.out.println("2");
        System.out.println(list);
    }

    @Test
    void testDeleteInt() {
        list.delete(6);
        System.out.println("3");
        System.out.println(list);
    }

    @Test
    void testUpdate() {
        list.update(0, "x");
        System.out.println("4");
        System.out.println(list);
    }

    @Test
    void testContains() {
        boolean test = list.contains("g");
        System.out.println("5");
        System.out.println(test);
    }
//
    @Test
    void testAt() {
        System.out.println("6");
        System.out.println(list.at(7));
    }

    @Test
    void testIndexof() {
        System.out.println("7");
        System.out.println(list.indexof("g"));
        
    }

}