链表实例应用

目录

一：只实现链表的增加与访问

                    内部类访问属性

二：链表存储的内容是类的对象 

---

一：只实现链表的增加与访问

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);
	    	   }
	       }
	       /*在Node类里面处理数组的数据*/
    	   public void toArrayNode() {
    		   /*
    		    1:第一次调用：Link类  this=Link.root
   		        2:第二次调用：Node类  this=Link.root.next
   		      */
    		   //加上Link.原因：内部类使用外部类属性的标志
    		   Link.this.retArray[Link.this.foot++]=this.data;
    		   if(this.next!=null) {
    			   this.next.toArrayNode();
    		   }
    	   }
		}//Node类结束
	private Node root;//根节点
	private int count=0;
	private int foot;//节点索引下标
	private String[] retArray;//返回的数组
	public void add(String data) {
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {
			this.root.addNode(newNode);
		}
		count++;
	}
	  /*toArray()方法，用于返回数组*/
	  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");
    	String []data=all.toArray();
       for(int x=0;x<data.length;x++) {
    	   System.out.println(data[x]);
       }
    }
 }

下面只分析链表转换为动态数组访问

---

class Link{
    private class Node{//内部类Node
           private String data;
           private Node next;
           public Node(String data) {
               this.data=data;
           }
           public void toArrayNode() {
               Link.this.retArray[Link.this.foot++]=this.data;
               if(this.next!=null) {
                   this.next.toArrayNode();
               }
           }
        }//Node类结束
    private Node root;//根节点
    private int count=0;
    private int foot;//节点索引下标
    private String[] retArray;//返回的数组
      public String[] toArray() {
          if(this.root==null)  return null;
          this.foot=0;
          this.retArray=new String[this.count];
          this.root.toArrayNode();
          return this.retArray;
      }
}

---

分析：首先在Link类定义了一个数组：string[] retArray;通过函数：String[]  toArray()来进行链表转化动态数组功能，该函数首先要判断根节点存在，然后通过索引foot为0来保证从头遍历。this.retArray=new String[this.count];为已有的链表数据开辟空间。
至于具体的数据处理通过Node类的toArrayNode()去实现
  Link.this.retArray[Link.this.foot++]=this.data;
由于retArray和foot都是外部类Link的私有属性，内部类使用要加上类名.操作
this.retArray[this.foot++]就是当前对象操作。
最后想访问输出：主程序要
                String []data=all.toArray();
         for(int x=0;x<data.length;x++) {
           System.out.println(data[x]);  }
把返回的数组retArray直接赋值给：分配的data.

内部类访问属性

二：链表存储的内容是类的对象 

class Book{
	private String title;
	private double price;
	public Book(String title,double price) {
		this.price=price;
		this.title=title;
	}
	public String getInfo() {
		return "图书名称:"+this.title+";"+"图书价钱:"+this.price;
	}
	//由于链表有contains()和remove()功能，所以类中要有对象比较的操作
	public boolean compare(Book book) {
		if(book==null) {
			return false;
		}
		if(this==book) {
			return true;
		}
		if(this.price==book.price&&this.title.equals(book.title)) {
			return true;
		}
		else {
			return false;
		}
		}
	}

 这是一个书类，属性是价钱和书名，方法有构造方法和访问私有属性信息的getInfo()方法。由于链表有删除和查询操作，所以补充一个compare函数，用于判断是否找到对象。同一对象的两个判断：1：this==book，内存地址相同，指针指向同一区域。2：私有属性的值完全相等。

主要内容的修改： 

private class Node{
        private Book data;//数据是：类的对象名
        private Node next;
        public Node(Book data) {
            this.data=data;
        }}

    private Node root;
    private Book[] retArray;//数组存储的内容变为对象名

Link类：public void add(Book data) 
主程序：all.add(new Book("java",17.9));//注意对象是实例化

只实现增加：

class Book{
	private String title;
	private double price;
	public Book(String title,double price) {
		this.price=price;
		this.title=title;
	}
	public String getInfo() {
		return "图书名称:"+this.title+";"+"图书价钱:"+this.price;
	}
	//由于链表有contains()和remove()功能，所以类中要有对象比较的操作
	public boolean compare(Book book) {
		if(book==null) {
			return false;
		}
		if(this==book) {
			return true;
		}
		if(this.price==book.price&&this.title.equals(book.title)) {
			return true;
		}
		else {
			return false;
		}
		}
	}//end Book
class Link{
	private class Node{
		private Book data;
		private Node next;
		public Node(Book 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();
			}
		}
	}//end Node
	private Node root;
	private int count=0;
	private int foot;
	private Book[] retArray;
	public void add(Book data) {/*增*/
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {
			this.root.addNode(newNode);
		}
		this.count++;
	}
	public Book[] toArray() {/*Link:返回数组*/
		if(this.root==null) return null;
		this.foot=0;
		this.retArray=new Book[this.count];
		this.root.toArrayNode();//从根节点起，对retArray各元素赋值
		return this.retArray;
	}
	  }
public class transfer {
    public static void main(String[] args) {
    	Link all=new Link();
    	all.add(new Book("java",17.9));
    	all.add(new Book("jsp",33.3));
    	Book[] data=all.toArray();
    	for(int x=0;x<data.length;x++) {
    		System.out.println(data[x].getInfo());
    	}
    }
 }

全部实现：增删改查

class Book{
	private String title;
	private double price;
	public Book(String title,double price) {
		this.price=price;
		this.title=title;
	}
	public String getInfo() {
		return "名:"+this.title+";"+"价:"+this.price;
	}
	//由于链表有contains()和remove()功能，所以类中要有对象比较的操作
	public boolean compare(Book book) {
		if(book==null) {
			return false;
		}
		if(this==book) {
			return true;
		}
		if(this.price==book.price&&this.title.equals(book.title)) {
			return true;
		}
		else {
			return false;
		}
		}
	}//end Book
class Link{
	private class Node{
		private Book data;
		private Node next;
		public Node(Book data) {
			this.data=data;
		}
		public void addNode(Node newNode) {//内部类：增加
			if(this.next==null) {
				this.next=newNode;
			}
			else {
				this.next.addNode(newNode);
			}
		}
		public Book getNode(int index) {//内部类：查询
			if(Link.this.foot++==index) {
				return this.data;
			}
			return this.next.getNode(index);
		}
		public boolean containsNode(Book data) {//内部类：判断
			if(data.compare(this.data)) {
				return true;
			}
			else {
				if(this.next!=null)
					return this.next.containsNode(data);
				else 
					return false;
			}
		}
		public void setNode(Book data,int index) {//内部类：修改
			if(Link.this.foot++==index) {
				this.data=data;
			}
			else {
				this.next.setNode(data, index);
			}
		}
		public void removeNode(Node pre,Book data) {//删除(保存上一节点)
			if(data.compare(this.data)) {//数据的比较
				pre.next=this.next;
			}
			else {
				this.next.removeNode(this, data);
			}
		}
		public void toArrayNode() {//内部类：节点保存数据变为对象数组
			Link.this.retArray[Link.this.foot++]=this.data;
			if(this.next!=null) {
				this.next.toArrayNode();
			}
		}
	}//end Node
	private Node root;
	private int count=0;
	private int foot;
	private Book[] retArray;
	public void add(Book data) {/*增*/
		Node newNode=new Node(data);
		if(this.root==null) {
			this.root=newNode;
		}
		else {
			this.root.addNode(newNode);
		}
		this.count++;
	}
	public Book get(int index) {//查询具体某一个节点
		if(index>this.count) return null;
		this.foot=0;
		return this.root.getNode(index);
		
	}
	public boolean contains(Book data) {//判断包含关系(判断前看是否有数据)
		if(this.root==null||data==null) return false;
		this.foot=0;
		return this.root.containsNode(data);
	}
	public void set(Book data,int index) {//改
		if(index>this.count) return;
		this.foot=0;
		this.root.setNode(data,index);
	}
	public int size() {//得到链表长度
		return this.count;
	}
	public void remove(Book data) {//删
		if(this.contains(data)) {
			if(data.equals(this.root.data)) {
				this.root=this.root.next;
			}
			else {
				this.root.next.removeNode(this.root,data);//后一节点
			}
			this.count--;
		}
	}
	public Book[] toArray() {/*Link:返回数组*/
		if(this.root==null) return null;
		this.foot=0;
		this.retArray=new Book[this.count];
		this.root.toArrayNode();//从根节点起，对retArray各元素赋值
		return this.retArray;
	}
	  }
public class transfer {
    public static void main(String[] args) {
    	Link all=new Link();
    	all.add(new Book("aaa",111));
    	all.add(new Book("bbb",222));
    	all.add(new Book("ccc",333));
    	all.add(new Book("ddd",444));
    	all.add(new Book("eee",555));
    	all.remove(new Book("ddd",444));
    	all.remove(new Book("ccc",333));
    	Book[] data=all.toArray();
    	  for(int x=0;x<data.length;x++) {
    		System.out.println(data[x].getInfo());
    	}
    	
    }
 }

这个程序说明：链表就是动态的对象数组

private Book retArray[ ]=private Book[ ] retArray;