数据结构与算法（java）—— 链表
数据结构概述
数据结构包括：线性结构和非线性结构
线性结构：存在一一对应关系，比如数组a[0]=1.（数组，队列，栈，链表）
线性结构有两种存储方式：顺序存储和链式存储，顺序存储称为线性表，存储的元素地址是连续的比如数组。链式存储的线性表称为链表，存储数据不连续，靠地址指针来定位。链式存储适用于在较频繁地插入、删除、更新元素时，而顺序存储结构适用于频繁查询时使用。
非线性结构：二维数组，图，树。
稀疏数组
队列arrayQueue
类似管道，先进先出，队列两种实现：数组实现和链表实现
单链表LinkedList
每个节点包括data域和next域
定义节点
//定义节点
class HeroNode {
public int number;
public String name;
public String nickName;
public HeroNode next;
public HeroNode(int hNumber, String hName, String hNickName) {
this.number = hNumber;
this.name = hName;
this.nickName = hNickName;
}
//重写toString来打印
@Override
public String toString() {
return "Hero: [ number: " + number + ", name: " + name + ", nickName: " + nickName + "]";
}
}
单链表
//单链表
class SingleLinkedList {
//先初始化头节点，不存放具体数据
private HeroNode head = new HeroNode(0, "", "");
public HeroNode getHead(){
return this.head;
}
//添加节点到链表尾部
public void add(HeroNode node) {
//使用临时节点
HeroNode temp = head;//temp=head则循环就要加next
//遍历找到尾节点来插入
//当temp的下一个节点为null时说明temp为尾节点
while (temp.next != null) {
temp = temp.next;//后移节点
}
//将最后一个节点指向新节点
temp.next = node;
}
//在特定位置插入节点
public void insert(HeroNode node) {
//创建temp需是在要插入节点的前一个节点
HeroNode temp = head;
//循环直到temp为最后一个节点
while (temp.next != null) {
if (temp.next.number == node.number) {
System.out.println("该节点已存在，不能插入");
return;
}
//遍历查找当temp.next.number > node.number那么就是找到了该节点位置
else if (temp.next.number > node.number) {//找到该节点位置
break;
}
temp = temp.next;
}
//找到之后插入，
node.next = temp.next;
temp.next = node;
}
//更新节点
public void update(HeroNode node) {
//不修改第一个
HeroNode temp = head.next;
boolean flag = false;
//循环直到temp为最后一个节点
while (temp != null) {
if (temp.number == node.number) {
flag = true;
break;
}
temp = temp.next;
}
//如果找到了
if (flag) {
temp.nickName = node.nickName;
temp.name = node.name;
} else {
System.out.println("没有找到该节点。");
}
}
//删除节点
//我们需要找到待删除节点的前一个节点
public void delete(int a) {
HeroNode temp = head;
boolean flag = false;
while (temp.next != null) {
if (temp.next.number == a) {
flag = true;
break;
}
temp = temp.next;
}
if (flag) {
temp.next = temp.next.next;
} else {
System.out.println("要删除的该节点不存在");
}
}
//查
public void get(int a) {
System.out.println("查询编号为：" + a);
HeroNode temp = head.next;
boolean flag = false;
while (temp != null) {
if (temp.number == a) {
flag = true;
break;
}
temp = temp.next;
}
if (flag)
System.out.println(temp);
else
System.out.println("没找到该节点");
}
//打印链表
public void printList() {
System.out.println("printList：");
//先判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
} else {
//头节点不能动，但是头节点数据是0，所以我们给temp作为next
HeroNode temp = head.next;
while (temp != null) {//一直循环直到当temp指向空节点，则跳出循环
System.out.println(temp);
temp = temp.next;
}
}
}
}
获取单链表的节点个数
//获取单链表有效节点个数
//形参为链表头节点
public static int countNode(HeroNode headNode) {
int length = 0;
//判断是否为空链表
if (headNode.next == null)
return 0;
HeroNode cur = headNode.next;
while (cur != null) {
length++;
cur = cur.next;
}
return length;
}
查找单链表中倒数第K个节点
//查找单链表中倒数第K个节点
//思路：先遍历得到链表长度然后计算处第几个节点
public static HeroNode getReverseNode(HeroNode headNode, int k){
int length = 0;
//判断是否为空链表
if (headNode.next == null)
return null;
//第一次遍历得到节点个数
HeroNode cur = headNode.next;
while (cur != null) {
length++;
cur = cur.next;
}
//第二次遍历得到该节点
if (k<=0 || k>length)
return null;
HeroNode cur2 = headNode.next;
//因为是第几个所有用for循环
for (int i = 0;i<length-k;i++){
cur2 = cur2.next;
}
//for循环移动指针之后这时就指向该节点
return cur2;
}
反转链表
//链表的反转
//思路：把传进的链表遍历每个节点插入到第二个链表的前端
public static void reverseLinkedList(HeroNode headNode) {
//如果链表为空或者只有一个节点，则直接返回
if (headNode.next == null || headNode.next.next == null) {
return;
}
HeroNode cur = headNode.next;//第一个cur遍历
HeroNode cur2 = null;//第二个cur进行链接后面的表
HeroNode reverseHead = new HeroNode(0, "", "");//反转链表头
while (cur != null) {
//cur2保存临时变量
cur2 = cur.next;
//将节点插入到第二个链表头节点后面
cur.next = reverseHead.next;
reverseHead.next = cur;
//后移cur，这时cur=cur.next已经不能后移了，而需要用到cur2
cur = cur2;
}
//所有节点放到第二个链表中把第一个链表头节点指向第二个链表
headNode.next = reverseHead.next;
}
逆序打印链表
//链表到逆序打印
//思路：一：我们可以反转链表打印，但会破坏链表结构。二：将链表节点压入一个栈，然后出栈就是逆序。
public static void reversePrint(HeroNode headNode) {
//判断为空
if (headNode.next == null) {
return;
}
//压栈
Stack<HeroNode> heroNodeStack = new Stack<>();
HeroNode cur = headNode.next;
while (cur != null) {
heroNodeStack.add(cur);
cur = cur.next;
}
//打印栈
while (heroNodeStack.size() > 0) {
System.out.println(heroNodeStack.pop());
}
}
双向链表
单链表只能一个方向查找且删除的时候需要靠辅助节点；
双向链表可以两个方向查找，且删除的时候可以自己删除。
全部代码实现
package DataStructure;
import java.util.Stack;
public class SingleLinkedListDemo {
public static void main(String[] args) {
HeroNode node1 = new HeroNode(1, "song", "ji");
HeroNode node2 = new HeroNode(2, "lujunyi", "yu");
HeroNode node3 = new HeroNode(3, "wuyong", "zhiduoxing");
HeroNode node4 = new HeroNode(4, "gongsunsheng", "ruyunlong");
HeroNode node5 = new HeroNode(3, "duyongxing", "zhid");
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(node1);
singleLinkedList.add(node2);
singleLinkedList.add(node3);//不要同一个对象添加两次
singleLinkedList.insert(node4);
singleLinkedList.printList();
singleLinkedList.update(node5);
singleLinkedList.printList();
singleLinkedList.delete(4);
singleLinkedList.printList();
singleLinkedList.get(1);
System.out.println(countNode(singleLinkedList.getHead()));
System.out.println(getReverseNode(singleLinkedList.getHead(), 5));
reversePrint(singleLinkedList.getHead());
}
//获取单链表有效节点个数
//形参为链表头节点
public static int countNode(HeroNode headNode) {
int length = 0;
//判断是否为空链表
if (headNode.next == null)
return 0;
HeroNode cur = headNode.next;
while (cur != null) {
length++;
cur = cur.next;
}
return length;
}
//查找单链表中倒数第K个节点
//思路：先遍历得到链表长度然后计算处第几个节点
public static HeroNode getReverseNode(HeroNode headNode, int k) {
int length = 0;
//判断是否为空链表
if (headNode.next == null)
return null;
//第一次遍历得到节点个数
HeroNode cur = headNode.next;
while (cur != null) {
length++;
cur = cur.next;
}
//第二次遍历得到该节点
if (k <= 0 || k > length)
return null;
HeroNode cur2 = headNode.next;
//因为是第几个所有用for循环
for (int i = 0; i < length - k; i++) {
cur2 = cur2.next;
}
//for循环移动指针之后这时就指向该节点
return cur2;
}
//链表的反转
//思路：把传进的链表遍历每个节点插入到第二个链表的前端
public static void reverseLinkedList(HeroNode headNode) {
//如果链表为空或者只有一个节点，则直接返回
if (headNode.next == null || headNode.next.next == null) {
return;
}
HeroNode cur = headNode.next;//第一个cur遍历
HeroNode cur2 = null;//第二个cur进行链接后面的表
HeroNode reverseHead = new HeroNode(0, "", "");//反转链表头
while (cur != null) {
//cur2保存临时变量
cur2 = cur.next;
//将节点插入到第二个链表头节点后面
cur.next = reverseHead.next;
reverseHead.next = cur;
//后移cur，这时cur=cur.next已经不能后移了，而需要用到cur2
cur = cur2;
}
//所有节点放到第二个链表中把第一个链表头节点指向第二个链表
headNode.next = reverseHead.next;
}
//链表到逆序打印
//思路：一：我们可以反转链表打印，但会破坏链表结构。二：将链表节点压入一个栈，然后出栈就是逆序。
public static void reversePrint(HeroNode headNode) {
//判断为空
if (headNode.next == null) {
return;
}
//压栈
Stack<HeroNode> heroNodeStack = new Stack<>();
HeroNode cur = headNode.next;
while (cur != null) {
heroNodeStack.add(cur);
cur = cur.next;
}
//打印栈
while (heroNodeStack.size() > 0) {
System.out.println(heroNodeStack.pop());
}
}
}
//单链表
class SingleLinkedList {
//先初始化头节点，不存放具体数据
private HeroNode head = new HeroNode(0, "", "");
public HeroNode getHead() {
return this.head;
}
//添加节点到链表尾部
public void add(HeroNode node) {
//使用临时节点
HeroNode temp = head;//temp=head则循环就要加next
//遍历找到尾节点来插入
//当temp的下一个节点为null时说明temp为尾节点
while (temp.next != null) {
temp = temp.next;//后移节点
}
//将最后一个节点指向新节点
temp.next = node;
}
//在特定位置插入节点
public void insert(HeroNode node) {
//创建temp需是在要插入节点的前一个节点
HeroNode temp = head;
//循环直到temp为最后一个节点
while (temp.next != null) {
if (temp.next.number == node.number) {
System.out.println("该节点已存在，不能插入");
return;
}
//遍历查找当temp.next.number > node.number那么就是找到了该节点位置
else if (temp.next.number > node.number) {//找到该节点位置
break;
}
temp = temp.next;
}
//找到之后插入，
node.next = temp.next;
temp.next = node;
}
//更新节点
public void update(HeroNode node) {
//不修改第一个
HeroNode temp = head.next;
boolean flag = false;
//循环直到temp为最后一个节点
while (temp != null) {
if (temp.number == node.number) {
flag = true;
break;
}
temp = temp.next;
}
//如果找到了
if (flag) {
temp.nickName = node.nickName;
temp.name = node.name;
} else {
System.out.println("没有找到该节点。");
}
}
//删除节点
//我们需要找到待删除节点的前一个节点
public void delete(int a) {
HeroNode temp = head;
boolean flag = false;
while (temp.next != null) {
if (temp.next.number == a) {
flag = true;
break;
}
temp = temp.next;
}
if (flag) {
temp.next = temp.next.next;
} else {
System.out.println("要删除的该节点不存在");
}
}
//查
public void get(int a) {
System.out.println("查询编号为：" + a);
HeroNode temp = head.next;
boolean flag = false;
while (temp != null) {
if (temp.number == a) {
flag = true;
break;
}
temp = temp.next;
}
if (flag)
System.out.println(temp);
else
System.out.println("没找到该节点");
}
//打印链表
public void printList() {
System.out.println("printList：");
//先判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
} else {
//头节点不能动，但是头节点数据是0，所以我们给temp作为next
HeroNode temp = head.next;
while (temp != null) {//一直循环直到当temp指向空节点，则跳出循环
System.out.println(temp);
temp = temp.next;
}
}
}
}
//定义节点
class HeroNode {
public int number;
public String name;
public String nickName;
public HeroNode next;
public HeroNode(int hNumber, String hName, String hNickName) {
this.number = hNumber;
this.name = hName;
this.nickName = hNickName;
}
//重写toString来打印
@Override
public String toString() {
return "Hero: [ number: " + number + ", name: " + name + ", nickName: " + nickName + "]";
}
}