【数据结构】Java实现常用数据结构

最新推荐文章于 2024-06-28 13:58:08 发布
最新推荐文章于 2024-06-28 13:58:08 发布
阅读量909 收藏
点赞数
分类专栏： # 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41864648/article/details/108599854
版权
【数据结构】Java算法基础一、前言KMP算法汉诺塔八皇后（分治算法）马踏棋盘算法（骑士周游问题）图的深度优先算法+贪心算法优化第一章、稀疏数组和队列1.1 稀疏数组基本介绍当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。稀疏数组的处理方法是:记录数组一共有几行几列，有多少个有效值把具有不同值的有效元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模package zy.code.sparsearray;/** * 稀
摘要由CSDN通过智能技术生成

【数据结构】Java算法基础

一、前言

KMP算法

汉诺塔

八皇后（分治算法）

马踏棋盘算法（骑士周游问题）图的深度优先算法+贪心算法优化

第一章、稀疏数组和队列

1.1 稀疏数组

基本介绍

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

稀疏数组的处理方法是:

  1. 记录数组一共有几行几列，有多少个有效值

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

image-20200722111428966 image-20200722112156194 image-20200722113436031 
package zy.code.sparsearray;

/**
 * 稀疏数组
 */
public class SparseArray {
   

    public static void main(String[] args) {
   
        //创建一个原始二维数组
        // 11 *11 的棋盘大小，1表示黑棋子，2表示蓝棋子
        int chessArr[][] = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        chessArr[4][5] = 2;

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

        //计算有效值
        int val = 0;
        for (int i=0; i<11;i++){
   
            for (int j=0;j<11;j++){
   
                if (chessArr[i][j] != 0){
   
                    val++;
                }
            }
        }
        System.out.printf("原来二维有效值有 %d 个\n",val);
        
/**
 * 二维数组 转 稀疏数组的思路
 * 1. 遍历  原始的二维数组，得到有效数据的个数 sum
 * 2. 根据sum 就可以创建 稀疏数组 sparseArr   int[sum + 1] [3]。加一是因为第一列放的是原二维数组有几行几列、几个有效值。
 * 3. 将二维数组的有效数据数据存入到 稀疏数组
 */
        //创建稀疏数组
        int spareArr[][] = new int[val+1][3];
        spareArr[0][0] = 11;
        spareArr[0][1] = 11;
        spareArr[0][2] = val;

        //定义一个稀疏数组的行计数器
        int spare_row = 0;
        for (int i = 0; i<11; i++){
   
            for (int j = 0; j <11; j++){
   
                if (chessArr[i][j] != 0){
   
                    spare_row++;
                    spareArr[spare_row][0] = i;
                    spareArr[spare_row][1] = j;
                    spareArr[spare_row][2] = chessArr[i][j];
                }
            }
        }
        // 遍历稀疏数组
        System.out.println("转换后的稀疏数组为：");
        for (int i = 0; i < spareArr.length; i ++){
   
            System.out.printf("%d\t%d\t%d\t\n",spareArr[i][0],spareArr[i][1],spareArr[i][2]);
        }

        System.out.println();


        /**
         * 稀疏数组 转 原始的二维数组的思路
         *
         * 1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组大小，比如上面的  chessArr2 = int [11][11]
         * 2. 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.
         */
        int row_count = spareArr[0][0];
        int column_count = spareArr[0][1];
        int chessArr_val = spareArr[0][2];
        //创建原数组大小
        int chessArr2[][] = new int[row_count][column_count];
        //遍历稀疏数组并赋值
        for (int i = 1; i<= chessArr_val; i ++){
   
             int r = spareArr[i][0];
             int c = spareArr[i][1];
             int v = spareArr[i][2];
             chessArr2[r][c] = v;
        }

        //输出还原数组
        System.out.println("原来的二维数组为：");
        for (int[] row : chessArr2){
   
            for (int data : row){
   
                System.out.printf("%d\t",data);
            }
            System.out.println();;
        }
    }
}

作业：

  • 抽取出普通二维数组与稀疏数组的转换，封装成工具类
  • 使用 I/O 流基础，序列化对象保存到磁盘文件中
/**
* 抽取普通二维数组与稀疏数组的转换。封装成工具方法
 */
public class SpareArryUtil {
   


    /**
     * 普通二维数组转换为稀疏数组
     */
    public static int[][] arrayTYoSpare(int[][] chessArr){
   
        //计算有效值
        int val = 0;
        for (int i=0; i<11;i++){
   
            for (int j=0;j<11;j++){
   
                if (chessArr[i][j] != 0){
   
                    val++;
                }
            }
        }

        //创建稀疏数组
        int spareArr[][] = new int[val+1][3];
        spareArr[0][0] = 11;
        spareArr[0][1] = 11;
        spareArr[0][2] = val;
        //定义一个稀疏数组的行计数器
        int spare_row = 0;
        for (int i = 0; i<11; i++){
   
            for (int j = 0; j <11; j++){
   
                if (chessArr[i][j] != 0){
   
                    spare_row++;
                    spareArr[spare_row][0] = i;
                    spareArr[spare_row][1] = j;
                    spareArr[spare_row][2] = chessArr[i][j];
                }
            }
        }


        return spareArr;
    }


    /**
     * 稀疏数组还原回普通二维数组
     */
    public static int[][] spareToArray(int[][] spareArr){
   

        int row_count = spareArr[0][0];
        int column_count = spareArr[0][1];
        int chessArr_val = spareArr[0][2];
        //创建原数组大小
        int chessArr2[][] = new int[row_count][column_count];
        //遍历稀疏数组并赋值
        for (int i = 1; i<= chessArr_val; i ++){
   
            int r = spareArr[i][0];
            int c = spareArr[i][1];
            int v = spareArr[i][2];
            chessArr2[r][c] = v;
        }

        return chessArr2;
    }
}


/**
 * 将对象序列化到磁盘文件
 */
public class SerializeObjToFile {
   
    public static void main(String[] args) throws IOException {
   
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("G:\\test\\data\\spareArr.data"));

        int chessArr[][] = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        chessArr[4][5] = 2;
        int[][] spareArr = SpareArryUtil.arrayTYoSpare(chessArr);
        int[][] chessArr2 = SpareArryUtil.spareToArray(spareArr);
        /**
         * 序列化对象到磁盘
         */
        oos.writeObject(spareArr);
        oos.flush();
        oos.close();

    }

}

1.2 数组模拟队列

（1）队列的数据结构：

当我们将数据存入队列时称为 ”addQueue”，addQueue 的处理需要有两个步骤：

  1. 尾指针后移：rear = rear+1 , 当 front == rear 【空】

  2. 判断尾指针 rear 小于数组队列的最大下标 [ maxSize - 1 ]，则将数据存入 rear所指的数组元素中，否则无法存入数据。

    注意：

    1. rear == maxSize - 1; [ 队列满 ]

    2. rear 是队列最后 [含]

    3. front 是队列最前元素 [不含]

image-20200722140953608 
class ArrayQueue(arrMaxSize: Int) {
   
  val maxSize: Int = arrMaxSize //队列的最大容量，等于数组的最大容量
  val array = new Array[Int](arrMaxSize) //数组的最大容量
  var front: Int = -1 //队首初始值
  var rear: Int = -1 //队尾初始值
}

 //初始化队列
 val queue = new ArrayQueue(3)

代码实现：

public class ArrayQueueDemo {
   

    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());
                    }
                    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[] arr; // 该数据用于存放数据, 模拟队列

    // 创建队列的构造器
    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];
    }
}

数组模拟队列的问题：

  • 假溢出
image-20200722150711261

1.3 循环队列

优化思路如下:

  1. front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
  • front 的初始值 = 0
  1. rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
  • rear 的初始值 = 0
  1. 当队列满时，条件是 (rear + 1) % maxSize == front 【满】
  2. 对队列为空的条件， rear == front 【空】
  3. 当我们这样分析， 队列中有效的数据的个数 count == (rear + maxSize - front) % maxSize // rear = 1 front = 0
  4. 我们就可以在原来的队列上修改得到，一个环形队列
image-20200722161228463

代码实现：

package zy.code.queue;


/**
 * 数组实现循环队列
 */
public class CircleArrayQueue {
   

    private int maxSize;//最大容量为数组大小
    private int front;//队首指向第一个元素，初始值为0
    private int rear;//队尾指向最后一个元素的下一个位置，初始值为0
    private int[] arr;//存储队列元素

    /**
     * 队列初始化
     * @param maxSize
     */
    public CircleArrayQueue(int maxSize) {
   
        this.maxSize = maxSize;
        this.front = 0;
        this.rear = 0;
        this.arr = new int[maxSize];
    }

    /**
     * 判断是否已满
     */
    public boolean isFull(){
   
        if ((rear + 1) % maxSize == front) {
   
            return true;
        }
        return false;
    }

    /**
     * 判空
     */
    public boolean isEmpty(){
   
        if (this.front == this.rear){
   
            return true;
        }
        return false;
    }

    /**
     * 添加数据
     */
    public void addQueue(int n){
   
        if (isFull()){
   
            System.out.println("队列满，不能添加数据。");
            return;
        }

        arr[rear] = n;//添加元素
        rear = (rear + 1) % maxSize;//指针后移
    }

    /**
     * 取数据
     */
    public int getQueue(){
   
        if(isEmpty()){
   
            throw new RuntimeException("队列空，不能取数据。");
        }
        // 先把队头元素保存在一个临时变量
        // 然后对头指针后移
        // 返回临时变量
        int temp = arr[front];
        front = (front + 1 ) % maxSize;
        return temp;
    }

    /**
     * 显示队列数据
     */
    public void showQueue(){
   
        if(isEmpty()){
   
            System.out.println("队列空，没有数据可以显示。");
        }

        //怎么遍历数组？
        int count = size();
        for (int i = front; i < front + count; i++){
   
            //从队头开始遍历，真正的下标可能会超出数组大小，必须转换为循环后的真正下标
            int index = i % maxSize;
            int val = arr[index];
            System.out.printf("arr[%d] = %d\n",index,val);
        }

    }


    /**
     * 取出队列有效元素的个数
     */
    public int size(){
   
        return (rear + maxSize - front) % maxSize;
    }


    /**
     * 查看第一个元素
     */
    public int headQueue(){
   
        if(isEmpty()){
   
            throw new RuntimeException("队列空，不能取数据。");
        }
        return arr[front];
    }

}



package zy.code.queue;

import java.util.Scanner;

/**
 * 测试循环队列
 */
public class CircleQueueTest {
   
    public static void main(String[] args) {
   
        //测试一把
        //创建一个队列
        CircleArrayQueue queue = new CircleArrayQueue(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());
                    }
                    break;
                case 'e': //退出
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }

        System.out.println("程序退出~~");
    }



}

第二章、链表

2.1 链表的介绍

image-20200723142750246

2.2 单链表

单链表是单方向的

image-20200723144237679 

/**
 * 单链表结点的结构定义
 */
public 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;

    }

    @Override
    public String toString() {
   
        // 不打印 next，只打印该节点的data信息
        return  "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
    }
}

/**
 * 单链表
 */
public class SingleLinkedList {
   

    private HeroNode head = new HeroNode(0,"","");
    //返回头节点
    public HeroNode getHead() {
   
        return head;
    }


    /**
     * 删除一个节点
     * 1. 遍历节点找到要删除的节点编号
     * 2. 要得到待删除节点的前一个节点，让 fore.next ---> temp.next
     */
    public void delete(int no){
   
        if (head.next == null){
   
            System.out.println("链表为空，不能更新....");
            return;
        }
        HeroNode temp = head.next;
        HeroNode fore = head;//指向temp的前一个节点
        boolean flag = false; //是否找到要删除的结点的标志
        while (temp != null){
   
            if(temp.no == no){
   
                flag = true;
                break;
            }
            // 没有找到也没有到尾部，指针后移
            fore = temp;
            temp = temp.next;
        }

        if (flag){
   
            // 找到匹配节点temp，删除
            fore.next = temp.next;
        }else{
   
            System.out.printf("删除失败，没有匹配  %d 号的节点\n",no);
        }

    }


    /**
     * 更新结点
     */
    public void update(HeroNode heroNode){
   
        if (head.next == null){
   
            System.out.println("链表为空，不能更新....");
            return;
        }
        HeroNode temp = head.next;
        boolean flag = false;
最低0.47元/天 解锁文章
_popo_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java实现常用数据结构和算法.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
常用数据结构及其算法的Java实现
06-17
本文将深入探讨一些常用的数据结构及其对应的Java实现，并结合"预算法"这一概念，为你的编程实践提供理论支持。 首先，我们要理解数据结构。数据结构是组织、管理、存储和检索数据的方式，它为数据提供了逻辑上的...
Java数据结构的实现
m0_43405302的博客
10-28 1797
一、Java数据结构 众所周知，数据结构是算法的基础。从事程序设计工作的人来说，我们在日常编程的编程过程中，我们都会有意无意的接触到一些数据结构和算法的知识。为了能够更好的对于程序进行优化，所以数据结构相关的知识必须有所了解。学完了Java面向对象的基础知识后，我们可以更深入的了解Java数据结构算法的基础知识，进而提高我们的编程思维和解决问题的思路。接下来，我将介绍Java数据结构相关的知识。 二、Java数组 Java数据是我们入门学的第一个最基本的数据结构，这是一个常用的线性储存结构。 1、初始化数组
数据结构：八种数据结构大全
緑水長流*z
07-29 20万+
数据结构 1.1 数据结构概述 数据结构是计算机存储、组织数据的方式；通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能；常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等； 1.2 数据结构的分类 1.2.1 排列方式 1）集合 集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系； 2）线性结构 线性
Java 中常见的数据结构算法及其应用
微笑听雨
06-28 646
在Java编程中，选择合适的数据结构对程序的性能和可维护性至关重要。本文将详细介绍Java中常见的数据结构及其应用场景。
力扣刷题(JAVA)常用数据结构总结
击水三千里的专栏
01-17 1409
力扣刷题常用数据结构总结
java中常见数据结构
gengpengfeiazxl的博客
04-18 4479
java中常见的数据结构
java常见的8种数据结构
weixin_51326478的博客
10-31 6499
红黑树的创建：节点的初始颜色为红色。2.2。
JAVA常见的8种数据结构
m554062212的博客
11-18 1万+
java中常见的8种数据结构，Array、Linked List、Stark、Hash、Queue、Tree、Heap、Graph
Java基础---常用类大全以及各数据结构的方法大全
tq02的博客
07-15 2445
不含讲解，包括了Java语言和Java数据结构所需要学的类和方法，趋向于笔记，可以复习哦。记录了Math类、Random类、String类、时间类、数组类等
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
Java中常用数据结构及方法
Liususiu的秃头日记
12-18 2570
记录总结Java中常用的结构和方法。
【入门必备】Java数据结构详解
weixin_62633072的博客
03-15 8704
数据结构入门必看！本文整理了稀疏数组、队列、链表、栈这几种经典的数据结构。快来一起敲代码吧！！！
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
【创新未发表】Matlab实现蛇群优化算法SO-Kmean-Transformer-LSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现北方苍鹰优化算法NGO-Kmean-Transformer-LSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现蝗虫优化算法GOA-Kmean-Transformer-BiLSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现蛇群优化算法SO-Kmean-Transformer-LSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【SCI一区】Matlab实现金豺优化算法GJO-CNN-LSTM-Attention的风电功率预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
Java实现的数据结构与算法详解
书中详细介绍了如何使用Java语言来理解和实现各种数据结构与算法，旨在帮助读者系统地建立起数据结构和算法的基础知识体系。" 在第一章"算法及其复杂度"中，作者首先引入了算法的概念，通过一系列生动的例子，如过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_popo_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值