目录
一、入门
数据结构分为线性结构和非线性结构
1、线性结构
- 最常用的数据结构，其特点是数据元素之间存在一对一的线性关系
- 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。
- 顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的
- 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。
- 线性结构常见的有：数组、队列、链表和栈
2、非线性结构
- 非线性结构包括：二维数组，多维数组，广义表，树，图
二、稀疏数组和队列
1、稀疏数组 sparsearray
当一个数组中大部分元素为０或同一个值时，为了节省存储空间，可以使用稀疏数组来保存该数组。
稀疏数组的处理方法是
- 第一行记录数组一共有几行几列，有多少个不同的值
- 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
二维数组 转 稀疏数组的思路
-
遍历原始的二维数组，得到有效数据的个数 sum
-
根据sum 就可以创建稀疏数组 sparseArr int[sum + 1] [3]
-
将二维数组的有效数据数据存入到稀疏数组
稀疏数组转原始的二维数组的思路
-
先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [11] [11]
-
在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.
代码：
public static void main(String[] args) {
//定义并打印原本的二维数组
int chessArr1[][] = new int[11][11];
chessArr1[1][2]=1;
chessArr1[2][3]=2;
System.out.println("原本二维数组");
for (int [] row:chessArr1){
for (int data:row){
System.out.printf("%d\t",data);
}
System.out.println();
}
//将二维数组转化为稀疏数组
int sum=0;
for (int i=0;i<11;i++){
for (int j=0;j<11;j++){
if (chessArr1[i][j]!=0){
sum++;
}
}
}
int sparseArr[][] = new int[sum+1][3];
sparseArr[0][0]=11;
sparseArr[0][1]=11;
sparseArr[0][2]=sum;
int count=0;
for (int i=0;i<11;i++){
for (int j=0;j<11;j++){
if (chessArr1[i][j]!=0){
count++;
sparseArr[count][0]=i;
sparseArr[count][1]=j;
sparseArr[count][2]=chessArr1[i][j];
}
}
}
System.out.println();
System.out.println("得到的稀疏数组为");
for (int i=0;i<sparseArr.length;i++){
System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
}
System.out.println();
//将稀疏数组 恢复回 二维数组
int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
for (int i=1;i<sparseArr.length;i++){
chessArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
}
System.out.println();
System.out.println("恢复后的二维数组");
for (int[] row:chessArr2){
for (int data:row){
System.out.printf("%d\t",data);
}
System.out.println();
}
}效果
2、队列
- 队列是一个有序列表，可以用数组或是链表来实现。
- 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
数组模拟队列思路
- 队列本身是有序列表，若使用数组的结构来存储队列的数据，其中 maxSize 是该队列的最大容量。
- 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 及 rear 分别记录队列前后端的下标， front 会随着数据输出而改变，而 rear 则是随着数据输入而改变，
当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：思路分析
- 将尾指针往后移：rear+1 , 当 front == rear 【队列为空】
- 若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear 所指的数组元素中，否则无法存入数据。 rear == maxSize - 1【队列满】
代码实现：
public class ArrayQueueDemo {
public static void main(String[] args) {
//创建一个队列
ArrayQueue arrayQueue = new ArrayQueue(3);
char key = ' '; //接收用户输入
Scanner scanner = new Scanner(System.in);
boolean loop = true;
//菜单
while (loop){
System.out.println("s显示队列");
System.out.println("e退出队列");
System.out.println("a添加数据");
System.out.println("g队列取出");
System.out.println("h查看队头");
key = scanner.next().charAt(0);//接收一个字符
switch (key){
case 's':
arrayQueue.showQueue();
break;
case 'e':
scanner.close();
loop=false;
break;
case 'a':
System.out.println("请输入一个数：");
int value = scanner.nextInt();
arrayQueue.addQueue(value);
break;
case 'g':
try {
int res = arrayQueue.getQueue();
System.out.println("取出的数据为："+res);
}catch (Exception e){
System.out.println(e.getMessage());
}
break;
case 'h':
try {
int res = arrayQueue.headQueue();
System.out.println("取出的队头为："+res);
}catch (Exception e){
System.out.println(e.getMessage());
}
break;
}
}
System.out.println("程序退出");
}
}
//数组模拟队列
class ArrayQueue{
private int maxSize;//数组最大容量
private int front;//队列头
private int rear; //队列尾
private int[] arr; //数组用于存放数据 模拟队列
//创建队列的构造器
public ArrayQueue(int arrMaxSize){
maxSize = arrMaxSize;
arr = new int[maxSize];
front = -1; //指向队列头部
rear = -1; //指向队列尾部
}
//判断队列是否满
public boolean isFull(){
return rear==maxSize-1;
}
//判断队列是否为空
public boolean isEmpty(){
return rear==front;
}
//添加数据到队列
public void addQueue(int n){
if (isFull()){
System.out.println("队列已经满不能添加");
return;
}
rear++; //让rear后移
arr[rear] = n;
}
//出队列
public int getQueue(){
if (isEmpty()){
throw new RuntimeException("队列为空 不能取出");
}
front++;
return arr[front];
}
//显示所有数据
public void showQueue(){
if (isEmpty()){
System.out.println("空");
return;
}
for (int i=0;i<arr.length;i++){
System.out.println(arr[i]+"\t");
}
}
//显示队列头
public int headQueue(){
if (isEmpty()){
throw new RuntimeException("队列为空");
}
return arr[front+1];
}
}问题分析并优化
- 目前数组使用一次就不能用， 没有达到复用的效果
- 将这个数组使用算法，改进成一个环形的队列 取模：%
数组模拟环形队列（难点）
代码实现：
import java.util.Scanner;
public class ArrayQueueDemo2 {
public static void main(String[] args){
//创建一个队列
ArrayQueue2 arrayQueue2 = new ArrayQueue2(3);
char Key = ' ';//接口用户输入
Scanner s= new Scanner(System.in);
boolean loop = true;
//输出菜单
while(loop){
System.out.println("s:显示队列");
System.out.println("e:退出程序");
System.out.println("a:添加数据到队列");
System.out.println("g:从队列取出数据");
System.out.println("h:查看队列头部数据");
Key = s.next().charAt(0);//接收一个字符
switch (Key){
case 's':
arrayQueue2.showQueue();
break;
case 'a':
System.out.println("请输入一个数");
int value= s.nextInt();
arrayQueue2.addQueue(value);
break;
case 'g':
try{
int res = arrayQueue2.getQueue();
System.out.println("去除的数据为："+res);
}catch (Exception e){
System.out.println(e.getMessage());//捕捉异常信息
}
break;
case 'h':
try{
int res = arrayQueue2.headQueue();
System.out.println("头元素为"+res);
}catch (Exception e){
System.out.println(e.getMessage());//捕捉异常信息
}
break;
case 'e':
s.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出");
}
}
class ArrayQueue2{
private int maxSize;
private int front;
private int rear;
private int[] arr;
public ArrayQueue2() {
}
public ArrayQueue2(int maxSize, int front, int rear, int[] arr) {
this.maxSize = maxSize;
this.front = front;
this.rear = rear;
this.arr = arr;
}
//船舰队列构造器
public ArrayQueue2(int maxSize){
this.maxSize = maxSize;
arr = new int[this.maxSize];
}
//判断是否为空
public boolean isEmpty(){
return rear == front;
}
//判断是否满
public boolean isFull(){
return (rear+1) % maxSize == front;
}
public void addQueue(int n){
if (isFull()){
System.out.println("队列满不能加入数据");
return;
}else {
arr[rear] = n;
//将rear后移
rear = (rear+1)%maxSize;
}
}
public int getQueue(){
if (isEmpty()){
throw new RuntimeException("队列空，不能取出");
}
int value = arr[front];
front = (front+1)%maxSize;
return value;
}
//显示队列
public void showQueue(){
if (isEmpty()){
throw new RuntimeException("队列空");
}
for (int i = front; i <front + (rear + maxSize - front) %maxSize; i++){
System.out.println(arr[i% maxSize]+ " " + i% maxSize);
}
}
//显示队列的头数据
public int headQueue(){
if (isEmpty()){
throw new RuntimeException("队列空");
}else {
return arr[front];
}
}
}链表
链表介绍
链表是有序的列表，但是它在内存中是存储如下
链表是以节点的方式来存储,是链式存储
每个节点包含 data 域， next 域：指向下一个节点.
发现链表的各个节点不一定是连续存储.
链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定
单链表(带头结点)
单链表的应用：
1、链表尾部插入节点
代码实现
public class SingleLikedListDemo {
public static void main(String[] args){
//先创建节点
HeroNode heroNode1 = new HeroNode(1,"x", "x");
HeroNode heroNode2 = new HeroNode(2,"xx","xx");
HeroNode heroNode3 = new HeroNode(3,"xxx","xxx");
//创建一个链表
SingleLikedlist singleLikedlist = new SingleLikedlist();
singleLikedlist.add(heroNode1);
singleLikedlist.add(heroNode2);
singleLikedlist.add(heroNode3);
singleLikedlist.showList();
}
}
//定义SingleLinkedlist 管理我们的英雄
class SingleLikedlist{
//先初始化一个头节点
private HeroNode head = new HeroNode(0,"","");
//添加节点到单向节点
//当不考虑编号的顺序时，找到当前链表的最后节点，将最后这个节点测next指向新节点
public void add(HeroNode heroNode){
//因为head节点不能动，因此我们需要一个辅助变量
HeroNode temp = head;
//遍历链表，找到最后
while(true){
if(temp.next == null){
break;
}
//没有到最后
temp = temp.next;
}
//当推出while循环时，temp指向链表最后
//将最后这个节点的next指向新的节点
temp.next = heroNode;//将最后一个节点的next指向新加入的点
}
//显示链表
public void showList(){
//先判断链表是否为空
if(head.next == null){
return;
}
HeroNode temp = head.next;
while(true){
//是否到链表最后
if (temp == null){
break;
}
//输出节点信息；
System.out.println(temp);
temp = temp.next;//后移节点
}
}
}
//定义一个HeroNode，每一个HroeNode就是一个节点
class HeroNode{
//定义节点的私有属性 编号，姓名 外号 和next
public int no;
public String name;
public String nickname;
public HeroNode next;
//构造器
public HeroNode() {
}
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
//重写toString 方便显示
public String toString(){
return "Heronode [no= "+no+",name="+name+",nickname="+nickname+"]";
}
}2、链表指定位置插入节点
代码实现
public class SingleLikedListDemo {
public static void main(String[] args){
//先创建节点
HeroNode heroNode1 = new HeroNode(1,"x", "x");
HeroNode heroNode2 = new HeroNode(2,"xx","xx");
HeroNode heroNode3 = new HeroNode(3,"xxx","xxx");
HeroNode heroNode4 = new HeroNode(4,"xxxx","xxxx");
HeroNode heroNode5 = new HeroNode(5,"xxxxx","xxxxx");
//创建一个链表
SingleLikedlist singleLikedlist = new SingleLikedlist();
singleLikedlist.addOder(heroNode1);
singleLikedlist.addOder(heroNode2);
singleLikedlist.addOder(heroNode3);
singleLikedlist.addOder(heroNode5);
singleLikedlist.addOder(heroNode4);
singleLikedlist.showList();
}
}
//定义SingleLinkedlist 管理我们的英雄
class SingleLikedlist{
//先初始化一个头节点
private HeroNode head = new HeroNode(0,"","");
//添加节点到单向节点
//当不考虑编号的顺序时，找到当前链表的最后节点，将最后这个节点测next指向新节点
public void add(HeroNode heroNode){
//因为head节点不能动，因此我们需要一个辅助变量
HeroNode temp = head;
//遍历链表，找到最后
while(true){
if(temp.next == null){
break;
}
//没有到最后
temp = temp.next;
}
//当推出while循环时，temp指向链表最后
//将最后这个节点的next指向新的节点
temp.next = heroNode;//将最后一个节点的next指向新加入的点
}
//按顺序添加
public void addOder(HeroNode heroNode){
//因为head节点不能动，因此我们需要一个辅助变量,找到添加的位置
//找的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;
}
}
//显示链表
public void showList(){
//先判断链表是否为空
if(head.next == null){
return;
}
HeroNode temp = head.next;
while(true){
//是否到链表最后
if (temp == null){
break;
}
//输出节点信息；
System.out.println(temp);
temp = temp.next;//后移节点
}
}
}
//定义一个HeroNode，每一个HroeNode就是一个节点
class HeroNode{
//定义节点的私有属性 编号，姓名 外号 和next
public int no;
public String name;
public String nickname;
public HeroNode next;
//构造器
public HeroNode() {
}
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
//重写toString 方便显示
public String toString(){
return "Heronode [no= "+no+",name="+name+",nickname="+nickname+"]";
}
}3、修改节点
public class SingleLikedListDemo {
public static void main(String[] args){
//先创建节点
HeroNode heroNode1 = new HeroNode(1,"x", "x");
HeroNode heroNode2 = new HeroNode(2,"xx","xx");
HeroNode heroNode3 = new HeroNode(3,"xxx","xxx");
HeroNode heroNode4 = new HeroNode(4,"xxxx","xxxx");
HeroNode heroNode5 = new HeroNode(5,"xxxxx","xxxxx");
HeroNode newheroNode = new HeroNode(2,"xx1","xx1");
//创建一个链表
SingleLikedlist singleLikedlist = new SingleLikedlist();
singleLikedlist.addOder(heroNode1);
singleLikedlist.addOder(heroNode2);
singleLikedlist.addOder(heroNode3);
singleLikedlist.addOder(heroNode5);
singleLikedlist.addOder(heroNode4);
singleLikedlist.showList();
singleLikedlist.updata(newheroNode);
singleLikedlist.showList();
}
}
//定义SingleLinkedlist 管理我们的英雄
class SingleLikedlist{
//先初始化一个头节点
private HeroNode head = new HeroNode(0,"","");
//添加节点到单向节点
//当不考虑编号的顺序时，找到当前链表的最后节点，将最后这个节点测next指向新节点
public void add(HeroNode heroNode){
//因为head节点不能动，因此我们需要一个辅助变量
HeroNode temp = head;
//遍历链表，找到最后
while(true){
if(temp.next == null){
break;
}
//没有到最后
temp = temp.next;
}
//当推出while循环时，temp指向链表最后
//将最后这个节点的next指向新的节点
temp.next = heroNode;//将最后一个节点的next指向新加入的点
}
//按顺序添加
public void addOder(HeroNode heroNode){
//因为head节点不能动，因此我们需要一个辅助变量,找到添加的位置
//找的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 updata(HeroNode heroNode){
if (head.next == null){
System.out.println("链表为空");
}
//找到需要修改的节点
HeroNode temp = head;
boolean flag = false;
while (true){
if (temp == null){
break;//链表已经遍历结束了
}
if (temp.no == heroNode.no){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.name = heroNode.name;
temp.nickname = heroNode.nickname;
}else {
System.out.println("没有找到这个编号" + heroNode.no);
}
}
//显示链表
public void showList(){
//先判断链表是否为空
if(head.next == null){
return;
}
HeroNode temp = head.next;
while(true){
//是否到链表最后
if (temp == null){
break;
}
//输出节点信息；
System.out.println(temp);
temp = temp.next;//后移节点
}
}
}
//定义一个HeroNode，每一个HroeNode就是一个节点
class HeroNode{
//定义节点的私有属性 编号，姓名 外号 和next
public int no;
public String name;
public String nickname;
public HeroNode next;
//构造器
public HeroNode() {
}
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
//重写toString 方便显示
public String toString(){
return "Heronode [no= "+no+",name="+name+",nickname="+nickname+"]";
}
}4、删除节点
public class SingleLikedListDemo {
public static void main(String[] args){
//先创建节点
HeroNode heroNode1 = new HeroNode(1,"x", "x");
HeroNode heroNode2 = new HeroNode(2,"xx","xx");
HeroNode heroNode3 = new HeroNode(3,"xxx","xxx");
HeroNode heroNode4 = new HeroNode(4,"xxxx","xxxx");
HeroNode heroNode5 = new HeroNode(5,"xxxxx","xxxxx");
HeroNode newheroNode = new HeroNode(2,"xx1","xx1");
//创建一个链表
SingleLikedlist singleLikedlist = new SingleLikedlist();
singleLikedlist.addOder(heroNode1);
singleLikedlist.addOder(heroNode2);
singleLikedlist.addOder(heroNode3);
singleLikedlist.addOder(heroNode5);
singleLikedlist.addOder(heroNode4);
singleLikedlist.showList();
System.out.println("修改后");
singleLikedlist.updata(newheroNode);
singleLikedlist.showList();
singleLikedlist.deleteNode(1);
singleLikedlist.deleteNode(5);
System.out.println("删除后");
singleLikedlist.showList();
}
}
//定义SingleLinkedlist 管理我们的英雄
class SingleLikedlist{
//先初始化一个头节点
private HeroNode head = new HeroNode(0,"","");
//添加节点到单向节点
//当不考虑编号的顺序时，找到当前链表的最后节点，将最后这个节点测next指向新节点
public void add(HeroNode heroNode){
//因为head节点不能动，因此我们需要一个辅助变量
HeroNode temp = head;
//遍历链表，找到最后
while(true){
if(temp.next == null){
break;
}
//没有到最后
temp = temp.next;
}
//当推出while循环时，temp指向链表最后
//将最后这个节点的next指向新的节点
temp.next = heroNode;//将最后一个节点的next指向新加入的点
}
//按顺序添加
public void addOder(HeroNode heroNode){
//因为head节点不能动，因此我们需要一个辅助变量,找到添加的位置
//找的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 updata(HeroNode heroNode){
if (head.next == null){
System.out.println("链表为空");
}
//找到需要修改的节点
HeroNode temp = head;
boolean flag = false;
while (true){
if (temp == null){
break;//链表已经遍历结束了
}
if (temp.no == heroNode.no){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.name = heroNode.name;
temp.nickname = heroNode.nickname;
}else {
System.out.println("没有找到这个编号" + heroNode.no);
}
}
//删除
public void deleteNode(int no){
if (head.next == null){
return;
}
boolean flag = false;
HeroNode temp = head;
while (true){
if (temp == null){
break;
}
if (temp.next.no == no){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.next = temp.next.next;
}
}
//显示链表
public void showList(){
//先判断链表是否为空
if(head.next == null){
return;
}
HeroNode temp = head.next;
while(true){
//是否到链表最后
if (temp == null){
break;
}
//输出节点信息；
System.out.println(temp);
temp = temp.next;//后移节点
}
}
}
//定义一个HeroNode，每一个HroeNode就是一个节点
class HeroNode{
//定义节点的私有属性 编号，姓名 外号 和next
public int no;
public String name;
public String nickname;
public HeroNode next;
//构造器
public HeroNode() {
}
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
//重写toString 方便显示
public String toString(){
return "Heronode [no= "+no+",name="+name+",nickname="+nickname+"]";
}
}双向链表
每个节点具有data，next和pre的域，变成了可以向前也可以向后遍历的链表
遍历：和单链表一样，多了个可以向前也可以向后
添加：添加到最后，先找到双向链表这个节点 temp.next=newHeroNode; newHeroNode.pre=temp
修改：和原来单链表的思路一样
删除：因为双向链表，所有可以自我删除，如果是最后一个要降价判断，代码：
temp.pre.next=temp.next;
if(temp.next!=null){
temp.next.pre=temp.pre;
}
环形链表
构建：
- 先创建第一个节点，让first指向该节点，并形成环形
- 后面当我们每创建一个新节点，就加入已有的环形链表中即可
代码实现
class CircleSingleLinkedList{
//创建一个first节点，当前没有编号
private Boy first = new Boy(-1);
public void add(int no){
//做一个数据校验
if(no < 1){
System.out.println("数据输入错误");
return;
}
//创建环形列表
Boy cur = new Boy();
for (int i =1; i < no+1; i++){
//根据编号创建节点
Boy boy = new Boy(i);
if (i == 1){
first = boy;
boy.setNext(first); // 构成环形
cur = first;
}else {
cur.setNext(boy);
boy.setNext(first);
cur = boy;
}
}
}遍历环形链表
- 先让一个辅助指针（变量）curBoy指向first节点
- 然后再通过while循环遍历环形链表即可，当curboy.next=first结束
代码实现
public void show(){
if (first == null){
System.out.println("链表为空");
return;
}
Boy cur =new Boy();
cur = first;
while (true){
System.out.print(cur.getNo()+ " ");
if (cur.getNext() == first){
break;
}
cur = cur.getNext();
}
}约瑟夫问题
/* @param strNo 表示从第几个小孩开始数数
* @param countNum 表示数几下
* @param nums 表示最初有多少小孩在圈中
*/
public void count(int strNo , int countNum, int nums){
//先对数据进行校验
if (first == null || strNo < 1 || strNo > nums){
System.out.println("参数输入有误");
return;
}
//创建一个辅助指针，帮助完成小孩出圈
Boy helper = first;
while (true){//辅助指针指向最后
if (helper.getNext() == first){
break;
}
helper = helper.getNext();
}
//在移动之前，先让first和helper移动到起点k
for (int j = 0; j < strNo - 1 ;j++){
first = first.getNext();
helper = helper.getNext();
}
//进行循环操作，直到圈中只有一个节点
while(true){
if (helper == first){
break;
}
//移动countNum-1次
for (int i =0; i< countNum-1;i++){
first = first.getNext();
helper = helper.getNext();
}
//这是first这个节点为出圈的节点
System.out.println(first.getNo());
first = first.getNext();
helper.setNext(first);
}
System.out.println("最后的一个节点" + first.getNo());
}
}未完待续(づ￣3￣)づ╭❤～
348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
