链表是类似一种数据结构的东西，就是分别存放有地址以及数据单项链表一般是上一个存放地址的地方存放下一个节点的地址，而双向的就是有两个存放地址的地方，分别存上一个以及下一个的地址。大概是这样子
成都创新互联专注于寿阳企业网站建设,成都响应式网站建设公司,电子商务商城网站建设。寿阳网站建设公司,为寿阳等地区提供建站服务。全流程按需定制制作，专业设计，全程项目跟踪，成都创新互联专业和态度为您提供的服务
代码：
// 删除下标为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.util.Linkedlist是双向链表，当然也就包括了单链表的功能，你可以去看他怎么写的啊
public class SingleLinkedListE {
private EntryE first, last;
private int size = 0;
public void add(E element) {
EntryE newEntry = new EntryE(element, null);
if (first == null) {
first = last = newEntry;
} else {
last.next = newEntry;
last = newEntry;
}
++size;
}
public E get(int index) {
if (index 0 || index = size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
EntryE e = first;
for (int i = 0; i index; ++i)
e = e.next;
return e.data;
}
private static class EntryE {
Entry(E data, EntryE next) {
this.data = data;
this.next = next;
}
E data;
EntryE next;
}
}
这是我写的一个差不多，你看一下吧：
package com.test.list;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class LinkedList {
public static void main(String[] args) {
MyList l = new MyList();
MyListNode node = l.createList();
l.printNode(node);
//l.searchNode(node, 4);
//node = l.insertNode(node, 3, "g");
//l.printNode(node);
node = l.deleteNode(node, "d");
l.printNode(node);
}
}
class MyListNode {
public String data;
public MyListNode nextNode;
}
class MyList {
public MyListNode createList() {
MyListNode node = new MyListNode();
MyListNode q ,p;
q = new MyListNode();
q = node;
while (true) {
String s = null;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("请输入节点数据：");
s = br.readLine();
if (s.equals("0")) {
break;
} else {
p = new MyListNode();
p.data = s;
p.nextNode = null;
q.nextNode = p;
q = p;
}
} catch (Exception e) {
e.printStackTrace();
}
}
return node;
}
public void printNode(MyListNode node) {
MyListNode p = node.nextNode;
while (p!= null) {
System.out.print(" "+p.data);
p = p.nextNode;
}
}
public void searchNode(MyListNode node, int i){
MyListNode p = node.nextNode;
int j = 1;
while (p != null ji) {
p = p.nextNode;
j++;
}
if( p == null || ji) {
System.out.println("error");
}
System.out.println(" --"+p.data+"--");
}
public MyListNode insertNode(MyListNode node, int i ,String s) {
MyListNode p = node.nextNode;
int j = 1;
while (p != null ji-1) {
p = p.nextNode;
j++;
}
if( p == null || ji-1) {
System.out.println("error");
}
MyListNode n = new MyListNode();
n.data = s;
n.nextNode = p.nextNode;
p.nextNode = n;
return node;
}
public MyListNode deleteNode(MyListNode node ,String s) {
MyListNode p = node;
while(p.nextNode != null !p.nextNode.data.equals(s)) {
p = p.nextNode;
}
p.nextNode = p.nextNode.nextNode;
return node;
}
}
/*逆位序创建
public MyListNode createList() {
MyListNode node = new MyListNode();
node.nextNode = null;
while(true) {
String s = null;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("请输入节点数据：");
s = br.readLine();
if(s.equals("0")) {
break;
}else {
MyListNode n = new MyListNode();
n.data = s;
n.nextNode = node.nextNode;
node.nextNode = n;
}
} catch (Exception e) {
e.printStackTrace();
}
}
return node;
}
*/
你可能对链表的数据结构并不是很清楚 给你个写示例代码理解下，最好打个断点每一步跟踪理解一下
//class ListNode {
// int val;
// jdb.ListNode next;
// ListNode(int x) { val = x; }
//}
public class Main {
public static void main(String[] args) throws Exception {
//现在有一个链表1-2-3
ListNode listNode = new ListNode(1);
listNode.next = new ListNode(2);
listNode.next.next = new ListNode(3);
listNode.next.next.next = new ListNode(4);
//我们来打印一下
printListNode(listNode);
//我现在要在2后面插入9
boolean flag = insertVal(listNode, 3, 9);
System.out.println("是否插入成功:"+flag);
//再来打印一下
printListNode(listNode);
}
/**
*
* @param listNode//原链表
* @param pre//插入前的位置
* @param val//插入的值
*/
public static boolean insertVal(ListNode listNode,Integer pre, Integer val) {
boolean rs = false;
//找插入前的位置
while (listNode != null listNode.val != pre) {
listNode = listNode.next;
}
if (listNode != null listNode.val==pre) {
//找到啦
//先把原链表后的数据保存起来 这边就是3-4
ListNode temp = listNode.next;
//把要插入的值连上，再把原来保存的值连上
listNode.next = new ListNode(val);
listNode.next.next = temp;
//上面代码中 listNode的值是2，listNode.next的值是9，listNode.next.next的值就是刚才保存的临时链表3-4
//插入成功标记一下哦
rs=true;
}
return rs;
}
/**
* 打印呀
* @param listNode
*/
public static void printListNode(ListNode listNode) {
if (listNode != null) {
ListNode temp = listNode;
while (temp != null) {
System.out.println(temp.val);
temp = temp.next;
}
}
System.out.println("-------------");
}
}