本文目录一览：
- java单链表遍历，最后会输出一个0，这个零是什么，头指针的引用吗
- 用java单链表实现一元多项式相加的算法？
- java循环单链表实现约瑟夫环
- 用java如何创建一个单链表和双链表
- java单链表根据内容删除节点
- [java 中单链表的equals方法](#java 中单链表的equals方法)
java单链表遍历，最后会输出一个0，这个零是什么，头指针的引用吗
单链表带头结点的遍历，如果把temp != null改成temp.next != null遍历就正常了，但是去掉.next就会多出一个0。这个0是一个未经初始化的内存中“残存”的数字，这一次是零，可能在下一次运行的时候，里面出现的数字就可能不是0，而是其他不规则的数字。
用java单链表实现一元多项式相加的算法？
public class Test {
public static void main(String[] args) {
try {
LinkList list1 = new LinkList();
LinkList list2 = new LinkList();
LinkList list3 = null;
list1.addAt(0, new Item(1, 5));
list1.addAt(1, new Item(-1.5, 3));
list1.addAt(2, new Item(1, 1));
list2.addAt(0, new Item(0.5, 5));
list2.addAt(1, new Item(0.5, 4));
list2.addAt(2, new Item(1.5, 3));
list2.addAt(3, new Item(3, 0));
list3 = mergeLinkList(list1, list2);
System.out.println("一元多项式的相加过程：");
list1.listAll();
System.out.println(" + ");
list2.listAll();
System.out.println(" = ");
list3.listAll();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 一元多项式的一般项类
*/
class Item {
private double coef; // 一元多项式的一般项的系数
private int exp; // 一元多项式的一般项的指数
public Item() {
this.coef = 0.0;
this.exp = 0;
}
public Item(double coef, int exp) {
this.coef = coef;
this.exp = exp;
}
public double getCoef() {
return this.coef;
}
public void setCoef(double coef) {
this.coef = coef;
}
public int getExp() {
return this.exp;
}
public void setExp(int exp) {
this.exp = exp;
}
}
/**
* 链表结点类
*/
class Node {
private Item data;
private Node next; // 链表结点的指针域，指向直接后继结点
public Node() {
data = null;
next = null;
}
public Node(Item data, Node next) {
this.data = data;
this.next = next;
}
public Item getData() {
return this.data;
}
public void setData(Item data) {
this.data = data;
}
public Node getNext() {
return this.next;
}
public void setNext(Node next) {
this.next = next;
}
}
/**
* 链表类
*/
class LinkList {
private Node head = null; // 头结点指针
private int size = 0;
public LinkList() {
head = new Node();
size = 0;
}
// 在i位置插入元素elem
public boolean addAt(int i, Item elem) {
if (i < 0 || i > size) {
return false;
}
Node pre, curr;
int pos;
for (pre = head; i > 0 && pre.getNext() != null; i--, pre = pre.getNext());
curr = new Node(elem, pre.getNext());
pre.setNext(curr);
size++;
return true;
}
// 删除i位置的元素
public boolean removeAt(int i) {
if (i < 0 || i >= size) {
return false;
}
Node pre, curr;
for (pre = head; i > 0 && pre.getNext() != null; i--, pre = pre.getNext());
curr = pre.getNext();
pre.setNext(curr.getNext());
size--;
return true;
}
}
Java 是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于 PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。
java循环单链表实现约瑟夫环
看了你的代码，不是很明白，给你提几个建议吧：
- 不需要 tail 节点
- remove 方法应该对删除节点前面的节点操作，而不是使用数字找
给你我修改的
LinkList类，你参考一下：
public class LinkList {
private Node head;
int curlen = 0;
// 创建链表
public void createlist(int code) throws Exception {
insert(curlen, code);
}
public void insert(int i, int code) throws Exception {
Node s = new Node(code);
if (i == 0) {
s.setNext(head);
head = s;
}
Node p = head;
int j = 0;
while (p != null && j < i - 1) {
p = p.getNext();
j++;
}
if (j > i || p == null) {
throw new Exception("插入位置不合理");
}
s.setNext(p.getNext());
p.setNext(s);
// tail = s;
// tail.setNext(head);
curlen = curlen + 1;
}
public void remove(int i) throws Exception {
Node p = head, q = null;
int j = 0;
i = i - 1;
while (j < i) {
q = p;
p = p.getNext();
j++;
}
if (j > i || p == null)
throw new Exception("删除位置不合法");
if (q == null) {
// tail.setNext(p.getNext());
head = head.getNext();
} else
q.setNext(p.getNext());
curlen = curlen - 1;
}
/**
* 按照节点删除
* @param i
* @throws Exception
*/
public void remove(Node p) throws Exception {
if (p.getNext() == p) {
p = null;
head = null;
} else {
Node q = p.getNext();
p.setNext(q.getNext());
}
curlen = curlen - 1;
}
public void out(int m) throws Exception {
Node p = head;
if (m == 1) {
System.out.print("按照顺序出列");
return;
}
int count = 1;
int n = m - 1;
while (curlen > 0) {
if (count == n) {
System.out.print(p.getNext().getData() + " ");
remove(p);
count = 1;
} else {
count++;
}
p = p.getNext();
}
}
public void display() {
Node node = head;
for (int i = 0; i < 2 * curlen; i++) {
System.out.print(node.getData() + " ");
node = node.getNext();
}
System.out.println();
}
}
用java如何创建一个单链表和双链表
单向链表
单向链表就是通过每个结点的指针指向下一个结点从而链接起来的结构。 单向链表的初始化：这里我所讲的链表都是头结点不参与计算的，也就是说第一个结点都是头结点后面的第一个结点。所以我要先申明一点，这里我把链表的初始化放在了构造函数部分，然后析构函数负责释放头结点的内存。 单向链表的创建过程：链表的创建就是添加结点到链表的最后，开始是添加一个结点到head结点后面，然后添加一个结点到上次添加的结点后面，每次新建的结点的指针总是指向NULL指针。从上面的示意图可以看出，我们需要一个辅助指针一直指向最后一个结点，这个辅助结点就是为了让每次添加的结点都放置在最后一个位置。 单向链表插入结点过程：源代码中的插入结点函数我设置了一个指定位置，就是在指定位置插入结点。首先，通过位置变量position让ptemp结点移动到要插入位置的前一个位置，然后接下来的过程就是和创建链表的过程是一样的，把新建的结点添加到ptemp的后面。这里变量position可以从1到链表长度加1，意思就是如果不算头结点的话有3个结点，那你的position变量就可以从1到4，这是因为ptemp指针可以到第3个结点的位置，所以新建结点的位置就可以到4了。 单向链表删除结点过程：源代码中的删除结点函数也有一个指定位置变量，为了删除指定位置的结点。和插入结点一样通过变量position把ptemp移动到要删除结点的前一个位置，然后让ptemp结点中的指针指向要删除结点后面的一个结点，也就是ptemp结点的下一个的下一个结点，虽然这个结点可能为空，但是程序还是正常运行。但是这里和插入结点不同的是变量position只能从1到链表的长度，是因为ptemp移动到最后一个结点的时候，它的下一个结点为空，所以不不需要参与删除了。
双向链表
- 听名字可能就能猜到双向链表就是链表结点包含两个指针，一个指针是指向下一个结点的，另一个指针当然就是指向上一个结点的。
- 双向链表的初始化：由于这里的链表头结点不参与计算，所以头结点的pPre指针是一直指向NULL指针的。
- 双向链表的创建过程：由于双向链表的每个结点包含两个指针那么这个时候我们就要小心处理好每一个指针的指向，要不然会有很多意想不到的错误。同样的，和单向链表的创建过程一样，需要一个辅助指针来指向最后一个结点，然后每新建一个结点，这个结点的pNext指针都是指向NULL指针的，pPre指针指向上一个结点（这是和单向链表不同的地方），然后让上一个指针的pNext指向新建的结点，这样整个链表就连接起来了。
- 双向链表插入结点过程：知道了双向链表的创建过程，那么插入结点的过程就大同小异了，有一点需要特别注意的就是这里的变量position范围也是从1到链表长度加1，但是如果待插入的位置是最后一个位置的话，情况就不同了，看到下面的图我们可以很好的理解，因为没新建一个结点的时候都需要处理两个指针，而且新建结点的下一个结点的pPre指针就需要指向这个新建的结点，但是有可能这个新建的结点可能就已经是最后一个结点了，那么这个时候再执行
ptemp-pNext-pPre = pnew;
这条指令的时候就会报错了，因为ptemp-pNext已经是个NULL指针了，那空指针哪里还有pPre呢。因此在程序中要进行一次判断，看看结点是否是最后一个结点。 5. 双向链表删除结点的过程：要注意的问题和插入结点一样，看看这个结点是否为NULL。这里就不重复了。
java单链表根据内容删除节点
代码：
// 删除下标为index的节点
public void remove(int index) {
if (index >= modCount) {
// 抛异常
System.out.println("indexOutOfBoundsException!"); // 最好自定义异常抛出，这里演示
return;
}
Node node = head;
// 如果节点为第一个节点
if (index == 0) {
head = head.next; // 将头节点指向第二个节点
modCount--;
return;
}
// 如果节点为最后一个节点,找到最后一个节点的前一个节点,不用管
if (index == modCount - 1) {
System.out.println("ddd");
// 找到最后一个节点的前一个节点
int j = 0;
while (node != null && j < index - 1) {
// 最后一个节点的前一个节点
node = node.next;
j++;
}
last = node; // 最后一个节点设置为前一个节点
modCount--;
return;
}
// 如果节点为中间节点
int j = 0;
while (node != null && j < index - 1) {
// 查找被删除的节点的前一个节点
node = node.next;
j++;
}
node.next = node.next.next; // 被删除节点的下一个节点设置为被删除节点的下下个节点
modCount--;
}
java 中单链表的equals方法
LinkedList对equals的定义大致是这样的：（下文将equals写作相等） 两个链表相等当且仅当其大小相等，并且每个对应元素也相等。 谈到相等，必须谈及hashCode方法，关系如下：
- hashCode相等的 可能相等（相等与否需进一步检测）
- hashCode不等的 一定不等（排除相等情况） 一般情况下，hashCode的计算一定比equals快，而且‘不等’的情况较多，因此作为判断相等的加速方案，Java会先检测hashCode，若不等，则对象一定不等。 那么，对于Java的常见类，例如：基本类型包装类、集合类、字符串类等 其 equals 与 hashCode已经写好，不用我们操心。 若是自定义类，一定要重新equals与hashCode方法，满足上述hashCode的2个关系。 例如自己的User类有name和pass，一个简单的方案如下：
public class User {
String name, pass;
// get/set....
public int hashCode() {
return name.hashCode() + pass.hashCode();
}
public boolean equals(Object o) {
if (o instanceof User) {
User u = (User) o;
return (name.equals(u.name)) && (pass.equals(u.pass));
}
return false;
}
}
