关于java实现链表的问题，求高手解惑啊
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了关于java实现链表的问题，求高手解惑啊相关的知识，希望对你有一定的参考价值。
class Node
int data; //数据域
Node next; //链域，存放下一个结点的引用
public class Link
Node header ; /* 构建含n个结点的链表链表的头用header指示 */
public Link(int n)
Node p,q; //用于链表的推进,p为链表中当前最后结点,q为要新加的结点
header=new Node(); //创建首结点
header.data=(int)(Math.random()*100); //给首结点的data域赋值
p=header;
for (int k=1;k<=n-1;k++)
q=new Node(); //创建一个新结点
q.data=(int)(Math.random()*100);
p.next=q; //将本结点链接添加到链表中
p=q;
/* 输出链表的所有元素的数据 */
void outputLink()
Node p=header;
while (p!=null)
System.out.print(p.data+"-->");
p=p.next;
System.out.println();
public static void main(String a[])
/* 创建含10个元素的链表,并输出该链表*/
Link x=new Link(10);
x.outputLink (); //输出链表
reverse(x).outputLink();
//下面方法用来实现链表的逆序存放，请问问题出在哪啊？
static Link reverse(Link x )
Link rev =new Link(0);
Link runner = x;
Node p=runner.header;
Node q;
while (p!= null)
q=p;
q.next=rev.header;
rev.header=q;
p=p.next;
return rev;
1）先说一个你的程序不是算法问题的错误，你的链表的header里面不应该存放具体数据，也就是说header里面的data应该不用。虽然你的outputLink 方法把header里的data也输出了，但是reverse方法忽略了header里的数据，而且你不可能创建长度为0的链表，因为你的构造方法里面header不管n为多少，都会有数据。
2）reverse里的错误就是q与p在循环里是同一个对象，q.next就是p.next，循环第二行q.next=rev.header，因此p.next也是rev.header，所以最后一行p=p.next，p永远不会是null，死循环。
3）想说一个不是错误的问题，不要把java与c弄混，不要把c语言的用法套到java里，比如java里面是不建议在另一个类中直接调用其他类的数据域的，像你这里header.data，在Link类里调用Node的data数据域，这样会出问题，应该使用get与set方法。还有最好每个类都有构造方法，Node类也应该有一个。
个人意见，仅供参考，谢谢。 参考技术A while (p != null)
q = p;
p = p.next;
q.next = rev.header;
rev.header = q;
解释下你为什么错了：
q=p;
q.next=rev.header;
rev.header=q;
p=p.next;
第一步：q=p；这两个同时指向一个Node。
第二步：q.next=rev.header；将当前Node的next指向新链表的头。但是，此时p的next也指向了这个新链表的头。这就导致了没有入口通向我们原来的链表了。
第三步：rev.header=q;调整新链表头的位置为第一个Node。此时，p，q，rev.header同时指向一个Node，就是这个新链表的头。我们现在已经完全和目标链表失去了联系。
第四步：p=p.next;p指向了Link rev = new Link(0);最初的头结点。
如此循环，表中只有两个数据在不停地加到新链表中，分别是两个链表的头。本回答被提问者采纳 参考技术B static Link reverse(Link x)
/*Link rev = new Link(0);
Link runner = x;
Node p = runner.header;
Node q;
while (p != null)
q = p;
q.next = rev.header;
rev.header = q;
p = p.next;
return rev;*/
Node q = x.header.next, r;
x.header.next=null;
while (q!=null)
r=q.next;
q.next=x.header;
x.header=q;
q=r;
return x;
链表的java实现（单向双向链表，单向链表的反转）
链表
链表
虽然顺序表的查询很快，时间复杂度为O(1),但是增删的效率是比较低的，因为每一次增删操作都伴随着大量的数据元素移动。这个问题有没有解决方案呢？有，我们可以使用另外一种存储结构实现线性表，链式存储结构。
链表是一种物理存储单元上非连续、非顺序的存储结构，其物理结构不能只管的表示数据元素的逻辑顺序，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点（链表中的每一个元素称为结点）组成，结点可以在运行时动态生成。
按照面向对象的思想，我们可以设计一个类，来描述结点这个事物，用一个属性描述这个结点存储的元素，用来另外一个属性描述这个结点的下一个结点。
| 类名 | Node |
|---|---|
| 构造方法 | Node(T t,Node next)：创建Node对象 |
| 成员变量 | T item:存储数据 Node next：指向下一个结点 |
结点类实现：
public class Node<T>
//存储元素
public T item;
//下一个元素的地址
public Node next;
public Node (T item,Node next)
this.item = item;
this.next = next;
生成链表：
public static void main(String[] args) throws Exception
//构建结点
Node<Integer> first = new Node<>(11,null);
Node<Integer> second = new Node<>(13,null);
Node<Integer> third = new Node<>(12,null);
Node<Integer> forth = new Node<>(7,null);
Node<Integer> fifth = new Node<>(8,null);
//生成链表
first.next = second;
second.next = third;
third.next = forth;
forth.next = fifth;
单向链表
单向链表是链表的一种，它由多个结点组成，每个结点都由一个数据域和一个指针域组成，数据域用来存储数据，指针域用来指向其后继结点。链表的头结点的数据域不存储数据，指针域指向第一个真正存储数据的结点。
单向链表API设计
| 类名 | LinkList |
|---|---|
| 构造方法 | LinkList()：创建LinkList对象 |
| 成员方法 | 1.public void clear()：空置线性表 2.publicboolean isEmpty()：判断线性表是否为空，是返回true，否返回false 3.public int length():获取线性表中元素的个数 4.public T get(int i):读取并返回线性表中的第i个元素的值 5.public void insert(T t)：往线性表中添加一个元素； 6.public void insert(int i,T t)：在线性表的第i个元素之前插入一个值为t的数据元素。 7.public T remove(int i):删除并返回线性表中第i个数据元素。 8.public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。 |
| 成员内部类 | private class Node:结点类 |
| 成员变量 | 1.private Node head:记录首结点 2.private int N:记录链表的长度 |
单向链表代码实现
单向链表类：
import java.util.Iterator;
public class LinkList<T> implements Iterable<T>
//头节点
private Node head;
//链表长度
private int N;
public LinkList()
//初始化
head = new Node(null,null);
N = 0;
//清空链表
public void clear()
head.next = null;
head.item = null;
N = 0;
//判断是否为空
public boolean isEmpty()
return N == 0;
//获取元素个数
public int length()
return N;
//获取第i个元素
public T get(int i)
if (i < 0 || i >= N)
throw new RuntimeException("位置不合法");
Node n = head.next;
for (int index = 0;index < i;index++)
n = n.next;
return n.item;
//添加一个元素
public void insert(T t)
//找到最后一个节点
Node n = head;
while (n.next != null)
n = n.next;
Node newOne = new Node(t,null);
n.next = newOne;
//链表长度++
N++;
//在i位置添加一个元素
public void insert(int i,T t)
if (i<0||i>=N)
throw new RuntimeException("位置不合法！");
//寻找i位置之前的节点
Node pre = head;
for (int j = 0; j <= i-1; j++)
pre = pre.next;
//找到位置i的节点
Node curr = pre.next;
//构建新节点，让新节点指向i节点
Node newNode = new Node(t,curr);
//让i位置之前的节点指向这个节点
pre.next = newNode;
//链表长度++
N++;
//删除并返回第i个位置的元素
public T delete(int i)
if (i<0||i>=N)
throw new RuntimeException("位置不合法！");
//寻找i之前的元素
Node pre = head;
for (int index = 0; index <=i-1; index++)
pre = pre.next;
//当前i位置的结点
Node curr = pre.next;
//前一个结点指向下一个结点，删除当前结点
pre.next = curr.next;
//长度-1
N--;
return curr.item;
//返回链表中首次出现指定元素的序号，弱不存在返回-1
public int indexOf(T t)
Node n = head;
for (int i = 0;n.next!=null;i++)
n = n.next;
if (n.item.equals(t))
return i;
return -1;
//节点类
private class Node
//存储数据
T item;
//下个结点
Node next;
public Node(T item,Node next)
this.item = item;
this.next = next;
@Override
public Iterator iterator()
return new LIterator();
private class LIterator implements Iterator<T>
private Node n;
public LIterator()
this.n = head;
@Override
public boolean hasNext()
return n.next != null;
@Override
public T next()
n = n.next;
return n.item;
测试类：
public class LinkListTest
public static void main(String[] args) throws Exception
LinkList<Integer> list = new LinkList<>();
System.out.println(list.length());
list.insert(0,1);
list.insert(1,2);
list.insert(2,3);
list.insert(3,4);
list.insert(4,5);
//测试length方法
for (int i : list)
System.out.println(i);
System.out.println(list.length());
System.out.println("-------------------");
//测试get方法
System.out.println(list.get(2));
System.out.println("------------------------");
//测试remove方法
int remove = list.remove(1);
System.out.println(remove);
System.out.println(list.length());
System.out.println("----------------");
for (int i : list) System.out.println(i);
0
1
2
3
4
5
5
---------------
3
---------------
2
4
---------------
1
3
4
5
双向链表
双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据的结点。
结点API设计
| 类名 | Node |
|---|---|
| 构造方法 | Node(T t,Node pre,Node next)：创建Node对象 |
| 成员变量 | T item:存储数据 Node next：指向下一个结点 Node pre:指向上一个结点 |
双向链表API设计
| 类名 | TowWayLinkList |
|---|---|
| 构造方法 | TowWayLinkList()：创建TowWayLinkList对象 |
| 成员方法 | 1.public void clear()：空置线性表 2.publicboolean isEmpty()：判断线性表是否为空，是返回true，否返回false 3.public int length():获取线性表中元素的个数 4.public T get(int i):读取并返回线性表中的第i个元素的值 5.public void insert(T t)：往线性表中添加一个元素； 6.public void insert(int i,T t)：在线性表的第i个元素之前插入一个值为t的数据元素。 7.public T remove(int i):删除并返回线性表中第i个数据元素。 8.public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。 9.public T getFirst():获取第一个元素 10.public T getLast():获取最后一个元素 |
| 成员内部类 | private class Node:结点类 |
| 成员变量 | 1.private Node first:记录首结点 2.private Node last:记录尾结点 2.private int N:记录链表的长度 |
双向链表代码实现
双向链表类：
import java.util.Iterator;
public class TwoWayLinkList<T> implements Iterable<T>
//结点类
private class Node
public Node(T item, Node pre, Node next)
this.item = item;
this.pre = pre;
this.next = next;
//存储数据
private T item;
//存储上一个结点
private Node pre;
//存储下一个节点
private Node next;
//首结点
private Node head;
//尾结点
private Node last;
//链表长度
private int N;
//构造方法
public TwoWayLinkList()
last = null;
head = new Node(null,null,null);
N = 0;
//清空链表
public void clear()
N = 0;
last = null;
head.next = last;
head.pre = null;
head.item = null;
//判断是否为空
public boolean isEmpty()
return N==0;
//获取元素个数
public int length()
return N;
//获取位置i的元素值
public T get(int i)
if (i<0 || i>= N)
throw new RuntimeException("位置不合法");
Node curr = head.next;
for (int j = 0; j < i; j++)
curr = curr.next;
return curr.item;
//添加一个元素在末尾
public void insert(T t)
if(last == null)
last = new Node(t,head,null);
head.next = last;
else
Node oldlast = last;
Node node = new Node(t,oldlast,null);
oldlast.next = node;
last = node;
N++;
//在i位置添加一个元素
public void insert(int i, T t)
if (i<0 || i>=N)
throw new RuntimeException("位置不合法");
//找到i位置的前一个结点
Node pre = head;
for (int index=0; index < i;index++)
pre = pre.next;
//设置当前结点
Node curr = pre.next;
//构建这个结点
Node newNode = new Node(t,pre,curr);
curr.pre = newNode;
pre.next = newNode;
//长度++
N++;
//删除并返回第i个元素
public T remove(int i)
if (i<0 || i>=N)
throw new RuntimeException("位置不合法");
//找到前一个结点
Node pre = head;
for (int index=0; index < i;index++)
pre = pre.next;
//设置当前结点
Node curr = pre.next;
//找到后一个结点
Node curr_next = curr.next;
pre.next = curr_next;
curr_next.pre = pre;
N--;
return curr.item;
//返回表中某元素首次出现的index，如果不存在就返回-1
public int indexOf(T t)
Node n = head;
for (int i = 0; n.next != null ; i++)
n = n.next;
if (n.next.equals(t))
return i;
return -1;
//获取第一个元素
public T getFirst()
if (isEmpty())
return null;
return head.next.item;
//获取最后一个元素
public T getLast()
if (isEmpty())
return null;
return last.item;
@Override
public Iterator<T> iterator()
return new TIterator();
private class TIterator implements Iterator
private Node n =head;
@Override
public boolean hasNext()
return n.next != null;
@Override
public Object next()
n = n.next;
return n.item;
Test类：
public class TwoWayLinkListTest
public static void main(String[] args) throws Exception
TwoWayLinkList<Integer> list = new TwoWayLinkList<>();
System.out.println(list.length());
list.insert(0,1);
list.insert(1,2);
list.insert(2,3);
list.insert(3,4);
list.insert(4,5);
//测试length方法
for (int i : list)
System.out.println(i);
System.out.println(list.length());
System.out.println("-------------------");
以上是关于关于java实现链表的问题，求高手解惑啊的主要内容，如果未能解决你的问题，请参考以下文章