Java实现双向链表

用java实现双向链表

程序解释见注释

interface My_Method {

    My_Data Get_Node(Object value);//开辟节点

    void Init_list(My_Data head);//初始化

    void NLinkListPushBack(My_Data head, Object value);//尾插

    void printlist(My_Data head);//打印

    void NLinkListPopBack(My_Data head);//尾删

    void NLinkListPushFront(My_Data head,Object value);//链表头插

    void NLinkListPopFront(My_Data head);//链表头删

    My_Data DLinkListFind(My_Data head,Object value);//按照值寻找节点

    void DLinkListInsert(My_Data pos,Object value);//在指定位置之前插入节点

    void DLinkListInsertAfter(My_Data pos, Object value);//在指定位置之后插入节点

    void DLinkListErase(My_Data pos);//删除指定位置的节点

    void DLinkListRemove(My_Data head,Object value);//删除指定位置的元素(所有的)

    void Delete_DLinkList(My_Data head);

}

class My_Data {//节点的结构
    public Object data;//Object接受任意类型的参数
    public My_Data prev;
    public My_Data next;
    My_Data(Object data) {//在创建新节点的时候使用此构造方法
        this.data = data;
    }
    My_Data() {
    }
}

    class Test implements My_Method {

        @Override
        public My_Data Get_Node(Object value) {//开辟节点
            My_Data New_Node = new My_Data(value);
            New_Node.next = null;
            New_Node.prev = null;
            return New_Node;
        }

        @Override
        public void Init_list(My_Data head) {//清空链表
            head.data = null;
            head.next = head;
            head.prev = head;
        }

        @Override
        public void NLinkListPushBack(My_Data head, Object value) {//链表尾插
            if (head == null) {
                return;
            }
            My_Data New_Node = Get_Node(value);
            My_Data Old_Node = head.prev;
            //New_Node vs Old_Node
            Old_Node.next = New_Node;
            New_Node.prev = Old_Node;
            //head vs New_Node
            head.prev = New_Node;
            New_Node.next = head;
        }

        @Override
        public void NLinkListPopBack(My_Data head) {//链表尾删
            if (head == null) {
                return;
            }
            if (head.next == head && head.prev == head) {
                return;
            }
            My_Data New_Tail = head.prev.prev;
            //New_Tail vs head
            head.prev = New_Tail;
            New_Tail.next = head;
        }

        @Override
        public void NLinkListPushFront(My_Data head, Object value) {//链表头插
            My_Data New_Node = Get_Node(value);
            My_Data Old_Node = head.next;
//            New_Node vs Old_Node
            New_Node.next = Old_Node;
            Old_Node.prev = New_Node;
//            head vs New_Node
            head.next = New_Node;
            New_Node.prev = head;
        }

        @Override
        public void printlist(My_Data head) {//链表打印
            My_Data cur = head.next;
            while (cur != head) {
                System.out.print(cur.data + " ");
                cur = cur.next;
            }
            System.out.println(" ");
            cur = head.prev;
            while (cur != head) {
                System.out.print(cur.data + " ");
                cur = cur.prev;
            }
            System.out.println(" ");
        }

        public void NLinkListPopFront(My_Data head) {//链表头删
            if (head == null) {
                return;
            }
            if (head.next == head && head.prev == head) {
                return;
            }
            My_Data New_Node = head.next.next;
//             New_Node vs head
            New_Node.prev = head;
            head.next = New_Node;
        }

        @Override
        public My_Data DLinkListFind(My_Data head, Object value) {//按照数值寻找节点
            if (head == null) {
                return null;
            }
            if (head.next == head && head.prev == head) {
                return null;
            }
            My_Data cur = head.next;
            while (cur != head) {
                if (cur.data == value) {
                    return cur;
                }
                cur = cur.next;
            }
            return null;
        }

        @Override
        public void DLinkListInsert(My_Data pos, Object value) {//在指定位置之前插入节点
            if (pos == null) {
                return;
            }
            My_Data New_Node = Get_Node(value);
            My_Data Before_pos = pos.prev;
//            New_Node vs Before_pos
            Before_pos.next = New_Node;
            New_Node.prev = Before_pos;
//            New_Node vs pos
            New_Node.next = pos;
            pos.prev = New_Node;
        }

        @Override
        public void DLinkListInsertAfter(My_Data pos, Object value) {//在指定位置之后插入节点
            if (pos == null) {
                return;
            }
            My_Data New_Node = Get_Node(value);
            My_Data After_pos = pos.next;
//            After_pos vs New_Node
            New_Node.next = After_pos;
            After_pos.prev = New_Node;
//            pos vs New_Node
            pos.next = New_Node;
            New_Node.prev = pos;
        }

        @Override
        public void DLinkListErase(My_Data pos) {//删除指定位置的节点
            if (pos == null) {
                return;
            }
            if (pos.next == pos && pos.prev == pos) {
                return;
            }
            My_Data After_pos = pos.next;
            My_Data Before_pos = pos.prev;
//            After_pos vs Before_pos
            After_pos.prev = Before_pos;
            Before_pos.next = After_pos;
        }

        @Override
        public void DLinkListRemove(My_Data head, Object value) {//删除指定数值的元素
            if (head == null) {
                return;
            }
            if (head.next == head && head.prev == head) {
                return;
            }
            My_Data cur = head.next;
            while (cur != head) {
                My_Data temp = cur.next;
                if (cur.data == value) {
                    DLinkListErase(cur);
                }
                cur = temp;
            }
        }

        @Override
        public void Delete_DLinkList(My_Data head) {//删除整个链表
            My_Data cur = head.next;
            My_Data temp;
            while(cur != head){
                temp = cur.next;
                cur.prev = null;
                cur.next = null;
                cur = temp;
            }
            head.next = null;
            head.prev = null;
        }
    }

    public class Main {
        public static void main(String[] args) {
            My_Data my_data = new My_Data();//创建新的双向链表
            My_Method My_Test = new Test();//向上转型创建测试对象
            My_Test.Init_list(my_data);//初始化
            My_Test.NLinkListPushBack(my_data,"1");//尾插
            My_Test.NLinkListPushBack(my_data,"2");//尾插
            My_Test.NLinkListPushBack(my_data,"3");//尾插
            My_Test.NLinkListPopBack(my_data);//尾删
            My_Test.NLinkListPushFront(my_data,"4");//头插
            My_Test.NLinkListPushFront(my_data,"5");//头插
            My_Test.NLinkListPushFront(my_data,"6");//头插
            My_Test.NLinkListPopFront(my_data);//头删
            My_Data ret = My_Test.DLinkListFind(my_data,"4");//根据值返回节点
            My_Test.DLinkListInsert(ret,"asd");//在指定位置之前插入节点
            My_Test.DLinkListInsertAfter(ret,"789");
            My_Test.DLinkListErase(ret);
            My_Test.NLinkListPushFront(my_data,"5");//头插
            My_Test.NLinkListPushFront(my_data,"7");//头插
            My_Test.NLinkListPushFront(my_data,"5");//头插
            My_Test.DLinkListRemove(my_data,"5");
            My_Test.NLinkListPushBack(my_data,8);//尾插
            My_Test.NLinkListPushBack(my_data,'b');//尾插
            My_Test.NLinkListPushBack(my_data,20.0);//尾插
            My_Test.printlist(my_data);//打印
            My_Test.Delete_DLinkList(my_data);//删除链表
        }
    }