Skip to content

Commit 15d9fcb

Browse files
longshilinlongshilin
committed
update
1 parent 70c82f5 commit 15d9fcb

File tree

3 files changed

+91
-91
lines changed

3 files changed

+91
-91
lines changed

‎src/dataStructure/linkedList/LinkedList.java‎

Lines changed: 84 additions & 84 deletions
Original file line numberDiff line numberDiff line change
@@ -2,174 +2,174 @@
22

33
import java.util.Scanner;
44

5-
class DATA {
6-
String key; // 结点的关键字
5+
class DATA{
6+
String key; // 结点的关键字
77
String name;
88
int age;
99
}
1010

1111
/*
12-
* 定义链表结构 Chain-type storage structure
12+
* 定义链表结构
13+
* Chain-type storage structure
1314
*/
14-
class CLType {
15+
class CLType{
1516
DATA nodeData = new DATA();
1617
CLType nextNode;
1718

18-
CLType CLAddEnd(CLType head, DATA nodeData) {
19-
CLType node, htemp;
20-
if ((node = new CLType()) == null) {
19+
CLType CLAddEnd(CLType head, DATA nodeData){
20+
CLType node,htemp;
21+
if((node=new CLType())==null){
2122
System.out.println("申请内存失败!\n");
2223
return null;
23-
} else {
24-
node.nodeData = nodeData; // 在新申请的结点中保存数据
25-
node.nextNode = null; // 设置结点引用为空，即为表尾
26-
if (head == null) { // 当head为空时，加入的新结点即为头引用
24+
}else{
25+
node.nodeData = nodeData; // 在新申请的结点中保存数据
26+
node.nextNode = null; // 设置结点引用为空，即为表尾
27+
if(head == null){ // 当head为空时，加入的新结点即为头引用
2728
head = node;
2829
return head;
2930
}
3031
htemp = head;
31-
while (htemp.nextNode != null) { // 查找链表的末尾
32+
while(htemp.nextNode != null){ // 查找链表的末尾
3233
htemp = htemp.nextNode;
3334
}
34-
htemp.nextNode = node; // 在链表的末尾插入该结点
35-
return head; // 返回指代整个链表的头引用
35+
htemp.nextNode = node; // 在链表的末尾插入该结点
36+
return head; // 返回指代整个链表的头引用
3637
}
3738
}
3839

39-
CLType CLAddFirst(CLType head, DATA nodeData) {
40+
CLType CLAddFirst(CLType head, DATA nodeData){
4041
CLType node;
41-
if ((node = new CLType()) == null) {
42+
if((node = new CLType())==null){
4243
System.out.println("申请内存失败!\n");
4344
return null;
44-
} else {
45-
node.nodeData = nodeData; // 保存数据
46-
node.nextNode = head; // 新加入的头结点的nextNode指向头引用所指的结点
47-
head = node; // 头引用指向新节点
45+
}else{
46+
node.nodeData = nodeData; // 保存数据
47+
node.nextNode = head; // 新加入的头结点的nextNode指向头引用所指的结点
48+
head = node; // 头引用指向新节点
4849
return head;
4950
}
5051
}
51-
52-
CLType CLFindNode(CLType head, String key) {
52+
53+
CLType CLFindNode(CLType head, String key){
5354
CLType htemp;
5455
htemp = head;
55-
while (htemp != null) { // 循环遍历，寻找关键字匹配的结点
56-
if (htemp.nodeData.key.compareTo(key) == 0) {
56+
while(htemp!=null){ // 循环遍历，寻找关键字匹配的结点
57+
if(htemp.nodeData.key.compareTo(key)==0){
5758
return htemp;
5859
}
5960
htemp = htemp.nextNode;
6061
}
6162
return null;
6263
}
63-
64-
CLType CLInsertNode(CLType head, String findKey, DATA nodeData) { // 插入关键字结点
64+
65+
CLType CLInsertNode(CLType head, String findKey, DATA nodeData){ // 插入关键字结点
6566
CLType node, nodetemp;
66-
if ((node = new CLType()) == null) {
67+
if((node = new CLType())==null){
6768
System.out.println("申请内存失败!\n");
6869
return null;
6970
}
7071
node.nodeData = nodeData;
71-
nodetemp = CLFindNode(head, findKey); // 获取插入位置关键字所指代的结点
72-
if (nodetemp == null) {
72+
nodetemp = CLFindNode(head, findKey); // 获取插入位置关键字所指代的结点
73+
if(nodetemp == null){
7374
System.out.println("未找到正确的插入位置!\n");
74-
} else {
75-
node.nextNode = nodetemp.nextNode; // 新插入的节点的nextNode指向关键字结点的下一结点
76-
nodetemp.nextNode = node; // 设置关键结点指向新插入结点
75+
}else{
76+
node.nextNode = nodetemp.nextNode; // 新插入的节点的nextNode指向关键字结点的下一结点
77+
nodetemp.nextNode = node; // 设置关键结点指向新插入结点
7778
}
7879
return head;
7980
}
80-
81-
int CLDeleteNode(CLType head, String key) { // 删除关键字结点
82-
CLType htemp, tempnode;
83-
if (head == null) {
81+
82+
int CLDeleteNode(CLType head, String key){ // 删除关键字结点
83+
CLType htemp,tempnode;
84+
if(head == null){
8485
return 0;
8586
}
8687
htemp = head;
8788
tempnode = head;
88-
while (htemp != null) {
89-
if (htemp.nodeData.key.compareTo(key) == 0) { // 遍历查找
90-
tempnode.nextNode = htemp.nextNode; // 当前结点的引用指向下一个结点的引用，以此删除htemp结点
89+
while(htemp != null){
90+
if(htemp.nodeData.key.compareTo(key)==0){ // 遍历查找
91+
tempnode.nextNode = htemp.nextNode; // 当前结点的引用指向下一个结点的引用，以此删除htemp结点
9192
return 1;
9293
}
93-
tempnode = htemp; // 保存当前结点
94-
htemp = htemp.nextNode; // 指向下一个结点
94+
tempnode = htemp; // 保存当前结点
95+
htemp = htemp.nextNode; // 指向下一个结点
9596
}
9697
return 0;
9798
}
98-
99-
int CLLength(CLType head) { // 返回结点总数
99+
100+
int CLLength(CLType head){ //返回结点总数
100101
CLType htemp;
101102
int len = 0;
102103
htemp = head;
103-
while (htemp != null) { // 循环遍历累计总结点数
104+
while(htemp!=null){ // 循环遍历累计总结点数
104105
len++;
105-
htemp = htemp.nextNode;
106+
htemp=htemp.nextNode;
106107
}
107108
return len;
108109
}
109-
110-
void CLAllNode(CLType head) { // 遍历链表输出所有数据
110+
111+
void CLAllNode(CLType head){ // 遍历链表输出所有数据
111112
CLType htemp;
112113
htemp = head;
113-
System.out.printf("\n当前链表共有%d个结点。链表所有数据如下：\n", CLLength(head));
114-
while (htemp != null) {
115-
System.out.printf("结点(%s,%s,%d)\n", htemp.nodeData.key, htemp.nodeData.name, htemp.nodeData.age);
114+
System.out.printf("\n当前链表共有%d个结点。链表所有数据如下：\n",CLLength(head));
115+
while(htemp != null){
116+
System.out.printf("结点(%s,%s,%d)\n",htemp.nodeData.key, htemp.nodeData.name, htemp.nodeData.age);
116117
htemp = htemp.nextNode;
117118
}
118119
}
119120
}
120121

121122
/**
122123
* 测试用例
123-
*
124124
* @author elon@elon33.com
125125
*
126126
*/
127127
public class LinkedList {
128128
public static void main(String[] args) {
129-
CLType node, head = null;
129+
CLType node,head=null;
130130
CLType CL = new CLType();
131-
String key, findkey;
131+
String key,findkey;
132132
Scanner input = new Scanner(System.in);
133133
System.out.println("链表测试:\n先输入链表中的数据，格式为：关键字 姓名 年龄 (键入0则结束)");
134-
do {
135-
DATA nodeData = new DATA(); // 构造新结点
134+
do{
135+
DATA nodeData = new DATA(); // 构造新结点
136136
nodeData.key = input.next();
137-
if (nodeData.key.equals("0")) {
137+
if(nodeData.key.equals("0")){
138138
break;
139-
} else {
139+
}else{
140140
nodeData.name = input.next();
141141
nodeData.age = input.nextInt();
142142
head = CL.CLAddEnd(head, nodeData);
143143
}
144-
} while (true);
145-
CL.CLAllNode(head); // 遍历所有结点
146-
144+
}while(true);
145+
CL.CLAllNode(head); // 遍历所有结点
146+
147147
System.out.printf("\n演示插入结点，输入插入位置的关键字：");
148148
findkey = input.next();
149149
System.out.printf("\n输入插入结点的数据(关键字 姓名 年龄)");
150-
DATA nodeData = new DATA(); // 构造新结点
151-
nodeData.key = input.next();
152-
nodeData.name = input.next();
153-
nodeData.age = input.nextInt();
154-
head = CL.CLInsertNode(head, findkey, nodeData);
155-
CL.CLAllNode(head);
156-
157-
System.out.printf("\n演示删除结点，输入要删除的关键字：");
158-
159-
key = input.next();
160-
int result = CL.CLDeleteNode(head, key);
161-
System.out.println(result == 1 ? "删除结点成功" : "删除结点失败");
162-
CL.CLAllNode(head);
163-
164-
System.out.printf("\n演示在链表中查找，输入查找关键字：");
165-
166-
key = input.next();
167-
node = CL.CLFindNode(head, key);
168-
if (node != null) {
169-
nodeData = node.nodeData;
170-
System.out.printf("关键字%s 对应的结点为(%s,%s,%d)\n", key, nodeData.key, nodeData.name, nodeData.age);
171-
} else {
172-
System.out.printf("在链表中未查找到关键字为%s的结点!\n", key);
173-
}
150+
DATA nodeData = new DATA(); // 构造新结点
151+
nodeData.key = input.next();
152+
nodeData.name = input.next();
153+
nodeData.age = input.nextInt();
154+
head = CL.CLInsertNode(head, findkey, nodeData);
155+
CL.CLAllNode(head);
156+
157+
System.out.printf("\n演示删除结点，输入要删除的关键字：");
158+
159+
key=input.next();
160+
int result = CL.CLDeleteNode(head, key);
161+
System.out.println(result==1?"删除结点成功":"删除结点失败");
162+
CL.CLAllNode(head);
163+
164+
System.out.printf("\n演示在链表中查找，输入查找关键字：");
165+
166+
key = input.next();
167+
node = CL.CLFindNode(head, key);
168+
if(node!=null){
169+
nodeData = node.nodeData;
170+
System.out.printf("关键字%s 对应的结点为(%s,%s,%d)\n",key,nodeData.key,nodeData.name,nodeData.age);
171+
}else{
172+
System.out.printf("在链表中未查找到关键字为%s的结点!\n",key);
173+
}
174174
}
175175
}

‎src/dataStructure/linkedList/README.md‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -3,14 +3,14 @@
33
典型的链表结构，包括如下内容：
44

55
1. 数据部分，保存的是该结点的实际数据。
6-
- 地址部分，保存的是下一个结点的地址。
6+
2. 地址部分，保存的是下一个结点的地址。
77
链表结构就是由许多这种结点构成的。在进行链表操作时，首先需定义一个“头引用”变量（一般以head表示），该引用变量指向链表结构的第一个结点，第一个结点的地址部分又指向第二个结点......直到最后一个结点。最后一个结点不再指向其他结点，称为“表尾”，一般在表尾的地址部分放一个空地址null，链表到此结束。
88

99
链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。链表结构还可以细分为如下几类：
1010
1. 单链表：同上面的链式结构一样，每个结点只包含一个引用。
11-
- 双向链表：若每个结点包含两个引用，一个指向下一个结点，另一个指向上一个结点，这就是双向链表。
12-
- 单循环链表：在单链表中，将终端结点的引用域null改为指向表头结点或开始结点即可构成单循环链表。
13-
- 多重链的循环链表：如果表中结点链在多个环上，将构成多重链的循环链表。
11+
2. 双向链表：若每个结点包含两个引用，一个指向下一个结点，另一个指向上一个结点，这就是双向链表。
12+
3. 单循环链表：在单链表中，将终端结点的引用域null改为指向表头结点或开始结点即可构成单循环链表。
13+
4. 多重链的循环链表：如果表中结点链在多个环上，将构成多重链的循环链表。
1414

1515
## 准备数据
1616
准备在 链表操作中需要用到的变量及类。
@@ -64,8 +64,8 @@ CLType CLAddEnd(CLType head, DATA nodeData){
6464
插入头结点即在链表的首部添加结点的过程。
6565
步骤如下：
6666
1. 分配内存空间，保存新增的结点。
67-
- 使新增结点指向头引用head所指向的结点。
68-
- 使头引用head指向新增结点。
67+
2. 使新增结点指向头引用head所指向的结点。
68+
3. 使头引用head指向新增结点。
6969
```java
7070
CLType CLAddFirst(CLType head, DATA nodeData){
7171
CLType node;

‎src/dataStructure/orderList/OrderList.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -114,7 +114,7 @@ public static void main(String[] args) {
114114
String key;
115115
System.out.println("顺序表操作演示!");
116116

117-
SL.SLInit(SL); // 初始化顺序表
117+
SL.SLInit(SL); // 初始化顺序表
118118
System.out.println("初始化顺序表完成!");
119119

120120
Scanner input = new Scanner(System.in);

0 commit comments

Comments
 (0)