Java链表拓展--排序,翻转

lkpalu Lv3

Java链表排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void SortList(Node head) {
Node newHead = head;
int i = 0;
ArrayList<Integer> SortArray = new ArrayList<>();
while (newHead != null) {
SortArray.add(newHead.data);
newHead = newHead.next;
}
SortArray.sort(Comparator.naturalOrder());
newHead = head;
while (newHead != null){
newHead.data = SortArray.get(i);
newHead = newHead.next;
i++;
}
}

排序采用了先转为数组,对数组进行排序再给链表重新赋值的方法

Java链表反转

1
2
3
4
5
6
7
8
9
10
11
12
13
    public static void Reverse(Node head) {
Node pre = null;
Node cur = head.next;
Node next = new Node(0);
while(cur != null){
next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
// return pre;
head.next = pre;
}

反转采用了三个节点依次翻转

链表类完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
package LinkList;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Comparator;

public class Node {
int data;
Node next;

public Node(int data) {
this.data = data;
this.next = null;
}

public static void Init(Node head, int length) {
int i = 0;
Node newHead = head;
while (i < length) {
Node tmp = new Node(0);
tmp.next = null;
newHead.next = tmp;
newHead = newHead.next;
i++;
}
}

public static void Print(Node head) {
Node newHead = head;
while (newHead != null) {
System.out.println(newHead.data);
newHead = newHead.next;
}
}

public static void Insert(Node head, int index, int data) {
Node newHead = head;
int i = 1;
while (i < index && newHead != null) {
newHead = newHead.next;
i++;
}
if (newHead == null) {
System.out.println("索引超过长度");
return;
}
Node tmp = new Node(data);
tmp.next = newHead.next;
newHead.next = tmp;

}

public static int Delete(Node head, int index) {
int res;
int i = 1;
Node newHead = head;
while (i < index && newHead != null) {
newHead = newHead.next;
i++;
}
if (newHead == null) {
System.out.println("索引超过长度,无法删除");
return 0;
}
res = newHead.next.data;
newHead.next = newHead.next.next;
return res;
}

public static int Find(Node head, int index) {
Node newHead = head;
int i = 0;
while (i < index && newHead != null) {
newHead = newHead.next;
i++;
}
if (newHead == null) {
System.out.println("索引超过长度,无法查找");
return 0;
}
return newHead.data;
}

public static void Alter(Node head, int index, int data) {
int i = 0;
Node newHead = head;
while (i < index && newHead != null) {
newHead = newHead.next;
i++;
}
if (newHead == null) {
System.out.println("索引超过长度,无法更改");
return;
}
newHead.data = data;
}

public static void SortList(Node head) {
Node newHead = head;
int i = 0;
ArrayList<Integer> SortArray = new ArrayList<>();
while (newHead != null) {
SortArray.add(newHead.data);
newHead = newHead.next;
}
SortArray.sort(Comparator.naturalOrder());
newHead = head;
while (newHead != null){
newHead.data = SortArray.get(i);
newHead = newHead.next;
i++;
}
}
public static void Reverse(Node head) {
Node pre = null;
Node cur = head.next;
Node next = new Node(0);
while(cur != null){
next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
// return pre;
head.next = pre;
}
public static int GetLength(Node head) {
Node newHead = head;
int length = -1;
while (newHead != null) {
length++;
newHead = newHead.next;
}
return length;
}
}
  • 标题: Java链表拓展--排序,翻转
  • 作者: lkpalu
  • 创建于 : 2024-11-03 00:00:00
  • 更新于 : 2024-11-05 17:54:00
  • 链接: https://redefine.ohevan.com/2024/11/03/Java链表拓展-排序,翻转/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。
评论
目录
Java链表拓展--排序,翻转