JAVA数据结构双向链表

仅作为个人学习记录~

双向链表和单向链表的最大差别就是在插入和删除操作的时候要考虑头尾结点是否为空。

package basic.practic;

public interface MyList {
    public int getSize();
    public boolean isEmpty();
    public void insert(int i,Object e);
    public boolean contains(Object obj);
    public int indexOf(Object o);
    public Object remove(Object o);
    public Object remove(int i);
    public Object get(int i);
    public Object replace(int i,Object o);
    public boolean insertBefore(Object p,Object e);
    public boolean insertAfter(Object p,Object e);
}

package basic.practic;

public class MydoubleLink implements MyList{
    private Node first;//指向头结点
    private Node last;//指向尾结点
    private int size=0;//保存元素的个数

    @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("越界！");
        }
        if(i==0){
            addFirst(e);
        }
        else if(i==size){
            addLast(e);
        }else{
//            找到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;
        if(i<0||i>=size){
            throw new IndexOutOfBoundsException("越界");
        }
        for(int j=0;j<i;j++){
            pnode=pnode.next;
        }
        return pnode;
    }

    private void addLast(Object e) {
        Node lnode=last;
        Node newnode = new Node(e,last,null);
        if(lnode==null){
            first=newnode;
        }else{
            lnode.next=newnode;
        }
        last=newnode;
        size++;
    }

    private void addFirst(Object e) {
        Node pnode=first;
        Node newnode=new Node(e,null,first);
        first=newnode;
        if(pnode==null){
            last=newnode;
        }else{
            pnode.prev=newnode;
        }
        size++;
    }

    @Override
    public boolean contains(Object obj) {
        return indexOf(obj)>=0;
    }

    @Override
    public int indexOf(Object o) {
        Node pnode=first;
        if(size==0){
            throw new RuntimeException("链表为空！");
        }
        for(int i=0;i<size;i++){
            if(o==null){
                if(pnode.data==null){
                    return i;
                }
            }else{
                if(o.equals(pnode.data)){
                    return i;
                }
            }
            pnode=pnode.next;
        }
        return -1;
    }

    @Override
    public Object remove(Object o) {
        return remove(indexOf(o));
    }

    @Override
    public Object remove(int i) {
        Node pnode =first;
        if(i<0||i>=size){
            throw new IndexOutOfBoundsException("越界");
        }
        for(int j=0;j<i;j++){
            pnode=pnode.next;
        }
        Object old=pnode.data;
        Node p1=pnode.prev;
        Node p2=pnode.next;

        if(p1==null){//删除的是头结点,要判断头结点是不是null
            first=p2;
        }else {
            p1.next = p2;

        }
        if(p2==null){//删除的是尾结点，要判断尾结点是不是null
            last=p1;
        }else{
            p2.prev = p1;
        }
        size--;
        return old;
    }

    @Override
    public Object get(int i) {
        Node pnode=first;
        if(i<0||i>=size){
            throw new IndexOutOfBoundsException("越界");
        }
        for(int j=0;j<i;j++){
            pnode=pnode.next;
        }
        Object old=pnode.data;
        return old;
    }


    @Override
    public Object replace(int i, Object o) {
        if(i<0||i>=size){
            throw new IndexOutOfBoundsException("越界");
        }
        Node newnode=getNode(i);
        newnode.data=o;
        return newnode.data;
    }

    @Override
    public boolean insertBefore(Object p, Object e) {
        if(contains(p)){
            insert(indexOf(p),e);
            return true;
        }
        return false;
    }

    @Override
    public boolean insertAfter(Object p, Object e) {
        if(contains(p)){
            insert(indexOf(p)+1,e);
            return true;
        }
        return false;
    }


    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;
        }
    }

/*    public void show(){
        if(isEmpty()){
            return;
        }
        Node pnode=first;
        while(pnode!=null){
            System.out.print(pnode.data);
            System.out.print(" ");
            pnode=pnode.next;
        }
    }*/

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

package basic.practic;

public class MydoubleLinkTest {
    public static void main(String[] args) {
        MydoubleLink t =new MydoubleLink();
        System.out.println(t.getSize());//0
        System.out.println(t.isEmpty());//true

        t.insert(0,"aa");
        t.insert(1,"bb");
        t.insert(2,"cc");
        t.insert(2,"dd");

        System.out.println(t.getSize());//4
        System.out.println(t);//[aa,bb,cc,dd]

//        t.show();
        System.out.println(t.contains("aa"));//true
        System.out.println(t.contains("ee"));//false

        System.out.println(t.remove(2));//dd
        System.out.println(t);//[aa,bb,cc]

        System.out.println(t.get(2));//cc
        System.out.println(t.replace(2,"AA"));//AA
        System.out.println(t);//[aa,bb,AA]

        System.out.println(t.insertBefore("bb","BB"));//true
        System.out.println(t);//[aa,BB,bb,AA]
        System.out.println(t.insertAfter("bb","BB"));//true
        System.out.println(t);//[aa,BB,bb,BB,AA]

    }
}