Java链表

链表的每一个节点中除了要保存本身的内容之后，还要保存下一个节点的引用

简单的建立一个链表，表头是root

//=================================================
// File Name       :	linked list demo
//------------------------------------------------------------------------------
// Author          :	Common
		

// 类名：Node
// 成员：1.节点内容
//　　　 2.下一个节点
// 方法：1.得到节点内容
//　　　 2.设置下一个节点
//　　　 3.取得下一个节点
class Node {
	private String data;	//保存节点内容
	private Node next;	//保存下一个节点
	
	public Node(String data){	//构造方法设置节点内容
		this.data = data;
	}
	
	public String getData(){	//得到节点内容
		return this.data;
	}
	
	public void setNext(Node next){		//设置下一个节点
		this.next = next;
	}
	
	public Node getNext(){	//取得下一个节点
		return this.next;
	}
};

//主类
//Function        : 	linked list
public class linkdemo {
	
	//主方法
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Node root = new Node("火车头");	//定义根节点
		Node n1 = new Node("车厢A");	//定义第1个车厢
		Node n2 = new Node("车厢B");	//定义第2个车厢
		Node n3 = new Node("车厢C");	//定义第3个车厢
		root.setNext(n1);	//火车头的下一个节点是第1个车厢
		n1.setNext(n2);	//第1个车厢的下一个节点是第2个车厢
		n2.setNext(n3);	//第2个车厢的下一个节点是第3个车厢
		printNode(root);
	}
	
	//输出方法，全局方法
	//输出节点的内容
	public static void printNode(Node node){
		System.out.println(node.getData());	//输出数据
		if(node.getNext() != null){	//判断节点是否为空
			printNode(node.getNext());	//继续向下打印
		}
	}

}

使用了内部类

在链表中进行删除、查询操作

//=================================================
// File Name       :	linked list demo
//------------------------------------------------------------------------------
// Author          :	Common
		


class Link{
	
	// 成员：1.root
	private Node root;	//建立根节点
	
	// 方法：1.添加节点方法
	public void addNode(String data){	
		Node newNode = new Node(data);	//建立一个新的节点
		if(this.root == null){
			this.root = newNode;						//如果没有根节点，则把上面建立的节点设置成根节点
		}else{
			this.root.add(newNode);					//如果有根节点，则把上面建立的节点设置成root节点后非空的节点
		}
	};
	
	// 方法：2.输出全部节点方法
	public void printNode(){		//输出节点的内容
		if(this.root != null){				//判断是否存在根节点
			this.root.print();					//继续向下打印
		}
	};
	
	// 方法：3.判断元素是否存在
	public boolean contains(String name){	//判断元素是否存在
		return this.root.search(name);	//调用Node类中的search()方法
	};
	
	// 方法：4.删除节点
	public void deleteNode(String data){		//删除节点
		if(this.contains(data)){					//判断节点是否存在
			if(this.root.data.equals(data)){			//判断根节点是否满足要求
				this.root = this.root.next;			//将根节点之后的节点设置成根节点
			}else{
				this.root.next.delete(root, data);		//删除节点
			}
		}
	}
	
	
	
	// 内部类名：Node
	// 成员：1.节点内容	2.下一个节点
	// 方法：1.得到节点内容	2.设置下一个节点	3.取得下一个节点	4.添加下一个节点	5.从某处删除一个节点	6.节点的查询结果	7.输出方法
	class Node {
		private String data;	//保存节点内容
		private Node next;	//保存下一个节点
		
		public Node(String data){	//构造方法设置节点内容
			this.data = data;
		}
		
		public String getData(){	//1.得到节点内容
			return this.data;
		}
		
		public void setNext(Node next){		//2.设置下一个节点
			this.next = next;
		}
		
		public Node getNext(){	//3.取得下一个节点
			return this.next;
		}
		
		public void add(Node newNode){		//4.添加下一个节点
			if(this.next == null){					//判断下一个节点是否为空
				this.setNext(newNode);				//如果下一个节点为空，则把新节点设置在next的位置上
			}else{							//如果不为空，则表示还有下一个节点
				this.next.add(newNode);				//在下一个位置处增加
			}
		}
		
		public void delete(Node preNode,String data){	//5.从某处删除一个节点
			if(data.equals(this.data)){				//找到了匹配的节点
				preNode.next = this.next;			//把前一个节点链接到后一个节点上
			}else{
				if(this.next != null){
					this.next.delete(this, data);		//继续向下找
				}
			}
		}
		
		public boolean search(String data){	//6.定义搜索方法
			if(data.equals(this.data)){			//判断当前节点的数据是否与查找的一致
				return true;
			}else{
				if(this.next != null){			//如果下一个节点存在，就继续查找
					return this.next.search(data);	//返回下一个节点的查询结果
				}else{
					return false;		
				}
			}
		}
		
		public void print(){				//7.定义全部输出方法
			System.out.print(this.data + "	");	//没有判断是否存在根节点
			if(this.next != null){			//如果下一个节点不为空的话，继续打印
				this.next.print();		//继续打印下一个节点
			}	
		}
		
	};
}


//主类
//Function        : 	linked list
public class linkdemo {
	
	//主方法
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Link l = new Link();
		l.addNode("A");
		l.addNode("B");
		l.addNode("C");
		l.addNode("D");
		l.addNode("E");
		System.out.println("===========删除之前===========");
		l.printNode();
		l.deleteNode("C");
		l.deleteNode("D");
		System.out.println();
		System.out.println("===========删除之后===========");
		l.printNode();
		System.out.println();
		System.out.println("查询节点:"+l.contains("A"));
	}	

}