双端链表

1数据结构

 2 特点

保持一个对链表最后一个元素的引用

3 方法摘要

class FirstLastList
   { // -------------------------------------------------------------
   public boolean isEmpty()      ;    // true if no links 
// ------------O[1]-------------------------------------------------
   public void insertFirst(LinkNode dd)  ;// insert at front of list 
// ------------O[1]-------------------------------------------------
   public void insertLast(LinkNode dd)  ; // insert at end of list 
// ------------O[1]-------------------------------------------------
   public long deleteFirst()   ;      // delete first link 
// -------------O[1]------------------------------------------------
   public void displayList();
// -------------------------------------------------------------
   }  // end class FirstLastList

4 代码

4.1 链表节点元素

public class LinkNode extends Object{
    public int iData;//data
    public double dData;//data
    public LinkNode next; //reference to next link
    
    //constructor
    public LinkNode(int id,double dd){
        iData = id;
        dData = dd;
    }
    public void displayLink(){
        //display itself
        System.out.println
        ("iData  :  "+iData+"    dData:"+dData);
    }
}//end class LinkNode

4.2 双向链表

public class FirstLastList {
    public static LinkNode first;
    private static LinkNode last;
    //ref to first link on list
    public void LinkList(){
        first = null;
        last = first;
        // constructor : no items on list yet
    }
    public boolean isEmpty(){
        return first==null;
    }
    /*时间效率 O(1)*/
    public void insertFirst(int i,double d){
        LinkNode newNode = new LinkNode(i,d);
         
            newNode.next = first;
            first = newNode; 
    }
    /*时间效率 O(1)*/
    public void insertLast(int i,double d){
        LinkNode newNode = new LinkNode(i,d);
        if(isEmpty()){
            last= newNode;
            first = last;
        }
         last.next = newNode ; 
         last= newNode;
    }
    public void displayList(){
        LinkNode current = first;
        System.out.println("From first to last   :");
        while(current!=null){
            current.displayLink();
            current = current.next;
        }
    } 
    /*时间效率 O(1)*/
    public LinkNode deleteFirst(){ 
        if (isEmpty()){
            return null;
        }
        LinkNode temp = first;
        first = first.next;
        return temp;
    }
 
    public LinkNode deleteDedecate(LinkNode node){//O[N] : 包含线性查找 
        LinkNode current = first;                                                                   
          LinkNode pre = current;                                                                     
          while (current!=null){//the  loop end condition:traverse to the last node of the link       
              if(current.dData == node.dData && current.iData==node.iData){//find the node                    
                if(current == first) first = first.next;                                                
                  pre.next = current.next;                                                                
                  return current;                                                                         
              }else{//go on to find it                                                                  
                  pre = current;                                                                          
                  current = pre.next;                                                                     
              }                                                                                         
          }                                                                                           
          return null;     
    }
    public LinkNode find(LinkNode node){//O[N] : 包含线性查找 
        LinkNode current = first;
         while (current!=null){
        //     current.displayLink();
             if(current.dData ==node.dData && current.iData == node.iData){
                 return current;
             }
            current = current.next;
         }
        return null;
    }
}

4.3 APP

    public static void main(String[] args) {
                //make a new List
                FirstLastList theList = new FirstLastList();
                //insert nodes
                theList.insertLast(11, 11.11);
                theList.insertLast(22, 22.22);
                theList.insertLast(33, 33.33);
                theList.insertLast(44, 44.44);  
                 
                System.out.println("Before delete  ---");
                theList.displayList();
                theList.deleteFirst();   
                theList.deleteDedecate(new LinkNode(33,33.33));
                System.out.println("After delete  ---");
                theList.displayList();  
                LinkNode node = theList.find(new LinkNode(22,22.22));
                if(node!=null){
                    System.out.println("Find the following one :"+node.iData +"   "+node.dData);
                }
    }
}

 5 双端链表的应用 实现队列Queue

5.1 队列

first in first out(先进先出)

public interface Queue {
//队列尾部插入一个新的元素
    public void insert(LinkNode node);
    //队列头部删除一个元素
    public Object remove();
    //查询队列头部(最前端)的一个元素
    public Object peekFront();
    public void display();
}

/*用双端链表实现队列  */
public class LinkQueue implements Queue{
    private FirstLastList theList;
    public LinkQueue(){
        theList = new FirstLastList();
    }
    public boolean isEmpty(){
        return theList.isEmpty();
    }
 
    public void insert(LinkNode node){
        theList.insertLast(node.iData, node.dData);
    }
    public LinkNode remove(){
        LinkNode node = theList.deleteFirst();
        return node;
    }
    public void display(){
        theList.displayList();
    }

public class LinkQueueApp {
    public static void main(String[] args) {
        LinkQueue que = new LinkQueue();
        que.insert(new LinkNode(10,10.10));
        que.insert(new LinkNode(20,20.20));
        que.insert(new LinkNode(30,30.30));
        que.insert(new LinkNode(40,40.40));
        que.insert(new LinkNode(50,50.50));
        
        que.display();
        System.out.println("Insert has been done  ");
        
        que.remove(); 
        que.display();
        System.out.println("Remove has been done  ");
    }
}

 

6 双端链表特点

6.1 尾部插入新节点 -- > 可以实现队列

7  双端链表缺陷

FirstLastList保存对最后一个节点的引用,不能有助于删除最后一个链结点.因为没有一个引用指向倒数第二个链结点.

===>双向链表可以轻易做到这一点.