java 链表的输出问题

Posted 2023-04-19

我自己写了一个链表，但是当我加入的节点相同是，可以加入，但是在输出是时候，是一个死循环。希望各位大哥大姐，给点建议，我真的是

想好久了。但还是没想出解决的办法来。
下面是我的代码。

//节点类-----------------------------------------------------
public class Node
private Object d;
private Node next;
public Node(Object d)
super();
this.d = d;


public Object getD()
return d;

public Node getNext()
return next;

public void setD(Object d)
this.d = d;

public void setNext(Node next)
this.next = next;

public String toString()
return d+"";



//-----------------------链表类------------------

public class MyLinkedList
private Node head=null;
private Node tatil=null;
private int count=0;

public void addToTatil(Node node) //加在后面
if(head==null)
head=tatil=node;

else
tatil.setNext(node);
tatil=node;

count++;


public void show()
Node tmp=head;
while(tmp.getNext()!=null)
System.out.println(tmp.getD());
tmp=tmp.getNext();

System.out.println(tmp.getD());

public int getCount()
return count;



//=---------------测试---------------------

public class Test
public static void main(String[] args)
MyLinkedList mll=new MyLinkedList();

Node n=new Node(2);
mll.addToTatil(n);
mll.addToTatil(n);
mll.addToTatil(n);
mll.addToTatil(n);
System.out.println("节点的个数------"+mll.getCount());
mll.show();
// 通过打印mll.getCount()可以知道加入了4个节点，但是在打印节点内容的时候，出现是死循环。是不是打印函数有问

题？？？？



但是在list中可以插入相同的元素啊。
Node n=new Node(2);
List list=new ArrayList();
list.add(n);
list.add(n);
list.add(n);
这个是输出是时候就没有死循环啊。该怎么解决这个元素的重复性的问题呢？？？？

怎么解决链表中元素的重复性问题??????????

几位的回答都比较清楚了，我想另外说点问题

你本就不应该加入‘表尾’这个属性，在数据结构中链表的特点就是能用一个地址带一个长串数据链的，不用这个属性的话思路会更加清晰。我也用java模拟过一些基本数据结构：

public class MyNode<T>

public T value;
public MyNode<T> next;

public MyNode()


public MyNode(T value)
this.value = value;


public MyNode(MyNode<T> t)
this.value = t.value;
this.next = t.next;


public void connect(MyNode<T> t)
this.next = t;


@Override
public String toString()
return null==value?"":value+"->";



在这个节点定义的基础上的链表定义：
public class MyLinkList<T>

public MyNode<T> next;

public MyLinkList()
this.next = new MyNode<T>();


public MyLinkList(T[] tList)
if(tList.length==0)return;
next = new MyNode<T>(tList[0]);
MyNode<T> temp = next;
for (int i = 1; i < tList.length; i++)
temp.connect(new MyNode<T>(tList[i]));
temp = temp.next;



@Override
public String toString()
StringBuilder sb = new StringBuilder();
MyNode<T> t = next;
while (null != t)
sb.append(t);
t = t.next;

return sb.toString();




然后是相关的操作类：

public class LinkListAction

MyLinkList<Comparable> list;

public LinkListAction(MyLinkList<Comparable> list)
this.list = list;


/**
* 头插法建立单链表(数组)
* */
public void createFromHead(Comparable...objects)
MyNode<Comparable> start;
for (int i = 0; i < objects.length; i++)
start = new MyNode<Comparable>(objects[i]);
start.next = list.next;
list.next = start;


/**
* 尾插法建立单链表(数组)
* */
public void createFromTail(Comparable...objects)
MyNode<Comparable> start;
MyNode<Comparable> end = list.next;
for (int i = 0; i < objects.length; i++)
start = new MyNode<Comparable>(objects[i]);
end.next = start;
end = start;

end.next = null;


/**
* 在单链表中查找第i个结点
* */
public MyNode<Comparable> get(int i)
if(i < 0)return null;
MyNode<Comparable> node = list.next;
int index = 0;
while (node != null && index < i)
node = node.next;
index++;

return node;


/**
* 在单链表中的按值查找
* */
public MyNode<Comparable> locate(Comparable obj)
if(null == obj)return new MyNode<Comparable>();
MyNode<Comparable> node = list.next;
while (node != null && !obj.equals(node.value))
node = node.next;

return node;


/**
* 求单链表的长度
* */
public int getLength()
int length = 0;
MyNode<Comparable> node = list.next;
while(null != (node = node.next))
length++;

return length;


/**
* 单链表的插入操作(按位置)
* */
public void insert(Comparable obj,int location)
int length = 0;
MyNode<Comparable> node = list.next;
while(node!=null && location != length++)node = node.next;
if(null == node)throw new RuntimeException("插入位置有误！");
MyNode<Comparable> inserter = new MyNode<Comparable>(obj);
inserter.next = node.next;
node.next = inserter;


/**
* 删除数据
* */
public Comparable delete(int i)
int length = 0;
MyNode<Comparable> node = list.next;
while(node!=null && i != length++)node = node.next;
if(null == node)throw new RuntimeException("删除位置有误！");
Comparable o = node.next.value;
node.next = node.next.next;
return o;


/**
* 合并两个有序的单链表
* */
public static MyLinkList<Comparable> mergeLinkList(MyLinkList<Comparable> la,MyLinkList<Comparable> lb)
MyLinkList<Comparable> lc = new MyLinkList<Comparable>();
MyNode<Comparable> pc = lc.next;
MyNode<Comparable> pa = la.next.next;
MyNode<Comparable> pb = lb.next.next;
while(null != pa || null != pb)
if(null == pa)
pc.next = pb;
break;

if(null == pb)
pc.next = pa;
break;

if(pa.value.compareTo(pb.value) <= 0)
pc.next = pa;
pa = pa.next;

else
pc.next = pb;
pb = pb.next;

pc = pc.next;

return lc;


@Override
public String toString()
return list.toString();


public static void main(String[] args)
MyLinkList<Comparable> list1 = new MyLinkList<Comparable>();
MyLinkList<Comparable> list2 = new MyLinkList<Comparable>();
LinkListAction lla = new LinkListAction(list1);
// lla.createFromHead(1,3,4,6,8,10);
lla.createFromTail(1,3,4,6,8,10);
LinkListAction llb = new LinkListAction(list2);
llb.createFromTail(2,5,7,9,11);
System.out.println(lla);
System.out.println(llb);
// System.out.println(lla.locate(7));
// System.out.println(lla.getLength());
//
// lla.insert(20, 6);
// System.out.println(lla);
// System.out.println(lla.delete(4));

System.out.println(LinkListAction.mergeLinkList(lla.list, llb.list));
System.out.println(lla);
System.out.println(llb);




我还写了一些其他的简单数据结构，感兴趣的话，你可以Hi我一下，呵呵。
圣诞快乐！ 参考技术A 问题在你的主函数中，你的
mll.addToTatil(n);
这句加入的都是一个相同的节点，所以你添加了四次但是每一个节点指向的下一个节点都是自己所以是死循环
并且上面的
Node n=new Node(2);
那句也有问题
我想你的意思是想要定义一个节点数组，然后依次插入，应该改成如下的方式
Node n[] = new Node[4];
for (int i = 0; i < n.length; i++)
n[i].setD("Node:" + i);
mll.addToTatil(n[i]);
参考技术B 你在第四次mll.addToTatil(n)之前，tail就已经是n了，即tail == n在addTatil的时候，你把 tatil.setNext(n)，即n.setNext(n)，这样当然会是一个死循环了…… 参考技术C 加入链表的四个节点都指向一个对象，这个节点的next永远指向自己，于是就无限循环了
用不同的节点对象测试本回答被提问者采纳

每天一道算法题（java数据结构与算法)——＞删除链表的倒数第 N 个结点

这是LeetCode上的 [19，删除链表的倒数第 N 个结点]，难度为 [中等]

题目
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例1

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例2

输入：head = [1], n = 1
输出：[]

示例2

输入：head = [1,2], n = 1
输出：[1]

题解（双指针）
思路分析

删除链表的倒数第n个结点，我们只需要找到倒数第n+1个结点（倒数第n个结点的前一个结点）,然后让倒数第n+1个结点指向倒数第n-1个结点（倒数第n个结点的下一个结点），就可以实现删除链表的倒数第n个结点

步骤

1. 定义两个指针front,back指向头结点

2. 第1个指针front从链表的头结点开始遍历n步，第2个指针back保持不动；

3. 从第n+1步开始指针back也从链表的头结点开始和指针front以相同的速度遍历。

4. 当指针p1指向链表的尾节点时指针p2正好指向倒数第n+1个节点(两个指针的距离始终保持为n)

5. 把倒数第n+1个节点的next指针指向倒数第n-1个节点

注意：由于head是链表的第一个结点（带数据），为了减少判断head是否为null逻辑，以及防止删除头结点出现空指针异常等情况，需要提供一个哨兵结点（虚拟结点不带数据）作为头结点

代码实现

解类如下，类里包含两个方法，一个是遍历链表的，一个是删除链表的倒数第 N 个结点的

public class Solution 

    public static ListNode removeNthFromEnd(ListNode head, int n) 
        // 定义一个哨兵结点作为虚拟头结点,这样可以减少判断头结点是否为null和删除头结点逻辑判断
        ListNode<Integer> dummy = new ListNode<>(0);
        // 让哨兵结点指向头结点
        dummy.next = head;
        // 定义两个结点初始化为哨兵结点
        ListNode front = dummy;
        ListNode back = dummy;
        // front遍历n步
        for (int i = 0; i < n; i++) 
            front = front.next;
        
         /* front,back以相同的速度遍历，front接上次位置遍历，back从哨兵遍历
          循环终止条件为front到达尾结点时*/
        while (front.next != null) 
            front = front.next;
            back = back.next;
        
        // 此时back的下一个结点就是要删除的结点，让back指向下一个结点的下一个结点
        back.next = back.next.next;
        return dummy.next;
    

    public static void printList(ListNode head) 
        System.out.print("[");
        while (head != null) 
            if (head.next == null) 
                System.out.print(head.val);
             else 
                System.out.print(head.val + ",");
            
            head = head.next;
        
        System.out.print("]");
    

结点类

public class ListNode<T> 

    T val;
    ListNode next;

    public ListNode() 

    

    public ListNode(T val) 
        this.val = val;
    

    public ListNode(T val, ListNode next) 
        this.next = next;
    

测试类

public class Test 

    @org.junit.Test
    public void test1() 
        ListNode<Integer> head = new ListNode<>(1);
        ListNode<Integer> listNode = new ListNode<>(2);
        ListNode<Integer> listNode1 = new ListNode<>(3);
        ListNode<Integer> listNode2 = new ListNode<>(4);
        ListNode<Integer> listNode3 = new ListNode<>(5);
        head.next = listNode;
        listNode.next = listNode1;
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        System.out.print("输入：");
        Solution.printList(head);
        System.out.println(" 2");
        ListNode head2 = Solution.removeNthFromEnd(head, 2);
        System.out.print("输出:");
        Solution.printList(head2);
    

    @org.junit.Test
    public void test2() 
        ListNode<Integer> head = new ListNode<>(1);
        System.out.print("输入：");
        Solution.printList(head);
        System.out.println(" 1");
        ListNode head2 = Solution.removeNthFromEnd(head, 1);
        System.out.print("输出:");
        Solution.printList(head2);
    

    @org.junit.Test
    public void test3() 
        ListNode<Integer> head = new ListNode<>(1);
        ListNode<Integer> listNode = new ListNode<>(2);
        head.next = listNode;
        System.out.print("输入：");
        Solution.printList(head);
        System.out.println(" 2");
        ListNode head2 = Solution.removeNthFromEnd(head, 1);
        System.out.print("输出:");
        Solution.printList(head2);
    

测试结果

复杂度分析

假设链表长度为n

时间复杂度：需要遍历链表，故时间复杂度为O(n)
空间复杂度：只声明几个固定的结点，故空间复杂度为O(1);