向自定义单向链表增加数据，　出现死循环

jige_hanhan 2013-10-22 04:24:27
向自定义单向链表增加数据，　出现死循环。debug了好久，　也没看出来原因。鄙视自己了好一会儿后，　决定发到ＣＳＤＮ求救。　多谢了！


public class LinkedArray {

	private Entry root;

	private int count;

	public static void main(String[] args) {

		LinkedArray la = new LinkedArray();

		for (int i = 0; i < 10; i++) {

			la.add(i+"");

		}		

	}

	

	public LinkedArray() {

		

	}



	private class Entry{

		private String data;

		private Entry next;

		

		private boolean add(String data){//有死循环

			while(this.next!=null){

				this.next.add(data);

			}

			if(this.next==null){

				this.next = new Entry(data);

			}

			return true;

		}

		

		



		public Entry(String data) {

			this.data = data;

		}

	}

	

	public boolean add(String value){

		if(value == null){

			return false;

		}

		this.count++;

		if(root==null){

			root = new Entry(value);

		}else{

			this.root.add(value);

		}

		return true;

	}

	

	

	



}
...全文
351 13 打赏 收藏 举报
写回复
用AI写文章
13 条回复
切换为时间正序
请发表友善的回复…
发表回复
jige_hanhan 2013-10-24
  • 打赏
  • 举报
 回复
引用 9 楼 preferme 的回复:
自己写了一个。
import java.util.Iterator;


/**
 * 带表头的单向链表。
 * 可以用迭代器，遍历里面的元素。
 */
public class OneWayList<T> implements Iterable<T>{

	class Entry{
		T data;
		Entry next;
		public Entry(T data) {
			this.data = data;this.next=null;
		}
	}
	
	/**
	 * 单向链表的表头，表头不存放数据。
	 */
	private Entry header = new Entry(null);
	
	public void add(T data){
		Entry tail = header;
		while(tail.next!=null){
			tail = tail.next;//指针后移
		}
		tail.next = new Entry(data);
	}
	
	/**
	 * 迭代器
	 */
	private class Iter implements Iterator<T>{
		Entry p = header;
		public boolean hasNext() {
			return p.next!=null;
		}
		public T next() {
			p = p.next;
			return p.data;
		}
		public void remove() {
			throw new IllegalStateException("Not support this operation.");
		}
	}
	
	public Iterator<T> iterator() {
		return new Iter();
	}
	
	/**
	 * 测试用例
	 */
	public static void main(String[] args) {
		OneWayList<String> la = new OneWayList<String>();         
		for (int i = 0; i < 10; i++) {             
			la.add(i+"");         
		}    
		for(String s :la){
			System.out.println(s);
		}
	}


}
这个超级棒！
jige_hanhan 2013-10-24
  • 打赏
  • 举报
 回复
在大家的帮助下，　我修改了代码并成功实现单向链表加数据。原因：递归本身就有ｗｈｉｌｅ的特性，然而我在ｗｈｉｌｅ中又调用了递归，才导致了死循环。我把ｗｈｉｌｅ改成了ｉｆ，　就成功执行了。代码如下： 

public class LinkedArray {
	private Entry root;
	private int count;
	public static void main(String[] args) {
		LinkedArray la = new LinkedArray();
		for (int i = 0; i < 10; i++) {
			la.add(i+"");
		}	
		System.out.print(la);
	}
	
	public LinkedArray() {
		
	}

	private class Entry{
		private String data;
		private Entry next;
		
		private boolean add(String data){
			
			if(this.next!=null){
				this.next.add(data);
				
			}else{
				this.next = new Entry(data);
			}
//			if(this.next==null){
//				this.next = new Entry(data);
//			}
			return true;
		}
		
		

		public Entry(String data) {
			this.data = data;
		}
	}
	
	public boolean add(String value){
		if(value == null){
			return false;
		}
		this.count++;
		if(root==null){
			root = new Entry(value);
		}else{
			this.root.add(value);
		}
		return true;
	}
	
	
	

}
冰思雨 2013-10-22
  • 打赏
  • 举报
 回复
修改楼主的代码如下：
public class LinkedArray {
	private Entry root;
	private int count;

	private class Entry {
		private String data;
		private Entry next;

		public Entry(String data) {
			this.data = data;
		}
	}

	public boolean add(String value) {
		if (value == null) {
			return false;
		}
		this.count++;
		if (root == null) {//没有表头就要先判断根是否为空
			root = new Entry(value);
		} else {
			Entry tail = root;
			while(tail.next!=null){
				tail = tail.next;
			}
			tail.next = new Entry(value);
		}
		return true;
	}
	
	public static void main(String[] args) {
		LinkedArray la = new LinkedArray();
		for (int i = 0; i < 10; i++) {
			la.add(i + "");
		}
	}

}
wind_elf 2013-10-22
  • 打赏
  • 举报
 回复
public class LinkedArray { private Entry root; private int count; public static void main(String[] args) { LinkedArray la = new LinkedArray(); for (int i = 0; i < 10; i++) { la.add(i + "fsad"); } } public LinkedArray() { } public boolean add(String value) { if (value == null) { return false; } this.count++; if (root == null) { root = new Entry(value); } else { root.add(value); } return true; } private class Entry { private String data; private Entry next; /* private boolean add(String data) {// 有死循环 while(this.next != null) { this.next.add(data); } if (this.next == null) { this.next = new Entry(data); } return true; } */ private boolean add(String data) { Entry last=null; for(last = root;last.next!=null;last=last.next); last.next = new Entry(data); System.out.println(last.data); return true; } public Entry(String data) { this.data = data; } } }
冰思雨 2013-10-22
  • 打赏
  • 举报
 回复
自己写了一个。
import java.util.Iterator;


/**
 * 带表头的单向链表。
 * 可以用迭代器，遍历里面的元素。
 */
public class OneWayList<T> implements Iterable<T>{

	class Entry{
		T data;
		Entry next;
		public Entry(T data) {
			this.data = data;this.next=null;
		}
	}
	
	/**
	 * 单向链表的表头，表头不存放数据。
	 */
	private Entry header = new Entry(null);
	
	public void add(T data){
		Entry tail = header;
		while(tail.next!=null){
			tail = tail.next;//指针后移
		}
		tail.next = new Entry(data);
	}
	
	/**
	 * 迭代器
	 */
	private class Iter implements Iterator<T>{
		Entry p = header;
		public boolean hasNext() {
			return p.next!=null;
		}
		public T next() {
			p = p.next;
			return p.data;
		}
		public void remove() {
			throw new IllegalStateException("Not support this operation.");
		}
	}
	
	public Iterator<T> iterator() {
		return new Iter();
	}
	
	/**
	 * 测试用例
	 */
	public static void main(String[] args) {
		OneWayList<String> la = new OneWayList<String>();         
		for (int i = 0; i < 10; i++) {             
			la.add(i+"");         
		}    
		for(String s :la){
			System.out.println(s);
		}
	}


}
寻找IT之路 2013-10-22
  • 打赏
  • 举报
 回复
引用
private class Entry{
private String data;
private Entry next;

private boolean add(String data){//有死循环
while(this.next!=null){
this.next.add(data); // 当i为2的时候，死循环是一直添加到root.next
}
if(this.next==null){
this.next = new Entry(data);
}
return true;
}

此处有问题 while(this.next!=null){
this.next.add(data); // 当i为2的时候，死循环是一直添加到root.next
}
teemai 2013-10-22
  • 打赏
  • 举报
 回复 

public class LinkedArray {
    private Entry root;
    private int count;
    public static void main(String[] args) {
        LinkedArray la = new LinkedArray();
        for (int i = 0; i < 10; i++) {
            la.add(i+"");
        }       
    }
     
    public LinkedArray() {
         
    }
 
    private class Entry{
        private String data;
        private Entry next;
         
        private boolean add(String data){//有死循环
            while(this.next!=null){
                this.next.add(data); // 当i为2的时候，死循环是一直添加到root.next
            }
            if(this.next==null){
                this.next = new Entry(data);
            }
            return true;
        }
         
         
 
        public Entry(String data) {
            this.data = data;
        }
    }
     
    public boolean add(String value){
        if(value == null){
            return false;
        }
        this.count++;
        if(root==null){
            root = new Entry(value);
        }else{
            this.root.add(value);
        }
        return true;
    }
     
     
     
 
}
闲鱼野鹤-PJY 2013-10-22
  • 打赏
  • 举报
 回复
引用 5 楼 zhuweisyyc 的回复:
最后this.next还是赋值了，还是跳不出循环啊
逻辑问题，换个思路吧，这个终止条件不合逻辑， 按你这逻辑的话，在while里要加上this.next=null; 试试吧
zhuweisyyc 2013-10-22
  • 打赏
  • 举报
 回复
最后this.next还是赋值了，还是跳不出循环啊
jige_hanhan 2013-10-22
  • 打赏
  • 举报
 回复
引用 1 楼 u010684923 的回复:
把if(this.next==null){ this.next = new Entry(data); } 这句放到while前面看看
同样的问题
jige_hanhan 2013-10-22
  • 打赏
  • 举报
 回复
引用 2 楼 zhuweisyyc 的回复:
这个第二次add的时候Root的next不空不是死了吗 while(this.next!=null){                 this.next.add(data);             }
这个是递归调用，while里面的this.next.add(data),执行后，在第二次调用递归时，this就变成了，上一层的this.next了。
zhuweisyyc 2013-10-22
  • 打赏
  • 举报
 回复
这个第二次add的时候Root的next不空不是死了吗 while(this.next!=null){                 this.next.add(data);             }
闲鱼野鹤-PJY 2013-10-22
  • 打赏
  • 举报
 回复
把if(this.next==null){ this.next = new Entry(data); } 这句放到while前面看看
单向链表和双向链表的优缺点及使用场景
单向链表：只有一个指向下一个节点的指针。 优点：单向链表增加删除节点简单。遍历时候不会死循环； 缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。 适用于节点的增加删除。 双向链表：有两个指针，一个指向前一个节点，一个后一个节点。 优点：可以找到前驱和后继，可进可退； 缺点：增加删除节点复杂，需要多分配一个指针存储空间。 适用于需要双向查找节点值的情况。 ...
单向链表与双向链表区别
单向链表： 由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为null,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。 双向链表： 对于双向链表来说，它的每个节点要指向“直接前驱”和“直接后继”，所以节点类需要含有两个指针域。指向直接前驱的指针使用pre表示，指向后继的指针使用next表示。双向链表是在单向链表基础上的一个改进，每个节点指向其直接前驱和直接后继节点。因此，从双向链表的任
单向链表和双向链表有什么区别？各自有什么优缺点？
1、指向不bai同：单向链表只有du一个指向下一结点的指针，zhi双向链表除了有一个指dao向下一结点的指针外，还有一个指向前一结点的指针。 2、功能不同：单向链表只能next ，双向链表可以return。 3、单双向不同：单链表只能单向读取，双向链表可以通过prev()快速找到前一结点。 单向链表优缺点： 1、优点：单向链表增加删除节点简单。遍历时候不会死循环； 2、缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。 双向链表优缺点： 1、优点：可以找到前驱和后继，可进可退
java实现单向链表
目录单向链表示意图：单向链表实现代码：测试：结果： 单向链表示意图： 以下是单链表相对于双链表的优缺点。 优点 （1) 只有一个指向下一个节点的指针。 （2) 单向链表增加删除节点简单。遍历时候不会死循环。 缺点 （1) 只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。 单向链表实现代码： import java.util.Arrays; import java.util.Iterator; import java.util.NoSuchElementException; import j
单向链表的原理和基本实现(Java实现)
单向链表的原理和基本实现(Java实现) 基本原理 链表是一种数据存储结构。在Java原生JDK中对于链表也进行了相应实现。 单向链表是链表的其中一种，其主要原理是: 链表是以节点（Node）的形式存储数据，节点对象中存储了要保存的数据。 单向链表中的每一个节点中都持有下一个节点的引用（Node next），通过上一个节点就可以找到下一个节点，依次串联，所以想要遍历整个单向链表就需要找到第一个节点。 链表不同于数组，在内存中不一定是连续的空间，由于是节点存储，可以利用内存中零散的空间进行保存，只需持有下一
Java SE

62,620

社区成员

307,251

社区内容

发帖
与我相关
我的任务
社区描述
Java 2 Standard Edition
社区管理员
  • Java SE
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章