单向链表

注意：

构造函数名不带泛型

链表 LinkedList

单向链表 SinglyLinkedList

 

get、set、add、remove、length、isEmpty、clear

 

get时可直接返回值，set时返回老值(跟Map的put一样)

add时，记得也前节点关联

add时，若为空链表，则将要添加的节点设为头节点

只add元素时，相当于：

 

add(E element) =  add(Integer.MAX_VALUE, element);  

 

单链表结点类Node声明如下：

  

public class Node<E>  {      public E Data;      public Node<E> Next;        public Node(E data,Node<E> next)      {          this.Data = data;          this.Next = next;      }        public Node(E Data)      {          this(Data,null);      }        public Node()      {          this(null,null);      }  }  

 

Node<E>类有两个成员变量，data表示结点的数据域，保存数据元素本身，数据类型是E；next表示结点的地址域，保存后继结点的地址。

Node类中成员变量next的数据类型是Node类自己，Node类是“自引用的类”。所谓自引用的类(self-referential calss)，是指一个类声明包含一个引用当前类的对象的成员变量。

 

建立并链接结点的语句如下：

  

public class MainForm  {      public static void main(String args[])      {          Node<String> CC =new Node<String>("C");          Node<String> BB =new Node<String>("B",CC);          Node<String> AA =new Node<String>("A",BB);                    System.out.println(AA.Data);          System.out.println(AA.Next.Data);          System.out.println(AA.Next.Next.Data);      }  }  

 

单链表的头指针head也是一个结点引用，声明如下：

Node<E> head = null;  

 

当head ==null时，表示空单链表。

 

 

实现：

public class SinglyLinkedList<E>            //单链表类  {      protected Node<E> head;                //头指针，指向单链表第一个结点            public SinglyLinkedList()              //构造空单链表      {          this.head = null;      }            public SinglyLinkedList(Node<E> head)  //构造指定头指针的单链表      {          this.head = head;      }                  //判断单链表是否为空      public boolean isEmpty()                  {          return this.head == null;      }             //返回单链表长度，单链表遍历算法      public int length()                     {          int i = 0;          Node<E> p = this.head;          while(p != null)          {              i ++;              p = p.Next;          }          return i;      }                  //返回序号为index的对象，若单链表为空或序号错误则返回null      public E get(int index)                {          if(this.head != null && index >= 0)          {              int j = 0;              Node<E> p = this.head;              while(p != null && j < index)              {                  j ++;                  p = p.Next;              }              if(p !=null)              {                  return (E)p.Data;              }          }          return null;      }                  //设置序号为index的对象为element，若操作成功，返回原对象，否则返回null     public E set(int index,E element)                               {          if(this.head != null && index >= 0 && element != null)          {              int j = 0;              Node<E> p = this.head;              while(p != null && j < index)              {                  j ++;                  p = p.Next;              }              if(p != null)              {                  E old = (E)p.Data;                  p.Data = element;  //若操作成功，则返回原对象                  return old;                                                 }          }  //操作不成功        return null;                                                  }            //插入element对象，插入后对象序号为index，若操作成功返回true      public boolean add(int index,E element)                         {          if(element ==null)          {              return false; //不能添加空对象(null)          }         //头插入          if(this.head == null || index <= 0)           {              Node<E> q = new Node<E>(element);              q.Next = this.head;              this.head = q;              //this.head = new Node(element,this.head); //头插入，相当于上述3句          }  //单链表不空且index>=1          else          {              int j = 0;              Node<E> p = this.head;              while(p.Next != null && j < index - 1)               //寻找插入位置              {                  j ++;                  p = p.Next;              }              Node<E> q = new Node<E>(element);                   //中间/尾插入              q.Next = p.Next;                                    //q插入在p结点之后              p.Next = q;              //p.Next = new Node(element,p.Next);                //中间/尾插入，相当于上述3句          }          return true;      }            //在单链表最后插入对象        public boolean add(E element)                                   {          return add(Integer.MAX_VALUE,element);      }                  //移去序号为index的对象，若操作成功则返回被移去的对象，否则返回null        public E remove(int index)                                      {          E old = null;          if(this.head != null && index >= 0)          {              if(index == 0)                                      //头删除              {                  old = (E)this.head.Data;                  this.head = this.head.Next;              }              else                                                //中间/尾删除              {                  int j = 0;                  Node<E> p = this.head;                  while(p.Next != null && j < index - 1)           //定位到待删除结点的前驱结点                  {                      j ++;                      p = p.Next;                  }                  if(p.Next != null)                  {                      old = (E)p.Next.Data;                       //若操作成功，返回被移去对象                      p.Next = (p.Next).Next;                     //删除p的后继结点                  }              }          }          return old;      }             //清空单链表      public void clear()                                            {          this.head = null;      }          //返回所有元素值对应的字符串          public String toString()                                        {          String str = "(";          Node<E> p = this.head;          while(p != null)          {              str += p.Data.toString();              p = p.Next;              if(p != null)              {                  str += ",";              }          }          return str + ")";      }  }