AI 助理
备案控制台
开发者社区 人工智能 文章 正文

数据结构与算法笔记（一）

2024-02-01 129
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 数据结构与算法笔记（一）


1. 数据结构与算法入门

前言

很早之前做的笔记了，做一个备忘

1.1 经典算法问题：

  1. 汉诺塔
  2. 八皇后问题
  3. 马踏棋盘

1.2 字符串匹配

1.2.1 暴力匹配

 

1.2.2 KMP算法

1.3 数据结构和算法重要性

  1. 算法是程序灵魂
  2. 内存计算框架

1.4 数据结构与算法关系

2. 实际算法问题：

2.1 str.replaceAll( str )

2.1.1 问题：

试写出单链表表示的字符串类以及字符串结点类的定义，并且依次实现它的构造函数，以及计算串的长度，串赋值，判断两串相等，求子串，两串连接，求子串在串中位置等七个成员函数

2.2 其他几个问题：

  1. 丢手帕问题
  2. 磁盘问题
  3. 公交车
  4. 画图
  5. 球和篮子
  6. 扔石头
  7. 修路问题，最小路径
  8. 最短路径问题
  9. 汉诺塔
  10. 八皇后

2.3 线性结构与非线性结构

  1. 数据与元素一对一的线性关系
  2. 顺序存储，元素都是连续的
  3. 链式存储，元素是不连续的
  4. 数组，队列，链表和栈

2.3.1 非线性结构

二维数组，多维数组，广义表，树结构，图结构

3. 稀疏数组和队列

3.1 稀疏数组的处理方法：

  1. 记录数组一共几行几列，有多少个不同的值
  2. 把具有不同值的元素的行列记录在一个小规模数组

3.1.1 二维数组转稀疏数组的方法

  1. 遍历原始二维数组，保留有效个数
  2. 根据sum创建稀疏数组spareArr int[sum+1][3]
  3. 二维数组的有效数据存入到稀疏数组

3.2 稀疏数组转二维数组：

  1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，
  2. 读取稀疏数组的后几行数据，并赋值给原始的二维数组

4. 稀疏数组的Java代码实现

package array;
import java.util.ArrayList;
import java.util.List;
/**
 * 稀疏数组
 * 1. 需要将二维数组转为稀疏数组存储
 * 2. 稀疏数组进行保存（文件读写）
 * 3. 读取文件恢复稀疏数组（文件读写）
 * 4. 将稀疏数组转回二维数组
 * @author zxd
 * @title: SpareceArray
 * @projectName structAlgorithms
 * @description: 稀疏数组
 * @date 2019/8/19 14:54
 */
public class SpareceArray {
    /**
     * 使用稀疏数组
     * @param args 数组
     */
    public static void main(String[] args) {
        int[][] twoArrayConvertSparecArray = twoArrayConvertSparecArray();
        // 稀疏数组如何转为二维住
        SparecArrayConverttwoArray(twoArrayConvertSparecArray);
    }
    /**
     * 稀疏数组转为二维数组
     */
    private static void SparecArrayConverttwoArray(int[][] array) {
        // 1. 根据第一行数据还原出二维数组的行与列
        int[][] result = new int[array[0][0]][array[0][1]];
        for (int i = 1; i < array.length; i++) {
            result[array[i][0]][array[i][1]] = array[i][2];
        }
        printArray(array);
        printArray(result);
    }
    /**
     * 稀疏数组转为二维数组的办法
     * 1. 创建二维数组，并且加入数据
     * 2.
     */
    private static int[][] twoArrayConvertSparecArray() {
        // 将二维数组转为稀疏数组 初始化为 11 11
        int[][] array = new int[8][8];
        List list = new ArrayList();
        // 在二维数组放两个子
        array[4][5] = 2;
        array[3][7] = 11;
        array[2][3] = 11;
        printArray(array);
        // 计算有几个有效数据
        // 存储有几个有效数据
        int sumCount = 0;
        sumCount = calcuArrSize(array, sumCount);
        // 创建稀疏数组
        int[][] spareceArray = new int[sumCount+1][3];
        // 第一行为 个数 棋盘的行 棋盘的列
        spareceArray[0][0] = array.length;
        spareceArray[0][1] = array[0].length;
        spareceArray[0][2] = sumCount;
        // 稀疏数组存储数据
        //count 用于记录是第几个非0数据
        int noZeroCount = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != 0) {
                    noZeroCount++;
                    // 存储第几行 第几列 值为多少
                    spareceArray[noZeroCount][0] = i;
                    spareceArray[noZeroCount][1] = j;
                    spareceArray[noZeroCount][2] = array[i][j];
                }
            }
        }
        return spareceArray;
    }
    /**
     * 计算有效数据的个数
     * @param array 原有的数组
     * @param sumCount 计算个数
     */
    private static int calcuArrSize(int[][] array, int sumCount) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != 0) {
                    sumCount++;
                }
            }
        }
        return sumCount;
    }
    /**
     * 打印数组的快捷方法
     * @param array 数组
     */
    private static void printArray(int[][] array) {
        System.err.println("-----------------我是分割线-----------------");
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + "\t" );
            }
            System.out.println();
        }
        System.err.println("-----------------我是分割线-----------------");
    }
}

5. 队列：

5.1 数组模拟队列

5.1.1 思路分析：addQueue

  1. 将尾指针 rear + 1 ， 表示入队。当 rear == front 表示空队列
  2. 如果rear 等于队列 maxSize - 1， 表示队列满，否则可以增加元素

5.1.2 思路分析：removeQueue

  1. 将队头指针进行出队操作
  2. 每次移除都需要队头指针 +1
  3. 将队列后面的数据向前拷贝

5.2 JAVA代码实现数组底层的队列

package array;
import javax.sql.rowset.serial.SerialArray;
import java.util.Arrays;
/**
 * 使用数组实现队列
 *
 * @author zhaoxudong
 * @title: MyQueue
 * @projectName structAlgorithms
 * @description: 使用数组实现队列
 * @date 2019/8/23 15:27
 */
public class MyQueue {
    /**
     * 队尾指针
     */
    private int rear;
    /**
     * 队头指针
     */
    private int front;
    /**
     * 最大数
     */
    private int maxSize;
    /**
     * 队列
     */
    private int[] arr;
    public MyQueue(int size) {
        if (size <= 0) {
            System.err.println("队列不能小于或者等于 0");
            return;
        }
        // 注意此处为什么是-1 ：因为队列的头部不应该执行队伍的第一个元素，因为此时是出于队列的头部，并没有数据
        rear = front = -1;
        this.arr = new int[size];
        this.maxSize = size;
    }
    /**
     * 出队操作：
     * 1. 队伍头部的元素删除即，使 return arr[front]
     * 2. 将队伍后面的元素向前拷贝
     */
    public int removeQueue() {
        if (isEmpty()) {
            System.err.println("队列为空，不能移除");
            return -1;
        }
        for (int i = 1; i < rear; i++) {
            arr[i - 1] = arr[i];
        }
//        arr[--rear] = 0;
        return arr[++front];
    }
    /**
     * 队尾+1 入队操作
     * 需要判断队列是否为空并且是否不满
     *
     * @param val
     */
    public void addQueue(int val) {
        // 判断是否为空或者是否已经满了
        boolean empty = isFull();
        if (!empty) {
            System.err.println("队列已满，无法添加");
            return;
        }
        arr[++rear] = val;
    }
    /**
     * 判断队列是否可以加入数据
     *
     * @return
     */
    private boolean isFull() {
        return rear != maxSize - 1;
    }
    private boolean isEmpty() {
        return rear == front;
    }
    public void showQueue(){
        System.err.println(Arrays.toString(this.arr));
    }
    public static void main(String[] args) {
        MyQueue myQueue = new MyQueue(3);
        myQueue.addQueue(2);
        myQueue.addQueue(5);
        myQueue.addQueue(6);
        myQueue.removeQueue();
        myQueue.removeQueue();
        myQueue.removeQueue();
        // 这里出现问题，因为队头和队尾都指向队列的尾部，会出现无法添加和无法删除掉问题
        myQueue.addQueue(6);
        myQueue.removeQueue();
        myQueue.showQueue();
    }
}

5.2.1 数组队列的弊端

  • 队头和队尾都执行队列的尾部时候，无法添加也无法删除
  • 数组只能使用一次
  • 数组复用性不好

5.3 数组实现循环队列

5.3.1 如何判定队列已经满了

算法

( rear + 1 ) % maxSize == front

5.3.2 如何判定队列是空的

rear == front

5.3.3 如何判定有效个数

举例：

maxSize = 7

front = 5

rear = 5

maxSize + (rear+1) - front % maxSize

5.3.4 使用数组实现循环队列的方式2

package array;
/**
 * 使用数组实现队列
 *
 * @author zhaoxudong
 * @title: MyQueue
 * @projectName structAlgorithms
 * @description: 使用数组实现队列
 * @date 2019/8/23 15:27
 */
public class MyQueue {
    /**
     * 队尾指针
     */
    private int rear;
    /**
     * 队头指针
     */
    private int front;
    /**
     * 最大数
     */
    private int maxSize;
    /**
     * 队列
     */
    private int[] arr;
    public MyQueue(int size) {
        if (size <= 0) {
            System.err.println("队列不能小于或者等于 0");
            return;
        }
        // 注意此处为什么是-1 ：因为队列的头部不应该执行队伍的第一个元素，因为此时是出于队列的头部，并没有数据
        rear = front = 0;
        this.arr = new int[size];
        this.maxSize = size;
    }
    /**
     * 出队操作：
     * 1. 队伍头部的元素删除即，使 return arr[front]
     * 2. 将队伍后面的元素向前拷贝
     */
    public int removeQueue() {
        if (isEmpty()) {
            System.err.println("队列为空，不能移除");
            return -1;
        }
//        for (int i = 1; i < rear; i++) {
//            arr[i - 1] = arr[i];
//        }
//        arr[--rear] = 0;
        return arr[++front];
    }
    /**
     * 队尾+1 入队操作
     * 需要判断队列是否为空并且是否不满
     *
     * @param val
     */
    public void addQueue(int val) {
        // 判断是否为空或者是否已经满了
        boolean empty = isFull();
        if (empty) {
            System.err.println("队列已满，无法添加");
            return;
        }
        arr[rear] = val;
        rear = (rear + 1) % maxSize;
    }
    /**
     * 判断队列是否可以加入数据
     *
     * @return
     */
    private boolean isFull() {
//        return rear != maxSize - 1;
        // 这是最新的一种判定方式： rear =
        return (rear  + 1) % maxSize == front;
    }
    private boolean isEmpty() {
        return rear == front;
    }
    public void showQueue(){
        if(arr == null || arr.length == 0){
            System.err.println("队列为空，不能遍历");
            return;
        }
        for (int i = front; i < front + size(); i++) {
            System.err.print(arr[i % maxSize] + "\t");
        }
//        System.err.println(Arrays.toString(this.arr));
    }
    public int size(){
        return (rear + maxSize - front) % maxSize;
    }
    public static void main(String[] args) {
        MyQueue myQueue = new MyQueue(8);
        myQueue.addQueue(2);
        myQueue.addQueue(55);
        myQueue.addQueue(35);
        myQueue.addQueue(25);
        myQueue.addQueue(65);
        myQueue.addQueue(85);
        myQueue.addQueue(75);
//        myQueue.addQueue(6);
        myQueue.removeQueue();
        myQueue.removeQueue();
        myQueue.removeQueue();
        // 这里出现问题，因为队头和队尾都指向队列的尾部，会出现无法添加和无法删除掉问题
//        myQueue.addQueue(6);
//        myQueue.removeQueue();
        myQueue.showQueue();
    }
}

6. 链表

6.1 使用自制的链表处理

6.1.1 使用java代码实现链表

package queue;
/**
 * 单链表实现
 *
 * @author zhaoxudong
 * @title: SpareceArray
 * @projectName structAlgorithms
 * @description: 单链表实现
 * @date 2019/8/19 14:54
 */
public class SingelQueue {
    public static void main(String[] args) {
        HeroNode heroNode1 = new HeroNode(0, "111", "111");
        HeroNode heroNode2 = new HeroNode(0, "222", "222");
        HeroNode heroNode3 = new HeroNode(0, "333", "333");
        HeroNode heroNode4 = new HeroNode(0, "444", "444");
        SingelLinkedList singelLinkedList = new SingelLinkedList();
        singelLinkedList.add(heroNode1);
        singelLinkedList.add(heroNode2);
        singelLinkedList.add(heroNode3);
        singelLinkedList.add(heroNode4);
        singelLinkedList.list();
    }
}
class SingelLinkedList {
    private HeroNode head = new HeroNode(0, "", "");
    /**
     * 在插入的使用最新的方式：
     * 根据id编号进行排序
     * 1.
     * @param node
     */
    public void add(HeroNode node) {
        // 1. 由于头结点不能动，需要使用
        HeroNode heroNode = head;
        while (true) {
            if(heroNode.getNext() == null){
                break;
            }
            heroNode = heroNode.getNext();
        }
        heroNode.setNext(node);
    }
    public void list(){
        HeroNode heroNode = head;
        while (true) {
            if(heroNode.getNext() == null){
                break;
            }
            System.err.println(heroNode);
            heroNode = heroNode.getNext();
        }
    }
}
/**
 * 构造函数的节点
 */
class HeroNode {
    private int no;
    private String name;
    private String nickName;
    private HeroNode next;
    /**
     * 初始化构造函数
     *
     * @param no
     * @param name
     * @param nickName
     */
    public HeroNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getNickName() {
        return nickName;
    }
    public void setNickName(String nickName) {
        this.nickName = nickName;
    }
    public HeroNode getNext() {
        return next;
    }
    public void setNext(HeroNode next) {
        this.next = next;
    }
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                ", next=" + next +
                '}';
    }
}

6.1.2 使用排序的方式插入链表改进上述链表

  1. 这里使用了查找的方式，判断是否相等，遍历的时候使用头指针的下一个节点进行遍历操作
  2. 插入节点使用被插入的节点的下一个节点指向当前遍历节点的下一个节点，当前循环节点指向指向当前被插入的节点
  3. 如果节点相等，给出提示
/**
     * 在插入的使用最新的方式：
     * 使用id编号进行排序，在查找的时候使用id进行排序查找
     * @param node
     */
    public void addByOrder(HeroNode node) {
        // 1. 由于头结点不能动，需要使用
        HeroNode heroNode = head;
        boolean flag = false;
        while (true) {
            if(heroNode.getNext() == null){
                break;
            }
            // 寻找编号大于被插入节点的节点，因为只能找被插入的节点的上一个节点
            if(heroNode.getNext().getNo() > node.getNo()){
                // 获取原来数据的下一个节点一个节点
                break;
            }else if(heroNode.getNext().getNo() == node.getNo()){
                //说明希望添加的heroNode的编号已然存在
                flag = true;
                break;
            }
            heroNode = heroNode.getNext();
        }
        if(flag) {
            System.err.println("被插入的节点已经存在");
        }else{
            node.setNext(heroNode.getNext());
            heroNode.setNext(node);
        }
    }

6.1.3 删除节点有多少种情况

  1. 如果删除的是头节点
  2. 如果是中间的节点，需要将被删除的上一个节点执行被删除节点的下一个节点
  3. 如果在尾部，删除尾部节点

6.1.4 删除的第一种方式实现办法

/**
     * 删除方式，
     * 第一种方式： 使用编号删除对应的节点
     *
     * @param no 节点编号
     */
    public void del(int no) {
        HeroNode temp = head;
        // 如果是头节点指向节点，需要变更头节点指向节点再删除节点
        if (temp.getNext().getNo() == no) {
            // 指向下一个节点的下一个节点
            head.setNext(head.getNext().getNext());
            return;
        }
        // 判断是否找到了节点
        boolean flag = false;
        while (true) {
            if (temp.getNext().getNo() == no) {
                flag = true;
                break;
            }
            temp = temp.getNext();
        }
        // 找到节点进行替换
        if(flag){
            temp.setNext(temp.getNext().getNext());
        }else{
            System.err.println("没有找到对应编号的英雄");
        }
    }

6.1.5 删除的第二种方式分析：

  1. 删除根据第几个来删除，必须我想删除第一个节点
  1. 第一个节点对应了头节点，需要对于头指针指向进行后移
  1. 其余根据no编号删除雷同,只需要编号判断改为第几个判断即可

6.2 关于链表的面试题（重点）

  1. 单链表当中有效节点的个数
  2. 获取倒数第n个节点的节点
  3. 反转链表
  1. 定义一个节点：反转用的头
  2. 从头到尾遍历原来链表，每遍历一个节点，就取出，放到新的链表前面
  3. 将旧链表的下一个节点指向逆序链表的下一个节点
  1. 从尾部到头部逆序打印链表
  1. 第一种方法：显逆序，逆序之后打印节点（不可取）
  2. 使用栈实现：将所有的节点加入栈当中，然后使用栈进行打印

6.2.1 节点个数的实现

较为简单，遍历统计遍历几次即可

6.2.2 倒数第N个节点

/**
     * 获取倒数第index个节点的值
     * @param index
     * @return
     */
    public HeroNode getLastIndexHeroNode(int index){
        // 1. 获取链表的总个数
        int count = count();
        if(index <= 0 || index > count){
            return null;
        }
        HeroNode temp = head.getNext();
        // 2. 根据size - index , 循环获取倒数第 index 节点
        int i = 0;
        int size = count-index;
        while (true) {
            if (i == size) {
                break;
            }
            i++;
            temp = temp.getNext();
        }
        // 3. 遍历拿到数据，返回结果
        return temp;
    }

6.2.3 反转链表

/**
     * 反转节点
     * 1. 定义一个反转节点的head
     * 2. 遍历原来的链表，使用类似入栈的方式，将每个节点接入到反转节点的指向节点，被接入节点指向原来的节点
     * 3. 反转节点完成
     */
    public void reverse(){
        if(head == null || head.getNext() == null || head.getNext().getNext() == null){
            System.err.println("无需反转");
            return;
        }
        HeroNode reverseHead = new HeroNode(0, "", "");
        HeroNode temp = head.getNext();
        HeroNode next = null;
        while (temp != null) {
            // 让当前节点接到新链表的下一个节点
            next = temp.getNext();
            temp.setNext(reverseHead.getNext());
            reverseHead.setNext(temp);
            temp = next;
        }
        // 使用反转节点替换原来的节点
        head.setNext(reverseHead.getNext());
    }

6.2.4 反序打印链表

  1. 需要使用到栈这种结构，将节点压进栈当中，然后从栈中取数据进行遍历
/**
     * 反序打印链表里面的内容
     * 使用的栈结构进行存放数据，然后使用栈进行输出操作
     */
    public void reversePrint() {
        System.err.println();
        if (head == null || head.getNext() == null || head.getNext().getNext() == null) {
            System.err.println("无需反转打印");
            return;
        }
        HeroNode hero = head.getNext();
        Stack<HeroNode> stack = new Stack<>();
        while (hero != null) {
            stack.push(hero);
            hero = hero.getNext();
        }
        while(stack.size()>0) {
            System.out.println(stack.pop());
        }
    }

6.2.5 合并两个链表

  1. 遍历两个链表，先将第一个链表进行插入，然后根据第二个链表进行相同的插入操作s
/**
     * 合并两个链表，合并之后依然有序
     * 1. 计算两个链表的个数
     * 2. 循环总数，判断两个节点的当前节点更大，
     *
     * @param list1
     * @param list2
     * @return
     */
    public static SingelLinkedList mergeList(SingelLinkedList list1, SingelLinkedList list2) {
        if(list1 == null && list2 == null){
            return null;
        }
        if(list1 == null) {
            return list2;
        }
        if(list2 == null) {
            return list1;
        }
        SingelLinkedList result = new SingelLinkedList();
        HeroNode next1 = list1.getHead();
        while (true) {
            if (next1 == null) {
                break;
            }
            HeroNode next = next1.getNext();
            SingelLinkedList.addByOrder(result, next1);
            next1 = next;
        }
        HeroNode next2 = list2.getHead().getNext();
        while(true){
            if(next2 == null) {
                break;
            }
            HeroNode next = next2.getNext();
            SingelLinkedList.addByOrder(result, next2);
            next2 = next;
        }
        return result;
    }

6.3 分析双向链表的遍历，添加、删除的操作思路

  1. 遍历方和单链表一样只是可以朝前，可以向后
  2. 添加
  1. 默认添加到双向链表的最后
  2. 先找到双向链表的最后这个节点
  3. temp.next = new heronode
  4. newheronode.pre = temp
  1. 删除
  1. 因为是双向的，可以自我删除
  2. 找到要删除的这个节点，temp
  3. temp.next.pre = temp.pre
  4. temp.pre.next = temp.next
  1. 修改
  1. 不需要太大变动，和原来的链表类似

6.4 循环链表（约瑟夫问题）

6.4.1 什么是循环链表

无论是加入还是删除节点，最后一个节点要么指向自己，要么指向链表的头节点，形成环状的一个链表

6.4.2 构建一个环形链表的思路

  1. 先创建一个节点，first 指向改节点， 并且形成环形
  2. 后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表当中即可
/**
     * 环形链表的添加和原来的添加代码有所不同
     * @param size
     */
    public void add(int size){
        if(size < 1){
            System.out.println("size的值不正确");
            return;
        }
        CircularNode cur = null;
        for (int i = 1; i <= size; i++) {
            CircularNode newcur = new CircularNode(i, "小孩"+i, "小孩昵称"+i);
            // 如果是第一个节点，则需要特殊处理
            if(i == 1){
                // 第一个节点复制给first节点
                first = newcur;
                first.setNext(first);
                // 将当前操作指针指向第一个节点
                cur = first;
            }else{
                cur.setNext(newcur);
                newcur.setNext(first);
                cur = newcur;
            }
        }
    }

6.4.3 遍历环形链表

  1. 先让一个辅助指针 curBoy ， 指向first
  2. 通过while循环，遍历环形链表，当curBoy.next == first 结束
/**
     * 遍历节点
     */
    public void list(){
        if(first == null){
            System.err.println("循环链表为空");
            return;
        }
        CircularNode circularQueue = first;
        while(true){
            System.err.println(circularQueue);
            if(circularQueue.getNext() == first){
                break;
            }
            circularQueue = circularQueue.getNext();
        }
    }

6.4.4 模拟约瑟夫问题的实现（重点）

/**
     *
     * @param begin 从第几个小孩开始数
     * @param countNum 数几个小孩
     * @param nums 表示最初有多少小孩在圈中
     */
    public void count(int begin, int countNum, int nums){
        // 先对数据进行校验
        if (first == null || begin < 1 || countNum > nums) {
            System.out.println("参数输入有误， 请重新输入");
            return;
        }
        // 创建辅助指针，指向环形链表的最后一个元素
        CircularNode helper = first;
        while(helper.getNext() != first){
            helper = helper.getNext();
        }
        //小孩报数前，先让 first 和  helper 移动 k - 1次
        for (int i = 0; i < begin; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        // 当小孩报数时，让first 和 helper 指针同时 的移动  m  - 1 次, 然后出圈
        // 这里是一个循环操作，知道圈中只有一个节点
        while(true){
            if(helper == first) {
                break;
            }
            //让 first 和 helper 指针同时 的移动 countNum - 1
            for (int i = 0; i < countNum - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            // 这时first指向的节点，就是要出圈的小孩节点\
            System.out.printf("小孩%d出圈\n", first.getNo());
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.printf("最后留在圈中的小孩编号%d \n", first.getNo());
    }
文章标签：
算法
Java
存储
关键词：
算法笔记
数据结构笔记
数据结构与算法笔记
懒时小窝
目录
相关文章
Codelinghu
|
3月前
|
算法
【❤️算法笔记❤️】-每日一刷-19、删除链表的倒数第 N个结点
【❤️算法笔记❤️】-每日一刷-19、删除链表的倒数第 N个结点
Codelinghu
80 1
Codelinghu
|
3月前
|
算法 索引
❤️算法笔记❤️-(每日一刷-141、环形链表)
❤️算法笔记❤️-(每日一刷-141、环形链表)
Codelinghu
54 0
Codelinghu
|
3月前
|
算法
【❤️算法笔记❤️】-(每日一刷-876、单链表的中点)
【❤️算法笔记❤️】-(每日一刷-876、单链表的中点)
Codelinghu
55 0
Codelinghu
|
3月前
|
算法
【❤️算法笔记❤️】-每日一刷-23、合并 K 个升序链表
【❤️算法笔记❤️】-每日一刷-23、合并 K 个升序链表
Codelinghu
36 0
Codelinghu
|
3月前
|
存储 算法
【❤️算法笔记❤️】-每日一刷-21、合并两个有序链表
【❤️算法笔记❤️】-每日一刷-21、合并两个有序链表
Codelinghu
116 0
zzy的aly
|
3月前
|
算法 API 计算机视觉
人脸识别笔记(一)：通过yuface调包(参数量54K更快更小更准的算法) 来实现人脸识别
本文介绍了YuNet系列人脸检测算法的优化和使用，包括YuNet-s和YuNet-n，以及通过yuface库和onnx在不同场景下实现人脸检测的方法。
zzy的aly
92 1
zzy的aly
|
3月前
|
JSON 算法 数据可视化
测试专项笔记(一): 通过算法能力接口返回的检测结果完成相关指标的计算（目标检测）
这篇文章是关于如何通过算法接口返回的目标检测结果来计算性能指标的笔记。它涵盖了任务描述、指标分析（包括TP、FP、FN、TN、精准率和召回率），接口处理，数据集处理，以及如何使用实用工具进行文件操作和数据可视化。文章还提供了一些Python代码示例，用于处理图像文件、转换数据格式以及计算目标检测的性能指标。
zzy的aly
82 0
测试专项笔记(一): 通过算法能力接口返回的检测结果完成相关指标的计算（目标检测）
Codelinghu
|
3月前
|
算法
❤️算法笔记❤️-(每日一刷-160、相交链表)
❤️算法笔记❤️-(每日一刷-160、相交链表)
Codelinghu
21 1
zzy的aly
|
3月前
|
数据可视化 搜索推荐 Python
Leecode 刷题笔记之可视化六大排序算法：冒泡、快速、归并、插入、选择、桶排序
这篇文章是关于LeetCode刷题笔记，主要介绍了六大排序算法（冒泡、快速、归并、插入、选择、桶排序）的Python实现及其可视化过程。
zzy的aly
25 0
Codelinghu
|
3月前
|
算法
❤️算法笔记❤️-(每日一刷-83、删除排序链表中的重复项)
❤️算法笔记❤️-(每日一刷-83、删除排序链表中的重复项)
Codelinghu
36 0

热门文章

最新文章

  • 1
    深入解析PID控制算法：从理论到实践的完整指南
  • 2
    猫狗宠物识别系统Python+TensorFlow+人工智能+深度学习+卷积网络算法
  • 3
    利用Python内置函数实现的冒泡排序算法
  • 4
    用 Python 实现快速排序算法。
  • 5
    深入解析图神经网络：Graph Transformer的算法基础与工程实践
  • 6
    【宠物识别系统】Python+卷积神经网络算法+深度学习+人工智能+TensorFlow+图像识别
  • 7
    马特赛特旋转算法：Python的随机模块背后的力量
  • 8
    基于改进遗传优化的BP神经网络金融序列预测算法matlab仿真
  • 9
    基于GA遗传算法的PID控制器参数优化matlab建模与仿真
  • 10
    基于波特图的控制系统设计算法
  • 1
    数据结构与算法 动态规划(启发式搜索、遗传算法、强化学习待完善)
    119
  • 2
    数据结构与算法 回溯
    41
  • 3
    数据结构与算法 分治
    52
  • 4
    数据结构与算法 搜索（下）
    50
  • 5
    数据结构与算法 搜索（上）
    38
  • 6
    数据结构与算法 搜索
    54
  • 7
    数据结构与算法 排序（下）
    69
  • 8
    数据结构与算法 排序（上）
    63
  • 9
    数据结构与算法 图
    37
  • 10
    数据结构与算法 树（B树，B+树，红黑树待完善）
    69

    • 相关课程

    更多
  • 智能运维赛（复赛）：利用数据和算法，快速定位系统异常并进行根因分析
  • 智能创作赛（复赛）：相册应用中的视频故事生成算法介绍
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • 数据+算法定义新世界
  • 袋鼠云基于实时计算的反黄牛算法
  • Alink：基于Apache Flink的算法平台

    • 相关实验场景

    更多
  • 使用Swing算法实现商品推荐
  • RSA密码算法设计与实现
  • RSA非对称加密算法
  • 欧拉图的构造性证明与算法实现
  • 推荐系统入门之使用ALS算法实现打分预测
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月