数据结构之链表的实现

简介：

1.链表分为单链表和双链表；

2.单链表的每个节点都存储了后继节点的内存地址，但没有上个节点的内存地址；

3.双链表的每个节点都有前驱和后继；

1.单链表的实现：

   1.1接口类：定义了单链表的方法

public interface LinkedList {
    public boolean isEmpty();
    public int size();
    public Object get(int index);
    public void remove(int index);
    public void insert(int index, Object theElement);
    public void add(Object element);
    public void printList();
}

   1.2节点类：单链表节点

package LinearStructure.LinkedList;

public class Node {

    //存放的数据 
    private Object element;
    //下一个节点的地址
    private Node next;

    public Node(Object element,Node next) {
        element = "";
        next = null;
    }
   
    //获取数据
    public Object getElement() {
        return element;
    }

    //存放数据
    public void setElement(Object element) {
        this.element = element;
    }

    //获取下一个节点
    public Node getNext() {
        return next;
    }

    //设置下一个节点
    public void setNext(Node next) {
        this.next = next;
    }
}

   1.3单链表方法类

package LinearStructure.LinkedList;

public class SingleLinkedList implements LinkedList{
    //当前节点
    private Node cur;
    //前一个节点
    private Node pre;
    //头节点
    private Node head;
    //链表大小
    private int size;

    public SingleLinkedList() {
        head = null;
        size = 0;
        pre = null;
        cur = null;
    }

    //判断链表是否为空
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    //获取链表大小
    @Override
    public int size() {
        return size;
    }

    //找到当前节点索引
    @Override
    public Object get(int index) {
        setCurrent(index);
        return cur;
    }

    //删除指定位置节点
    @Override
    public void remove(int index) {
        if (index == 1){
            head = null;
        }else {
            setCurrent(index);
            pre.setNext(cur.getNext());
        }
        size--;
    }

    //指定位置插入节点
    @Override
    public void insert(int index, Object theElement) {
        if (index == 1) {
           Node new_Node = new Node(theElement,head);
           head = new_Node;
        }else {
            setCurrent(index);
            Node new_Node = new Node(theElement, pre.getNext());
            pre.setNext(new_Node);
        }
        size++;
    }

    //新增节点
    @Override
    public void add(Object element) {
        if (head == null){
            head = new Node(element,null);
        }else {
            setCurrent(size);
            cur.setNext(new Node(element,null));
        }
        size++;
    }

    //输出链表
    @Override
    public void printList() {
        Node aNode = head;
        while (aNode != null){
            System.out.println(aNode.getElement());
            aNode = aNode.getNext();
        }
    }

    //找到当前节点
    public void setCurrent(int index){
        int k;
        pre = null;
        cur = head;
        for (k  = 1; k < index; k++){
            pre = cur;
            cur = cur.getNext();
        }
    }
}

2.双链表的实现：

   2.1接口类：定义双链表的方法

package doublelinkedlistapp;


public interface LinearListInterface {
    public boolean isEmpty();
	public int size();
	public Object get(int index);
	public void remove(int index);
	public void add(int index, Object theElement);
	public String printList();
        
        public String printListBwd();

}

   2.2节点类：定义双链表

package doublelinkedlistapp;


public class DlNode {
        private Object element;
	private DlNode next;
	private DlNode prev;

    public DlNode(Object e, DlNode n, DlNode p){
	element = e;
	next = n;
        prev = p;
    }
    public DlNode getNext() {
	return next;
    }
    public void setNext(DlNode n) {
	next = n;
    }
    public DlNode getPrev() {
	return prev;
    }
    public void setPrev(DlNode p) {
	prev = p;
    }
    public Object getElement() {
        return element;
    }

    public void setElement(Object e) {
	element = e;
    }

}

  2.3双链表方法类

package doublelinkedlistapp;


public class DLList implements LinearListInterface
{
    private DlNode head;
    private int size;
    private DlNode curr;
    private DlNode prev;

    public DLList()
    {
      head = null;
      size = 0;
      curr = null;
      prev = null;
    }

    public boolean isEmpty()
    {
	 if (size ==0)
		return true;
	else
		return false;

    }

    public int size()
    {
	 return size;
    }

   // assume the index is in the correct range
   public void add(int index, Object item)
   {
       // special case of adding at the head of the list ( on the first position)
       if (index == 1)
      {
     	    DlNode newNode = new DlNode(item,head,null);
            head = newNode;
      }
      else
      {
            setCurrent(index);
            DlNode newNode = new DlNode(item, curr,null);
            prev.setNext(newNode);
      }
      // as  a new one was added the size counter must be increased by 1
      size=size+1;
   }

   //add an elemenst at the end of the list (on the last position)
   public void add(Object element)
   {
     DlNode newNode = new DlNode(element,null,null);
     if (head == null ) {
       	head = newNode;
        }
     else {
         setCurrent(size);
         curr.setNext(newNode);
     }
      size = size+1;
  }

    public Object get(int index) {
      setCurrent(index);
      return curr;
  }

  public void remove(int index){
  // special case for removing the head of the list / first node.
	if (index == 1){
            head = head.getNext();
	}
      else{
           // find the previous and current nodes
       	   setCurrent(index);
           prev.setNext(curr.getNext());
	}
     // as one node was removed the size counter must be decreased by 1
     size = size -1; 
  }

  private void setCurrent(int index){
      // sets curr to the node at position specified by index
      // sets prev to the node previous to curr
      int k;
      prev = null;
      curr = head;
      for (k  = 1; k < index; k++){
            prev = curr;
            curr = curr.getNext();
      }
   }
    //************************************************************/
    // Provide a printBackwardList() method which will print out       */
    // the information from the nodes starting from the last node up to the first node                                */
    //************************************************************/

    public String printListBwd()
    {
        int i = size;
        String allItems = new String();
        setCurrent(i);
        for (DlNode aNode = curr; aNode != null; aNode = prev)
         {
            String oneItem = (aNode.getElement()).toString();
            allItems = allItems+ oneItem + ", ";
            setCurrent(i);
            i--;
         }
        return allItems;
    }
    
    public String printList()
    {
        String allItems = new String(); 
        for (DlNode aNode = head; aNode != null; aNode = aNode.getNext())
         {
            String oneItem = (aNode.getElement()).toString();
            allItems = allItems+ oneItem + ", ";
         }
        return allItems;
    }
    
}