Java单链表的模板类

package shujujiegou;

public class ListNode4 {
	//带附加头结点的单链表的定义
	public class ListNode { //链表节点的定义
		ListNode data; //数据域
		ListNode next; //指针域
		ListNode first; //头指针
		ListNode(ListNode ptr){
			ptr = next; //仅初始化指针成员函数的构造函数
		}
		ListNode(ListNode item,ListNode ptr){
			//初始化数据与指针成员函数的构造函数
			ptr = null;
			data = item;
			next = ptr;
		}
		public ListNode(Object x) {
			// TODO Auto-generated constructor stub
		}
		public ListNode4.ListNode getHead() {
			// TODO Auto-generated method stub
			return null;
		}
	}
	private ListNode4.ListNode first;
	
	//将链表置为空表
	public  void makeEmpty(){
		ListNode q;
		while(first->next != null){ //当链不空时，删除链表所有结点
			q = first->next; 
			first->next = q->next; //保存被删结点，从链上摘下该结点
			delete q; //删除（仅保留一个表头结点）
		}
	} 
	
	//计算带附加头结点的单链表的长度
	public int Length(){
		int count = 0;
		ListNode p = first->next;
		while(p != null){ //循链扫描
			 p = p->next;
			 count++;
		}
		return count;
	}
	
	//在表中搜索含数据x的结点，搜索成功时函数返回该节点地址，否侧返回null值
	public Object Search(ListNode x){
		ListNode current = first->next;
		while(current != null){
			if(current->data == x) break; //循链找含x结点
			else current = current->next;
		}
		return current;
	}
	
	//定位函数，返回表中第i个元素的地址，若i<0或i超出表中结点个数，则返回null值
	public Object Locate(int i){
		if(i < 0) return null;
		ListNode current = first;
		int k =0;
		while(current != null && k <i){
			current = current->next; //循链找第i个结点
			k++;
		}
		return current; //返回第i个结点地址，若返回null值，表示i值太大
	}
	
	//取出链中第i个元素的值
	public Object getData(int i, int x){
		if(i <= 0) return null; //i值太小
		Object current =Locate(i);
		return current;
		if(current == null) return false; //i值太大
		else {
			x = current->data;
			return true;
		}
	}
	
	//给链表中第i个元素赋值x 
	public void setData(int i,int x){
		if(i <= 0) return; //i值太小
		Object current = Locate(i);
		if(current == null) return; //i值太大
		else current->data = x;
	}
	
	//将新元素x插入在链表中第i个结点之后
	public Object Insert(int i,int x){
		Object current = Locate(i);
		if(current == null) return null; //插入不成功
		ListNode newNode = new ListNode(x);
		if(newNode == null){
			System.out.print("存储分配错误！");
		}
		newNode->next = current->next; //链接在current之后
		current->next = newNode;
		return true; //插入成功
	}
	
	//将链表中的第i个元素删去，通过引用型参数x返回该元素的值
	public Object Remove(int i,int x){
		Object current = Locate(i-1);
		if(current == null || current->next == null) return false; //删除不成功
		ListNode del = current->next; //重新拉链，将被删结点从链中摘下
		current->next = del->next;
		x = del->data; //取出被删结点中的数据值
		delete del;
		return true;
	}
	
	//单链表的输出函数，将单链表中所有数据按逻辑顺序输出到屏幕中
	public void output(){
		ListNode current = first->next;
		while(current != null){
			System.out.print("current->data");
		}
		current = current->next;
	}
	
	//重载函数，赋值操作，形式如A=B，其中A市调用此操作的List对象，B是与参数表中的应用型参数L结合的实参
	public void operator(ListNode L){
		ListNode value;
		ListNode srcptr = L.getHead(); //被复制表的附加头结点地址
		ListNode destptr = first = new ListNode;
		while(srcptr->next != null){ //逐个结点复制
			value = srcptr->next->data;
			destptr->next = new ListNode(value);
			destptr = destptr->next;
			srctptr = srcptr->next;
		}
		destptr->next = null;
		return this; //返回操作对象地址
	}
	
	public static void main(String[] args) {

	}
}