关于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 MyDualLinkedList implements MyList {
    private Node first;  //指向前结点
    private Node last;  //指向尾结点
    private int size;   //保存元素的个数
    
    //返回元素的个数
    @Override
    public int getSize() {

        return size;
    }

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

        return size==0;
    }

    //在指定位置插入元素
    @Override
    public void insert(int i, Object e) {
        //1.检查索引是否越界
        checkIndex(i);        
        //2.如果i==0;
        if(i==0){
            addFirst(e);
        }else if(i==size){
        //3.如果i==size,在尾部添加
            addLast(e);
        }else{
        //4.列表中心添加
            //找到i结点,在i结点前面插入元素
            Node pNode=getNode(i);
            Node PrevNode=pNode.prev;
            //生成新的结点
            Node newNode=new Node(e, PrevNode, pNode);
            //修改前驱结点的后缀
            
            PrevNode.next=newNode;
            pNode.prev=newNode;
            size++;
            
            
        }
    }

    //返回索引值对应的结点
    private Node getNode(int i) {
        //
        Node pNode=first;
        for(int x=0;x<i;x++){
            pNode=pNode.next;
        }
        return pNode;
    }

    
    //判断链表中是否包含指定的元素e,如果存在返回true
    @Override
    public boolean contains(Object e) {

        return indexOf(e)>=0;
    }

    //判断元素e在链表中第一次出现的位置,如果不存在返回-1
    @Override
    public int indexOf(Object e) {
        int i=0;
        //依次遍历链表中各个结点,比较结点的元素与指定的e是否一样
        if(e==null){
            for(Node pNode=first;pNode!=null;pNode=pNode.next){
                if(pNode.data==null){
                    return i;
                }
                i++;
            }
        }else{
            for(Node pNode=first;pNode!=null;pNode=pNode.next){
                if(e.equals(pNode.data)){
                    return i;
                }
                i++;
            }
            
        }
        return -1;
    }
    
    //从链表中删除指定元素,并返回删除元素
    @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) {
        //判断索引值是否越界
        checkIndex(i);
        //找到对应的结点
        Node pNode=getNode(i);
        Node prevNode=pNode.prev;
        Node nextNode=pNode.next;
        if(prevNode==null){
            //删除头结点
            first=nextNode;
        }else{
            prevNode.next=nextNode;
        }
        if(nextNode==null){
            //删除尾结点
            last=prevNode;
        }else{
            nextNode.prev=prevNode;
            
        }
        size--;
        return pNode.data;
    }

    //修改指定索引值得元素
    @Override
    public Object replace(int i, Object e) {
        //检查是否越界
        checkIndex(i);
        //找到索引值为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;
    }

    
    //在指定元素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) {
        int index=indexOf(p);
        if(index<0){
            return false;
        }
        insert(index+1,e);
        return true;
    }
    //检查索引值是否越界
        private void checkIndex(int i){
            if(i<0||i>size){
                throw new IndexOutOfBoundsException(i+"越界");
            }
        }
        
        @Override
        public String toString() {
            //依次遍历各个结点,吧元素转化为字符串
            StringBuilder sb=new StringBuilder();
            sb.append("[");
            for(Node node=first;node!=null;node=node.next){
                sb.append(node.data);
                if(node!=last){
                    sb.append(",");
                    
                }
            }
            sb.append("]");
            return sb.toString();
        }
       //常用对头结点和尾结点的操作
        //在头部添加元素
        public void addFirst(Object e){
            Node pNode = first;
            //生成一个新的结点
            Node newNode=new Node(e,null,first);
                first = newNode;   //修改first指向新的结点
                if(pNode==null){
                    last=newNode;
                }else{
                    pNode.prev=newNode;
                }
                size++;  //元素个数加一
            }
        //在尾部添加
        public void addLast(Object e){
            Node pNode=last;
            //生成一个新的结点
            Node newNode=new Node(e,last,null);
            if(pNode==null){
                first=newNode;
            }else{
                pNode.next=newNode;
            }
            last=newNode;
            size++;            
        }
        //删除第一个元素,删除头元素
        public Object removeFirst(){
            return remove(0);
        }
        //删除最后一个元素,尾元素
        public Object removeLast(){
            return remove(size-1);
        }
        //返回头元素
        public Object getFirst(){
            return get(0); 
        }
        //返回尾元素
        public Object getLast(){
            return get(size-1);
        }
        
    //定义一个内部类描述双向列表的结点
    private class Node{
        Object data;
        Node prev;   //指向前驱结点
        Node next;   //指向后续结点
        public Node(Object data, Node prev, Node next) {
            super();
            this.data = data;
            this.prev = prev;
            this.next = next;
        }
        
        
    }
}

测试类:

package demo1;
/**
 * 测试双向列表
 * @author ASUS
 *
 */
public class TestDualLinkedList {

    public static void main(String[] args) {
        //创建双向列表
        MyDualLinkedList linkedList=new MyDualLinkedList();
        
        System.out.println(linkedList.getSize());
        System.out.println(linkedList.isEmpty());
        
        linkedList.insert(0,"gg");
        linkedList.insert(0,"jj");
        linkedList.insert(1,"dd");
        linkedList.insert(2,"mm");
        
        System.out.println(linkedList);
        System.out.println("-------------------");
        //测试是否包含某个元素及第一次出现的位置
        System.out.println(linkedList.indexOf("jj"));
        System.out.println(linkedList.contains("mm"));
        System.out.println(linkedList.indexOf("MM"));
        System.out.println(linkedList.indexOf("xx"));
        System.out.println(linkedList.indexOf("gg"));
        System.out.println("-------------------");
        //删除指定的元素
        System.out.println(linkedList.remove(1));
        System.out.println(linkedList);
        System.out.println(linkedList.remove("mm"));
        System.out.println(linkedList);
        System.out.println("-------------------");
        //替换指定元素
        System.out.println(linkedList.replace(0, "哈哈"));
        System.out.println(linkedList);
        //返回指定元素的
        System.out.println(linkedList.get(0));
        System.out.println("-------------------");
        
        //在指定元素前面加入
        System.out.println(linkedList.insertBefore("哈哈", "前面"));
        System.out.println(linkedList);
        //后面
        System.out.println(linkedList.insertAfter("哈哈", "后面"));
        System.out.println(linkedList);
        System.out.println("--------------------");
        //头部尾部添加删除返回
        linkedList.addFirst("头部");
        linkedList.addLast("尾部");
        System.out.println(linkedList);
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());
        //删除头部尾部
        linkedList.removeFirst();
        linkedList.removeLast();
        System.out.println(linkedList);
    
    }

63}

运行截图: