《Java数据结构和算法》单链表

1、链结点

链表中。每个数据项都被包含在链结点中（Link），即Node，每个链结点Link都包含一个data和一个对下一个链结点的引用

class Link{
    public int iData;
    public douvle dData;
    public Link next;//reference to next data
}

这种类定义有时叫“自引用”式，因为它包含了一个和自己类型相同的字段next. 一个真正的程序中data部分可能包含更多的数据类型，通常用一个包含这些数据类的对象来代替这些数据项。

class Link{
    public inventoryItem iT;//object holding data
   
    public Link next;
}

2、关于“引用”：

类型为Link的next字段仅仅是对另外一个对象的“引用”，而不是一个对象。

一个引用是一个对某个对象的参照数值，是一个计算机内存中对象地址，不需要知道它的具体值，只需要把它当成一个奇妙的数，它会告诉你对象在哪里。

对象与对象的引用：

 A a1 = new A();

A是一个类，new A()是对象，a1是对象的引用并不是对象。

A a2 = new A(); 

a1 = a2;//"="是一个传地址的过程，将a2指向的对象的地址传给a1,使a1指向a2对象的地址。

3、简单数据类型（int/double..）的存储与对象的存储。

double salary = 95663.00;

它在内存中创建了一个空间，并把数字95663.00放进去。

Link aLink = someLink; //someLink和aLink都指向Link类型的对象。

它把对Link对象的引用，叫做someLink,放到变量aLink中。而someLink对象本身是在其他地方的，通过这个语句，它没有移动，更不会被创建，它必须在此之前就已经被创建：

Link someLink = new Link();

someLink字段也没有真正拥有一个对象，它仍然是一个引用。

4、数组与链表

数组中，每个数据项占用一个特定的位置，通过下标去访问，而在链表中寻找一个特定元素的唯一方法就是沿着这个元素的链一直向下寻找，直到找到。

5、LinkList类

只包含一个数据项，即对链表第一个链结点的引用first.

  class LinkList {
  private Link first;
  
  public LinkList(){
   first = null;
  }
  
  public boolean isEmpty(){
   return(first==null);
  }
  }

6、单链表

包含链结点Link和LinkList类

package Structure;

class Link{
 public int iData;
 public double dData;
 public Link next;
public Link(int id,double dd){
 iData = id;
 dData = dd;
}

public void displayLink(){
 System.out.print("{"+iData+","+dData+"}");
}
}//end class Link(node)

 
 class LinkList {
  private Link first;
  
  public LinkList(){
   first = null;
  }
  
  public boolean isEmpty(){
   return(first==null);
  }
  
  public void insertFirst(int id,double dd){
   Link newLink = new Link(id,dd);
   newLink.next = first;
   first = newLink;
  }
  
  public Link deleteFirst(){
   Link temp = first;
   first = first.next;
   return temp;
  }
  
  public Link find(int key){
   Link current = first;
   while(current.iData!=key){
    if(current.next==null)
     return null;
    else
     current = current.next;
   }
   return current;
  }
  
  /*搜索要删除的链结点，它需要掌握的不仅是指向当前链结点（current）的引用,还有
   * 指向当前结点的前一个链结点（previous），因为当删除一个结点时必须把前一个结点和
   * 后一个结点连在一起*/
 
  public Link delete(int key){
   Link current = first;
   Link previous = first;
   while(current.iData!=key){
    if(current.next==null)
     return null;
    else{
     previous = current;
     current = current.next;
    }
   }
   if(current==first)
    first = first.next;
   else
    previous.next = current.next;
   return current;
  }
  public void displayList(){
   System.out.print("List(first-->last):");
   Link current = first;
   while(current!=null){
    current.displayLink();
    current = current.next;
   }
   System.out.println("");
  }
}//end class LinkList

public class LinkListD{
 
 public static void main(String[] args){
  LinkList theList = new LinkList();
  
  theList.insertFirst(22, 20.1);
  theList.insertFirst(12, 120.1);
  theList.insertFirst(202, 210.1);
  theList.insertFirst(232, 240.1);
  theList.insertFirst(242, 220.1);
  theList.insertFirst(212, 270.1);
  
  theList.displayList();
  
  Link f = theList.find(212);
  if(f!=null)
   System.out.println("found link with key "+f.iData);
  else
   System.out.println("Can't find link");
  
  Link d = theList.delete(232);
  if(d!=null)
   System.out.println("Deleted link with key "+d.iData);
  else
   System.out.println("Can't delete link");
  theList.displayList();
  
  while(!theList.isEmpty()){
   Link aLink = theList.deleteFirst();
   System.out.print("the deleted:");
   aLink.displayLink();
   System.out.println("");
  }
  theList.displayList();
 }
}