关于JAVA数据结构_线性表(通过单向链表实现)的学习

list接口

package demo1;

public interface MyList {

    int getSize();//返回线性表中元素的个数
    boolean isEmpty();//判断线性表是否为空
    void insert(int i,Object e);//在线性表的i索引值添加元素e
    boolean contains(Object e);//判断线性表中元素e的索引值
    int indexOf(Object e);//返回线性表中元素e的索引值
    Object remove(Object e);//删除线性表第一个与e相同的元素,并返回该元素
    Object remove(int i);//删除线性表第一个与i相同的元素,并返回该元素
    Object replace(int i,Object e);//使用元素e代替i,并返回就得元素
    Object get(int i);//返回索引值为i的元素
    boolean insertBefore(Object p,Object e);//在线性表元素p前面插入元素e
    boolean insertAfter(Object p,Object e);//在线性表元素p后面插入元素e
    

}

通过单向链表实现:

package demo1;
/**
 * 通过单向链表实现线性表
 * @author ASUS
 *
 */
public class MySingleLink implements MyList {

    private Node head;
    private int size;
    
    //返回元素的个数
    @Override
    public int getSize() {

        return size;
    }

    //判断线性表是否为空
    @Override
    public boolean isEmpty() {

        return size==0;
    }

    //在线性表插入元素
    @Override
    public void insert(int i, Object e) {
        //判断索引值是否越界
        if(i<0||i>size){
            throw new IndexOutOfBoundsException(i+"越界");
        }
        //创建节点
        Node newNode = new Node(e,null);
         //头结点为null的情况,链表不存在,刚刚添加的节点就是头结点
        if(head==null){
            head = newNode;
            
        }else{
            //在0位置插入结点
            if(i==0){
                newNode.next=head;  //修改新结点next域指向头结点
                head=newNode;  //刚插入的为新的节点
            }else {
                //插入结点,先找到i-1的节点
                Node pNode=head;
                for(int x=1;x<i;x++){
                    pNode = pNode.next;
                }
                //注意,先修改新结点next指针域,再修改i-1的指针域
                newNode.next=pNode.next;
                pNode.next=newNode;
}
        }
        size++;
        
        //元素个数加0
    }

    //线性表中是否包含指定的元素
    @Override
    public boolean contains(Object e) {

                return indexOf(e)>=0;
    }

    //返回元素e在线性表中的第一次出现的索引值
    @Override
    public int indexOf(Object e) {
        int i=0;  //保存元素e的索引值
        Node pNode = head;
        while(pNode !=null){
            if(e==null && pNode.data==null){
                return i;
            }else if(e!=null&&e.equals(pNode.data)){
                return i;
            }
            i++;
            pNode=pNode.next;
        }
        

        return -1;
    }

    //从线性表中删除第一个与e相同的元素
    @Override
    public Object remove(Object e) {
        //找到e第一次出现的索引值
        int index=indexOf(e);
        if(index<0){
            return null;  //不存在
        }
        return remove(index);
    }

    //从线性表中删除指定索引的元素
    @Override
    public Object remove(int i) {
        //判断是否越界
        if(i<0||i>=size){
            throw new IndexOutOfBoundsException(i+"越界");
        }
        Node pNode=head;
        //删除头结点
        if(i==0){
            head=head.next;
            size--;
            return pNode.data;  //返回删除后的结果
        }
        for(int x=1;x<i;x++){
            pNode =pNode.next;
            }
        //
        Object old=pNode.next.data;  //保存删除结点的数据
        pNode.next=pNode.next.next;
        size--;
        return old;
    }
    
    //把线性表i索引值得元素替换为e
    @Override
    public Object replace(int i, Object e) {
        //判断是否越界
        checkIndex(i);
        Node pNode=getNode(i);
        Object old = pNode.data;
        pNode.data=e;
        return old;
    }
    //返回线性表中i索引值得元素
    @Override
    public Object get(int i) {
        checkIndex(i);
        Node pNode=getNode(i);
        return pNode.data;
    }
    //定义方法,返回线性表i索引的元素
    private Node getNode(int i){
        if(i<0||i>=size){
            return null;
        }if(i==0){
            return head;
        }
        //找到i结点
        Node pNode=head;
        for(int x=i;x<i;x++){
            pNode=pNode.next;
            
        }
        return pNode;
    }
    //检查索引值是否越界
    private void checkIndex(int i){
        if(i<0||i>size){
            throw new IndexOutOfBoundsException(i+"越界");
        }
    }

    //在指定的元素p前面插入元素e
    @Override
    public boolean insertBefore(Object p, Object e) {

        //找p的位置
        int index=indexOf(p);
        if(index<0){
            return false;
        }
        insert (index,e);
        return true;
    }
    
    
    //在指定的元素p后面插入元素e
    @Override
    public boolean insertAfter(Object p, Object e) {
        //找p的位置
        int index =indexOf(p);
        if(index<0){
            return false;
        }
        insert(index+1,e);
        
        return true;
    }
    
    //重写toString 
    @Override
    public String toString() {
        //把链表中各个结点的数据域连接起来
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        Node pNode=head;
        while(pNode!=null){
            sb.append(pNode.data);
            //使用逗号分隔
            if(pNode.next!=null){
                sb.append(",");
                
            }
            pNode=pNode.next;
            
        }
        sb.append("]");
        
        return sb.toString();
    }
    
    
    //定义一个内部类表示单向链表中的节点
    private class Node{
        
        Object data;
        Node  next;
        public Node(Object data, Node next) {
            super();
            this.data = data;
            this.next = next;
        }
        
    }
    

}

测试类:

package demo1;
/**
 * 测试单向链表
 * @author ASUS
 *
 */
public class MysingleLinkTest {

    public static void main(String[] args) {

        //1.创建链表
        MySingleLink link=new MySingleLink();
        //2.判断
        System.out.println(link.isEmpty());
        System.out.println(link.getSize());
        //3.输入元素
        link.insert(0, "aa");
        link.insert(0, "bb");
        link.insert(0, "cc");
        link.insert(0, "dd");
        
        //4.直接打印输出
        System.out.println(link);
        //5.判断元素是否存在
        System.out.println(link.indexOf("aa"));
        System.out.println(link.indexOf("cc"));
        System.out.println(link.indexOf("xx"));
        System.out.println(link.contains("cc"));
        //6.删除结点
        System.out.println(link.remove("xx"));
        System.out.println(link.remove("bb"));
        System.out.println(link);
        System.out.println(link.remove(0));
        System.out.println(link);
        //7.返回元素,元素替换
        System.out.println(link.get(0));
        System.out.println(link.replace(0, "CC"));
        System.out.println(link);
        //8.在指定元素的前面或后面插入指定的元素
        link.insertBefore("CC", "前面");
        link.insertAfter("CC", "后面");
        System.out.println(link);
    }

}

运行截图: