链表2:增删改查

目录

一：数据的增加  public void add(数据类型   变量)

二：取得链表中保存的元素个数  public int size() 

三：数据查询    public boolean contains(数据类型 变量) 

四：取得指定位置的链表的元素数据（索引查找） public  数据类型  get(int Index)

         修改指定索引内容 ：public void set (int index,数据类型，变量)

五：数据删除(最麻烦)  public void remove(数据类型 变量)

                     链表操作汇总 

操作（hard）：取得全部的数据（通过对象数组） public 数据类型【】toArray()

---

链表的增删改查等操作

        Node类负责：节点数据的保存和节点关系的匹配，故而不应该单独使用Node类.现在要修改设计结构让Node类只能被Link类使用。
        解决：使用内部类。一是：内部类可以使用private修饰，二是：内部类可以方便的与外部类之间进行私有属性的直接访问。

class Link{
	private class Node{//内部节点类
		private String data;
		private Node next;
		public Node(String data) {//由于内部类之间方便访问数据，故不需要函数：getDate,getNext
			this.data=data;
		}
	}
}

注意设置和访问属性值的函数统称为：setter,getter方法。

一：数据的增加  public void add(数据类型   变量)

思路：Link类负责节点对象的产生并且负责维护根节点；Node类负责所有节点的关系匹配

class Link{
	private class Node{//1：内部节点类
		private String data;
		private Node next;
		public Node(String data) {//由于内部类之间方便访问数据，故不需要函数：getDate,getNext
			this.data=data;
		}
		public void addNode(Node newNode) {//Node类负责节点的关系匹配
			if(this.next==null)
				this.next=newNode;
			else//向后继续保存（递归）
				this.next.addNode(newNode);
		}
		public void printNode() {
			System.out.println(this.data);
			if(this.next!=null) {
				this.next.printNode();
			}
		}
	}
	private Node root;//2：根节点
	/*3:Link类的内部函数*/
	public void add(String data) {
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {//根节点存在
			this.root.addNode(newNode);
		}
	}
	/*数据的访问*/
	public void print() {
		if(this.root!=null) {
			this.root.printNode();
		}
	}
}

public class transfer {
    public static void main(String[] args) {
    	Link all=new Link();
    	all.add("aaa");
    	all.add("bbb");
    	all.add("ccc");
    	all.add("ddd");
    	all.print();
    }
 }

分析：Link类有一个内部类Node，有一个私有属性：根节点（Node root）,有两个函数：1：访问链表数据的：print()2：增加元素的函数add().由于Node负责数据的保存和节点关系的匹配，所以都需要利用Node的内部函数addNode()和printNode()去保存。

二：取得链表中保存的元素个数  public int size() 

很容易：Link类加一个count属性，默认值为0；然后在link的add操作内部加一个count++,函数返回count值即可。

class Link{
	private class Node{//内部类Node
		private String data;
		private Node next;
		public Node(String data) {
			this.data=data;
		}
		public void addNode(Node newNode) {
			if(this.next==null) {
				this.next=newNode;
			}
			else {
				this.next.addNode(newNode);
			}
		}
		public void printNode() {
			System.out.println(this.data);
			if(this.next!=null) {
				this.next.printNode();
			}
		}
	}
	
	private Node root;//根节点
	private int count=0;//保存元素的个数
	public void add(String data) {//增加节点
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {
			this.root.addNode(newNode);
		}
		this.count++;
	}
	public void print() {//输出节点数据
		if(this.root!=null) {
			this.root.printNode();
		}
	}
	public int size() {
		return this.count;
	}
	}
	
public class transfer {
    public static void main(String[] args) {
    	Link all=new Link();
    	all.add("aaa");
    	all.add("bbb");
    	all.add("ccc");
    	all.add("ddd");
    	all.print();
    	System.out.println(all.size());
    }
 }

判断空链表 只需要判断count值是否为0；
public boolean isEmpty( )   {  return this.count==0; }

三：数据查询    public boolean contains(数据类型 变量) 

String 类的数据比较用到函数：equals(),数据查询是一个遍历的操作。

class Link{
	private class Node{//内部类Node
		private String data;
		private Node next;
		public Node(String data) {
			this.data=data;
		}
		public void addNode(Node newNode) {
			if(this.next==null) {
				this.next=newNode;
			}
			else {
				this.next.addNode(newNode);
			}
		}
		public boolean containsNode(String data) {
			if(data.equals(this.data)) 
				return true;
			else {
				if(this.next!=null) {
					return this.next.containsNode(data);
				}
				else {
					return false;
				}
			}
		}
	}
	
	private Node root;//根节点
	public void add(String data) {//增加节点
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {
			this.root.addNode(newNode);
		}
	}
	public boolean contains(String data) {
		if (data==null||this.root==null) {
			return false;
		}
		else {
			return this.root.containsNode(data);
		}
	}
	}
	
public class transfer {
    public static void main(String[] args) {
    	Link all=new Link();
    	all.add("aaa");
    	all.add("bbb");
    	all.add("ccc");
    	all.add("ddd");
    System.out.println(all.contains("bbb"));
    System.out.println(all.contains("eee"));
    }
 }

 link类：
    public boolean contains(String data) {
        if (data==null||this.root==null) {//判断操作：有根节点，有数据
            return false;
        }
        else {
            return this.root.containsNode(data);
        }
    }
Node类：
   public boolean containsNode(String data) {
            if(data.equals(this.data)) 
                return true;
            else {
                if(this.next!=null) {
                    return this.next.containsNode(data);
                }
                else {
                    return false;
                }
            }
        }

四：取得指定位置的链表的元素数据（索引查找） public  数据类型  get(int Index)

class Link{
	private class Node{//内部类Node
		private String data;
		private Node next;
		public Node(String data) {
			this.data=data;
		}
		public void addNode(Node newNode) {
			if(this.next==null) {
				this.next=newNode;
			}
			else {
				this.next.addNode(newNode);
			}
		}
		public String getNode(int index) {
			if(Link.this.foot++==index) {
				return this.data;
			}
			else {
				return this.next.getNode(index);
			}
		}
		}
	
	private Node root;//根节点
	private int count=0;
	private int foot;
	public void add(String data) {//增加节点
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {
			this.root.addNode(newNode);
		}
		this.count++;
	}
    public String get(int index) {
    	if(this.count<index) return null;
    	this.foot=0;
    	return this.root.getNode(index);
    }
	}
	
public class transfer {
    public static void main(String[] args) {
    	Link all=new Link();
    	all.add("aaa");
    	all.add("bbb");
    	all.add("ccc");
    	all.add("ddd");
        System.out.println(all.get(0));
    }
 }

 Link类：
    private int count=0;
    private int foot;//link类增加foot属性，表示每一个Node的编号
    public String get(int index) {
        if(this.count<index) return null;
        this.foot=0;//在索引符合标准时候，每次从头开始查询
        return this.root.getNode(index);//Node类执行具体查询操作
    }

 Node类：
    public String getNode(int index) {
            if(Link.this.foot++==index) {//foot是LInk类的，在Node类判断前加上：link.
                return this.data;
            }
            else {//由于判断了foot和count，故而不必：if(this.next!=null)
                return this.next.getNode(index);
            }
        }

由于链表是可以删除数据的，因而对应的索引编号是动态的。
Link类定义foot索引：每次在Node类查找时候要从跟去查。

修改指定索引内容 ：public void set (int index,数据类型，变量)

class Link{
	private class Node{//内部类Node
		private String data;
		private Node next;
		public Node(String data) {
			this.data=data;
		}
		public void addNode(Node newNode) {//增加节点
			if(this.next==null) {
				this.next=newNode;
			}
			else {
				this.next.addNode(newNode);
			}
		}
		public String getNode(int index) {//查询节点
			if(Link.this.foot++==index) {
				return this.data;
			}
			else {
				return this.next.getNode(index);
			}
		}
		public void setNode(int index,String data) {//修改节点
			if(Link.this.foot++==index) {
				this.data=data;
			}
			else {
				this.next.setNode(index, data);
			}
		}
		}
	
	private Node root;//根节点
	private int count=0;
	private int foot;
	public void add(String data) {//增
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {
			this.root.addNode(newNode);
		}
		this.count++;
	}
    public String get(int index) {//查
    	if(this.count<index) return null;
    	this.foot=0;
    	return this.root.getNode(index);
    }
    public void set(int index,String data) {//改
    	if(this.count<index) return;
    	this.foot=0;
    	this.root.setNode(index, data);
    }
	}
	
public class transfer {
    public static void main(String[] args) {
    	Link all=new Link();
    	all.add("aaa");
    	all.add("bbb");
    	all.add("ccc");
    	all.add("ddd");
    	all.set(0, "mmm");
        System.out.println(all.get(0));
    }
 }

 Link：
 public void set(int index,String data) {//改
        if(this.count<index) return;
        this.foot=0;
        this.root.setNode(index, data);
    }
Node:
    public void setNode(int index,String data) {//修改节点
            if(Link.this.foot++==index) {
                this.data=data;
            }
            else {
                this.next.setNode(index, data);
            }
        }
区别只是函数的参量多了一个需要改变的内容而已。而且不需要进行return操作

五：数据删除(最麻烦)  public void remove(数据类型 变量)

具体分为两种情况：
1：要删除的是根节点    指向：root=root.next;

   2：要删除的是普通节点

 

  

class Link{
	private class Node{//内部类Node
		private String data;
		private Node next;
		public Node(String data) {
			this.data=data;
		}
		public void addNode(Node newNode) {//增加节点
			if(this.next==null) {
				this.next=newNode;
			}
			else {
				this.next.addNode(newNode);
			}
		}
		public String getNode(int index) {//查询节点
			if(Link.this.foot++==index) {
				return this.data;
			}
			else {
				return this.next.getNode(index);
			}
		}
		public void setNode(int index,String data) {//修改节点
			if(Link.this.foot++==index) {
				this.data=data;
			}
			else {
				this.next.setNode(index, data);
			}
		}
		public void removeNode(Node pre,String data) {//删除节点
			if(data.equals(this.data)) {
				pre.next=this.next;
			}
			else {
				this.next.removeNode(this, data);
			}
		}
		}
	
	private Node root;//根节点
	private int count=0;
	private int foot;
	public void add(String data) {//增
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {
			this.root.addNode(newNode);
		}
		this.count++;
	}
    public String get(int index) {//查
    	if(this.count<index) return null;
    	this.foot=0;
    	return this.root.getNode(index);
    }
    public void set(int index,String data) {//改
    	if(this.count<index) return;
    	this.foot=0;
    	this.root.setNode(index, data);
    }
    public void remove(String data) {//删
    	if(data.equals(this.root.data)) {//Link直接处理根节点的删除
    		this.root=this.root.next;
    	}
    	else {
    		this.root.next.removeNode(this.root,data);
    	}
    }
	}
public class transfer {
    public static void main(String[] args) {
    	Link all=new Link();
    	all.add("aaa");
    	all.add("bbb");
    	all.add("ccc");
    	all.add("ddd");
    	all.remove("aaa");
        System.out.println(all.get(0));
    }
 }

 Link类：
public void remove(String data) {//删
        if(data.equals(this.root.data)) {//Link直接处理根节点的删除
            this.root=this.root.next;
        }
        else {
            this.root.next.removeNode(this.root,data);
        }
    }
Node类：
public void removeNode(Node pre,String data) {//删除节点
            if(data.equals(this.data)) {
                pre.next=this.next;
            }
            else {
                this.next.removeNode(this, data);
            }
        }

这个代码存在两个问题：
1：删除前应该先判断有没有数据
2：删除后count值应该减少

链表操作汇总 

class Link{
	private class Node{//内部类Node
		private String data;
		private Node next;
		public Node(String data) {
			this.data=data;
		}
		public void addNode(Node newNode) {//增加节点
			if(this.next==null) {
				this.next=newNode;
			}
			else {
				this.next.addNode(newNode);
			}
		}
		public String getNode(int index) {//查询节点
			if(Link.this.foot++==index) {
				return this.data;
			}
			else {
				return this.next.getNode(index);
			}
		}
		public void setNode(int index,String data) {//修改节点
			if(Link.this.foot++==index) {
				this.data=data;
			}
			else {
				this.next.setNode(index, data);
			}
		}
		public boolean containsNode(String data) {//判断指定节点是否存在
			if(data.equals(this.data)) 
				return true;
			else {
				if(this.next!=null) {
					return this.next.containsNode(data);
				}
				else {
					return false;
				}
			}}
		public void removeNode(Node pre,String data) {//删除节点
			if(data.equals(this.data)) {
				pre.next=this.next;
			}
			else {
				this.next.removeNode(this, data);
			}
		}
		public void printNode() {//访问数据
			System.out.println(this.data);
			if(this.next!=null) {
				this.next.printNode();
			}
		}
		}
	
	private Node root;//根节点
	private int count=0;
	private int foot;
	public void add(String data) {//增
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {
			this.root.addNode(newNode);
		}
		this.count++;
	}
    public String get(int index) {//查
    	if(this.count<index) return null;
    	this.foot=0;
    	return this.root.getNode(index);
    }
    public void set(int index,String data) {//改
    	if(this.count<index) return;
    	this.foot=0;
    	this.root.setNode(index, data);
    }
    public boolean contains(String data) {//判断存在与否
		if (data==null||this.root==null) {
			return false;
		}
		else {
			return this.root.containsNode(data);
		}
	}
    public void remove(String data) {//删
    	if(this.contains(data)) {
    	if(data.equals(this.root.data)) {//Link直接处理根节点的删除
    		this.root=this.root.next;
    	}
    	else {
    		this.root.next.removeNode(this.root,data);
    	}
    	this.count--;
    }}
    /*数据的访问*/
	public void print() {
		if(this.root!=null) {
			this.root.printNode();
		}
	}
	public int size() {
		return this.count;
	}
	}
public class transfer {
    public static void main(String[] args) {
    	Link all=new Link();
    	all.add("aaa");
    	all.add("bbb");
    	all.add("ccc");
    	all.add("ddd");
    	all.add("eee");
    	all.remove("ccc");
    	all.set(1, "fff");
        all.print();
        System.out.println(all.size());
    }
 }

操作（hard）：取得全部的数据（通过对象数组） public 数据类型【】toArray()

 任何情况，不管什么样的类都不能在类中使用输出语句，想输出只能将数据返回到调用处，由于链表是一个动态数组，所以用动态数组返回最好。

 首先在Link类增加一个可返回的动态数组

class Link{
	private class Node{//内部类Node
		private String data;
		private Node next;
		public Node(String data) {
			this.data=data;
		}
		public void addNode(Node newNode) {//增加节点
			if(this.next==null) {
				this.next=newNode;
			}
			else {
				this.next.addNode(newNode);
			}
		}
		public void toArrayNode() {
			Link.this.retarray[Link.this.foot++]=this.data;
			if(this.next!=null) {
				this.next.toArrayNode();
			}
		}
		}
	
	private Node root;//根节点
	private int count=0;
	private int foot;
	public String[] retarray;
	public void add(String data) {//增
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {
			this.root.addNode(newNode);
		}
		this.count++;
	}
	public String [] toArray() {
		if(this.root==null) return null;
		this.foot=0;
		this.retarray=new String[this.count];//开辟数组空间
		this.root.toArrayNode();
		return this.retarray;
	}
	}
public class transfer {
    public static void main(String[] args) {
    	Link all=new Link();
    	all.add("aaa");
    	all.add("bbb");
    	all.add("ccc");
    	all.add("ddd");
    	all.add("eee");
    	String []data=all.toArray();
    	for(int x=0;x<data.length;x++) {
        System.out.println(data[x]);}
    }
 }

清空链表： this.root=null; this.count=0;