Java数据结构与算法一1-阿里云开发者社区

整体框架：

算法先简单 ==》做复杂，把复杂算法拆分成简单的问题 ==》解决问题

经典算法

1 字符串匹配

str1 = “nihdisoadisaoidhi” str2=“aoi”

str1 是否包含有 str2

暴力破解
KMP算法

2 汉诺塔游戏

将A塔的所有圆盘移动到C塔。并且规定小盘上不能有大盘，三根柱子之间一次只能移动一个圆盘

分治算法

3 八皇后问题（92种）

在一个8 × 8 的国际象棋摆放 8个皇后，使其不能互相攻击

任意两个皇后都不能处于同一列、同一行或者同一斜线上，问有多少种摆法

回溯算法

4 马踏棋盘算法（骑士周游）

马放在 8 × 8 的国际象棋的棋盘中，board[0~7] [0~7] 某一个格中，马走日，要求每个格子只进入一次，走完64个格子

使用图的深度优化遍历算法 (DFS) + 贪心算法优化

数据结构与算法简介

算法是程序的灵魂
程序使用内存计算框架（Spark）和缓存技术（Redis）优化程序

数据结构与算法的关系

数据结构（Data Structure）：研究组织数据方式的学科
程序 = 算法 + 数据结构
结合实际生活问题

实际编程遇到的问题

约瑟夫问题（丢手帕问题）：单向环形链表【数据结构】
修路问题：最小生成树（普利姆算法）
最短路径问题：弗洛伊德算法
汉诺塔：分治算法
八皇后问题：回溯算法

数据结构

数据结构：线性结构和非线性结构

线性结构

元素之间存在一对一的线性关系

存储结构

顺序存储结构：顺序存储的线性表为顺序表，存储元素是连续的

链式存储结构：链式存储的线性表为链表，链表中元素不一定连续，元素节点中存放数据元素以及相邻元素的地址信息

常见的线性结构：数据、队列、链表、栈

非线性结构

非线性结构：二维数组、多维数组、广义表、树结构、图结构

稀疏数组和队列

稀疏数组

当一个数组中大部分元素为 0 ，或者为同一个值的数组时，可以使用稀疏数组来保存该数组

处理方法：

记录数组一共有几行几列，有多少个不同的值
把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

原始二维数组 ==》稀疏数组

应用实例

使用稀疏数组，来保留类似前面的二维数组
把稀疏数组存盘，并且可以重新恢复到原来的二维数组

二维数组==>稀疏数组：

遍历原始的二维数组，得到有效数据的个数 sum

根据sum 就可以创建稀疏数组 sparseArr int[sum + 1] [3]

将二维数组的有效数据数据存入到稀疏数组

稀疏数组==>原始的二维数组：

先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [ 11 ] [ 11 ]

在读取稀疏数组后几行的数据，并赋给原始的二维数组即可

package com.sparse;
/**
 * @author Kcs 2022/8/5
 */
public class SparseArray {
    public static void main(String[] args) {
        //创建一个原始的数组 11 * 11
        // 0 ：无棋子 ，1：黑子 ，2：白子
        int chessArr[][] = new int[11][11];
        //黑子位置
        chessArr[1][2] = 1;
        // 白子位置
        chessArr[2][3] = 2;
        chessArr[6][5] = 2;
        // 遍历原始数组
        System.out.println("原始的二维数组：");
        for (int[] row : chessArr) {
            //每一个元素数据
            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 (chessArr[i][j] != 0) {
                    sum++;
                }
            }
        }
        //2创建对应的稀疏数组
        int sparseArr[][] = new int[sum + 1][3];
        // 稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;
        // 遍历二维数组，将非零的值存放到sparseArr中
        //用于记录非零的元素个数
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j] != 0) {
                    count++;
                    //列位置
                    sparseArr[count][0] =i;
                    //行位置
                    sparseArr[count][1] =j;
                    sparseArr[count][2] =chessArr[i][j];
                }
            }
        }
        //输出稀疏数组的格式
        System.out.println();
        System.out.println("稀疏数组：");
        System.out.printf("%s\t%s\t%s\n","列","行","值");
        for (int i = 0; i < sparseArr.length; i++) {
            System.out.printf("%d\t%d\t%d\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }
        //稀疏数组 转 原始数组
        //1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
        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();
        }
    }
}

队列

有序列表，用数组或链表来实现
先进先出：存入队列的数据，要先取出

front 随着数据出队而改变
rear 随着数据入队而改变

队列操作

队空条件：front == rear == null，rear + 1
队满条件：rear = maxSize - 1，则继续入队，否则队满：rear = maxSize - 1

import java.util.Scanner;
/**
 * @author Kcs 2022/8/7
 */
public class ArrayQueueDemo1 {
    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.println("取出的数据是：" + res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                //查看队列头数据
                case 'h':
                    try {
                        int res = queue.headQueue();
                        System.out.println("队列头的数据：" + res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                //程序退出
                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[] array;
    /**
     * 构造器
     */
    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        array = 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++;
        array[rear] = n;
    }
    /**
     * 出队操作
     */
    public int getQueue() {
        //判断是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列为空，没有数据可取");
        }
        // front后移
        front++;
        return array[front];
    }
    /**
     * 显示队列数据
     */
    public void showQueue() {
        // 遍历队列
        if (isEmpty()) {
            System.out.println("队列为空，没有数据！！");
            return;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.printf("array[%d] = %d\n", i, array[i]);
        }
    }
    /**
     * 显示队列头部数据,不是取数据
     */
    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，没有数据~~");
        }
        return array[front + 1];
    }
}

此时把内容取出完，但也不能添加入数据，还在占用空间

环形队列

分析

front 变量的含义做一个调整：front 指向队列的第一个元素，array[front] ，front 的初始值 = 0

rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置，空出一个空间作为约定，rear 初始值 = 0

队列满条件：(rear + 1) % maxSize = front

队列为空的条件：rear = front

队列中有效数据的个数：( rear +maxSize - front ) % maxSize // rear =1 , front = 0

import java.util.Scanner;
/**
 * @author Kcs 2022/8/7
 */
public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        //创建一个环形队列对象
        // 队列有效数据最多只有3个
        CircleQueue queue = new CircleQueue(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.println("取出的数据是：" + res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                //查看队列头数据
                case 'h':
                    try {
                        int res = queue.headQueue();
                        System.out.println("队列头的数据：" + res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                //程序退出
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}
//使用数据模拟队列编写一个ArrayQueue类
class CircleQueue {
    /**
     * 表示数组的最大容量
     */
    private int maxSize;
    /**
     * front 指向队列的第一个元素，array[front] ，front 的初始值 = 0
     */
    private int front;
    /**
     * 1. rear 指向队列的最后一个元素的后一个位置，空出一个空间作为约定，rear 初始值 = 0
     */
    private int rear;
    /**
     * 存放数据数组
     */
    private int[] array;
    /**
     * 构造器
     */
    public CircleQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        array = new int[maxSize];
    }
    /**
     * 判断队列是否满 (rear + 1) % maxSize == front
     */
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }
    /**
     * 判断队列是否为空 rear =  front
     */
    public boolean isEmpty() {
        return rear == front;
    }
    /**
     * 入队操作,添加数据
     */
    public void addQueue(int n) {
        //判断是否队满
        if (isFull()) {
            System.out.println("队满，不可以添加数据");
            return;
        }
        // 直接将数据加入
        array[rear] = n;
        //将rear后移，取模，判断队满,防止地址溢出
        rear = (rear + 1) % maxSize;
    }
    /**
     * 出队操作，取数据
     */
    public int getQueue() {
        //判断是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列为空，没有数据可取");
        }
        // front直接指向队列的第一个元素
        //1. front 对应的值保存到临时变量
        int value = array[front];
        //2. front 后移,取模，防止地址溢出
        front = (front + 1) % maxSize;
        //3.将临时保存的变量返回
        return value;
    }
    /**
     * 显示队列数据
     */
    public void showQueue() {
        // 遍历队列
        if (isEmpty()) {
            System.out.println("队列为空，没有数据！！");
            return;
        }
        //从front开始遍历，有效个数:( rear +maxSize - front ) % maxSize
        for (int i = front; i < front + effectiveValue(); i++) {
            System.out.printf("array[%d] = %d\n", i % maxSize, array[i % maxSize]);
        }
    }
    /**
     * 求出当前队列有效数据的个数
     */
    public int effectiveValue() {
        return (rear + maxSize - front) % maxSize;
    }
    /**
     * 显示队列头部数据,不是取数据
     */
    public int headQueue() {
        //判断为空
        if (isEmpty()) {
            throw new RuntimeException("队列为空，没有数据~~");
        }
        return array[front];
    }
}

链表Linked List

带头节点的链表
没有头节点的链表

有序的列表，链表以节点方式存储，链式存储
每个节点包含 data 域，next 域：指向下一个节点
链表的节点之间不一定是连续的

单链表

带头结点（单链表）逻辑结构示意图

内存布局图

水浒传英雄排行榜管理

分析

完成CRUD功能
添加英雄方式

直接添加到链表尾部
根据排名将英雄插入到指定位置（英雄存在，则无效）

单链表创建示意图

单链表添加节点

先创建一个head头节点，单链表的头
每添加一个节点，就直接加入到链表的最后遍历

遍历

通过一个变量遍历，帮助遍历整个链表

package com.linkedlist;
/**
 * @author Kcs 2022/8/7
 */
public class SingleLinkedListDemo {
    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.list();
    }
}
/**
 * 定义一个SingleLinkedList管理英雄
 */
class SingleLinkedList {
    /**
     * 初始化一个头节点
     */
    private HeroNode head = new HeroNode(0, "", "");
    /**
     * 添加节点到单向链表
     * 找当前链表的最后节点
     * 最后节点的next 指向新的节点
     */
    public void add(HeroNode heroNode) {
        //添加一个临时变量temp
        HeroNode temp = head;
        //遍历链表，找到最后
        while (true) {
            //找到链表的最后
            if (temp.next == null) {
                break;
            }
            //如果没有找到，temp后移
            temp = temp.next;
        }
        //退出循坏，temp就指向链表的最后
        temp.next = heroNode;
    }
    //显示链表,遍历
    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 = temp.next;
        }
    }
}
/**
 * 定义一个HeroNode，每个heroNode对象就是一个节点
 */
class HeroNode {
    /**
     * 编号
     */
    public int no;
    /**
     * 姓名
     */
    public String name;
    /**
     * 昵称
     */
    public String nickname;
    /**
     * 指向下一个节点
     */
    public 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;
    }
    /**
     * 重写toString
     */
    @Override
    public String toString() {
        return "Heroes{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

以上代码，添加的顺序改变是无序的，就按添加的代码进行排序（也就是第一种方式）

方式二添加英雄方式

根据排名（编号）将英雄插入到指定位置（英雄存在，则无效）

分析

首先找到新添加的节点的位置，通过辅助变量（指针），通过遍历

新的节点.next = temp.next

temp.next = 新的接点

package com.linkedlist;
import com.sun.xml.internal.ws.util.StreamUtils;
/**
 * @author Kcs 2022/8/7
 */
public class SingleLinkedListDemo {
    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.addHeroByOrder(hero4);
        singleLinkedList.addHeroByOrder(hero1);
        singleLinkedList.addHeroByOrder(hero3);
        singleLinkedList.addHeroByOrder(hero2);
        //显示
        singleLinkedList.list();
    }
}
/**
 * 定义一个SingleLinkedList管理英雄
 */
class SingleLinkedList {
    /**
     * 初始化一个头节点
     */
    private HeroNode head = new HeroNode(0, "", "");
    /**
     * 根据排名(编号)将英雄插入到指定位置（英雄存在，则无效）
     */
    public void addHeroByOrder(HeroNode heroNode) {
        //设置一个临时遍历，找到要添加的位置 ，temp位于添加位置的前一个节点，否则插入失败
        HeroNode temp = head;
        //标志编号是否存在
        boolean flag = false;
        while (true) {
            //到链表的最后，为空
            if (temp.next == null) {
                break;
            }
            //确定添加位置
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                //添加的编号已存在，无效
                flag = true;
                break;
            }
            //后移，继续遍历
            temp = temp.next;
        }
        //判断flag
        if (flag) {
            //已存在编号
            System.out.printf("该英雄编号%d已存在,不能添加\n", heroNode.no);
        } else {
            //插入链表中，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }
    /**
     * 显示链表,遍历
     */
    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 = temp.next;
        }
    }
}
/**
 * 定义一个HeroNode，每个heroNode对象就是一个节点
 */
class HeroNode {
    /**
     * 编号
     */
    public int no;
    /**
     * 姓名
     */
    public String name;
    /**
     * 昵称
     */
    public String nickname;
    /**
     * 指向下一个节点
     */
    public 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;
    }
    /**
     * 重写toString
     */
    @Override
    public String toString() {
        return "Heroes{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

单链表修改节点

修改英雄的信息

/**
 * 修改节点信息，根据编号修改，编号不能修改
 * 根据newHeroNode 的 no 来修改信息
 */
public void update(HeroNode updateHeroNode) {
    //判断链表是否空
    if (head.next == null) {
        System.out.println("链表为空！！！");
        return;
    }
    //找到修改的节点，根据no
    HeroNode temp = head.next;
    //判断是否找到节点
    boolean flag = false;
    while (true) {
        if (temp == null) {
            break;
        }
        //找到
        if (temp.no == updateHeroNode.no) {
            flag = true;
            break;
        }
        //后移
        temp = temp.next;
    }
    //判断是否为要修改的节点
    if (flag) {
        temp.name = updateHeroNode.name;
        temp.nickname = updateHeroNode.nickname;
    } else {
        //没有找到
        System.out.printf("没有找到编号 %d的信息，不能修改\n", updateHeroNode.no);
    }
}

单链表删除节点

找到要删除节点的前一个节点temp
temp.next = temp.next.next （跳过的节点，就是直接删除掉，被垃圾回收了）

/**
 * 删除节点，不能改变head 节点，通过temp找到待删除的节点的前一个节点
 * temp.next.no 与删除节点的no比较
 */
public void delete(int no) {
    HeroNode temp = head;
    //标志是否找到待删除的节点
    boolean flag = false;
    while (true) {
        //temp到链表最后
        if (temp.next == null) {
            break;
        }
        if (temp.next.no == no) {
            //找到要删除节点的前一个节点
            flag = true;
            break;
        }
        //后移
        temp = temp.next;
    }
    //判断flag
    if (flag) {
        //找到 ，删除
        temp.next = temp.next.next;
    } else {
        System.out.println("要删除的节点%d不存在\n" + no);
    }
}

单链表查询节点

/**
 * 查找英雄信息
 */
public void search(int no) {
    //判断链表是否为空
    HeroNode temp = head;
    if (temp.next == null) {
        System.out.println("链表为空！！！");
        return;
    }
    //判断是否找到节点
    boolean flag = false;
    while (true) {
        //temp到链表最后
        if (temp.next == null) {
            break;
        }
        if (temp.no == no) {
            //找到要查找节点的前一个节点
            flag = true;
            break;
        }
        //后移
        temp = temp.next;
    }
    //判断flag
    if (flag) {
        //查找到
        System.out.println(temp);
    } else {
        System.out.println("要查找的节点%d不存在\n" + no);
    }
}

单链表面试题

单链表（节点）反转

定义一个节点 reverse = new HeroNode（）

从头到尾遍历原来的链表，每遍历一个节点，并放在新的链表的最前端，最前端的next域指向上一个最前端的地方，原来的链表的第一个就没有next

原来的链表的 head.next = reverseHead.next

//将链表反转
public static void reverseList(HeroNode head) {
    //如果链表为空，或者只有一个节点，无须反转，直接返回
    if (head.next == null || head.next.next == null) {
        return;
    }
    //辅助变量
    HeroNode cur = head.next;
    //指向当前节点（cur节点）的下一个节点，
    HeroNode next = null;
    HeroNode reverseHead = new HeroNode(0, "", "");
    //遍历原来的链表,每遍历一个新的节点，就将其取出，放在新的链表reverseHead 的最前端
    while (cur != null) {
        //暂存当前节点的下一个节点
        next = cur.next;
        //将cur的下一个节点的指向新的链表的最前端
        cur.next = reverseHead.next;
        //cur链接到新的链表上
        reverseHead.next = cur;
        //cur后移,不能是cur.next 因为反转后的next以及不存在了
        cur = next;
    }
    //将原始链表的head.next指向reverseHead.next 实现反转
    head.next = reverseHead.next;
}

Java数据结构与算法一1

经典算法

1 字符串匹配

2 汉诺塔游戏

3 八皇后问题（92种）

4 马踏棋盘算法（骑士周游）

数据结构与算法简介

数据结构与算法的关系

实际编程遇到的问题

数据结构

线性结构

非线性结构

稀疏数组和队列

稀疏数组

应用实例

队列

队列操作

环形队列

链表Linked List

单链表

单链表添加节点

单链表修改节点

单链表删除节点

单链表查询节点

单链表面试题

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java数据结构与算法 一1

经典算法

1 字符串匹配

2 汉诺塔游戏

3 八皇后问题（92种）

4 马踏棋盘算法（骑士周游）

数据结构与算法简介

数据结构与算法的关系

实际编程遇到的问题

数据结构

线性结构

非线性结构

稀疏数组和队列

稀疏数组

应用实例

队列

队列操作

环形队列

链表Linked List

单链表

单链表添加节点

单链表修改节点

单链表删除节点

单链表查询节点

单链表面试题

热门文章

最新文章

相关课程

相关电子书

相关实验场景

Java数据结构与算法一1