5.双端链表和双向链表

双端链表：

        链表对象不仅保留了对头节点的引用还保留了对尾节点的引用。

实现：

public class FirstLastLinkList {
    //链表的头节点的引用，每个链表只关心自己的头节点是什么就可以找到所有的数据
    private Node first;
    //链表的尾节点的引用。
    private Node last;
    //构造空链表
    public FirstLastLinkList(){
        first=null;
        last=null;
    }
    //在头节点处插入node
    public void insertFirst(int data){
        Node node = new Node(data);
        node.setNext(first);
        first=node;
        //第一次插入节点时为last节点赋值
        if (last==null){
            last=node;
        }
    }
    //在链表的尾部插入新节点
    public void insertLast(int value){
        Node node = new Node(value);
        if (last==null){
            last=node;
            first=node;
        }else{
            last.setNext(node);
            last=node;
        }
    }
    //删除头节点
    public Node deleteFirst(){
        Node delete = first.getNext();
        first=first.getNext();
        return delete;
    }
    //根据数据查找节点
    public Node selectNode(int value){
        Node node=first;
        while (node.getData()!=value){
            if (node.getNext()==null){
                return null;
            }
            node=node.getNext();
        }
        return node;
    }
    //根据值删除一个节点
    public String deleteNode(int value){
        //当前的节点
        Node node=first;
        //上一个节点
        Node previous=first;
        while (node.getData()!=value){
            if (node.getNext()==null){
                return "false 未找到该节点";
            }
            previous=node;
            node=node.getNext();
        }
        if (node==first){
            first=first.getNext();
        }else{
            previous.setNext(node.getNext());
        }
        return "success 删除成功";
    }
    //显示所有的节点
    public void display(){
        Node node=first;
        while (node!=null){
            System.out.print(node.display()+"   ");
            node=node.getNext();
        }
    }
    //判断链表是否为空
    public boolean  isEmpty(){
        return first==null;
    }
}

 

双向链表：

              链表的节点中存储的不只有对下一个节点的引用，还存在着对上一个节点的引用。

Node：

public class Node {
    //数据域
    private int data;
    //节点域，存放下一个节点
    private Node next;
    private Node previous;

    public Node getPrevious() {
        return previous;
    }

    public void setPrevious(Node previous) {
        this.previous = previous;
    }

    public Node(int data){
        this.data= data;
        next=null;
        previous=null;
    }

    public int display(){
        return this.data;
    }


    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

DoubleLinkList:

public class DoubleLinkList {
    //链表的头节点的引用，每个链表只关心自己的头节点是什么就可以找到所有的数据
    private Node first;
    //链表的尾节点的引用。
    private Node last;
    //构造空链表
    public DoubleLinkList(){
        first=null;
        last=null;
    }
    //在头节点处插入node
    public void insertFirst(int data){
        Node node = new Node(data);
        node.setNext(first);
        node.setPrevious(null);
        first=node;
        //第一次插入节点时为last节点赋值
        if (last==null){
            last=node;
        }
    }
    //在链表的尾部插入新节点
    public void insertLast(int value){
        Node node = new Node(value);
        if (isEmpty()){
            first=node;
        }else{
            node.setPrevious(last);
            last.setNext(node);
        }
            last=node;
    }
    //删除头节点
    public boolean deleteFirst(){
        if (isEmpty()){
            return false;
        }else if (first.getNext()==null){
            first=null;
            last=null;
        }else {
            first.getNext().setPrevious(null);
            first=first.getNext();
        }
        return true;
    }
    //删除尾节点
    public boolean deleteLast(){
        if (isEmpty()){
            return false;
        }else if (last.getPrevious()==null){
            last=first=null;
            return true;
        }else {
            last=last.getPrevious();
            last.getNext().setPrevious(null);
            last.setNext(null);
            return true;
        }
    }
    //根据数据查找节点
    public Node selectNode(int value){
        Node node=first;
        while (node.getData()!=value){
            if (node.getNext()==null){
                return null;
            }
            node=node.getNext();
        }
        return node;
    }
    //根据值删除一个节点
    public String deleteNode(int value){
        //当前的节点
        Node node=first;
        while (node.getData()!=value){
            if (node.getNext()==null){
                return "false 未找到该节点";
            }
            node=node.getNext();
        }
        if (node==first){
            //获取下一个节点  设置原首节点的next为null  设置节点前引用为空
            first=first.getNext();
            first.getPrevious().setNext(null);
            first.setPrevious(null);
        }else{
            node.getNext().setPrevious(node.getPrevious());
            node.getPrevious().setNext(node.getNext());
        }
        return "success 删除成功";
    }
    //显示所有的节点
    public void display(){
        Node node=first;
        while (node!=null){
            System.out.print(node.display()+"   ");
            node=node.getNext();
        }
    }
    //判断链表是否为空
    public boolean  isEmpty(){
        return first==null;
    }
}

 

 

 

 

 

 

 

转载于:https://my.oschina.net/helloXia/blog/1860845