La lista vinculada es una estructura de almacenamiento no contigua en la estructura de almacenamiento física, y el orden lógico de los elementos de datos se realiza mediante el orden de enlace de referencia en la lista vinculada.
Recientemente, aprendí la lista enlazada individualmente en la estructura de datos de Java. Con el fin de mejorar mi capacidad de código y comprensión de la lista enlazada individual, me di cuenta manualmente de la operación de parte de la lista enlazada individualmente.
1. 创建单链表
2. 打印单链表
3. 找到倒数第一个节点
4. 链表的长度
5. 找到倒数第二个节点
6. 找到第n个节点（n从1开始）
7. 是否包含关键字key节点
8. 头插法
9. 尾插法
10. 找到index-1位置的节点
11. 在任意位置插入data节点
12. 找到关键字key的节点
13. 删除第一个出现key的节点
14. 删除所有key节点
15. 清空一个单链表
16. 反转一个单链表
17. 返回中间链表，如果有两个中间节点，返回第二个
MyLinkedList
class Node {
public int val;
public Node next;
public Node() {
}
public Node(int val) {
this.val = val;
}
}
public class MyLinkedList {
public Node head;//表示当前链表的头 默认是null
//创建单链表
public void createLinked() {
this.head = new Node(12);
Node node2 = new Node(22);
Node node3 = new Node(32);
Node node4 = new Node(42);
this.head.next = node2;
node2.next = node3;
node3.next = node4;
}
//打印单链表
public void display() {
Node cur = this.head;
while (cur != null) {
System.out.print (cur.val +" ");
cur = cur.next;
}
System.out.println();
}
//找到倒数第一个节点
public Node findLastNode() {
if(this.head == null) {
System.out.println("head == null");
return null;
}
Node cur = this.head;
while (cur.next != null) {
cur = cur.next;
}
return cur;
}
//链表的长度
public int size() {
Node cur = this.head;
int count = 0;
while(cur != null) {
count++;
cur = cur.next;
}
return count;
}
//找到倒数第二个节点
public Node findLastTwoNode() {
if(this.head == null) {
System.out.println("链表为空！");
return null;
}
if(this.head.next == null) {
System.out.println("只有一个节点！");
return null;
}
Node cur = this.head;
while(cur.next.next != null) {
cur = cur.next;
}
return cur;
}
//找到第n个节点（n从1开始）
public Node findN(int n) {
if(this.head == null) {
System.out.println("链表为空！");
return null;
}
if(n <= 0) {
System.out.println("n太小了！");
return null;
}
if(n > size()) {
System.out.println("n太大了！");
}
int count = 1;
Node cur = this.head;
while(count != n) {
count++;
cur = cur.next;
}
return cur;
}
//是否包含关键字key节点
public boolean contains(int key) {
Node cur = this.head;
while(cur != null) {
if(cur.val == key) {
return true;
}
cur = cur.next;
}
return false;
}
//头插法
public void addFirst(int data) {
Node node = new Node(data);
if(this.head == null){
this.head = node;
}else{
node.next = this.head;
this.head = node;
}
}
//尾插法
public void addLast(int data) {
Node node = new Node(data);
if(this.head == null) {
this.head = node;
}else{
Node cur = this.head;
while(cur.next != null) {
cur = cur.next;
}
cur.next = node;
}
}
//找到index-1位置的节点
public Node moveIndex(int index) {
Node cur = this.head;
int count = 0;
while(count != index-1) {
cur = cur.next;
count++;
}
return cur;
}
//在任意位置插入data节点
public void addIndex(int index,int data) {
if(index < 0 || index >size()) {
System.out.println("index不合法");
return;
}
if(index == 0) {
addFirst(data);
return;
}
Node cur = moveIndex(index);
Node node= new Node(data);
node.next = cur.next;
cur.next=node;
}
//找到关键字key的节点
public Node searchPrev(int key) {
Node cur = this.head;
while(cur.next != null) {
if(cur.next.val == key) {
return cur;
}
cur = cur.next;
}
return null;
}
//删除第一个出现key的节点
public void remove(int key) {
if(this.head == null) {
return;
}
if(this.head.val == key) {
this.head = this.head.next;
}
Node prev = searchPrev(key);
if(prev == null) {
System.out.println("此前驱为空");
}else{
Node del = prev.next;
prev.next = del.next;
}
}
//删除所有key节点
public void removeAllKey(int key) {
Node prev = this.head;
Node cur = prev.next;
while(cur != null) {
if(cur.val == key) {
prev.next = cur.next;
}else{
prev = cur;
}
cur = cur.next;
}
if(this.head.val == key) {
this.head = this.head.next;
}
}
//清空一个单链表
public void clear() {
this.head = null;
}
//反转一个单链表
public Node reverseList() {
Node cur = this.head;
Node prev = null;
Node newHead = null;
while(cur != null) {
Node curNext = cur.next;
if(curNext == null) {
newHead = cur;
}
cur.next = prev;//后继变前驱
prev = cur;
cur = curNext;
}
return newHead;
}
//返回中间链表，如果有两个中间节点，返回第二个
public Node middleNode() {
Node fast = this.head;
Node slow = this.head;
while(fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
}
return slow;
}
}
TestDemo
public class TestDemo {
public static void main(String[] args) {
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addFirst(19);
myLinkedList.addFirst(29);
myLinkedList.addFirst(39);
myLinkedList.display();//39 29 19
myLinkedList.addLast(1);
myLinkedList.addLast(2);
myLinkedList.addLast(3);
myLinkedList.addLast(4);
myLinkedList.display();//39 29 19 1 2 3 4
myLinkedList.addIndex(0,110);
myLinkedList.display();//110 39 29 19 1 2 3 4
myLinkedList.addIndex(2,120);
myLinkedList.display();//110 39 120 29 19 1 2 3 4
myLinkedList.addIndex(9,119);
myLinkedList.display();//110 39 120 29 19 1 2 3 4 119
myLinkedList.addIndex(-9,119);
}
public static void main2(String[] args) {
MyLinkedList myLinkedList = new MyLinkedList();
//这个函数结束之后，我们拿到了当前链表的头节点
myLinkedList.createLinked();
myLinkedList.display();
System.out.println("==================");
int n = 4;
Node ret = myLinkedList.findN(n);
System.out.println("第"+n+"个节点是："+ret.val);
System.out.println("==================");
System.out.println(myLinkedList.size());
System.out.println("==================");
System.out.println(myLinkedList.contains(421));
}
public static void main1(String[] args) {
MyLinkedList myLinkedList = new MyLinkedList();
//这个函数结束之后，我们拿到了当前链表的头节点
myLinkedList.createLinked();
myLinkedList.display();
System.out.println("==================");
try {
//放的是可能出现异常代码
Node ret = myLinkedList.findLastTwoNode();
System.out.println(ret.val);
}catch (NullPointerException e) {
}
System.out.println("==================");
/*ret = myLinkedList.findLastTwoNode();
System.out.println(ret.val);*/
System.out.println("虽然发生了异常，但是我还是想打印这句话");
}
}
Resultados de la prueba
39 29 19
39 29 19 1 2 3 4
110 39 29 19 1 2 3 4
110 39 120 29 19 1 2 3 4
110 39 120 29 19 1 2 3 4 119
index不合法