对链表的 操作

package com.test;
/*
 * 1、链表类
 * 2、一个构造方法，一个显示方法
 * */
public class Link {
	public int iData;
	public Link next;
	public Link previous;
	public Link(int id){
		iData = id;
	}
	public void displayLink(){
		System.out.println(iData+"---");
	}
}

双向链表：

package com.test;

/*
 * 双向链表
 * 
 *  3=current.pre   4=current  5=current.next
 * *****************************
 * | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
 * *****************************
 * */
public class DoublyLinkedList {
	private Link firstLink;
	private Link lastLink;
	
	public DoublyLinkedList(){
		firstLink = null;
		lastLink = null;
	}
	public boolean isEmpty(){
		return firstLink == null ;
	}
	public void insertFirst(int id){
		Link newLink = new Link(id);
		if(isEmpty()){					
			lastLink =newLink;			//若if成立 则必须给lastLink 赋值
		}else{							
			firstLink.previous = newLink;		//让第一个连接点的前一个连接点 等于 新的连接点
			newLink.next = firstLink;			//让新的连接点的下一个连接点 等于 第一个连接点			
		}
		firstLink = newLink;			//给第一个连接点赋值
	}
	public void insertLast(int id){
		Link newLink = new Link(id);
		if(isEmpty()){
			firstLink = newLink;		//若链表为空则让新的连接点 等于 第一个连接点等于
		}else{			
			lastLink.next = newLink;
			newLink.previous = lastLink;	
		}
		lastLink = newLink;
	}
	//在当前节点后面插入新的连接点
	public boolean insertAfter(int key,int id){
		Link current = firstLink;
		while (current.iData != key) {      //循环链表 当current = key时跳出循环
			current = current.next;
			if(current == null){
				return false;
			}
		}
		Link newLink = new Link(id);
		if(current == lastLink){			//当current = lastLink时
			newLink.next = null;
			lastLink = newLink;
		}else{								//否则
			newLink.next = current.next;	//新连接点的下一个 指向 当前连接点的下一个 
			current.next.previous = newLink;//当前连接点的前一个连接点 等于 新的连接点
		}
		newLink.previous = current;			//新的连接点的前一个连接点 等于 当前连接点
		current.next = newLink;				//当前连接点的下一个 等于 新的连接点
		return true;		
	}
	public Link deleteFirst(){
		Link tempLink = firstLink;
		if(firstLink.next == null){
			lastLink = null;
		}else{
			firstLink.next.previous = null;
			firstLink = firstLink.next;
		}	
		return tempLink;
	}	
	public Link deleteLast(){
		Link tempLink = lastLink;
		if(lastLink.previous == null){
			firstLink = null;
		}else{
			lastLink.previous.next = null;
			lastLink = lastLink.previous;
		}
		return tempLink;
	}
	public Link deleteKey(int key){
		Link current = firstLink;
		while (current.iData!=key) {
			current = current.next;
			if(current == null){
				return null;
			}
		}
		if(current == firstLink){			//当删除的等第一个连接点是
			firstLink = current.next;
		}else{
			current.previous.next = current.next; //被删除节点的前一个连接点指向被删除连接点的后一个连接点
		}
		if(current == lastLink){
			lastLink = current.previous;
		}else{
			current.next.previous = current.previous;//被删除节点的下一个连接点节点指向被删除节点的前一个连接点
		}
		return current;
	}
	public void displayForward(){
		System.out.println("List---(first--->last)");
		Link currentLink = firstLink;
		while(currentLink != null) {
			currentLink.displayLink();
			currentLink = currentLink.next;		
		}		
	}
	public void displayBackward(){
		System.out.println("List---(last--->first)");
		Link currentLink = lastLink;
		while (currentLink != null) {
			currentLink.displayLink();
			currentLink = currentLink.previous;
		}
	}
	public static void main(String[] args) {
		DoublyLinkedList list = new DoublyLinkedList();
		list.insertFirst(1);
		list.insertFirst(2);
		list.insertFirst(3);
		list.insertLast(4);
		list.insertLast(5);
		list.insertLast(6);
		list.displayForward();
		list.displayBackward();
		list.insertAfter(1, 7);
		list.displayForward();
		Link linkFirstLink = list.deleteFirst();  //在删除的时候应该先判断链表是否为空，此处省略
		System.out.println("deleteFirst--->"+linkFirstLink.iData);
		Link linkLastLink = list.deleteLast();
		System.out.println("deleteLast---->"+linkLastLink.iData);
		Link linkDeleteKey = list.deleteKey(1);
		System.out.println("delteKey------>"+linkDeleteKey.iData);
		

	}	
}

双端链表：

package com.test;
/*
 * 双端链表
 * 1、删除不掉最后一个连接点
 * */
public class FirstLastList {
	public Link first;
	public Link last;
	public FirstLastList(){
		first = null;
		last = null;
	}
	public boolean isEmpty(){
		return first == null;		
	}
	public void insertFirst(int id){
		Link newLink = new Link(id);
		if(isEmpty()){
			last = newLink;		若Link 为空 则insertFirst 将last指向新的连接点
		}
		newLink.next = first;
		first = newLink;		// 将新插入的值赋给链表中的第一个数
	}
	public void insertLast(int id){
		Link newLink = new Link(id);
		if(isEmpty()){
			first = newLink;	//若Link 为空 则insertLast 将first指向新的连接点
		}else{
			last.next = newLink;
		}
		last = newLink;			//将新插入的值赋给链表中最后一个数
	}
	//插入排序
	public void insert(Link k){
		Link previous = null;	//从表头开始
		Link current = first;
		while (current!=null && k.iData < current.iData ) {
			previous = current;			
			current = current.next;
			
		}
		if(previous == null){	//如果要插入的数在表头
			first = k;
		}else{					//如果要插入的数不在表头
			previous.next = k;
		}
		k.next = current;
	}
	public Link deleteLink(){
		Link temp = first;
		if(first.next!=null){
			last = null;
		}
		first.next = first;
		return temp;
	}
	public void display(){
		System.out.println("list :(first ---> last)");
		Link current = first;
		while (current != null) {
			current.displayLink();
			current = current.next;
		}
	}
	public static void main(String[] args) {
		FirstLastList fll = new FirstLastList();
		fll.insertFirst(1);
		//fll.insertFirst(2);
		fll.insertFirst(3);
		
		fll.insertLast(55);
		fll.insertLast(77);
		Link k = new Link(2);
		fll.insert(k);
		//fll.deleteLink();   //删除不掉最后一个
		fll.display();
		//fll.deleteLink();
		
	}
}

链表的增删查改

package com.test;

/*
 * 1、链表的插入、删除
 * 2、查找链表中指定的连接点
 * 3、删除链表中指定的连接点
 * 
 * */

public class LinkList {
	private Link  firstLink;   //链表中第一个数
	public LinkList(){
		firstLink = null;
	}
	public boolean isEmpty(){
		return (firstLink==null);
	} 
	public void insertFirst(int id){
		Link newLink = new Link(id);
		newLink.next = firstLink;	// 让新创建的连接点的next指向原来（第一个）的连接点
		firstLink = newLink;		// 改变原来firstLink的值，让他指向新的连接点	
	}
	public Link deleteFirst(){
		Link  temp = firstLink;    //在删除之前将链表中第一个存在temp中,然后删除firstLink（假设有删除操作）
		firstLink = firstLink.next;//将firstLink指向原来firstLink的下一个（next）
		return temp;			   //返回删除后的这个数
	}
	public void displayList(){
		Link current = firstLink;
		while (current != null) {
			current.displayLink();
			current = current.next;					
		}
	}
	/*
	 * currentLink 的变量开始指向第一个连接点（即，firstLink）
	 * 然后通过不断的把自身的值赋值给 currentLink.next，沿着链表向前移动
	 * 检查每个连接点的key 是否与 参数（id）相等
	 * 若找到匹配的，则返回此连接点的引用，否则返回 null
	 * */
	public Link find(int id){
		Link currentLink = firstLink;		//保存第一个连接点（即 currentLink 引用第一个练级点）
		while (currentLink.iData!= id) {	//若连接点的key 与参数是否相等
			if(currentLink.next == null){	//若连接点的的下一个为空
				return null;
			}else{
				currentLink = currentLink.next;	//否则让此连接点等于下一个连接点，继续循环			
			}		
		}
		return currentLink;
	}
	public Link deleteLink(int id){
		Link beforLink = firstLink;   //被删除数的前一个数
		Link tempLink = firstLink;	  //被删除的数
		while (tempLink.iData!=id) {
			if(tempLink == null){
				return null;
			}else{
				beforLink = tempLink;			//beforLink 始终等于 被删除数（tempLink） 的前一个数
				tempLink = tempLink.next;				
			}
		}
		if(tempLink == firstLink){			//若 被删除数（tempLink） 为 链表中的第一个数，则让firstLink 等于他的下一个
			firstLink = firstLink.next;
		}else{
			beforLink.next = tempLink.next;  //否则 让被删除数（tempLink） 的后一个数等于 被删除数的位置 （即beforLink.next） 
		}
		return tempLink;
	}
	public static void main(String[] args) {
		LinkList theLinkList = new LinkList();
		theLinkList.insertFirst(1);
		theLinkList.insertFirst(2);
		theLinkList.insertFirst(3);
		theLinkList.displayList();
		//循环删除 链表里面的值
		while (!theLinkList.isEmpty()) {
			Link aLink = theLinkList.deleteFirst();
			System.out.println("Delete");
			aLink.displayLink();			
		}		
		theLinkList.displayList();
		//找到指定的连接点
		Link  find = theLinkList.find(2);
		if(find!=null){
			System.out.println("find link with key--->"+find.iData);
		}else{
			System.out.println("can't find "+find.iData);
		}
		//删除指定的连接点
		Link delet = theLinkList.deleteLink(2);
		if(delet!=null){
			System.out.println("delete link with key--->"+find.iData);
		}else{
			System.out.println("can't find "+find.iData);
		}
	}
}