java 二维链表_Java数据结构与算法----数组与链表
数据类型
1 数据类型介绍
数据类型的分类(按照结构划分)：线性结构和非线性结构
线性结构：线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系
线性结构有两种不同的存储结构，即顺序存储结构(数组)和 链式存储结构(链表)，顺序存储的线性表为顺序表，顺序表中存储的元素是连续的
链式存储结构的线性表称为链表，链表中的存储的元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息
吸纳行结构常见的有：数组，队列，链表，栈
非线性结构：
非线性结构包括：二维数组，多维数组，广义表，树结构，图结构
2 数据类型之——稀疏数组
2.1 引入实例
分析问题：因为该二维数组的很多值都是默认值0，因此记录了很多没有意义的数据，所以要用到稀疏数组来节省空间
2.2 稀疏数组的基本介绍
当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组
稀疏数组的处理方式是：记录数组一共有几行几列，有多少个不同的值
把具有不同值的元素的行列和值记录在一个小规模的数组中，从而缩小程序的规模
3
2.3 应用实例
使用稀疏数组来保存类似前面的二维数组(棋盘，地图等)
把稀疏数组存盘，并且可以重新恢复原来的二维数组
2.4 思路分析
二维数组转稀疏数组的思路
1) 遍历原始的二维数组，得到有效数据的个数 sum
2) 根据sum就可以创建稀疏数组 sparsArr int[sum + 1][3]
3) 将二维数组的有效数据存入到稀疏数组
稀疏数组转原始的二维数组的思路
1) 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr = int[11][11]
2) 再读取稀疏数组后面几行的内容，并赋给原始的二位数组即可
public class SparseArray {
public static void main(String[] args) {
//创建一个棋盘(原始的二维数组11*11)
//0：表示没有棋子，1：表示黑色棋子，2：表示蓝色棋子
int[][] chessArr = new int[11][11];
chessArr[1][2] = 1;
chessArr[2][3] = 2;
chessArr[4][5] = 2;
//输出原始的二维数组
System.out.println('原始的二维数组');
for (int[] row : chessArr) {//对二维数组中的整行遍历
for (int data : row) {
System.out.printf('%d\t', data);
}
System.out.println();
}
//将二维数组转稀疏数组的思想
//1.先遍历二维数组，得到非0数据的个数
int sum = 0;
for (int[] row : chessArr) {
for (int data : row) {
if (data != 0) {
sum++;
}
}
}
System.out.println('sum=' + sum);
//创建对应的稀疏数组
int[][] sparsArr = new int[sum + 1][3];
//给稀疏数组赋值
sparsArr[0][0] = chessArr.length;
sparsArr[0][1] = chessArr[0].length;
sparsArr[0][2] = sum;
//遍历二维数组，将非0的值存放到稀疏数组中
int count = 1;//计数器，用于记录是第几个非零数据
for(int i = 0; i
for (int j =0; j
if (chessArr[i][j]!=0){
sparsArr[count][0] = i;
sparsArr[count][1] = j;
sparsArr[count][2] = chessArr[i][j];
count++;
}
}
}
//输出稀疏数组
System.out.println('稀疏数组');
for (int[]row:sparsArr){
for (int data:row){
System.out.printf('%d\t',data);
}
System.out.println();
}
System.out.println('还原的二维数组');
//将稀疏数组恢复成原始的二维数组
//1.根据sparsArr第一行创建二维数组
int[][] chessArr2 = new int[sparsArr[0][0]][sparsArr[0][1]];
//2.再读取稀疏数组的后几行的数据(从第二行开始)，并赋值给新的二维数组即可
for (int i = 1; i<=sparsArr[0][2];i++){
chessArr2[sparsArr[i][0]][sparsArr[i][1]] = sparsArr[i][2];
}
for (int[] row:chessArr2){
for (int data:row){
System.out.printf('%d\t',data);
}
System.out.println();
}
}}
3 单向队列
3.1 队列介绍队列是一个有序列表，可以用数组
或是链表
来实现
遵循先入先出
的原则，即：先存入队列的数据要先取出，后存入的要后取出
示意图(用数组模拟队列)
3.2 数组模拟队列队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如上图所示，其中maxSize是该队列的最大容量
因为队列的输出、输入是分别从前后端来处理的，因此需要两个变量front及rear分别记录队列前后端的下标，front会随着数据输出而改变，rear会随着数据的插入而改变
3.3 思路分析
我们将数据存入队列的时候称为“addQueue”，addQueue的处理需要有两个步骤将尾指针(rear)往后移: rear + 1 (队列为空时：rear == front)
若为指针rear小于队列的最大下标，maxSize-1， 则将数据存入rear所指的数组元素中，否则无法存入数据。(队列满时：rear == maxSize-1)
3.4 代码实现import java.util.Scanner;public class ArrayQueueDemo {
public static void main(String[] args) {
ArrayQueue arrayQueue = new ArrayQueue(5);
Scanner s = new Scanner(System.in);
boolean loop = true;
while (loop){
System.out.println('a(add):添加数据');
System.out.println('g(get):得到数据');
System.out.println('s(show):显示数据');
System.out.println('q(quit):退出程序');
char text = s.next().charAt(0);
switch (text){
case 'a':
System.out.println('请输入要添加的数据');
arrayQueue.addQueue(s.nextInt());
break;
case 'g':
try{
System.out.println('得到的数据为');
arrayQueue.getQueue();
}catch (Exception e){
System.out.println(e.getMessage());
}
break;
case 's':
arrayQueue.show();
break;
case 'q':
s.close();//关闭输入器防止异常
loop = false;
break;
}
}
}}//创建数组队列类class ArrayQueue{
private int maxSize;//表示数组的最大容量
private int front;//头指针
private int rear;//尾指针
private int[] arr;//该数组用于存放数据，模拟队列
//创建数组队列的构造器
public ArrayQueue(int maxSize){
this.maxSize = maxSize;
this.arr = new int[maxSize];
front = -1;//指向队列头部，分析出front是指向队列头的前一个位置
rear = -1;//指向队列尾部，指向队列尾(即队列最后一个数据)
}
//判断队列是否为空
public boolean isEmpty(){
return front == rear;
}
//判断队列是否满了
public boolean isFull(){
return rear == maxSize - 1;
}
//向队列中添加数据
public void addQueue(int n){
//如果满了则输出异常不添加数据
if (isFull()){
System.out.println('错误：队列已满不能再添加');
return;
}
//没满，则指针后移，向指针所指的格子中添加数据
rear++;
arr[rear] = n;
}
//从队列中获得数据
public int getQueue(){
//如果队列是空的，抛出异常
if (isEmpty()){
throw new RuntimeException('队列是空的，不能取出数据');
}
//指针后移返回数据
front++;
return arr[front];
}
//将队列格式化输出
public void show(){
if (isEmpty()){
System.out.println('队列是空的，没有数据');
return;
}
for (int i = 0; i
System.out.printf('arr[%d] = %d\n',i,arr[i]);
}
}}
3.5 存在的问题目前数组使用一次就不能继续用了，没有达到复用的效果，造成了空间浪费
将这个数组使用算法，改进成一个环形队列(用取模的方式%)
(类比钟表：maxSize为12)
4 数组模拟队列的改进——环形队列
4.1 思路分析对front变量的含义做一个调整：front就指向队列的第一个元素，也就是说arr[front] 就是队列的第一个元素front的初始值为0
对rear变量的含义做一个调整：rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间(rear指向的空间
)做约定(该约定用来判断队列是不是满了)rear 的初始值是0
当队列满时，条件为 (rear + 1)%maxSize == front【满了】
(该条算法是在判断rear节点的下一个节点是不是front，如果是，则这个环形队列满了)
队列为空的条件是：rear == front【空的】
当我们这样分析，队列中的有效的数据个数(rear+maxSize-front)%maxSize
(类似于钟表，5点和16点在表盘上差了几点：(5+12-16)%12 = 1)环形队列示意图
4.2 注意约定的位置(内容永远为空的位置，最后一个数据位的下一个位置) 是在动态变化的，永远位于最后一个元素的后一个位置
(注意：环形队列是放不满的(在当前算法下)，一定会有一个空余的位置)
addQueue时和单向队列的区别
1)单向队列：先后移，再插入数据(rear指向的位置永远是有数据的)
2)环形队列：先插入数据，再后移(rear指向的位置永远是空的)
getQueue时和单向队列的区别：
1)单向队列：front++，返回arr[front](front的初始值是-1)
2)环形队列：返回arr[front]，front++(front的初始值是0)
show()和单向队列的区别
1)单向队列：从i=0，遍历到i=arr.length()(将数据全部打印出)
2)环形队列：从i=front，遍历到 i=front+size，(左闭右开)
(其中size = (rear + maxSize -front)%maxSize)
isFull和单向队列的区别：
1)单向队列：rear == masSize-1
2)环形队列：(rear+1)%maxSize ==front
(rear的下一个元素是front，则说明该队列满了)环形队列满的条件
环形队列空的条件
4.3 代码实现
import java.util.Scanner;public class CircleArrayQueueDemo {
public static void main(String[] args) {
CircleArrayQueue circleArrayQueue = new CircleArrayQueue(5);//说明：设置4，但是有效数据最大是3，有一个空间是作为约定的
Scanner s = new Scanner(System.in);
boolean loop = true;
while (loop) {
System.out.println('a(add):添加数据');
System.out.println('g(get):得到数据');
System.out.println('s(show):显示数据');
System.out.println('q(quit):退出程序');
System.out.println('h(head):查看队列的第一个数据');
char text = s.next().charAt(0);
switch (text) {
case 'a':
System.out.println('请输入要添加的数据');
circleArrayQueue.addQueue(s.nextInt());
break;
case 'g':
try {
System.out.println('得到的数据为' + circleArrayQueue.getQueue());
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 's':
circleArrayQueue.show();
break;
case 'q':
s.close();//关闭输入器防止异常
loop = false;
break;
case 'h':
circleArrayQueue.headQueue();
break;
}
}
}}//创建数组队列类class CircleArrayQueue {
private int maxSize;//表示数组的最大容量
private int front;//头指针
private int rear;//尾指针
private int[] arr;//该数组用于存放数据，模拟队列
//创建数组队列的构造器
public CircleArrayQueue(int maxSize) {
this.maxSize = maxSize;
this.arr = new int[maxSize];
front = 0;//指向队列头部，即队列的第一个元素
rear = 0;//指向队列尾部，指向队列尾的后一个数据
}
//判断队列是否为空
public boolean isEmpty() {
return front == rear;
}
//判断队列是否满了
public boolean isFull() {
//如果尾指针的下一个元素是front，则满了
return (rear + 1) % maxSize == front;
}
//向队列中添加数据
public void addQueue(int n) {
//如果满了则输出异常不添加数据
if (isFull()) {
System.out.println('错误：队列已满不能再添加');
return;
}
//没满，向当前位置所指的格子中添加数据(因为rear所指的格子是空的)
arr[rear] = n;
//指针后移
rear = (rear + 1) % maxSize;//防止出界
}
//从队列中获得数据
public int getQueue() {
//如果队列是空的，抛出异常
if (isEmpty()) {
throw new RuntimeException('队列是空的，不能取出数据');
}
//这里需要分析出front是指向队列的第一个元素
//先输出，再后移front
//1. 先把front对应的值保留到一个临时变量
//2. 将front后移
//3. 将临时变量返回
int temp = arr[front];
front = (front + 1) % maxSize;
return temp;
}
//将队列格式化输出
public void show() {
if (isEmpty()) {
System.out.println('队列是空的，没有数据');
return;
}
//思路：从front开始遍历，遍历多少个元素
for (int i = front; i < front + (rear - front + maxSize) % maxSize; i++) {
System.out.printf('arr[%d] = %d\n', i % maxSize, arr[i % maxSize]);
}
}
//显示队列的头数据，不是取出数据
public int headQueue() {
if (isEmpty()) {
throw new RuntimeException('队列是空的，没有数据');
}
return arr[front];
}}
5 单链表
5.1 单链表介绍
链表是有序的列表，但是它在内存中的存储如下
(实际在内存中的存储)
逻辑结构示意图如下
总结链表是以结点的方式来存储的，链式存储
每个节点包含data域，next域：指向下一个节点
如图：发现在内存中链表的各个节点不一定是有序存储的
链表分带头节点和不带头结点的链表，根据实际需求来确定
5.2 链表的创建按顺序直接在尾部添加
每个节点中的内容
添加(创建)的过程
1)先创建一个head头节点，作用是表示单链表的头(标明此链表的头部位置)
2)后面我们每添加一个节点，就直接加入到链表的最后
3)遍历：通过一个辅助节点遍历，帮助遍历整个链表
按照编号顺序添加
根据排名将英雄插入到指定的位置，(如果该位置已经存在英雄，则添加失败)
思路：
1)首先找到新添加的节点位置，是通过辅助变量(指针)找到的，通过遍历得到
2)新的节点.next = temp.next
3)temp.next = 新的节点
5.3 节点的修改
通过辅助(指针)遍历链表，发现节点内部编号相等，则与新的节点内容进行互换
5.4 节点的删除
思路：我们先找到需要删除的节点的前一个结点
temp.next = temp.next.next
(不用考虑被删除的节点是最后一个的情况，temp.next = null和temp.next.next 在这种情况下是一样的)
被删除的节点，将不会有其他的引用所指向，会被GC回收
5.5 代码实现public class SingleLinkedListDemo {
public static void main(String[] args) {
//测试
//先创建节点
HeroNode hero1 = new HeroNode(1, '宋江', '及时雨');
HeroNode hero2 = new HeroNode(2, '卢俊义', '玉麒麟');
HeroNode hero3 = new HeroNode(3, '吴用', '智多星');
HeroNode hero4 = new HeroNode(4, '林冲', '豹子头');
//创建链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero2);
singleLinkedList.add(hero3);
singleLinkedList.add(hero4);
singleLinkedList.List();
singleLinkedList.delete(hero4);
singleLinkedList.delete(hero3);
singleLinkedList.delete(hero2);
singleLinkedList.delete(hero1);
System.out.println('删除后');
singleLinkedList.List();
}}class SingleLinkedList {
//先初始化一个头结点，头节点不要动，不要存放具体的数值
HeroNode head = new HeroNode(0, '', '');
//添加节点到单向链表
//思路：当不考虑编号顺序时
//1. 找到当前链表的最后节点
//2. 将最后这个节点的next指向新的节点
public void add(HeroNode heroNode) {
//因为head节点不能动，因此我们需要一个辅助遍历temp
HeroNode temp = head;
//遍历链表找到最后一个节点
while (true) {
//找到最后一个节点，终止循环
if (temp.next == null) {
break;
}
//如果没有找到，将temp向后移动
temp = temp.next;
}
//while退出时，temp已经指向的最后的节点
temp.next = heroNode;
}
public void addByOrder(HeroNode heroNode) {
//因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
//因为单链表，因此我们找到的temp是位于添加位置的前一个结点，否则插入不进去
HeroNode temp = head;//辅助指针，初始值在head
boolean flag = false;//标识：表示该插入的对象是否已经在链表中存在了，默认为false(没有存在)
//遍历，从head开始到链表尾
while (true) {
//如果已经在链表尾
if (temp.next == null) {
break;
}
//如果找到位置，就在temp后面插入
if (temp.next.heroNo > heroNode.heroNo) {//temp的heroNo不大于，但是temp.next大于，说明插入位置在temp和temp.next之间
break;//找到位置，退出循环
}
if (temp.next.heroNo == heroNode.heroNo) {
flag = true;//说明该节点存在
break;
}
//如果以上条件都不满足，将temp后移
temp = temp.next;
}
//此时得到了一个flag值或者一个temp位置
//首先判断flag
if (flag) {
//说明该节点已经存在
System.out.printf('节点%d已经存在，不能再添加\n', heroNode.heroNo);
} else {
//该节点不存在的话，就在temp后面插入新的节点
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//修改节点
public void update(HeroNode newHeroNode) {
//首先确定一下链表是否为空
if (head.next == null) {
System.out.println('链表为空，无法修改');
}
//创建辅助结点来遍历链表
HeroNode temp = head.next;
//创建flag变量，判断该节点是否找到
boolean flag = false;
while (true) {
//如果已经遍历到尾节点，终止
if (temp == null) {
break;
}
if (temp.heroNo == newHeroNode.heroNo) {
//找到该节点
flag = true;
break;
} else {
temp = temp.next;
}
}
//循环结束后通过flag值判断是否修改
if (flag) {
temp.heroName = newHeroNode.heroName;
temp.nickName = newHeroNode.nickName;
//next和no都不用变
} else {
System.out.printf('没有编号为%d的节点,无法修改\n', newHeroNode.heroNo);
}
}
//删除节点
//思路：
//1.head不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
//2.说明我们在比较时，是temp.next.heroNo 和要删除的节点的heroNo比较
public void delete(HeroNode delHeroNode) {
//如果链表为空，无法删除
if (head.next == null) {
System.out.println('链表为空，无法删除\n');
return;
}
//构建辅助节点，帮忙遍历链表
HeroNode temp = head;
//flag表示是否找到该节点的前一位，默认为false
boolean flag = false;
while (true) {
//如果遍历到最后一位，说明该节点不存在，终止循环
if (temp.next == null) {
break;
}
if (temp.next.heroNo == delHeroNode.heroNo) {
//找到了要删除的节点的上一位
flag = true;
break;
} else {
//没有找到，继续往后走
temp = temp.next;
}
}
//循环终止后通过判断flag值决定是否删除节点
if (flag) {
//如果要删除的节点在最后一位，则将上一位的next指向null
/*if (temp.next.next==null){
temp.next = null;
}
else {
//要删除的节点不在最后一位
temp.next = temp.next.next;
}*/
//如果要删除的节点在最后一位，则temp.next.next本身就等于null，以上两种情况可以合并
temp.next = temp.next.next;
} else {
System.out.printf('没有编号为%d的节点，无法删除\n', delHeroNode.heroNo);
}
}
public void List() {
//判断链表是否为空
if (head.next == null) {
System.out.println('链表为空');
return;
}
//因为头节点不能动，所以需要一个辅助节点来遍历
HeroNode temp = head.next;
while (true) {
//判断是否到链表最后
if (temp == null) {
break;
}
//如果还没有遍历到最后
System.out.println(temp);
//将temp后移
temp = temp.next;
}
}}//定义HeroNode，每一个HeroNode对象就是一个节点class HeroNode {
public int heroNo;
public String heroName;
public String nickName;
HeroNode next;
public HeroNode(int heroNo, String heroName, String nickName) {
this.heroNo = heroNo;
this.heroName = heroName;
this.nickName = nickName;
}
//为了显示方法，我们重写toString
public String toString() {
return 'HeroNode [no = ' + heroNo + ', name = ' + heroName + ', nickname = ' + nickName + ']';
}}
5.6 单链表面试题
5.6.1 求单链表中有效节点的个数
韩老师的方法写在了测试类中，为静态方法：
/**
*
* @param head 链表的头节点
* @return 返回链表的长度
*/
public static int getLength(HeroNode head){
//空链表
if (head.next == null){
return 0;
}
int result = 0;
//辅助接点遍历，将头节点排除在外
HeroNode cur = head.next;
while (cur!=null){
result++;
cur = cur.next;
}
return result;
}//同时因为head为SingleLinkedList类中的private属性，所以在SingleLinkedList中添加一个getter方法
public HeroNode getHead() {
return head;
}
//==========================
我写在了SingleLinkedList类中，为实例方法，不需要参数，可以直接使用对象调用//方法：获取单链表的节点的个数(如果是带头节点的，需要不统计头节点)
public int getLength2(){
int result = 0;
HeroNode temp = head;
while (true){
if (temp.next == null){
break;
}
temp = temp.next;
result++;
}
return result;
}
我感觉在实际情况中，韩老师的方法更对一些，因为SingleLinkedList在实际应用情况下是封装好的，外部是不能够更改内部的，所以应该用外部的方法取实现要求。
5.6.2 查找单链表中的倒数第k个节点
思路：编写一个方法，接受head节点，同时接受一个index
index表示是倒数第index个节点
先把链表从头到尾遍历，得到链表的总长度getLength
得到size之后，我们从链表的第一个节点(非head)开始遍历(size-index)个，就可以得到
如果找到了，则返回该节点，否则返回null示意图
代码示例：
/**
*
* @param head 链表的头节点
* @param k
* @return 返回倒数第K个节点
*/
public static HeroNode findLastKNode(HeroNode head, int k){
//如果链表为空，返回null
if (head.next == null){
return null;
}
//找到链表的长度
int length = getLength(head);
//先做一个index校验
if ( k <= 0 || k > length){
return null;
}
//辅助节点帮助遍历
HeroNode cur = head.next;
//遍历K次
for (int i = 0; i < length - k; i++) {
cur = cur.next;
}
return cur;
}
5.6.3 从尾到头打印单链表(反向遍历)
思路：方式1：先将单链表进行反转操作，然后再遍历即可，但是这样做的问题会破坏原来的单链表的结构，不建议
方式2：利用栈数据结构，将各个节点压入到栈中，利用栈的先进后出的特点实现了逆序打印的效果