每日一省之—基于双数组和二分查找法实现符号表(或者字典)

FineReport V11.0安装避坑指南:从下载到激活的完整流程(附百度网盘链接) 本文提供FineReport V11.0从下载、安装到激活的完整避坑指南。详细解析了部署前的环境准备、安装过程中的JVM内存等核心配置、激活流程以及安装后的优化与常见问题排查,旨在帮助用户一次部署成功,确保企业级报表平台的稳定运行。 阅读详情

今天想要复习的数据结构是符号表,也称为字典。可能说到这里大家还是没明白我要复习一种什么样的数据结构。此时我不得不承认本人文笔真的是不太好。所以,还是说的更加具体点吧,这种数据结构的功能对使用者来讲,与JDK中的HashMap极其相似:可以按键值对进行数据的存储,然后根据键可以查找到与其对应的值。

只不过,我这里讲的符号表在底层实现上:存储数据利用的是两个大小相等的数组。其中一个数组存储键,另一个数组存储对应键的值。然后,在插入键值对或者根据键进行查找的时候,为了提高效率,又利用了很普通的二分查找法。说到二分查找法,对这种算法还有印象的同学应该立刻猜测到,这个存储键的数组中存储的键一定是有序的。对!能想到这,想必下面的代码要看懂是一件非常容易的事情。当然啦,在生产环境中使用它代替HashMap等数据结构可就值得商榷了,为什么,当然是效率问题啦。why? 鉴于个人理论性不强,就不在这里造次了。有兴趣的大家自己多思考啦,总之,思考有百利而无一害。有想法朋友也不妨在下面留言咯。

好了,废话不多说了,直接看代码吧。代码中有注释,我就不唠叨啦。


import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Queue;

/**
 * 一个基于二分查找法的字典类,可以根据键值对进行存储或根据键进行查询
 */
public class BinarySearchBasedDictionary<K extends Comparable<K>, V> {

    /**
     * keys数组和values数组的初始大小(也即数组长度)
     */
    private static final int INITIAL_CAPACITY = 4;
    /**
     * 存储键的数组
     */
    private K[] keys;
    /**
     * 存储值的数组
     */
    private V[] values;
    /**
     * keys数组或者values数组中存储的元素的数目
     */
    private int N = 0;

    /**
     * 初始化存储键和值得数组的大小
     * 
     * @param initialCapacity
     */
    public BinarySearchBasedDictionary(int initialCapacity) {
        keys = (K[]) new Comparable[INITIAL_CAPACITY];
        values = (V[]) new Object[INITIAL_CAPACITY];
    }

    public BinarySearchBasedDictionary() {
        this(INITIAL_CAPACITY);
    }

    /**
     * 求存储的键值对的数量
     * 
     * @return
     */
    public int size() {
        return N;
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean contains(K key) {
        if (key == null) {
            throw new NullPointerException("key不能为空!!!");
        }
        return get(key) != null;
    }

    /**
     * 根据key查找相应的值
     * 
     * @param key
     * @return
     */
    public V get(K key) {
        if (key == null) {
            throw new NullPointerException("key不能为空!!!");
        }
        if (isEmpty()) {
            return null;
        }
        int i = rank(key);
        if (i < N && keys[i].compareTo(key) == 0) {
            return values[i];
        }
        return null;

    }

    /**
     * 计算指定的键存在于数组中的哪一个位置,此处用的是二分查找法。 因为存入数组中的键是在数组中进行有序存储的。
     * 
     * @param key
     * @return
     */
    public int rank(K key) {
        if (key == null) {
            throw new NullPointerException("key不能为空!!!");
        }
        int low = 0, high = N - 1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            int comp = key.compareTo(keys[mid]);
            if (comp < 0) {
                high = mid - 1;
            } else if (comp > 0) {
                low = mid + 1;
            } else {
                return mid;
            }
        }

        return low;
    }

    public void put(K key, V value) {

        if (key == null) {
            throw new NullPointerException("key不能为空!!!");
        }

        if (value == null) {
            remove(key);
            return;
        }

        int i = rank(key);

        /*
         * 倘若对应的键已经存在,则替换旧值为新值
         */
        if (i < N && keys[i].compareTo(key) == 0) {
            values[i] = value;
            return;
        }

        /*
         * 空间不够,则进行扩容
         */
        if (N == keys.length)
            resize(2 * keys.length);

        for (int j = N; j > i; j--) {
            keys[j] = keys[j - 1];
            values[j] = values[j - 1];
        }
        keys[i] = key;
        values[i] = value;
        N++;

        assert check();
    }

    public void remove(K key) {
        if (key == null)
            throw new NullPointerException("key不能为空!!!");
        if (isEmpty())
            return;

        // 计算键所在的位置
        int i = rank(key);

        // 如果不存在该键,直接返回
        if (i == N || keys[i].compareTo(key) != 0) {
            return;
        }

        for (int j = i; j < N - 1; j++) {
            keys[j] = keys[j + 1];
            values[j] = values[j + 1];
        }

        N--;

        keys[N] = null; // 置空, 避免游离
        values[N] = null; // 置空, 避免游离

        // 降低数组容量,避免大量空间空闲
        if (N > 0 && N == keys.length / 4) {
            resize(keys.length / 2);
        }

        assert check();
    }

    private boolean check() {
        return isSorted() && rankCheck();
    }

    /**
     * 判断存储键的数组是否有序
     * 
     * @return
     */
    private boolean isSorted() {
        for (int i = 1; i < size(); i++) {
            if (keys[i].compareTo(keys[i - 1]) < 0) {
                return false;
            }
        }
        return true;
    }

    private boolean rankCheck() {
        for (int i = 0; i < size(); i++) {
            if (i != rank(select(i))) {
                return false;
            }
        }
        for (int i = 0; i < size(); i++) {
            if (keys[i].compareTo(select(rank(keys[i]))) != 0) {
                return false;
            }

        }
        return true;
    }

    public K select(int i) {
        if (i < 0 || i >= N) {
            return null;
        }
        return keys[i];
    }

    /**
     * 重新调整底层数组的大小
     * 
     * @param capacity
     */
    private void resize(int capacity) {
        assert capacity >= N;
        K[] tempk = (K[]) new Comparable[capacity];
        V[] tempv = (V[]) new Object[capacity];
        /*
         * 把已有的元素移植到临时数组中
         */
        for (int i = 0; i < N; i++) {
            tempk[i] = keys[i];
            tempv[i] = values[i];
        }
        /*
         * 用临时数组替换旧的数组,实现扩容
         */
        keys = tempk;
        values = tempv;
    }

    public K min() {
        if (isEmpty()) {
            return null;
        }
        return keys[0];
    }

    public K max() {
        if (isEmpty()) {
            return null;
        }
        return keys[N - 1];
    }

    public K floor(K key) {
        if (key == null) {
            throw new NullPointerException("key不能为空!!!");
        }
        int i = rank(key);
        if (i < N && key.compareTo(keys[i]) == 0) {
            return keys[i];
        }
        if (i == 0) {
            return null;
        } else {
            return keys[i - 1];
        }

    }

    public K ceiling(K key) {
        if (key == null) {
            throw new NullPointerException("key不能为空!!!");
        }
        int i = rank(key);
        if (i == N) {
            return null;
        } else {
            return keys[i];
        }
    }

    public void deleteMin() {
        if (isEmpty()) {
            throw new NoSuchElementException("删除失败!没有任何元素存储其中");
        }
        remove(min());
    }

    public void deleteMax() {
        if (isEmpty()) {
            throw new NoSuchElementException("删除失败!没有任何元素存储其中");
        }
        remove(max());
    }

    public int size(K low, K high) {
        if (low == null) {
            throw new NullPointerException("low不能为空");
        }
        if (high == null) {
            throw new NullPointerException("high不能为空");
        }

        if (low.compareTo(high) > 0) {
            return 0;
        }

        if (contains(high)) {
            return rank(high) - rank(low) + 1;
        } else {
            return rank(high) - rank(low);
        }
    }

    public Iterable<K> keys() {
        return keys(min(), max());
    }

    public Iterable<K> keys(K low, K high) {
        if (low == null) {
            throw new NullPointerException("low不能为空");
        }
        if (high == null) {
            throw new NullPointerException("high不能为空");
        }
        Queue<K> queue = new LinkedList<K>();
        if (low.compareTo(high) > 0) {
            return queue;
        }
        for (int i = rank(low); i < rank(high); i++) {
            queue.offer(keys[i]);
        }
        if (contains(high)) {
            queue.offer(keys[rank(high)]);

        }
        return queue;
    }

     public static void main(String[] args) { 
         BinarySearchBasedDictionary<String, String> map = new BinarySearchBasedDictionary<String, String>();
         map.put("China", "leader");
         map.put("America", "savage");
         map.put("Japan", "dog");
         System.out.println("now this size is: " + map.size());
         map.remove("China");
         map.remove("America");
         System.out.println("now this size is: " + map.size());

        }

}
从生成到检测:全面解析Deepfake技术的演进与对抗策略 本文全面解析了Deepfake技术的演进与对抗策略,从GAN生成技术到先进的检测手段,探讨了其在娱乐与安全领域的双重影响。文章详细介绍了Deepfake的核心原理、技术迭代关键节点以及最新的检测方法,揭示了AI生成与识别的激烈博弈。同时,展望了量子计算和生物特征认证在未来攻防战中的潜在应用。 阅读详情

相关推荐

ESP32开发环境与微信小程序通信的完整示例

通过搭建稳定的esp32开发环境,实现其与微信小程序间的双向通信,涵盖Wi-Fi连接、数据收发与协议设计,为物联网应用提供低成本解决方案。

weixin_42126677的博客 1135

基础查找算法(二分,哈希,字典树)

一、二分查找(最简单的查找) 1. 应用条件: 必须采用顺序存储结构。 必须按关键字大小有序排列。 2. 思想: 取中间值划分左右区间,因为元素都是有序的,取中间值划分左右区间,因此左侧都小于中间值,右侧都大于中间值 因此为了减少比较次数,每次都让关键字和中间值进行比较 相等则找到,不等则判断,小于则在左边区间,大于则在右边区间 持续划分区间,直到区间无法划分或者找到 3.步骤 准备测试数据 创建二分查找函数 声明所需的变量 边界判断(很重要养成习惯) 初始化 划分区间 1. 确定一开始的

此战必胜 677

【01】VisionMaster入门到精通——VisionMaster V4.0.0 试用版安装教程(安装试用补丁与试用授权)

本文详细介绍了海康VisionMaster 4.0.0试用版的安装步骤:首先从官网下载基础安装包、软加密试用版和示例程序(可选);安装时需按顺序完成主程序安装(选择软加密)、试用补丁安装和30天试用授权安装;最后提供了两种启动方式。文章还列出了试用版的7项功能限制,包括最多支持2个流程、2个全局相机等,并特别提醒试用版不维护、不提供补丁,建议用户转为正式版本。安装过程中若出现蓝屏需重启覆盖安装,授权失败时可参考指定解决方案。

程序员,他们想的是什么?他们想的永远都是技术,他们崇尚的也永远都是技术。 9013

【双数组二分法+控制划分点】两有序数组取第k小数

Median of Two Sorted Arrays  Total Accepted: 16280 Total Submissions: 95001My Submissions There are two sorted arrays A and B of size m and n respectively. Find the median of the two sorte

一地鸡毛 964

【技术拆解】Illumina边合成边测序(SBS)核心流程全解析 | 从文库构建到数据分析

本文深入解析了Illumina边合成边测序(SBS)技术的完整流程。从DNA样本的文库构建(片段化、加接头、扩增),到Flowcell上的簇生成(桥式PCR),再到核心的边合成边测序(SBS)循环(荧光标记、可逆终止),最后简述了从原始数据到生物学洞见的数据分析步骤,为理解这一主流高通量测序技术提供了清晰的框架。

weixin_29201859的博客 541

V-REP(Cooprliesim EDU)自学笔记 实现UR5机械臂末端按轨迹移动

V-REP(Cooprliesim EDU)自学笔记 实现UR5机械臂末端按轨迹移动

xu_white的博客 7584

力扣第4题-Swift题解:寻找两个正序数组的中位数

双数组二分查找 题目描述 来源 难度 时间复杂度 力扣 困难 O( log(n) ) 给定两个大小分别为 m 和 n 的正序(从小到大)数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。 示例 1: 输入: nums1 = [1,3], nums2 = [2] 输出: 2.00000 解释: 合并数组 = [1,2,3] ,中位数 2 示例2: 输入: nums1 = [1,2], nums2 = [3,4] 输出: 2.50000 解释: 合并数组 .

madaxin的博客 612

YOLO11数据增强中的色彩空间变换:HSV、YUV等增强技术的原理、实现与参数调优全解析

摘要 本文介绍了色彩空间的基本概念及其在数据增强中的应用,重点分析了HSV色彩空间的原理与特性。色彩空间作为颜色表示的数学模型,在计算机视觉中具有重要作用,RGB、HSV、YUV等常用色彩空间各有特点。数据增强中的色彩变换能提升模型鲁棒性、缓解数据不平衡并防止过拟合。HSV色彩空间将颜色分为色调(H)、饱和度(S)和明度(V)三个独立分量,更符合人类视觉感知,便于针对性调整图像属性。文章详细阐述了HSV与RGB的转换公式,为YOLO11等目标检测框架的数据增强提供了理论基础。

本博客聚焦 YOLOv11 全流程落地,涵盖架构优化、数据集处理、训练技巧与多场景部署,兼及国产数据库、Java 开发与 AI 模型应用,内容兼顾理论与工程实践,为开发者提供系统干货,助力高效提升技术能力。 288

双数组查找中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。 请你找出这两个有序数组的中位数,并且要求算法的时间复杂度为 O(log(m + n))。 你可以假设 nums1 和 nums2 不会同时为空。 示例 1: nums1 = [1, 3] nums2 = [2] 则中位数是 2.0 示例 2: nums1 = [1, 2] nums2 = [3, 4] 则中位数是 (2 + 3)...

weixin_41666429的博客 464

Openclaw接入大模型API,操作本地windows文件

本文介绍了在WSL2环境下配置OpenClaw使用阿里百炼API的方法。主要内容包括:1)确认WSL2安装完成;2)配置阿里百炼API(需注意Qwen3-Max-Thinking为收费模型);3)提供正确的JSON配置格式示例,强调apiKey必须填写真实值;4)说明配置错误需修改Linux配置文件;5)建议通过询问模型信息验证连接成功。后续将介绍如何切换免费API及本地文件访问功能。

qq_27246521的博客 989

5-EP4CE10F17C8-引脚配置

EP4CE10F17C8-引脚配置

weixin_44479192的博客 722

解方程——对分法

对分法的理论依据是:设f是区间[a,b]上得连续函数,满足f(a)f(b)<0,那么f在a和b之间有一个根r,使得f(r) = 0 算法分析: 1.首先确定r在(a,b)区间内 2.令c0 = (a0 + b0)/2 if f(c0)f(a0) < 0 b1 = c0; a1 = a0 else a1 = c0; b1 = b0 3.以此类推 matlab代码实现...

weixin_30894389的博客 612

企业级大模型落地:私有化部署的安全合规全流程实战指南

摘要:本文针对企业在大模型私有化部署中面临的数据泄露、合规风险及系统稳定性难题,提出一套覆盖数据安全、模型合规、审计追踪与灾备方案的全流程解决方案。通过双加密管道(国密SM4传输加密+AES-GCM存储加密)、SGX可信执行环境等技术,实现数据全生命周期保护;结合等保2.0三级要求与《生成式AI服务管理暂行办法》,提供合规性实施细则;并给出本地GPU集群、混合云、边缘推理盒子三种企业级部署方案及成本模型。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 929

对分区间法求解方程组

import numpy as np import math a=1 b=2 for x in range(0,20): #Xn=(a+b)/2 Xn=round((a+b)/2,8) fxn=round(Xn**3+4*Xn**2-10,8) Xn=(a+b)/2 fxn=Xn**3+4*Xn**2-10 #fxn=Xn**3+4*Xn**2...

ShineRoyal 2359

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

对分法求非线性方程的根

对于非线性方程的求解,有时候很难找到解的解析函数,所以只能才用数值求解。常见的一些非线性方程为基本原理:如果非线性方程f(x)=0,的左端函数f(x)在区间[a,b]上连续,并满足f(a)f(b)<0,则方程至少有一个实根。 基本思想:逐步缩小这个有根的区间,当这个区间减少到一定程序时,就取这个中点作为根的近似值。如果在区间[a,b]内有多个实根,则单独利用对分法只能得到其一个实根。所以,将对分法

zhutou1280的博客 4663

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

对分法(二分法)求解非线性方程-M语言

求解函数 f(x) = sin(exp(x)), 起始区间[0,3],精度 <0.00001a = 0; b = 3; while (b-a)>0.00001, c = (a+b)/2; if sin(exp(a)) * sin(exp(c)) < 0 b =c; elseif sin(exp(b)) * sin(exp(c)) < 0

wang870039239的博客 2179

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

双重二分查找的应用

前几天面试的时候遇到一个问题,给定n个ip地址和m个ip地址块,如何判断,这n个地址是否在这m个ip地址块中的任意一个中。 后来想到了一个双重二分查找的方法,思路如下: 以IPv4地址为例,一共32位,为了方便记忆采用点分10进制方法标识。其本质是32位无符号整形,每一位不是0就是1,这样用来标 记2^32-1个不同的unsigned型整数, 每一个数代表一个网络地址。所以,对于一个给定的

caoyan_12727的博客 1083

LeetCode 4 两个排序数组的中位数(数组、二分查找、分治法)

题目要求: 给定两个大小为 m 和 n 的有序数组 nums1 和 nums2 。 请找出这两个有序数组的中位数。要求算法的时间复杂度为 O(log (m+n)) 。 你可以假设 nums1 和 nums2 不同时为空。 示例 1: nums1 = [1, 3] nums2 = [2] 中位数是 2.0 示例 2: nums1 = [1, 2] nums2 = [3, 4] ...

volcano_Lin 的博客 1678

八皇后问题的递归解法(最易理解的版本)

八皇后问题是一个古来而著名的问题,该问题是19世纪著名的数学家高斯同学提出来的。在8*8的国际象棋上摆放八个皇后,使其不能互相的攻击,也就是说,任意的两个皇后不能放在同一行或则是同一个列或者是同一个对角线上,问有多少个摆放的方法 本算法的思路是按行来规定皇后位置,第一行放置一个皇后,第二行放置一个皇后, 第N行也放置一个皇后… 这样, 可以保证每行都有一个皇后,那么各行的皇后应该放置在那

lhever_的博客 1万+

括号匹配算法的一种正确实现(java)

本人需要判断一个字符串里括号是否成对出现,发现正则满足不了或者正则表达式太复杂,只能用java算法实现了,网上找了几段代码,发现要么不合适,要么有的情况会误判,无奈只能参考那些例子进行改造了,现在贴出来,希望对某些人有用。 import java.util.HashMap; import java.util.Map; import java.util.Stack;public class match

lhever_的博客 1万+

字符串搜索算法Boyer-Moore的Java实现

欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来,用它写博客,将会带来全新的体验哦: Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl

lhever_的博客 5497

每日一省之————字符串排序算法(包括低位优先、高位优先、三向快速排序)

今天的目的是循序渐进的分别复习字符串排序的低位优先算法、高位优先算法和三向快速排序算法。不过,在开始这三中算法之前,作为基础,我们先从一种字符串的分组算大讲起。一:字符串的分组算法/** 假设存在下列字符串,这些字符串都以一个数字结尾, 结尾的数字代表这个字符串的组号(组号的范围在0-9之内), 现在我们想要将这些字符串按照其所属的组号归类,并且归类以后组号小的在前面,组号大的在后面。可以使用如

lhever_的博客 4562

每日一省之————递归法计算数组的所有排列组合

本算法的目的: 给定一组数字,求这些数字的所有可能的排序组合。算法内部逻辑:模拟人进行排列组合的过程。 1. 假设仅有2个数字, 则交换其位置,可以得到所有可能的组合,也即2组。 2. 假设有3个数字。则取出第1个数字,将第2和第3个数字交换位置后得到2种组合,然后在每种组合的开头插入第1个数字。得到了3个数字排列组合的其中两种; 然后取出第2个数字,将第1和第3个数字交换位置后得到

lhever_的博客 4125

Java模拟两个大整数的加法、乘法、除法

package ddd;import java.math.BigInteger; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern;public class BigInteg

lhever_的博客 3551

每日一省之————加权有向图的最短路径问题

1 加权有向图中边的数据结构 /** * 该类用于表示有向图中的一条有向边 * @author lhever 2017年3月2日 下午11:25:30 * @version v1.0 */ public class DirectedEdge { private final int v; private final int w; private final double

lhever_的博客 3031

蛇形打印(java实现)最易理解的版本

蛇形矩阵是指一个呈螺旋状的矩阵,它的数字由第一行开始到右边不断变大,向下变大,向左变大,向上变大,如此循环。 ` /** * 蛇形矩阵是指一个呈螺旋状的矩阵,它的数字由第一行开始到右边不断变大,向下变大,   向左变大,向上变大,如此循环。 * @author lhever 2017年4月4日 下午3:24:47 * @version v1.0 */ public class SnakeP

lhever_的博客 2825
上一篇: 每日一省之—使用线性探测法(仅利用数组作为底层数据结构)实现HashMap
下一篇: 每日一省之——使用递归法实现二叉查找树(BST),API齐全
lhever_
博客等级 码龄14年 213粉丝 130原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值