数据结构中实现单链表

数据结构中实现单链表
需要实现的方法

package cn.dataStructure.com;

public interface List {

    //返回线性表的大小，即数据元素的个数
    public int size();

    //返回线性表中序号为i的数据元素
    public Object get(int i);

    //如果线性表为空，返回true，否则返回false
    public boolean isEmpty();

    //判断线性表是否包含数据元素key
    public boolean contains(Object key);

    //返回数据元素key在线性表中的序号
    public int indexOf(Object key);

    //将数据元素key插入到线性表中i号位置
    public void add(int i,Object key);

    //将数据元素key插入到线性表末尾
    public void add(Object key);

    //将数据元素key插入到元素obj之后
    public boolean addAfter(Object obj,Object key);

    //将数据元素key插入到元素obj之前
    public boolean addBefore(Object obj,Object key);

    //删除线性表中序号为i的元素，并将其返回
    public Object remove(int i);

    //删除线性表中第一个与Object相同的元素
    public boolean remove(Object obj);

    //替换线性表中序号为i的数据元素为key,返回原数据元素
    public Object replace(int i,Object key);
}

定义一个节点类

package cn.dataStructure.com;

public class Node {
    Object data;
    Node next;

    public Node() {

    }

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

实现的具体方法过程

package cn.dataStructure.com;

public class MySingleList implements List {
    private Node head = new Node();
    private int size;

    @Override
    public int size() {
        return size;
    }

    @Override
    public Object get(int i) {
        //定义一个节点指向头节点的下一个节点，也就是第0 个节点
        Node p = head.next;
        for (int j = 0; j < i; j++) {
            p  = p.next;
        }
        return p.data;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean contains(Object key) {
        Node p = head.next;
        for (int i = 0; i < size ; i++) {
            if (p.data == key) {
                return true;
            }
            p = p.next;
        }
        return false;
    }

    @Override
    public int indexOf(Object key) {
        Node p = head.next;
        for (int i = 0; i < size; i++) {
            if (p.data == key) {
                return i;

            }
            p = p.next;
        }
        return -1;
    }
    private void checkIndex(int i) {
        //这里的i可以为size位置，也就是放在末尾
       if (i < 0 || i > size) {
            throw new RuntimeException("下标越界异常:"+i);
        }
    }
    @Override
    public void add(int i, Object key) {
        checkIndex(i);
        Node node = new Node(key);
        Node p = head;
        for (int j = 0; j < i; j++) {
            p = p.next;
        }
        node.next = p.next;
        p.next = node;
        size++;
    }

    @Override
    public void add(Object key) {
        this.add(size,key);
    }

    @Override
    public boolean addAfter(Object obj, Object key) {
        Node p = head.next;
        Node node = new Node(key);
        for (int i = 0; i < size; i++) {
            if (p.data == obj) {
                node.next = p.next;
                p.next = node;
                size++;
                break;
            }
             p = p.next;
        }
        return true;
    }

    @Override
    public boolean addBefore(Object obj, Object key) {
         Node p = head.next;
         Node pre = head;
         Node node= new Node(key);
        for (int i = 0; i < size; i++) {
            if (p.data == obj) {
                node.next = p;
                pre.next = node;
                size++;
                break;
            }
            p = p.next;
            pre = pre.next;
        }
        return true;
    }


    @Override
    public Object remove(int i) {
        Node p = head.next;
        Node pre = head;
        Object ds = null;

        for (int j = 0; j < i; j++) {
            p = p.next;
            pre= pre.next;
        }
        ds = p.data;
        pre.next = p.next;
        size--;
      return ds;
    }

    @Override
    public boolean remove(Object obj) {
        Node p = head.next;
        Node pre = head;
        for (int i = 0; i < size; i++) {
            if (p.data == obj) {
                pre.next = p.next;
                size--;
                break;
            }
            p = p.next;
            pre = pre.next;
        }
        return true;
    }

    @Override
    public Object replace(int i, Object key) {
        Node p = head.next;
        Node pre = head;
        Object datas = null;
        for (int j = 0; j < i; j++) {
            p = p.next;
            pre = pre.next;
        }
        datas = p.data;
        p.data = key;
        return datas;
    }

    @Override
    public String toString() {
        Node p = head.next;
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < size ; i++) {
            if ( i != size - 1) {
                sb.append(p.data+",");
            }else {
                sb.append(p.data);
            }
            p = p.next;
        }
        sb.append("]");
        return sb.toString();
    }
}

测试结果

package cn.dataStructure.com;

public class TestMySingleList {
    public static void main(String[] args) {
        List list = new MySingleList();
        list.add("1");
        list.add("15");
        list.add("6");
        list.add("8");
        list.add("2");
        list.add("0");
        list.add(6,"66");

        System.out.println(list);
//        list.addAfter(66,"99");
//        System.out.println(list);

//        list.addBefore(66,20);
//        System.out.println(list);

        list.add(0,"小红");
        System.out.println(list);

        list.remove("1");
        System.out.println(list);

        list.replace(6,"小明");
        System.out.println(list);

//        list.remove(3);
//        System.out.println(list);



        System.out.println(list.indexOf("0"));

        System.out.println(list.contains("67"));
        System.out.println(list.get(6));
        System.out.println(list);
        System.out.println(list.size());
        System.out.println(list.isEmpty());
    }
}