Single Linked List& Double Linked List
概述
- 链表是有序列表
- 以节点方式链式存储, 也就是节点之间不一定是连续的地址
- 每个节点包含数据域和指向下一个节点的地址/引用
- 链表分
带头节点的链表
和不带头节点的链表
单链表(Single Linked List)
/** 定义链表节点类*/
class DataNode {
/** 节点编号*/
public int no;
/** 节点标题*/
public String title;
/** 指向下一个节点, 如果是 null, 则当前节点为尾节点*/
public DataNode next;
public DataNode() {}
public DataNode(int no, String title) {
this.no = no;
this.title = title;
}
@Override
public String toString() {
return "DataNode [no=" + no + ", title=" + title + "]";
}
}
/** 定义单链表类*/
class SingleLinkedList {
/** 初始化头节点, 此节点不设定数据*/
private DataNode head = new DataNode();
public DataNode getHead() {
return head;
}
/**
* 添加新节点:
* 给尾部节点的 next指向新的节点引用
* */
public void add(DataNode DataNode) {
/** 为了从头节点开始往后遍历找出尾部节点*/
DataNode temp = head;
/** 遍历找出尾部节点*/
while(true) {
/** 当前节点为尾部节点便停止循环*/
if(temp.next == null) {
break;
}
/** 如果当前节点不为尾部节点, 则再往后移*/
temp = temp.next;
}
/** 将新的节点引用加到, 当前(尾部)节点的 next变量中*/
temp.next = DataNode;
}
/** 遍历所有节点*/
public void print() {
if(head.next == null) {
System.out.println("链表为空!");
return;
}
/** 头节点不能被覆盖, 所有先使用辅助变量转移第一个(有效)节点*/
DataNode temp = head.next;
while(true) {
/** 到了链表尾部时停止遍历*/
if(temp == null) {
break;
}
/** 输出当前节点的信息*/
System.out.println(temp);
/** 往后移一个节点, 继续遍历*/
temp = temp.next;
}
}
}
public class SingleLinkedListApp {
public static void main(String[] args) {
/** 创建链表实例*/
SingleLinkedList list = new SingleLinkedList();
/** 添加节点*/
list.add(new DataNode(4, "节点4"));
list.add(new DataNode(2, "节点2"));
list.add(new DataNode(1, "节点1"));
list.add(new DataNode(3, "节点3"));
/** 输出所有节点*/
list.print();
}
}
输出:
> DataNode [no=4, title=节点4]
> DataNode [no=2, title=节点2]
> DataNode [no=1, title=节点1]
> DataNode [no=3, title=节点3]
- 排序添加(添加时根据编号排序)
- 思路:
- 首先锁定将要插入的下一个(next)位置
- DataNode.next = temp.next; temp.next = DataNode;
/** 排序添加(添加时根据编号排序)*/
public void addByOrder(DataNode DataNode) {
DataNode temp = head;
/** 标志: 是否重复*/
boolean bRepeat = false;
while(true) {
/** 到了链表尾部时停止遍历*/
if(temp.next == null) {
break;
}
/** 找到了, 排序位*/
if(temp.next.no > DataNode.no) {
break;
} else if (temp.next.no == DataNode.no) {
/** 编号重复*/
bRepeat = true;
break;
}
/** 往后移一个节点, 继续遍历*/
temp = temp.next;
}
/** 判断编号是否重复*/
if(bRepeat) {
System.out.printf("重复节点 %d, 不能添加\n", DataNode.no);
} else {
/** 将新节点插入到下一个(next)位置, 再把之前的 next引用地址指向新节点的下一个(next)*/
DataNode.next = temp.next;
temp.next = DataNode;
}
}
/** 创建链表实例*/
SingleLinkedList list = new SingleLinkedList();
list.addByOrder(new DataNode(4, "节点4"));
list.addByOrder(new DataNode(2, "节点2"));
list.addByOrder(new DataNode(1, "节点1"));
list.addByOrder(new DataNode(3, "节点3"));
/** 输出所有节点*/
list.print();
输出:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
- 链表修改
- 思路:
- 修改指定节点信息, 根据编号(no)锁定节点, 即编号不能改
- temp.title = newDataNode.title;
/** 链表修改(修改指定节点信息, 根据编号(no)锁定节点)*/
public void update(DataNode newDataNode) {
if(head.next == null) {
System.out.println("链表为空!");
return;
}
/** 头节点不能被覆盖, 所有先使用辅助变量转移第一个(有效)节点*/
DataNode temp = head.next;
/** 标记: 是否找到指定节点*/
boolean flag = false;
while(true) {
/** 到了链表尾部时停止遍历*/
if (temp == null) {
break;
}
if(temp.no == newDataNode.no) {
/** 找到节点*/
flag = true;
break;
}
/** 往后移一个节点, 继续遍历*/
temp = temp.next;
}
if(flag) {
/** 修改属性*/
temp.title = newDataNode.title;
} else {
System.out.printf("没有找到 编号 %d 的节点\n", newDataNode.no);
}
}
/** 创建链表实例*/
SingleLinkedList list = new SingleLinkedList();
list.addByOrder(new DataNode(4, "节点4"));
list.addByOrder(new DataNode(2, "节点2"));
list.addByOrder(new DataNode(1, "节点1"));
list.addByOrder(new DataNode(3, "节点3"));
System.out.println("原链表:");
list.print();
DataNode newStu = new DataNode(3,"节点03");
list.update(newStu);
System.out.println("修改后的链表:");
list.print();
输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 修改后的链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点03]
> DataNode [no=4, title=节点4]
- 链表删除
- 思路:
- 我们先锁定要删除的节点的前一个节点
- 将下下一个节点的引用覆盖到下一个节点(要删除的节点)的 next. temp.next = temp.next.next;
/** 链表删除*/
public void del(int no) {
DataNode temp = head;
boolean flag = false;
while (true) {
if (temp.next == null) {
break;
}
if(temp.next.no == no) {
flag=true;
break;
}
temp = temp.next;
}
if (flag) {
temp.next = temp.next.next;
}else {
System.out.printf("要删除的编号 %d 节点不存在", no);
}
}
/** 创建链表实例*/
SingleLinkedList list = new SingleLinkedList();
list.addByOrder(new DataNode(4, "节点4"));
list.addByOrder(new DataNode(2, "节点2"));
list.addByOrder(new DataNode(1, "节点1"));
list.addByOrder(new DataNode(3, "节点3"));
System.out.println("原链表:");
list.print();
list.del(2);
System.out.println("删除后的链表:");
list.print();
输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 删除后的链表:
> DataNode [no=1, title=节点1]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
- 链表长度(有效节点的个数, 不统计头节点)
/** 链表长度(有效节点的个数)*/
public int getLength() {
/** 空链表*/
if(head.next == null) {
return 0;
}
int length = 0;
DataNode temp = head.next;
while(temp != null) {
length++;
/** 往后移一个节点, 继续遍历*/
temp = temp.next;
}
return length;
}
/** 创建链表实例*/
SingleLinkedList list = new SingleLinkedList();
list.addByOrder(new DataNode(4, "节点4"));
list.addByOrder(new DataNode(2, "节点2"));
list.addByOrder(new DataNode(1, "节点1"));
list.addByOrder(new DataNode(3, "节点3"));
System.out.println("原链表:");
list.print();
System.out.println("有效节点个数: "+ list.getLength());
输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 有效节点个数: 4
- 获取倒数第几的节点
- 思路:
- 首先获取有效节点总长度-指定倒数第几=N. 然后遍历到 N次后返回
/** 获取倒数第几的节点*/
public DataNode findLastIndexNode(int index) {
if(head.next == null) {
return null;
}
/** 获取有效节点个数*/
int size = getLength();
if(index <=0 || index > size) {
return null;
}
DataNode temp = head.next;
/**
* 例: size = 4; index = 1
* size - index = 3
* */
int leftSize = size - index;
for(int i =0; i< leftSize; i++) {
temp = temp.next;
}
return temp;
}
/** 创建链表实例*/
SingleLinkedList list = new SingleLinkedList();
list.addByOrder(new DataNode(4, "节点4"));
list.addByOrder(new DataNode(2, "节点2"));
list.addByOrder(new DataNode(1, "节点1"));
list.addByOrder(new DataNode(3, "节点3"));
System.out.println("原链表:");
list.print();
int lastNo = 2;
DataNode DataNode = list.findLastIndexNode(lastNo);
System.out.printf("倒数第 %d 个节点: ", lastNo);
System.out.println(DataNode);
输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 倒数第 2 个节点: DataNode [no=3, title=节点3]
- 单链表的反转(实际节点调换)
- 思路:
- 定义新链表 DataNode reverseHead = new DataNode();
- 遍历原链表, 每遍历一个节点, 将其取出, 并加到 reverseHead的最前端
/** 单链表的反转*/
public void reversetList() {
/** 必须有1个以上的有效节点*/
if(head.next == null || head.next.next == null) {
return ;
}
DataNode cur = head.next;
/** 指向当前节点的下一个节点*/
DataNode next;
/** 全新链表*/
DataNode reverseHead = new DataNode();
/** 遍历原链表, 每遍历一个节点, 将其取出, 并加到 reverseHead的最前端*/
while(cur != null) {
/** 暂时保存当前节点的下一个节点*/
next = cur.next;
/** 将 cur的下一个节点指向新的链表的最前端*/
cur.next = reverseHead.next;
/** 将 cur连接到新的链表上*/
reverseHead.next = cur;
/** 将 cur后移*/
cur = next;
}
/** 将 head.next指向 reverseHead.next*/
head.next = reverseHead.next;
}
/** 创建链表实例*/
SingleLinkedList list = new SingleLinkedList();
list.addByOrder(new DataNode(4, "节点4"));
list.addByOrder(new DataNode(2, "节点2"));
list.addByOrder(new DataNode(1, "节点1"));
list.addByOrder(new DataNode(3, "节点3"));
System.out.println("原链表:");
list.print();
System.out.println("反转链表:");
list.reversetList();
list.print();
输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 反转链表:
> DataNode [no=4, title=节点4]
> DataNode [no=3, title=节点3]
> DataNode [no=2, title=节点2]
> DataNode [no=1, title=节点1]
- 单链表的反转(只是反转输出, 实际节点未反转)
- 思路:
- 通过栈数据结构, 利用栈的先进后出的特点, 实现逆序输出的效果
/**
* 单链表的反转(只是反转输出, 实际节点未反转):
* 通过栈数据结构, 利用栈的先进后出的特点, 实现逆序输出的效果
* */
public void reversePrint() {
if(head.next == null) {
return;
}
/** 创建一个栈*/
Stack<DataNode> stack = new Stack<>();
DataNode cur = head.next;
while(cur != null) {
/** 将链表的所有节点压入栈*/
stack.push(cur);
/** 将 cur后移*/
cur = cur.next;
}
/** 将栈中的节点一一输出(出栈)*/
while (stack.size() > 0) {
System.out.println(stack.pop());
}
}
/** 创建链表实例*/
SingleLinkedList list = new SingleLinkedList();
list.addByOrder(new DataNode(4, "节点4"));
list.addByOrder(new DataNode(2, "节点2"));
list.addByOrder(new DataNode(1, "节点1"));
list.addByOrder(new DataNode(3, "节点3"));
System.out.println("原链表:");
list.print();
System.out.println("逆序打印单链表:");
list.reversePrint();
输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 逆序打印单链表:
> DataNode [no=4, title=节点4]
> DataNode [no=3, title=节点3]
> DataNode [no=2, title=节点2]
> DataNode [no=1, title=节点1]
双向链表(Double Linked List)
- 不同于单链表:
(1) 每个节点包含数据域, 指向下一个节点的 next(地址/引用)和多了一个上一个节点的 pre(地址/引用)
(2) 单向链表是只能单方向查找节点, 而双向链表可以向前或向后查找节点
(3) 单向链表不能自我删除, 而双向链表, 则可以自我删除节点
(4) 添加方法: 将新的节点引用加到, 当前(尾部)节点的 next变量中, 同时当前节点引用加到新节点的 pre变量中; temp.next = dataNode; dataNode.pre = temp;
(5) 找出要删除的节点(temp). temp.pre.next = temp.next; temp.next.pre = temp.pre;
/** 定义链表节点类*/
class DataNode {
/** 节点编号*/
public int no;
/** 节点标题*/
public String title;
/** 指向下一个节点, 如果是 null, 则当前节点为尾节点*/
public DataNode next;
/** 指向上一个节点, 如果是 null, 则当前节点为头节点*/
public DataNode pre;
public DataNode() {}
public DataNode(int no, String title) {
this.no = no;
this.title = title;
}
@Override
public String toString() {
return "DataNode [no=" + no + ", title=" + title + "]";
}
}
/** 定义双向链表类*/
class DoubleLinkedList {
/** 初始化头节点, 此节点不设定数据*/
private DataNode head = new DataNode();
/**
* 添加新节点:
* 给尾部节点的 next指向新的节点引用
* */
public void add(DataNode dataNode) {
/** 为了从头节点开始往后遍历找出尾部节点*/
DataNode temp = head;
/** 遍历找出尾部节点*/
while(true) {
/** 当前节点为尾部节点便停止循环*/
if(temp.next == null) {
break;
}
/** 如果当前节点不为尾部节点, 则再往后移*/
temp = temp.next;
}
/** 将新的节点引用加到, 当前(尾部)节点的 next变量中, 同时当前节点引用加到新节点的 pre变量中*/
temp.next = dataNode;
dataNode.pre = temp;
}
/** 遍历所有节点*/
public void print() {
if(head.next == null) {
System.out.println("链表为空!");
return;
}
/** 头节点不能被覆盖, 所有先使用辅助变量转移第一个(有效)节点*/
DataNode temp = head.next;
while(true) {
/** 到了链表尾部时停止遍历*/
if(temp == null) {
break;
}
/** 输出当前节点的信息*/
System.out.println(temp);
/** 往后移一个节点, 继续遍历*/
temp = temp.next;
}
}
/** 排序添加(添加时根据编号排序)*/
public void addByOrder(DataNode dataNode) {
DataNode temp = head;
/** 标记: 是否重复*/
boolean bRepeat = false;
while(true) {
/** 到了链表尾部时停止遍历*/
if(temp.next == null) {
break;
}
/** 找到了, 排序位*/
if(temp.next.no > dataNode.no) {
break;
} else if (temp.next.no == dataNode.no) {
/** 编号重复*/
bRepeat = true;
break;
}
/** 往后移一个节点, 继续遍历*/
temp = temp.next;
}
/** 判断编号是否重复*/
if(bRepeat) {
System.out.printf("重复节点 %d, 不能添加\n", dataNode.no);
} else {
dataNode.next = temp.next;
if (temp.next != null) temp.next.pre = dataNode;
temp.next = dataNode;
dataNode.pre = temp;
}
}
/** 链表删除*/
public void del(int no) {
if(head.next == null) {
System.out.println("链表为空!");
return;
}
DataNode temp = head.next;
boolean flag = false;
while (true) {
if (temp == null) {
break;
}
if(temp.no == no) {
flag=true;
break;
}
temp = temp.next;
}
if (flag) {
temp.pre.next = temp.next;
if (temp.next != null) temp.next.pre = temp.pre;
}else {
System.out.printf("要删除的编号 %d 节点不存在", no);
}
}
}
public class DoubleLinkedListApp {
public static void main(String[] args) {
// /** 创建链表实例*/
// DoubleLinkedList list = new DoubleLinkedList();
// /** 添加节点*/
// list.add(new DataNode(4, "节点4"));
// list.add(new DataNode(2, "节点2"));
// list.add(new DataNode(1, "节点1"));
// list.add(new DataNode(3, "节点3"));
// /** 输出所有节点*/
// list.print();
/** 创建链表实例*/
DoubleLinkedList list = new DoubleLinkedList();
list.addByOrder(new DataNode(4, "节点4"));
list.addByOrder(new DataNode(2, "节点2"));
list.addByOrder(new DataNode(1, "节点1"));
list.addByOrder(new DataNode(3, "节点3"));
System.out.println("原链表:");
list.print();
list.del(2);
System.out.println("删除后的链表:");
list.print();
}
}
输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 删除后的链表:
> DataNode [no=1, title=节点1]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
如果您觉得有帮助,欢迎点赞哦 ~ 谢谢!!