千峰Java教程：072. 数据结构之链表②

书接上文

然后是删除操作，可以看一下：

public class Demo1
{
	public static void main(String[] args)
	{
		NodeManager nm = new NodeManager();
		nm.add(5);
		nm.add(4);
		nm.add(3);
		nm.add(2);
		nm.add(1);
		nm.print();
		nm.del(3);
		nm.print();
	}
}

class NodeManager
{
	private Node root;
	
	public void add(int data)
	{
		if(root == null)
		{
			root = new Node(data);
		}
		else
		{
			root.addNode(data);
		}
	}
	public void del(int data)//删除操作，删除哪个节点，用int data
	{
		if(root.getData() == data)//如果要删除的是根节点的话，根节点应该就等于下一个根节点了
		{
			root = root.next;
		}
		else//否则，根节点下面还有节点，这就进入内部类了
		{
			root.delNode(data);
		}
	}
	public void print()
	{
		if(root != null)
		{
			System.out.print(root.getData() + "->");
			root.printNode();
			System.out.println();
		}
	}
	public boolean find(int data)
	{
		
		return false;
	}
	public void update(int oldData, int newData)
	{
		
	}
	public void insertNode(int index, int data)
	{
			
	}
	
	private class Node
	{
		private int data;
		private Node next;
		
		public Node(int data)
		{
			this.data = data;
		}
		public void setData(int data)
		{
			this.data = data;
		}
		public int getData()
		{
			return data;
		}
		
		//下面是增、删、输出、查询、修改、插入方法。这些方法只能是NodeManager来用，主函数不知道这些，这时候，就在NodeManager里也加上这些方法
		public void addNode(int data)
		{
			if(this.next == null)
			{
				this.next = new Node(data);
			}
			else
			{
				this.next.addNode(data);
			}
		}
		public void delNode(int data)
		{
			if(this.next != null)//先判断这个的下一个节点等不等于空，等于空就退出了，如果不等于空：
			{
				if(this.next.data == data)//如果等于要删除的data，
				{
					this.next = this.next.next;
				}
				else//否则就递归，再看看下面那个节点是不是跟传进去要删的data一样
				{
					this.next.delNode(data);//因为这个next也是Node类型，所以也可以调用Node里的递归
				}
			}
		}
		public void printNode()
		{
			if(this.next != null)
			{
				System.out.print(this.next.data + "->");
				this.next.printNode();
			}
		}
		public boolean findNode(int data)
		{
			return false;
		}
		public void updateNode(int oldData, int newData)
		{
			
		}
		public void insertNode(int index, int data)
		{
			
		}
	}
}
/*
结果：
5->4->3->2->1->
5->4->2->1->
*/

再来看一看查找该链表是否存在所查询的节点：

public class Demo1
{
	public static void main(String[] args)
	{
		NodeManager nm = new NodeManager();
		nm.add(5);
		nm.add(4);
		nm.add(3);
		nm.add(2);
		nm.add(1);
		nm.print();
		nm.del(3);
		nm.print();
		System.out.println(nm.find(1));
		System.out.println(nm.find(3));
	}
}

class NodeManager
{
	private Node root;
	
	public void add(int data)
	{
		if(root == null)
		{
			root = new Node(data);
		}
		else
		{
			root.addNode(data);
		}
	}
	public void del(int data)
	{
		if(root == null)
		{
			System.out.println("链表中没有数据！");
			return;
		}
		if(root.getData() == data)
		{
			root = root.next;
		}
		else
		{
			root.delNode(data);
		}
	}
	public void print()
	{
		if(root != null)
		{
			System.out.print(root.getData() + "->");
			root.printNode();
			System.out.println();
		}
	}
	public boolean find(int data)
	{//147
		if(root == null)//首先看看该链表是不是空链表，如果空，返回false
			return false;
		if(root.getData() == data)//如果非空，看看根节点是不是要找的节点，是则true
		{
			return true;
		}
		else//不是则递归查找
		{
			return root.findNode(data);
		}
	}
	public boolean update(int oldData, int newData)
	{
		return false;
	}
	public void insertNode(int index, int data)
	{
			
	}
	
	private class Node
	{
		private int data;
		private Node next;
		
		public Node(int data)
		{
			this.data = data;
		}
		public void setData(int data)
		{
			this.data = data;
		}
		public int getData()
		{
			return data;
		}
		
		//下面是增、删、输出、查询、修改、插入方法。这些方法只能是NodeManager来用，主函数不知道这些，这时候，就在NodeManager里也加上这些方法
		public void addNode(int data)
		{
			if(this.next == null)
			{
				this.next = new Node(data);
			}
			else
			{
				this.next.addNode(data);
			}
		}
		public void delNode(int data)
		{
			if(this.next != null)
			{
				if(this.next.data == data)
				{
					this.next = this.next.next;
				}
				else
				{
					this.next.delNode(data);
				}
			}
		}
		public void printNode()
		{
			if(this.next != null)
			{
				System.out.print(this.next.data + "->");
				this.next.printNode();
			}
		}
		public boolean findNode(int data)
		{//59
			if(this.next != null)//先看看后面的链表是不是空链表，不是才能往下进行
			{
				if(this.next.data == data)//这是，找到了那个数据，返回true
				{
					return true;
				}
				else//这次没找到，则接着往下递归
				{
					return this.next.findNode(data);
				}
			}
			return false;//最后都没找到，返回false
		}
		public boolean updateNode(int oldData, int newData)
		{
			return false;
		}
		public void insertNode(int index, int data)
		{
			
		}
	}
}
/*
结果：
5->4->3->2->1->
5->4->2->1->
true
false
*/
//注意，有些类里面的方法，要加上return，否则返回的true可能返回的是false，这次我这个findNode的方法有一个没加，就这样错了

再看看更新节点：

public class Demo1
{
	public static void main(String[] args)
	{
		NodeManager nm = new NodeManager();
		nm.add(5);
		nm.add(4);
		nm.add(3);
		nm.add(2);
		nm.add(1);
		nm.print();
		nm.del(3);
		nm.print();
		System.out.println(nm.find(1));
		System.out.println(nm.find(3));
		nm.update(2, 6);
		nm.print();
	}
}

class NodeManager
{
	private Node root;
	
	public void add(int data)
	{
		if(root == null)
		{
			root = new Node(data);
		}
		else
		{
			root.addNode(data);
		}
	}
	public void del(int data)
	{
		if(root == null)
		{
			System.out.println("链表中没有数据！");
			return;
		}
		if(root.getData() == data)
		{
			root = root.next;
		}
		else
		{
			root.delNode(data);
		}
	}
	public void print()
	{
		if(root != null)
		{
			System.out.print(root.getData() + "->");
			root.printNode();
			System.out.println();
		}
	}
	public boolean find(int data)
	{//147
		if(root == null)
			return false;
		if(root.getData() == data)
		{
			return true;
		}
		else
		{
			return root.findNode(data);
		}
	}
	public boolean update(int oldData, int newData)
	{//162
		if(root == null)//看看链表是否为空，为空就不往下执行了
		{
			System.out.println("链表中找不到数据！");
			return false;
		}
		if(root.getData() == oldData)//不为空，看根节点是不是等于原先传进去的节点，要是等于，更新这个节点
		{
			root.setData(newData);
			System.out.println("替换成功！");
			return true;
		}
		else//要是不等于，往下递归查找
		{
			return root.updateNode(oldData,newData);
		}
	}
	public void insertNode(int index, int data)
	{
			
	}
	
	private class Node
	{
		private int data;
		private Node next;
		
		public Node(int data)
		{
			this.data = data;
		}
		public void setData(int data)
		{
			this.data = data;
		}
		public int getData()
		{
			return data;
		}
		
		//下面是增、删、输出、查询、修改、插入方法。这些方法只能是NodeManager来用，主函数不知道这些，这时候，就在NodeManager里也加上这些方法
		public void addNode(int data)
		{
			if(this.next == null)
			{
				this.next = new Node(data);
			}
			else
			{
				this.next.addNode(data);
			}
		}
		public void delNode(int data)
		{
			if(this.next != null)
			{
				if(this.next.data == data)
				{
					this.next = this.next.next;
				}
				else
				{
					this.next.delNode(data);
				}
			}
		}
		public void printNode()
		{
			if(this.next != null)
			{
				System.out.print(this.next.data + "->");
				this.next.printNode();
			}
		}
		public boolean findNode(int data)
		{//59
			if(this.next != null)
			{
				if(this.next.data == data)
				{
					return true;
				}
				else
				{
					return this.next.findNode(data);
				}
			}
			return false;
		}
		public boolean updateNode(int oldData, int newData)
		{//72
			if(this.next == null)//递归过来，如果这个节点是空，则返回false
			{
				return false;
			}
			else//否则
			{
				if(this.next.data == oldData)//如果这个节点是咱们要找的这个节点，就更新
				{
					this.next.data = newData;
					return true;
				}
				else//否则接着往下递归
				{
					return this.next.updateNode(oldData, newData);
				}
			}
		}
		public void insertNode(int index, int data)
		{
			
		}
	}
}
/*
结果：
5->4->3->2->1->
5->4->2->1->
true
false
5->4->6->1->
*/

注意上面的几个方法，它们都是先检查有没有根节点，然后往下来走。