线性和非线性结构

稀疏数组

前言

引入

稀疏数组的介绍


二维数组和稀疏数组互转的思路

代码

二维数组转稀疏数组

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][4] = 2;
        chessArr1[4][3] = 1;

        //输出原始的二维数组
        System.out.println("原始的二维数组：");
        //#1.java中的双循环特殊写法 --把下面的双循环更换看看效果--一样的
        for(int[] row : chessArr1){
            for (int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        //将二维数组 转为 稀疏数组
        //1.先遍历二维数组得到非0数据个数
        int sum = 0;
        for (int i = 0;i<11;i++){
            for (int j = 0;j<11;j++){
                if (chessArr1[i][j] != 0){
                    sum++;
                }
            }
        }
//        //新双循环版本
//        for (int[] row : chessArr1){
//            for (int data:row){
//                if (data != 0){
//                    sum++;
//                }
//            }
//        }
        System.out.println("sum = "+sum);

        //2.创建对应的稀疏数组
        int sparseArr[][] = new int[sum + 1][3];
        //给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;
        //遍历二维数组，将非0的值存放到sparseArr中
        int count = 0;//用于记录是第几个非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("得到稀疏数组为：");
        //#2.多维数组的length是行吗？
        for (int i = 0; i < sparseArr.length; i++) {
            //#3.只有printf可以处理类似%d的转义字符
            System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }
        System.out.println();
    }
}

稀疏数组转为二维数组

System.out.println("=================================");

        //稀疏数组转为二维数组
        //1.先读取稀疏数组的第一行，工具第一行的数据，创建原始的二维数组
        int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];


        //2.在读取稀疏数组后几行的数据（从第二行开始），并赋值 原始的二维数组
        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();
        }

刷类型题

【题目】
稀疏数组搜索。有个排好序的字符串数组，其中散布着一些空字符串，编写一种方法，找出给定字符串的位置。
【示例1】
输入: words = [“at”, “”, “”, “”, “ball”, “”, “”, “car”, “”, “”,“dad”, “”, “”], s = “ta”
输出：-1
说明: 不存在返回-1
【示例2】
输入：words = [“at”, “”, “”, “”, “ball”, “”, “”, “car”, “”, “”,“dad”, “”, “”], s = “ball”
输出：4
【提示】
words的长度在[1, 1000000]之间

思路
思路
1.一维字符型数组转稀疏数组
稀疏数组构成：
num sum
13 1
pos ch
4 ball
2.拿ball去遍历查找稀疏数组
3.找到输出sparsearray[i][0]的值

问题：
1.没搞懂怎么自行输入空的元素
2.count要注意他的写法

关于这道题的快速解法
JAVA练习195-稀疏数组搜索

package sparseArrayDemo;

import java.util.Scanner;

public class T1 {
    public static void main(String[] args) {
        //创建一个一维字符数组
        String words[] = new String[13];
        //给原数组赋值
        words[0] = "at";
        words[4] = "ball";
        words[7] = "car";
        words[10] = "dad";

        //输入s的值
        Scanner scanner = new Scanner(System.in);
        String s = scanner.next();

        //转换为稀疏数组

        //获取sum值
        int sum = 0;
        for (int i = 0; i < words.length; i++) {
            //# 数组中空元素的表示
            if (words[i] != null){
                sum++;
            }
        }
        String sparseArr[][] = new String[sum+1][2];
        //给稀疏数组赋值
        //# toString的效率最高
        sparseArr[0][0] = Integer.toString(words.length);
        sparseArr[0][1] = Integer.toString(sum);

        int count = 0;
        for (int i = 0; i < words.length; i++) {
            if (words[i] != null){
                count++;
                sparseArr[count][0] = Integer.toString(i);
                sparseArr[count][1] = words[i];
            }
        }

        //输出稀疏数组 ok
//        for (int i = 0; i < sum+1; i++) {
//            for (int j = 0; j < 2; j++) {
//                //# %s表示
//                System.out.printf("%s\t",sparseArr[i][j]);;
//            }
//            System.out.println();
//        }

        //查找输入的s的位置
        boolean flag = false;
        for (int i = 1; i < sum; i++) {
            if (sparseArr[i][1].equals(s)){
                System.out.println(sparseArr[i][0]);
                flag = true;
            }
        }
        if (flag == false){
            System.out.println(-1);
        }
    }
}

队列

非环形队列

队列的概念

数组模拟队列
数组模拟队列–存入分析

演示程序：

package ArrayQueueDemo;

import java.util.Scanner;

public class queueDY {
    public static void main(String[] args) {
        //创建一个队列
        ArrayQueue queue = new ArrayQueue(3);
        char key = ' '; //接收用户输入
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;    //构造菜单循环

        //输出菜单
        while (loop){
            System.out.println("s(show)：显示队列");
            System.out.println("e(exit)：退出程序");
            System.out.println("a(add)：添加数据到队列");
            System.out.println("g(get)：从队列取出数据");
            System.out.println("h(head)：查看队列头的数据");

            key = scanner.next().charAt(0); //接收一个字符
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try{
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是%d\n",res);
                    }catch (Exception e){
                        //TODO:handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try{
                        int res = queue.headQueue();
                        System.out.printf("取出的数据是%d\n",res);
                    }catch (Exception e){
                        //TODO:handle exception
                        System.out.println(e.getMessage());
                    }
                case 'e':
                    //#
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出！");
    }

}
//使用数组模拟队列--编写一个ArrayQueue类
class ArrayQueue{
    private int maxSize;    //表示数组的最大容器
    private int front;         //队列头
    private int rear;       //队列尾
    private int[] arr;      //该数组用于存放数据，mono队列

    //创建队列的构造器
    public ArrayQueue(int arrMaxSize){
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1; //指向队列的头部，(front是指向队列头的前一个位置)
        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++;    //front后移
        return arr[front];
    }

    //显示队列的所有数据
    public void showQueue(){
        //遍历
        if (isEmpty()){
            System.out.println("队列空，不能加入到队列!");
            return;
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n",i,arr[i]);
        }
    }

    //显示队列的头数据，注意不是取出数据
    public int headQueue(){
        //判断
        if (isEmpty()){
            throw new RuntimeException("队列空，不能取数据");
        }
        return arr[front+1];
    }
}

bug：
1 showQueue()内i从0开始，所以取了数据也查看不到，只能用headQueue查看情况
2 现在用过的地方，就算是空的，也不能再用了，因为front和rear一直在++,所以肯定会超出
因为需要对数组进行取模，构成环形队列

环形队列

代码

1 showQueue改为i从front，解决bug1
2 取模变成了环形队列，解决bug2

package ArrayQueueDemo;

import java.util.Scanner;

public class CircleArrayQueue {
    public static void main(String[] args) {
        //创建一个队列
        //此时多了一个月定位置，所以需要+1
        CircleArray queue = new CircleArray(4);
        char key = ' '; //接收用户输入
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;    //构造菜单循环

        //输出菜单
        while (loop){
            System.out.println("s(show)：显示队列");
            System.out.println("e(exit)：退出程序");
            System.out.println("a(add)：添加数据到队列");
            System.out.println("g(get)：从队列取出数据");
            System.out.println("h(head)：查看队列头的数据");

            key = scanner.next().charAt(0); //接收一个字符
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try{
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是%d\n",res);
                    }catch (Exception e){
                        //TODO:handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try{
                        int res = queue.headQueue();
                        System.out.printf("队列的头数据是：%d\n",res);
                    }catch (Exception e){
                        //TODO:handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    //#
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出！");
    }


}
class CircleArray{
    private int maxSize;        //表示数组的最大容器
    private int front;          //队列头
    private int rear;           //队列尾
    private int[] arr;          //该数组用于存放数据，mono队列

    public CircleArray(int arrMaxSize){
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = 0;
        rear = 0;
        //front和rear默认值为0，所以也可以不写
    }

    //判断队列是否满
    public boolean isFull(){
        return (rear + 1) % maxSize == front;
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return rear == front;
    }

    //添加数据到队列
    public void addQueue(int n){
        //判断队列是否满
        if (isFull()){
            System.out.println("队列满，不能加入到队列");
            return;
        }
        //直接将数据加入
        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 int size(){
        return (rear + maxSize - front) % maxSize;
    }

    //显示队列的所有数据
    public void showQueue(){
        //遍历
        if (isEmpty()){
            System.out.println("队列空，没有数据！");
            return;
        }
        //i从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];
    }
}

刷题

没看到只有关队列的题

单链表

单链表的定义

案例演示–代码

代码

1.按照顺序添加

package linkedlist;

public class SingleLinkedListD3emo {
    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.add(hero1);
//        singleLinkedList.add(hero2);
//        singleLinkedList.add(hero3);
//        singleLinkedList.add(hero4);
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        singleLinkedList.add(hero2);

        //显示操作
        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就指向了链表的最后
        temp.next = heroNode;
    }

    //显示链表
    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);
            //将temp后移
            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 + '\'' +
                ", next=" + next +
                '}';
    }
}

要求：按照顺序添加

2.按英雄排名插入

链表的插入

代码：
（在SingleLinkedList类中添加方法addByOrder）

//第二种添加方式：按排名添加
    public void addByOrder(HeroNode heroNode){
        //因为头节点不能动，因此我们需要一个辅助指针temp
        //因为是单链表，所以我们找的temo是位于添加位置前一个节点，否则插入失败
        HeroNode temp = head;
        boolean flag = false;   //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){//说明希望添加的heroNode的标号已经存在
                flag = true;//说明标号存在
                break;
            }
            temp = temp.next;
        }
        if (flag){
            //说明编号存在
            System.out.printf("准备插入的英雄的编号%d已经存在了，不能加入\n",heroNode.no);
        }else {
            //插入到链表中(temp的后面)
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

不论插入顺序，输出仍然保持有序：

3.根据no编号来修改节点信息

代码：（在SingleLinkedList类中添加方法）

//修改节点的信息，根据no编号来修改（no本身不能改
    //1.根据newHeroNode 的 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;
        }
        //根据flag 判断是否找到要修改的节点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        }else {//没找到
            System.out.printf("没找到编号%d的节点，不能修改\n",newHeroNode.no);
        }
    }

4.删除节点

SingleLinkedList类中

//删除节点
    public void del(int no){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                //已经到链表的最后
                break;
            }
            if (temp.next.no == no){
                //找到的待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            //找到
            temp.next = temp.next.next;
        }else {
            System.out.printf("要删除的%d节点不存在\n",no);
        }
    }

main方法中

//删除一个节点
        singleLinkedList.del(1);
        singleLinkedList.del(4);
        singleLinkedList.del(2);
        singleLinkedList.del(3);
        System.out.println("删除后链表的情况：");

显示：

单链表刷题

1.求单链表中有效节点的个数

在主类，但main外部设置方法：

    //获取单链表中有效节点的个数
    public static int getLength(HeroNode head){
        if (head.next == null){//空链表
            return  0;
        }
        int length = 0;
        //定义一个辅助变量
        HeroNode cur = head.next;
        while (cur != null){//遍历
            length++;
            cur = cur.next;
        }
        return length;
    }

在main内部：

        System.out.println("有效的节点个数："+getLength(singleLinkedList.getHead()));//4

2.查找单链表中的倒数第k个节点

自己版：

//查找单链表中的倒数第k个节点
    public static void getReK(int len,int k,HeroNode head){
        //转变为正数下的顺序数
        int no = len - k + 1;

        //去找no序号，并输出其信息
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                //已经走到最后都没找到
                break;
            }
            if (temp.next.no == no){
                //找到no序号，去输出其信息
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            //找到
            //输出节点的信息
            System.out.println(temp.next);

        }else {
            System.out.printf("单链表中的不存在倒数第%d个节点！",k);
        }
    }

System.out.println("去查找单链表中的倒数第k个节点，k==");
        int k = scanner.nextInt();
        getReK(len,k,singleLinkedList.getHead());

老师版：

妙处：
1.方法内部的互相调用
2.声明此方法类型为HeroNode

//老师版
    //index: 倒数第K
    public static HeroNode findLastIndexNode(HeroNode head,int index){
        //如果链表为空
        if (head.next == null)
                return null;
        //得到链表的长度
        int size = getLength(head);
        //正数第K个节点的位置：size - index
        //先做一个index检验
        if (index <= 0 || index > size){
            return null;
        }
        HeroNode cur = head.next;
        for (int i = 0;i<size - index;i++){
            cur = cur.next;
        }
        return cur;
    }

HeroNode res = findLastIndexNode(singleLinkedList.getHead(),1);
        System.out.println("res="+res);

3.单链表的反转

思路：

代码：（老师版）
main方法内：

System.out.println("反转单链表：");
        reverseList(singleLinkedList.getHead());
        singleLinkedList.list();

main方法外主类内：

//将单链表反转
    public static void reverseList(HeroNode head){
        //如果当前链表为空，或者只有一个节点，则无需反转
        if (head.next == null || head.next.next == null){
            return;
        }

        HeroNode cur = head.next;
        HeroNode next = null; //指向当前节点[cur]的下一个节点（没有记录下个节点，会导致链表记录断开，因为这是单链表）
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表，没遍历一个节点，就取出放在新链表reverseHead的最前端
        while (cur != null){
            next = cur.next;    //先暂时保存当前节点的下一个节点
            //完整的连接操作
            cur.next = reverseHead.next;//将cur的下一个节点指向链表的最前端
            reverseHead.next = cur;

            cur = next;//让cur后移
        }
        //将head.next指向reverseHead.next，实现反转的最后一步
        head.next = reverseHead.next;
    }

显示：

4.从尾到头打印单链表【方式1: 反向遍历。 方式2: Stack栈】

//可以利用栈这个数据结构，将各个节点压入栈中，
    // 然后利用栈的先进后出的特点，就实现了逆序打印的效果
    public static void reversePrint(HeroNode head){
        if (head.next == null){
            return;//空链表不打印
        }
        //创建要给一个栈，将各个节点压入栈中
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur =head.next;
        //将链表的所有节点压入栈中
        while (cur != null){
            stack.push(cur);
            cur = cur.next;//cur后移，这样就可以压入下一个节点
        }
        //将栈中的节点进行打印 pop出栈
        while (stack.size() > 0){
            System.out.println(stack.pop()); //stack特点是先进后出
        }
    }

main中

//方式2：打印反转的单链表
        System.out.println("逆序打印单链表，但没有改变链表的结构：");
        reversePrint(singleLinkedList.getHead());

显示：

5.合并两个有序的单链表，合并之后的链表依然有序

自己版（woc我竟然写出来了…）

//合并并有序
    public static void comOrdLink(HeroNode head1,HeroNode head2){
        //合并
        //1.都采用addByOrder的形式加入 2.遍历到第一个链表的最后 3.连接两个链表的头尾
        HeroNode temp1 = head1;
        //遍历到第一个链表的最后
        while (true){
            if (temp1.next == null){
                break;
            }
            temp1 = temp1.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //连接两个链表的头尾
        temp1.next = head2.next;
    }

main内：

//合并并有序
        System.out.println("合并并有序化两个链表：");
        comOrdLink(singleLinkedList1.getHead(),singleLinkedList2.getHead());
        singleLinkedList1.list();

输出：

【单链表四道经典例题（必会）】

链表的相交问题

（1）判断两个链表是否相交？
（2）如果相交请找到相交的节点。

思想：

解答：

Java 判断两个链表是否相交

判断链表是否存在回文

java判断单链表是否是回文链表

---

双向链表

思路：

双向连表的建立：

//创建一个双线链表的类
class DoubleLinkedList{
    //先初始化一个头节点，头节点不动，不存放
    private HeroNode2 head = new HeroNode2(0,"","");

    public HeroNode2 getHead() {
        return head;
    }

    //删除双向链表节点
    public void del(int no){

        //判断当前链表是否为空
        if (head.next == null){
            System.out.println("链表空，无法删除！");
            return;
        }
        HeroNode2 temp = head.next;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                //已经到链表的最后
                break;
            }
            if (temp.no == no){
                //找到的待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            //找到
//            temp.next = temp.next.next;
            temp.pre.next = temp.next;
            //如果是最后一个节点，就不需要执行下面这句话，否则出现空指针
            if (temp.next != null){
                temp.next.pre = temp.pre;
            }
        }else {
            System.out.printf("要删除的%d节点不存在\n",no);
        }
    }

    //修改的操作和单向链表一样
    //只是节点类型改为HeroNode2
    public void upDate(HeroNode2 newHeroNode){
        //判断是否为空
        if (head.next == null){
            System.out.println("链表为空！");
            return;
        }
        //找到需要修改的节点
        HeroNode2 temp = head.next;
        boolean flag = false;
        while (true){
            if (temp == null){
                break; //已经遍历完链表
            }
            if (temp.no == newHeroNode.no){
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag 判断是否找到要修改的节点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        }else {//没找到
            System.out.printf("没找到编号%d的节点，不能修改\n",newHeroNode.no);
        }
    }

    public void add(HeroNode2 heroNode){
        //输出和使用temp的时候都有变.next，所以不用修改为head.next
        HeroNode2 temp = head;
        while (true){
            if (temp.next == null){
                break;
            }
            temp = temp.next;
        }
        //此时temp指向链表的最后
        //形成一个双向链表
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    //显示链表,遍历方法同单向链表
    public void list(){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp = head.next;
        while (true){
            if (temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }


}
class HeroNode2{
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next;//指向下一个节点 默认为null
    public HeroNode2 pre;//指向下一个节点 默认为null

    //构造器
    public HeroNode2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    @Override
    public String toString() {
        return "HeroNode2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

修改双向链表：

//先创建节点
        HeroNode2 hero1 = new HeroNode2(1,"宋江","及时雨");
        HeroNode2 hero2 = new HeroNode2(2,"卢俊义","玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3,"吴用","智多星");
        HeroNode2 hero4 = new HeroNode2(4,"林冲","豹子头");

        //创建一个双线链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);

        doubleLinkedList.list();

        //修改
        HeroNode2 newHeroNode = new HeroNode2(4,"公孙胜","入云龙");
        doubleLinkedList.upDate(newHeroNode);
        System.out.println("修改后链表情况：");
        doubleLinkedList.list();

删除双向链表：

//删除
        doubleLinkedList.del(3);
        System.out.println("删除链表的情况：");
        doubleLinkedList.list();

小测–按排名添加

自己代码：
main 外：

//按照编号顺序添加
    public static void addByOdser(HeroNode2 heroNode,HeroNode2 head){
        HeroNode2 temp = head;
        boolean flag = false;   //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){//说明希望添加的heroNode的标号已经存在
                flag = true;//说明标号存在
                break;
            }
            temp = temp.next;
        }
        if (flag){
            //说明编号存在
            System.out.printf("准备插入的英雄的编号%d已经存在了，不能加入\n",heroNode.no);
        }else {
            //插入到链表中(temp的后面)
            heroNode.pre = temp;
            temp.next = heroNode;
        }
    }

main内：

//按编号no排序添加
        addByOdser(hero1,doubleLinkedList.getHead());
        addByOdser(hero2,doubleLinkedList.getHead());
        addByOdser(hero3,doubleLinkedList.getHead());
        addByOdser(hero4,doubleLinkedList.getHead());

输出：

发现问题：单向链表add与addByOder添加时
语句不同的原因


问题类似双向链表中的，del处理删除最后一个节点的情况

总结：
时刻注意着节点在最后一位时，它的next是否为空节点的情况

单向环形链表

介绍

应用场景–约瑟夫问题

代码实现

创建单向环形链表&环形单链表的添加

• 思路

注意：
boy：不是指针，是一个节点对象
curboy：是一个指针

• 代码

package linkedlist;

public class Josepfu {
    public static void main(String[] args) {
        //测试-构建 环形链表 和 遍历输出
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(10);
        circleSingleLinkedList.showBoy();
    }
}
//创建一个环形单向链表
class CircleSingleLinkedList {
    //创建一个first急待你，当前没有编号（相当于赋初值,后面才给它确切的值
    private Boy first = new Boy(-1);

    //添加小孩节点，构建一个环形链表
    public void addBoy(int nums) {
        //nums做一个 数据检验
        if (nums < 1) {
            System.out.println("nums值不正确");
            return;
        }
        Boy curBoy = null;  //辅助指针，帮助构建
        //使用for来创建我们的环形链表
        //？？？为啥单向链表不能用for来创建
        for (int i = 1; i <= nums; i++) {
            //根据编号 创建小孩节点
            Boy boy = new Boy(i);
            //如果是第一个小孩
            if (i == 1) {
                first = boy;
                first.setNext(first);//构成环
                curBoy = first; //让curBoy指向第一个小孩
            } else {
                //一般添加节点操作
                curBoy.setNext(boy);
                boy.setNext(first);
                curBoy = boy;
            }
        }
    }

    //遍历当前环形链表
    public void showBoy() {
        //判断链表是否为空
        if (first == null) {
            System.out.println("没有任何小孩！");
            return;
        }
        //因为first不能动，所以仍然需要一个curBoy完成遍历
        Boy curBoy = first;
        while (true) {
            System.out.printf("小孩的编号 %d \n", curBoy.getNo());
            if (curBoy.getNext() == first) {//说明已经遍历完成
                break;
            }
            curBoy = curBoy.getNext();//curBoy后移
        }
    }
}
class Boy{
    private int no; //编号
    private Boy next;   //指向下一个节点，默认null

    public Boy(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }
}

输出

环形单链表的出圈

CircleSingleLinkedList内方法：

//出圈小孩节点
    public void countBoy(int startNo,int countNum,int nums){
        //先对数据进行检验
        if (first == null || startNo < 1 || startNo > nums){
            System.out.println("参数输入有误，请重新输入");
            return;
        }
        //创建辅助指针
        Boy helper = first;
        //helper指针应该事先，指向环形链表的最后节点
        while (true){
            if (helper.getNext() == first){
                break;
            }
            helper = helper.getNext();
        }
        //小孩报数前，先让first和helper移动k - 1次
        for (int j = 0;j < startNo - 1;j++){
            first = first.getNext();
            helper = helper.getNext();
        }

        //当小孩报数时，让first和helper指针同时移动m - 1次，然后出圈
        //way：喜欢操作，直到全栈只有一个节点
        while (true){
            if (helper == first){
                //说明圈中只有一个节点
                break;
            }
            //让first和helper指针同时移动countNum - 1(m - 1)
            for (int i = 0; i < countNum - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            //这时forst指向的节点就是，要出圈的小孩节点
            System.out.printf("小孩%d出圈\n",first.getNo());
            //将first指向的节点出圈
            first = first.getNext();
            //???这样不就forst和helper指向同一个节点了？ --理解错误
            //这是一整套完整的出圈操作  等价于：helper.next = first(还是不懂就去看图)
            helper.setNext(first);
        }
        System.out.printf("最后留在全栈的小孩编号%d\n",first.getNo());
    }

main内：

//测试-小孩出圈是否正常
        circleSingleLinkedList.countBoy(1,2,5);

刷题

2288 蓝桥杯2018年第九届真题 约瑟夫环

自己代码：（正确
main外

//刷题1
    public static int getLatNo(int k,int n,Boy first){
        int lastNo;//最后一个剩下的人编号
        //让helper指针应实现走，指向环形链表的最后节点
        Boy helper = first;
        while (true){
            if (helper.getNext() == first){
                break;
            }
            helper = helper.getNext();
        }

        //开始报数，让forst和helper同时移动k - 1,然后出圈
        while (true){
            if (helper == first){
                //说明圈中只剩下一个节点
                break;
            }
            //开始移动m - 1
            for (int i = 0; i < k - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            //让forst指向的节点出圈
            first = first.getNext();
            helper.setNext(first);
        }
        lastNo = first.getNo();
        return lastNo;
    }

小知识点

String类中的replaceAll方法：public String replaceAll(String regex,String replacement)

java中的双循环特殊写法

for(int[] row : chessArr1){
   for (int data:row){
        System.out.printf("%d\t",data);
    }
    System.out.println();
}

多维数组的length是行数
sparseArr.length

只有printf可以处理类似%d的转义字符

System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);