单链表----java语言实现

节点

  数据域：存放数据

  指针域:存放下一个数据的地址

1、常用操作

  查找

  插入

  删除

查找：

（1）按照索引查找index位置上的节点：从头节点head开始依次向下找到第index位置的节点。

（2）找到指定数据的索引位置：查找是否有节点中存放的数据与给定的数据相同，若有则返回节点的位置，没有返回-1.从头节点开始，一一对比。

插入：

（1）头插法：每次插入的新节点作为链表的头节点

（2）尾插法：在链表的尾部插入心节点

（3）在指定的索引位置插入：将值为element的新节点插入到链表index的位置，首先找到位置index-1位置的节点，生成一个新节点newNode,让index-1的next指向新节点，新节点指向原来index.

删除

将链表的第index个节点删除。先找到链表中index-1处的节点，让index-1处的节点指向原来index+1的节点，并释放index处的节点。

代码实现：

public class LinkList<T>
{
	private class Node//节点类
	 {
	 	   private T data;
	 	   private Node next;
	 	   public Node()
	 	   {
	 	   }
	 	   public Node(T data,Node next)
	 	   {
	 		  this.data = data;
	 		  this.next = next;
	 	   }
	 }
	
	private Node head;//指向链表头节点的引用变量
	private Node tail;//指向链表尾节点的引用变量
	int size;//链表中当前总节点数
	//生成链表对象是一个空表 
	public LinkList()
	{
		head = null;
		tail = null;
	}
	//生成链表对象时有一个头节点 （有参构造器）
	public LinkList (T data)
	{
	  head = new Node(data,null);//指定一个头节点的数据域值为data,不指向其他节点
	  tail = head;
	  size++;
	}
	//返回链表的长度
	public int length()
	{
		return size;
	}
	//获取指定位置的元素
	public T getElement(int index)
	{
	  return findNodeByIndex(index).data;
	}
	//查找    指定索引位置的节点
	public Node findNodeByIndex(int index)
	{
		if(index < 0 || index > size-1)
		{
			throw new IndexOutOfBoundsException("线性表索引越界");
		}
		Node current = head;//从头节点开始下移遍历
		for (int i = 0;i < size &¤t.next!=null;i++,current = current.next)
		{
			if(i == index)
			{
				return current;
			}
		}
		return null;
	}
	//查找      指定元素的位置(查找数据域存放的是element的节点位置)
	public int findIndexByElement(T element)
	{
		Node current = head;//从第一个节点开始查找对比数据
		for(int i=0; i<size&¤t.next!=null;i++,current=current.next)
		{
			if(current.data.equals(element))
				return i;
		}
		return -1;
	}
	//插入  在指定位置插入一个元素
	public void insert(int index,T element)
	{
		if(index < 0 || index > size)
		{
			throw new IndexOutOfBoundsException("线性表索引越界");
		}
		if(head == null)//如果链表为空，直接调用add方法
		{
			add(element);
		}
		else //链表不为空时
		{
			if(index==0)//在链表头插入
			{
				addAtHead(element);
			}
			else
			{
				Node prev = findNodeByIndex(index-1);//找到要插入位置的前一个节点
				prev.next = new Node(element,prev.next);//插入后prev的next指向新节点，新节点的next指向原来prev的下一个节点
				size++;
			}
		}
		
	}
	//插入 尾插法在每次在链表尾添加新节点
	public void add(T element)
	{
		if(head==null)
		{
			head = new Node(element,null);
			tail = head;
		}
		else
		{
			Node newNode = new Node(element,null);
			tail.next = newNode;
			tail = newNode;
		}
		size++;
	}
	//插入 头插法在链表头部加入新节点
	public void addAtHead(T element)
	{
		//在头部插入新节点，就是让新节点的next指向原来的head,让新节点作为链表的头节点
		head = new Node(element,head);
		//newNode.next = head;
		//head = newNode;
		//如果插入之前是空链表
		if(tail==null)
		{
			tail=head;
		}
	}
	//删除指定位置的节点 返回删除节点中的元素值
	public T delete (int index)
	{
		Node deleteNode = null;
		if(index<0||index>size-1)
		{
			throw new IndexOutOfBoundsException("线性表索引越界");
		}
		if(index==0)//删除头节点
		{
			deleteNode = head;
		 	head = head.next;
		}
		else
		{
			Node prev = findNodeByIndex(index-1);//获取要删除的节点的前一个节点
			deleteNode = prev.next;//要删除的节点就是prev的next指向的节点
			prev.next=deleteNode.next;//删除以后prev的next指向被删除节点之前所指向的next
			
			deleteNode.next = null;
		}
		return deleteNode.data;
		
	}
	//删除  链表中最后一个元素
	public T removeLast()
	{
		return delete(size-1);
	}
	//清除链表中所有的元素
	public void clear()
	{
		head = null;
		tail = null;
		size = 0;
	}
	//判断链表是否为空
	public boolean isEmpty()
	{
		return size==0;
	}
	
	public String toString()//链表的输出  重写toString方法
	{
		if(isEmpty())
		{
			return "[]";
		}
		else
		{
			StringBuilder sb = new StringBuilder("[");//使用StringBuilder类
			for(Node current = head;current != null ; current = current.next)//从head开始遍历
			{
				sb.append(current.data.toString()+",");//把节点的数据拼接起来
			}
			int len = sb.length();
			return sb.delete(len-1,len).append("]").toString();//把最后一个元素的，删除然后加上]
		}
	}
}

测试

public class LinkListTest
{
   public static void main(String[] args)
 {
	LinkList<String> list = new LinkList<String>();
	    list.add("aa");
	    list.add("bb");
	    list.add("cc");
	    System.out.println(list);
	    list.addAtHead("11");
	    list.insert(1,"22");
	    System.out.println(list);
	    list.delete(2);
	    System.out.println(list);
	    list.clear();
	    System.out.println(list);
 }
}

运行结果：

[aa,bb,cc]
[11,22,aa,bb,cc]
[11,22,bb,cc]
[]