系列文章目录
前言
上一篇文章学习了稀疏数组和队列
一、环形队列
环形队列图如下：
自我理解图：
思路：
1，front变量，初始值为 0，指向队列的第一个元素也是待取出的数据，
也就是说arr[front]是队列的第一个元素
2，rear变量，rear 初始值为 0，指向待添加数据的位置，队列添加数据时，因逻辑上的闭环，指针可能再次回到前面的位置，不能单一递增处理，会出现角标越界异常，需通过取模来重新计算指针的值
3，当队列满时 条件是 (rear + 1) % maxsize == front 假如，maxsize 为10，front为0，rear为9 此时队列就满了
4，当队列为空时，条件是rear == front
5，rear指针指向待添加数据的元素位置，假设队列内部数组的最大容量为maxsize ，当rear指针指向maxsize -1时，实际该位置上并无数据，因此，队列的最大容量只有maxsize -1，即队列的最大有效数据个数为maxsize -1，因为预留一个位置
代码实现
package com.java.zzw;
import java.util.Scanner;
/**
* @author 赵志文
* @date 2021/8/10
*/
public class CircleArrayQueue {
public static void main(String[] args) {
System.out.println("环形队列...........");
CircleArray quee = new CircleArray(4);
Scanner scanner = new Scanner(System.in);
boolean loop = true;
while (loop){
System.err.println("(s) 显示队列信息");
System.err.println("(a) 添加数据到队列");
System.err.println("(g) 从队列取出数据");
System.err.println("(h) 显示队列头数据");
System.err.println("(e) 退出程序");
char key = scanner.next().charAt(0);
switch (key){
case 'e':
loop = false;
break;
case 's':
try {
quee.showQueue();
} catch (Exception e) {
System.err.println(e.getMessage());
}
break;
case 'a':
try {
System.out.println("请输入一个数据添加到队列");
int i = scanner.nextInt();
quee.addQueue(i);
} catch (Exception e) {
System.err.println(e.getMessage());
}
break;
case 'g':
try {
System.out.println("取出:"+quee.getQueue());
} catch (Exception e) {
System.err.println(e.getMessage());
}
break;
case 'h':
try {
System.out.println("头数据:"+quee.headQueue());
} catch (Exception e) {
System.err.println(e.getMessage());
}
break;
}
}
}
}
class CircleArray{
private int maxSize; //表示数组的最大值
private int front; //队列头,初始值0
private int rear; //队列尾，初始值0，因为要空出一个位置，所以rear只能是maxsize-1，而且这个rear没有任何值
private int[] arr; //用于存放数据的数组，模拟环形队列
//创建队列的构造器
public CircleArray(int maxSize){
//这里传入 4 则有效数据只有3个 因为设置了一个空的空间
this.maxSize = maxSize;
arr = new int[maxSize];
front = 0;// 指向队列头部 就是 队列头数据的前一个数据
rear = 0;// 队列尾部 就是 队列的最后一个数据
}
// 判断队列是否满
public boolean isFull(){
return (rear+1) % maxSize == front;
}
// 判断队列是否为null
public boolean isEmpty(){
return rear == front;
}
// 添加数据到队列, 进队列
public void addQueue(int num){
if(isFull()){
throw new RuntimeException("队列已满,加入不了");
}
//rear指向待添加数据的位置
arr[rear] = num;
// rear后移 必须考虑取模 避免越界
rear = (rear+1) % maxSize ;
}
// 获取队列的数据 ,出队列
public int getQueue(){
if (isEmpty()){
throw new RuntimeException("队列为空,不能取值");
}
//front是指向待取出的数据位置
//1,先把front对应的值取出保存到临时变量
//2,front后移 避免越界,考虑取模
//3,将临时变量返回
int temp = arr[front];
front = (front+1) % maxSize;
return temp;
}
// 显示队列数据
public void showQueue(){
if (isEmpty()){
throw new RuntimeException("队列为空,没有数据");
}
// 从front开始遍历 遍历多少个元素
for (int i = front; i < front+size() ; i++) {
System.out.printf("arr[%d]=%d\n",i%maxSize,arr[i%maxSize]);
}
}
// 显示队列头数据
public int headQueue(){
if (isEmpty()){
throw new RuntimeException("队列为空,没有数据");
}
return arr[front];
}
// 获取队列的有效个数
public int size(){
return (rear+maxSize-front)%maxSize;
}
}
二、链表
链表介绍
- 链表是以节点的方式来存储,是链式存储
- 每个节点包含 data 域， next 域：指向下一个节点.
- 如图：发现链表的各个节点不一定是连续存储.
- 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定
单链表
链表通过指针将一组零散的内存块串联在一起，内存块称为链表的“结点”。每个链表的结点除了存储数据之外，还需要记录链上的下一个结点的地址，叫作后继指针 next。链表有两个特殊的结点，分别是第一个结点（头结点）和最后一个结点（尾结点）。头结点用来记录链表的基地址，用它可以遍历得到整条链表。尾结点指向一个空地址 NULL，表示这是链表上最后一个结点。
双向链表
双向链表支持两个方向，每个结点同时有后继指针 next 指向后面的结点，还有一个前驱指针 pre 指向前面的结点。双向链表需要额外的两个空间来存储后继结点和前驱结点的地址，存储同样的数据，双向链表要比单链表占用更多的内存空间。
循环链表
循环链表跟单链表的区在尾结点指针是指向链表的头结点。和单链表相比，循环链表的优点是从链尾到链头比较方便。当要处理的数据具有环型结构特点时，采用循环链表实现代码会简洁很多。
图解单链表以及完整代码
- 不多BB，上图：
- 不多BB，上码：
package com.java.zzw.list;
public class SingleLinkedListDemo {
public static void main(String[] args) {
//进行测试
//创建节点
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(5, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
//创建
SingleLinkedList singleLinkedList = new SingleLinkedList();
// singleLinkedList.add(hero1);
// singleLinkedList.add(hero2);
// singleLinkedList.add(hero3);
// singleLinkedList.add(hero4);
//根据编号顺序添加
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero2);
singleLinkedList.list();
//测试修改节点的代码
System.out.println("修改2号：");
HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟。。。");
singleLinkedList.update(newHeroNode);
//显示
System.out.println("修改后情况！");
singleLinkedList.list();
//删除一个节点
System.out.println("删除1号：");
singleLinkedList.delete(1);
System.out.println("删除后的链表情况");
singleLinkedList.list();
}
}
//定义一个SingleLinkedList 管理我们的英雄
class SingleLinkedList {
//先初始化一个头节点， 头节点不要动, 不存放具体数据
private 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就指向了链表的最后
//将最后这个节点的next 指向 新的节点
temp.next = heroNode;
}
//第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)
public void addByOrder (HeroNode heroNode) {
//通过一个辅助指针来帮助找到添加的位置
//因为单链表，因此我们找的temp是位于添加位置的前一个节点，否则插入不了
HeroNode temp = head;
boolean flag = false;//标志添加的编号是否存在
while (true) {
if (temp.next == null) { //说明temp已经在链表最后
break;
}
if (temp.next.no > heroNode.no) { //位置找到，就在temp的后面插入
break;
} else if (temp.next.no == heroNode.no) { //添加的编号存在
flag = true; //编号存在
break;
}
temp = temp.next;
}
//判断flag的值
if (flag) {
//编号存在，不能添加
System.out.println("准备插入的编号" + heroNode.no +"已经存在了");
} else {
//插入到链表中，temp的后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//修改节点的信息，根据no编号来修改
//
public void update(HeroNode newHeroNode) {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//找到需要修改的节点
HeroNode temp = head.next;
boolean flag = false; //表示是否找到该节点
while (true) {
if (temp == null) {
break; //已经遍历完链表
}
if (temp.no == newHeroNode.no) {
//找到
flag = true;
break;
}
temp = temp.next;
}
if (flag) {
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
} else {
//没有找到
System.out.println("没有找到编号为" +newHeroNode.no + "的节点");
}
}
//删除节点
//思路
//1.head 节点不动，需要一个temp辅助节点，找到待删除节点的前一个节点
//2.说明我们在比较时，是temp.next.no和待删除的节点的no比较
public void delete(int no) {
HeroNode 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.println("要删除的"+ no +"这个节点不存在");
}
}
//显示链表
public void list() {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头节点不能动，所以需要一个辅助遍历temp
HeroNode temp = head.next;
while (true) {
if (temp == null) {
break;
}
//输出节点信息
System.out.println(temp);
//将next后移
temp = temp.next;
}
}
}
//定义HeroNode，每个HeroNode 对象就是一个节点
class HeroNode {
public int no;
public String name;
public String nickname;
public HeroNode next; //指向下一个节点
//构造器
public HeroNode (int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
//重写toString
@Override
public String toString() {
return "HeroNode [no = "+ no +", name = "+ name +", nickname = "+ nickname +"]";
}
}
总结
学习了链表与环形队列，逐步了解了一些算法公式
发现了，原来想要解决问题，必要的时候需要建立参考对象
加油加油加油！！！！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
