稀疏数组
用于表示保存一个二维数组/矩阵中非0的有效数值的信息。
格式为 多行3列
第一行 保存原数组的行,列,有效值的个数。
其他行 保存各个值在原数组中对应的 行,列,值
如下图有一个矩阵及它对应的稀疏数组
举例,创建一个11*11的矩阵,将它装成对应的稀疏数组,
public class SparseArray {
public static void main(String[] args) {
//先创建一个原始的二维数组 11* 11
//0: 表示没有棋子,1表示黑子,2表示篮子
int[][] chessArr1= new int[11][11];
chessArr1[1][2] = 1;
chessArr1[2][3] = 2;
chessArr1[4][5] = 2;
System.out.println("原始的二维数组");
for (int[] row:chessArr1) {
for (int data:row) {
System.out.printf("%d\t",data);
}
System.out.println();
}
//将数组转化成稀疏数组
/**
* 稀疏数组, 格式为 多行3列 ,第一行 保存原数组的行,列,有效值的个数
* 其他行 保存各个值在原数组中对应的 行,列,值
*
*/
int sum = 0;
for (int i =0;i<chessArr1.length;i++){
for (int j =0;j<chessArr1[i].length;j++){
if (chessArr1[i][j]!=0){
sum++;
}
}
}
System.out.println(sum);
//创建稀疏数组 大小为 sum+1行 3列
int[][] spareArr= new int[sum+1][3];
//给稀疏数组赋值
spareArr[0][0] = 11;
spareArr[0][1] =11;
spareArr[0][2] = sum;
int count = 1;
for (int i =0;i<chessArr1.length;i++){
for (int j =0;j<chessArr1[i].length;j++){
if (chessArr1[i][j]!=0){
spareArr[count][0] = i;
spareArr[count][1] = j;
spareArr[count][2] =chessArr1[i][j] ;
count++;
}
}
}
System.out.println("稀疏数组为~~~~~~~~~~~~~~~~");
for (int i = 0;i<spareArr.length;i++){
System.out.printf("%d\t%d\t%d\t\n",spareArr[i][0],spareArr[i][1],spareArr[i][2]);
}
//将稀疏数组转化成原数组
int[][] chessArr2 = new int[spareArr[0][0]][spareArr[0][1]];
for (int i = 1; i < spareArr.length; i++) {
chessArr2[spareArr[i][0]][spareArr[i][1]] = spareArr[i][2];
}
System.out.println("原数组为~~~~~~~~~~~~~~~~");
for (int i = 0;i<chessArr2.length;i++){
for (int j =0;j<chessArr2[i].length;j++)
System.out.printf("%d\t",chessArr2[i][j]);
System.out.println();
}
}
队列
队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,具有先进先出的特点。
用数组来模拟单项队列,并给他添加一些方法
class Queue{
//定义数组的大小
private int maxSize;
// 定义两个指针 front 头指针 rear 尾指针
private int front;
private int rear;
//定义一个数组
private int[] arr;
//初始化
Queue(int size){
this.maxSize = size;
arr =new int[size];
// 刚开始front rear 都是-1,指向 队列的头
this.front = -1;
this.rear = -1;
}
//模拟方法进入队列
public void add(int value){
//首先判断队列是否满了
if(rear==(maxSize-1)){
throw new RuntimeException("队列满了,无法加入数据");
}
rear++;
arr[rear] = value;
}
public int get(){
//判断队列是否为空 当front 与 rear 相等时 队列为空
if(front ==rear){
throw new RuntimeException("队列为空,无法取出数据");
}
front++;
return arr[front];
}
public void show(){
//显示当前队列的数据
//判断队列是否为空 当front 与 rear 相等时 队列为空
if(front ==rear){
throw new RuntimeException("队列为空");
}
for (int i = front+1; i <=rear ; i++) {
System.out.printf("当前队列的数据为arr[%d]:%d",i,arr[i]);
}
}
public void getHead(){
if(front ==rear){
throw new RuntimeException("队列为空");
}
System.out.printf("当前头元素为:%d",arr[front]);
}
}
环形队列
package com.zdxh.strutures.queue;
import java.util.Scanner;
public class CirleQueue {
public static void main(String[] args) {
AnnulusQueue queue = new AnnulusQueue(3);
Scanner scanner = 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("h(head)");
System.out.println("e(exit)");
char c = scanner.next().charAt(0);
switch (c){
case 'a':
try {
System.out.println("请输入一个数");
int i = scanner.nextInt();
queue.add(i);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'g':
try {
System.out.printf("取出元素:%d",queue.get());
System.out.println();
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 's':
try {
queue.show();
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'h':
try {
queue.getHead();
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'e':
loop = false;
break;
}
}
}
}
class AnnulusQueue{
//定义数组的大小
private int maxSize;
// 定义两个指针 front 头指针 rear 尾指针
private int front;
private int rear;
//定义一个数组
private int[] arr;
//初始化
AnnulusQueue(int size){
this.maxSize = size;
arr =new int[size];
// 刚开始front rear 都是-1,指向 队列的头
this.front = 0; //初始化为0,指向当前的数据,取数据时不用先++,可以不写,初始化为0
this.rear = 0;
}
//模拟方法进入队列,添加值
public void add(int value){
//首先判断队列是否满了 因为为环形队列,所以队列满的条件变为(rear+1)%maxSize ==front
if((rear+1)% maxSize ==front){
throw new RuntimeException("队列满了,无法加入数据");
}
//直接将数据加入
arr[rear] = value;
//将rear 后移,这里需要考虑取模的问题
// 当rear加到数组顶部满了,它+1,但是数组有空余,那么将它重新指向对头,因为是环形的,相当于饶了一圈
rear = (rear+1)%maxSize;
}
public int get(){
//判断队列是否为空 当front 与 rear 相等时 队列为空
if(front ==rear){
throw new RuntimeException("队列为空,无法取出数据");
}
//这里需要分析出front是指向队列的第一个元素
//先取出front 所在的数据,然后front递增,
// 但是在递增的过程中跟rear一样,遇到在数组的顶部再递增的情况,是不是要重新回到队首,所以考虑取模,
// 取模-->相当于在数值的基础上减去几倍 模数(对哪个数取模)当数值小于模数,返回原值
int value = arr[front];
front=(front+1)%maxSize;
return value;
}
public void show(){
//显示当前队列的数据
//判断队列是否为空 当front 与 rear 相等时 队列为空
if(front ==rear){
throw new RuntimeException("队列为空");
}
//思路:从front开始遍历,那么需要遍历多少个元素? --即有效的数据长度为(rear + maxSize-front)%maxSize
//为什么是(rear + maxSize-front)%maxSize?
for (int i = front; i < front+(rear + maxSize-front)%maxSize ; i++) {
System.out.printf("当前队列的数据为arr[%d]:%d",i%maxSize,arr[i%maxSize]);
}
}
public void getHead(){
if(front ==rear){
throw new RuntimeException("队列为空");
}
System.out.printf("当前头元素为:%d",arr[front]);
}
}
针对有效长度的解析:有以下两种情况:(为什么是((rear + maxSize-front)%maxSize))
有效长度从front开始到rear结束(包含front,不包含rear,也可以包含,但是判断队列满的条件就要改变,这里预留一个位置rear,所以判断队列满的条件为(rear+1)%maxSize==front)
对于第一种情况,rear小于front ,rear-front为负,加上maxSize 可以得到有效长度,而且这种情况不会溢出,所以取模对他没有影响,
对于第二种情况,rear大于front ,rear-front为正,加上maxSize 就会溢出,所以需要取模,去掉maxSize,结果对它没有影响
(rear + maxSize-front)%maxSize)包含两种情况
单向链表
结构如下:有自身的信息、有一个指向下一个节点的指针
class HeroNode{
/**
* 节点信息
*/
public int nodeno;
public String nodename;
public String nickname;
public HeroNode(int nodeno, String nodename, String nickname) {
this.nodeno = nodeno;
this.nodename = nodename;
this.nickname = nickname;
}
//指向下一个节点
public HeroNode next;
@Override
public String toString() {
return "HeroNode{" +
"nodeno=" + nodeno +
", nodename='" + nodename + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
方法
class SingleLinkList{
//先初始化一个头节点,头节点不要动,不存放具体的
private HeroNode head=new HeroNode(0,"","");
public HeroNode getHead() {
return head;
}
public void setHead(HeroNode head) {
this.head = head;
}
public void add(HeroNode heroNode){
HeroNode temp = head;
while (true){
//当temp
if(temp.next==null){
break;
}
temp=temp.next;
}
temp.next=heroNode;
}
//根据节点no按序加入节点
public void addByOrder(HeroNode heroNode){
//因为头结点不能动,因此我们仍然要通过一个辅助指针变量来帮助找到添加的位置
HeroNode temp = head;
boolean flag =false;
while (true){
if(temp.next==null){ //说明temp 已经在链表的最后
break;
}
if (temp.next.nodeno>heroNode.nodeno){ //位置找到,就在temp的后面
break;
}else if(temp.next.nodeno==heroNode.nodeno){
flag=true;
break;
}
temp=temp.next;
}
if(flag){
System.out.println("添加的节点已存在");
}else{
heroNode.next=temp.next;
temp.next= heroNode;
}
}
//修改链表节点
public void update(HeroNode heroNode){
//定义一个临时变量用于遍历链表
HeroNode temp = head.next;
//定义一个变量,用于表示是否找到编号相同的节点
boolean flag = false;
while (true){
if (temp==null) {
System.out.println("链表为空");
break;
}
if(temp.nodeno==heroNode.nodeno){
flag=true;
break;
}
temp = temp.next;
}
if(flag){
temp.nodename = heroNode.nodename;
temp.nickname = heroNode.nickname;
}else {
System.out.printf("没有找到编号%d 的节点\n",heroNode.nodeno);
}
}
//删除节点信息,根据节点的no删除
public void delete(HeroNode heroNode){
HeroNode temp = head;
boolean flag = true;
while (true){
if (temp.next==null) {
System.out.println("链表为空");
break;
}
if(temp.next.nodeno==heroNode.nodeno){
flag=true;
break;
}
temp = temp.next;
}
if(flag){
temp.next = temp.next.next;
}else {
System.out.printf("没有找到编号%d 的节点\n",heroNode.nodeno);
}
}
//查看链表数据
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.next;
}
}
}
面试题目
1.链表反转
//反转链表
public static void reverse(HeroNode head){
//首先判断是否为空
if(head.next ==null){
return;
}
//新建一个节点用于保存反转后的链表
HeroNode reverseNode = new HeroNode(0,"","");
//定义一个辅助指针帮助我们遍历链表
HeroNode cur = head.next;
//定义一个指针指向cur的下个节点,用于保存原链表中的数据
HeroNode next= null;
//循环条件为cur不为空 遍历要反转链表的数据
while (cur!=null){
//保存cur指针后面的节点数据,
next = cur.next;
//将cur当前这个节点的数据拼到reverseNode的后面
cur.next = reverseNode.next;
reverseNode.next = cur;
//循环条件
cur=next;
}
//完成之后将原来的节点头的next指向反转后的节点头的next
head.next = reverseNode.next;
}
2.重排序两个有序链表
public static HeroNode joinNode(HeroNode heroNode1,HeroNode heroNode2){
//分别找出两个有序的单链表的最小节点进行比较,
//首先找出两个节点的长度,用于做循环条件
HeroNode temp1 = heroNode1.next;
HeroNode temp2 = heroNode2.next;
if(temp1==null&&temp2!=null){
return heroNode2;
}else if(temp2==null&&temp1!=null) {
return heroNode1;
}else if(temp1==null&&temp2==null){
return null;
}
// 定义一个链表用于保存新的数据
HeroNode new_node = new HeroNode(0,"","");
HeroNode temp = new_node;
while (true){
if(temp1==null&&temp2!=null){
temp.next = temp2;
temp = temp.next;
temp2= temp2.next;
}else if(temp2==null&&temp1!=null) {
temp.next = temp1;
temp = temp.next;
temp1= temp1.next;
}else if(temp1==null&&temp2==null){
break;
}else {
if(temp1.nodeno<=temp2.nodeno){
temp.next = temp1;
temp = temp.next;
temp1= temp1.next;
} else if (temp1.nodeno>temp2.nodeno) {
temp.next = temp2;
temp = temp.next;
temp2= temp2.next;
}
}
}
return new_node;
}
参考网上教程,记录一下