LintCode 463: Sort Integers (QuickSort和MergeSort 经典模板!!!)

chrome-headless-shell-mac-x64-160.0.8160.0(Canary).zip 内容概要:Chrome for Testing 官方 chrome-headless-shell 160.0.8160.0 x64 平台(金丝雀版通道),原版未修改,附来源说明。 适合人群:x64 上的自动化测试工程师、爬虫开发者、CI 环境搭建者。 使用场景及目标:①无头浏览器(Playwright/Puppeteer/Selenium 无界面自动化与爬虫的运行内核);②服务器/容器离线内置;③版本精准匹配(chromedriver 与 Chrome 需同大版本)。 其他说明:Chrome for Testing 为 Google 官方发布、允许自由分发的文件;本资源为第三方整理的下载便利服务。 立即下载
  1. Sort Integers
    中文English
    Given an integer array, sort it in ascending order. Use selection sort, bubble sort, insertion sort or any O(n2) algorithm.

Example
Example 1:
Input: [3, 2, 1, 4, 5]
Output: [1, 2, 3, 4, 5]

Explanation: 
return the sorted array.

Example 2:
Input: [1, 1, 2, 1, 1]
Output: [1, 1, 1, 1, 2]

Explanation: 
return the sorted array.

解法1:
QuickSort经典模板。
注意:

  1. pivot是取值而不是取index,因为QuickSort过程中元素会交换,index会变。
  2. quickSort()刚进来要备份left=start, right=end,因为start和end会变。
  3. 所有比较left和right的地方都必须用<=,所有比较A[left]/A[right]和pivot的地方都必须用<。否则可能溢出,因为递归的时候start和end老是不变。
    代码如下。
  4. quickSort()里面一开始if(start>=end) return这里可以用>=也可以用>。但MergeSort()这个地方只能用>=。所以为了统一,这里都用>=。
class Solution {
public:
    /**
     * @param A: an integer array
     * @return: nothing
     */
    void sortIntegers(vector<int> &A) {
        int n = A.size();
        if (n == 0) return;
        
        quickSort(A, 0, n - 1);
    }
    
private:
    void quickSort(vector<int> &A, int start, int end) {
        if (start >= end) return; //这里也可以用>
        int left = start, right = end;
        int pivot = A[left + (right - left) / 2];
        
        while(left <= right) {
            while(left <= right && A[left] < pivot) { // 注意这里要写pivot,而不是A[left + (right - left) / 2]; 因为A[left + (right - left) / 2]值可能会变!!!
                left++;
            }    
            while(left <= right && A[right] > pivot) { // 注意这里要写pivot,而不是A[left + (right - left) / 2]; 因为A[left + (right - left) / 2]值可能会变!!!
                right--;
            }
            if (left <= right) {
                swap(A[left], A[right]);
                left++;
                right--;
            }
        }
        
        quickSort(A, start, right);
        quickSort(A, left, end);
    }
};

另一个quickSort的解法,是把结尾元素当成pivot,每次quickSort执行后,start…i-1之间是小于pivot的,i等于pivot,i+1…end是大于pivot的。有点类似选择排序,不同点是选择排序每次是在i+1到end间选一个最小值跟a[i]交换,而这里是在i+1到end间找到第一个大于pivot的值就跟a[i]交换。

class Solution {
public:
    /**
     * @param a: an integer array
     * @return: nothing
     */
    void sortIntegers(vector<int> &a) {
        int n = a.size();
        quickSort(a, 0, n - 1);
    }
private:
    void quickSort(vector<int> &a, int start, int end) {
        if (start >= end) return;
        int i = start;
        for (int j = start; j < end; j++) {
            if (a[j] < a[end]) {
                swap(a[i], a[j]);
                i++;
            }
        }
        swap(a[i], a[end]);

        quickSort(a, start, i - 1);
        quickSort(a, i + 1, end);
    }    
};

解法2:MergeSort经典模板。
注意:

  1. mergeSort()刚进去的地方if(start>=end) continue;这里只能用>=, 和quickSort()不同。
  2. mergeSort() 外面一定要开辟一个n长度的数组,这是mergeSort比quickSort费事的地方,因为开辟一个区间(之后还要回收)很费时间。
  3. mergeSort()进去了start和end都要备份。记得这里right=mid+1 (quickSort是right=end)。
  4. 所有的比较都用<=。
  5. merge()里面最后记得把buf[]的start…end元素拷贝到A[]里面(不能直接A=buf)。
  6. mid是取index(不是取值!)。
  7. 简而言之,mergeSort的代码结构是while-if-while-while-for,而quickSort是while-{while-while}-if。
    代码如下:
class Solution {
public:
    /**
     * @param A: an integer array
     * @return: nothing
     */
    void sortIntegers(vector<int> &A) {
        int n = A.size();
        if (n == 0) return;
        vector<int> temp(n, 0);
        mergeSort(A, 0, n - 1, temp);
    }
    
private:
    void mergeSort(vector<int> &A, int start, int end, vector<int> &buf) {
        if (start >= end) return;//这里只能用>=
        int mid = start + (end - start) / 2;
        mergeSort(A, start, mid, buf);
        mergeSort(A, mid + 1, end, buf);
        merge(A, start, end, buf);
    }
    
    void merge(vector<int> &A, int start, int end, vector<int> &buf) {
        int mid = start + (end - start) / 2;
        int left = start;
        int right = mid + 1;
        int index = left;
        
        while(left <= mid && right <= end) {
            if (A[left] <= A[right]) {
                buf[index++] = A[left++];
            } else {
                buf[index++] = A[right++];
            }
        }
        
        while(left <= mid) {
            buf[index++] = A[left++];
        }
        
        while(right <= end) {
            buf[index++] = A[right++];
        }
        
        //remember to copy buf back to A
        //cannot directly use A = buf!
        for (int i = start; i <= end; ++i) {
            A[i] = buf[i];
        }
    }
};

下面是其它一些排序算法的代码:

  1. 冒泡排序
void bubble_sort(int arr[], int len) {
    int i, j, temp;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - 1 - i; j++)
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

  1. 插入排序
class Solution {
public:
    /**
     * @param A: an integer array
     * @return: nothing
     */
    void sortIntegers(vector<int> &A) {
        int sizeA = A.size();
        if (sizeA == 0) return;
        insertionSort(A);
        return;
    }
private:
    void insertionSort(vector<int> &A) {
        int len = A.size();
        for (int i = 1; i < len; i++) {
            int j = i;
            while (j > 0) {
                if (A[j] < A[j - 1]) {
                    int tmp = A[j];
                    A[j] = A[j - 1];
                    A[j - 1] = tmp;
                    j--;
                } else {
                    break;
                }
            }
        }
    }
};

注意:上面的版本是错的!!!这个版本实际上是冒泡排序。插入排序不需要swap。
新版本如下:

class Solution {
public:
    /**
     * @param a: an integer array
     * @return: nothing
     */
    void sortIntegers(vector<int> &a) {
        //insertion sort  
        int len = a.size();
        for (int i = 0; i < len; i++) {
            int value = a[i];
            int pos = 0;
            for (int j = i - 1; j >= 0; j--) {
                if (a[j] > value) {
                    a[j + 1] = a[j];
                } else {
                    pos = j + 1;
                    break;
                }
            } 
            a[pos] = value; 
        }
    }
};

注意,冒泡排序和插入排序时间复杂度都是O(n^2),为什么还是插入排序更受欢迎呢?因为冒泡排序需要swap,所以每次交换有至少3个赋值操作。而插入排序每次只有a[j+1]=a[j]这一个赋值操作。

  1. 选择排序
class Solution {
public:
    /**
     * @param A: an integer array
     * @return: nothing
     */
    void sortIntegers(vector<int> &A) {
        int sizeA = A.size();
        if (sizeA == 0) return;
        selectionSort(A);
        return;
    }
private:
    void selectionSort(vector<int> &A) {
        int len = A.size();
        for (int i = 0; i < len - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < len; j++) {
                if (A[minIndex] > A[j]) minIndex = j;
            }
            int tmp = A[minIndex];
            A[minIndex] = A[i];
            A[i] = tmp;
        }
        return;
    }
};

注意:直接选择排序算法是不稳定的,举个简单的例子,就知道它是否稳定…例如:(7) 2 5 9 3 4 [7] 1…当我们利用直接选择排序算法进行排序时候,(7)和1调换,(7)就跑到了[7]的后面了,原来的次序改变了,这样就不稳定了。
总结,有swap的排序都不稳定。

  1. Shell排序
  2. Heap排序
  3. Radix排序
  4. 桶排序
多智能体-系统-形成-控制 附matlab代码.rar 立即下载

相关推荐

具有PWM控制VSC-HVDC链路的IEEE30总线传输系统(Simulink仿真实现)

内容概要:本文构建了一个包含PWM控制VSC-HVDC链路的IEEE30节点电力传输系统,并基于Simulink平台完成了系统的建模仿真。该模型聚焦于高压直流输电(HVDC)技术在区域电网互联中的应用,采用电压源型换流器(VSC)与脉宽调制(PWM)技术实现高效、灵活的电能传输。研究重点在于分析VSC-HVDC链路在复杂多节点电网中对潮流分布、系统稳定性及电能质量的调控能力,特别关注其在区域电网互联、新能源大规模接入以及跨区域电力交换等场景下的动态响应特性与控制性能,为现代智能电网的发展提供技术支撑与仿真验证手段。; 适合人群:具备电力系统、电气工程或自动化等相关专业背景的研究生、科研人员及工程技术人员。; 使用场景及目标:①用于研究VSC-HVDC在多节点电网(如IEEE30节点)中的建模与仿真方法;②分析PWM控制策略下HVDC链路对电网潮流分布、电压稳定性和故障穿越能力的影响;③为区域电网互联、新能源并网及智能电网调度等课题提供仿真基础和技术验证。; 阅读建议:此资源以Simulink仿真实现为核心,建议读者在掌握电力电子技术和电力系统分析基础知识的前提下,结合仿真模型深入理解VSC-HVDC的工作原理与控制策略。在学习过程中,应着重关注模型参数设置、控制环路设计及仿真结果的分析,以达到理论与实践相结合的目的。

lintcode

1、利用C++特性:class Solution { public: /** * @param A an integer array * @return void */ void sortIntegers(vector&lt;int&gt;&amp; A) { // Write your code here sort(A...

qq_32555995的博客 1074

基于KDE-CDF置信带的不确定综合能源系统鲁棒调度优化研究(Matlab代码实现)

内容概要:本研究针对不确定综合能源系统中的鲁棒调度优化问题,提出一种基于核密度估计-累积分布函数(KDE-CDF)置信带的建模方法,用以精确刻画风能、光伏及负荷等不确定性因素的非正态概率分布特征。通过构建KDE-CDF模型,能够有效捕捉实际运行中新能源出力与负荷需求的波动性与随机性,并在此基础上设计鲁棒优化调度框架,提升系统在不确定性环境下的运行可靠性与经济性。该方法结合Matlab编程实现,综合考虑系统运行成本、峰谷差、碳排放等多重目标,实现多维度协调优化。研究还探讨了与智能优化算法(如粒子群算法)相结合的应用路径,增强了模型的求解效率与工程实用性,为含多种储能装置、电转气设备及碳捕集系统的复杂综合能源系统提供了科学的调度决策支持。; 适合人群:具备电力系统分析、优化理论基础及Matlab编程能力的研究生、科研人员,以及从事综合能源系统规划、运行与调度工作的工程技术人员。; 使用场景及目标:①解决高比例可再生能源接入背景下综合能源系统调度中的不确定性建模难题;②提升调度方案在面对新能源强波动性时的鲁棒性与适应能力;③为融合多类型灵活性资源(如储能、电转气、碳捕集)的综合能源系统提供精细化、可落地的优化运行策略。; 阅读建议:建议读者在掌握概率统计、随机优化与电力系统运行基础知识的前提下,结合文中提供的Matlab代码进行实践操作,重点关注KDE-CDF置信带的构建流程及其在鲁棒优化模型中的嵌入机制,通过调整输入数据分布、参数设置与场景配置开展仿真对比实验,深入理解不确定性建模精度对调度决策质量的影响,进而掌握从数据驱动角度提升系统鲁棒性的关键技术路径。

MergeSort与QuickSort的详细分析

 MergeSort和QuickSort是两种比较类似的sort方式,他们都是通过Divide and Conquer来实现的。都需要使用recursion的方式进行排序。他们的相同之处在于原理上一致。首先要做的是split,将N个element分成两部分进行排序,每一部分也会再继续分成两部分排序,直到只有2个element的时候就可以很容易的比较排序。这个就是recursion的使用方法。属于D

QT_pixie的专栏 1万+

含分布式电源的配电网可靠性评估研究(Matlab代码实现)

内容概要:本文系统研究了含分布式电源的配电网可靠性评估方法,基于Matlab代码实现了完整的评估模型与算法框架。研究深入分析了分布式电源接入后对配电网结构与运行特性的影响,重点探讨了其对供电可靠性的作用机制。采用序贯蒙特卡洛模拟法对系统各类状态进行抽样与仿真,综合考虑了分布式电源出力的随机性、负荷波动性以及网络拓扑变化等多种不确定性因素,精确计算了系统及负荷点的多项可靠性指标。通过在标准测试系统上的仿真实验,验证了所提方法的有效性和实用性,为新型电力系统环境下配电网的规划、运行与可靠性提升提供了有力的技术支撑和决策依据。; 适合人群:具备电力系统分析、概率统计及可靠性基础理论知识,熟悉Matlab编程语言,从事电力系统规划、运行、可靠性评估等相关工作的科研人员、高校研究生以及电力行业工程师。; 使用场景及目标:①掌握含分布式电源的现代配电网可靠性评估的核心理论与关键技术;②学习并实践基于序贯蒙特卡洛模拟的电力系统可靠性分析算法的Matlab实现方法;③为实际工程中分布式电源的优化配置、配电网的升级改造以及制定可靠性提升策略提供科学的仿真工具和量化分析依据。; 阅读建议:建议读者结合文中提供的Matlab代码,逐行阅读并运行程序,重点理解系统建模、状态抽样、潮流计算与指标统计等核心模块的实现逻辑。可尝试调整分布式电源的类型、容量、接入位置及负荷水平等参数,观察其对系统可靠性指标的影响趋势,从而深化对系统动态行为与关键影响因素的理解。

退出微软账户-解除微软账户绑定 .exe

退出微软账户_解除微软账户绑定小工具

【排序算法】归并排序与快速排序:深入解析与比较

无论是在数据库操作中的数据检索,还是在高效算法的设计中,良好的排序机制都能显著提升性能和效率。合并时,从两个数组的起始位置开始比较,选择两者中较小的元素放入结果数组中,然后移动指针,重复此过程,直到所有元素都被合并。分区策略: 快速排序通过选择一个基准元素,然后重新排列数组,使得所有小于基准的元素都移到基准的左边,所有大于基准的元素都移到基准的右边。基准元素的选择: 基准的选择可以多样化,常见的方法包括选择第一个元素、最后一个元素、中间元素,或者随机选择一个元素作为基准。归并排序是一种稳定的排序算法。

Ricky的博客 6743

宝塔面板+pbootCMS建站全流程:从服务器选购到上线优化(附常见问题排查)

本文提供了一份详尽的宝塔面板与pbootCMS建站实战指南。内容涵盖从云服务器选购、宝塔面板部署与安全加固,到pbootCMS安装、权限配置、数据库连接等核心步骤。同时深入讲解了PHP环境优化、Nginx伪静态设置、缓存开启等性能与SEO优化技巧,并附有常见问题排查与后期维护建议,帮助用户高效、稳健地完成专业网站构建。

e4f5g6h的博客 661

merge sort 和 quick sort

归并排序 (Merge sort) 核心思想是:分治法(divide-and-conquer),时间复杂度是O(nlogn)O(nlogn)O(nlogn)。 首先,什么是分治法? 这里用一个经典问题来说明:假设给你27枚硬币,其中有一个假币会比真的轻一点,你有一个天平,如何仅测量三次来找到这枚假币呢? 答:先把硬币分成三等份每份9个,一次测量便可得知最轻的是哪9枚硬币。然后再平分三份每份3枚,测量,再平分三份……这样便可三次得出结果 归并排序是分治法的典型应用,这个算法顾名思义,就是要更高效地实现排序

weixin_41989712的博客 330

别再只盯着CXL协议了,聊聊CXL.mem里那个能动态调优内存性能的‘QoS遥测’到底怎么用

本文深入解析CXL.mem协议中的QoS遥测功能,探讨如何通过DevLoad指标动态调优内存性能。文章详细介绍了QoS遥测的核心机制、多QoS类别设备的实战配置,以及AI训练、金融交易和视频处理场景中的优化案例,帮助数据中心实现高效内存资源管理。

weixin_33725722的博客 437

在实战中学AI-车流量统计项目-YOLOV11车辆检测-YOLOV11模型的部署

考虑实际落地中部署推理资源消耗,速度与模型精度之间的均衡,同时,车辆属于比较通用场景的目标检测,我们将YOLOV11作为最终的模型选择,目前官方开源的模型基于coco数据集训练,里面已经包含了车辆相关类别,经测试,在监控视角下效果基本可用,所以,在落地过程中,我们先用这个模型来打通部署链路,后面再逐步优化模型性能。在Nvidia的硬件下做部署,部署框架优先选择官方框架TensorRT,下面重点讲述如何用TensorRT部署YOLOV11模型。

Aleo_优快云的博客 2168

关于快排

“`“`void quicksort(int a[], int left, int right) { if (left >= right) { return; } int c = left; int b = right; int spot = a[left]; while (c < b) {

柳予欣的三味书屋~ 229

C#海康威视摄像头控制,将IntPtr转换成Bitmap图片

C#通过skd控制海康威视摄像头,获取bitmap格式图片

ReflexMechanism的博客 6588

LintCode-31: Partition Array 及QuickSort学习

Partition Array类似于quickSort里面的Paritition的过程,但是有点细微区别。代码如下: int partitionArray(vector&amp;lt;int&amp;gt; &amp;amp;nums, int k) { int start=0, end=nums.size()-1; while (start&amp;lt;=end) { //note:...

roufoo的博客 638

MATLAB 车牌识别系统

车牌识别系统利用计算机视觉和图像处理技术,自动识别车辆牌照上的字符信息。本系统基于 MATLAB 实现车牌识别,包括图像预处理、车牌定位、字符分割、字符识别等模块。车牌识别系统是实现智能交通和公共安全的重要手段,具有广泛的应用前景。MATLAB 提供了丰富的工具和函数,可以方便地进行算法仿真和系统开发。

走向CTO的路上... 800

[AI] 嵌入模型选择:bge / text-embedding-3 / Jina Embeddings 对比与选型指南

摘要: 本文对比了BGE-M3、OpenAI和Jina三种主流嵌入模型在语言覆盖、性能、延迟、维度和成本等维度的差异。BGE-M3适合中文场景,本地部署成本低;OpenAI API多语能力强但依赖网络;Jina在多语表现突出但需关注商用许可。测试显示BGE-M3本地延迟3-6ms,OpenAI API延迟200-600ms。选型建议:隐私场景选BGE本地部署,多语低维护选OpenAI,高精度选Jina。部署时需注意批处理优化、向量库压缩和商用许可等问题,建议建立评测指标并监控关键指标。

每日出拳老爷子的博客 428

Sort Integers (Map Reduce)

Sort integers by Map Reduce framework. In the mapper, key is the document id which can be ignored, value is the integers. In the reducer, your can specify what the key / value is (this depends on how...

leetcode 解题思路 284

使用 YOLO26 的牙科全景X光片分析:从牙齿检测到疾病诊断

从数据预处理自动化、模型架构针对性优化到基于视觉特征的性能分析。它证明了在医学图像分析中,模型架构的进步(如YOLO26的特性)可以有效缓解数据不平衡和目标微小的问题,为临床自动化诊断提供了一个高效、可靠的解决方案。Python"""全局配置模块包含数据集路径、类别名称、论文复现参数、划分比例等常量"""import os# ==================== 路径配置 ====================

u012133341的博客 104

#463 Sort Integers

题目描述: Given an integer array, sort it in ascending order. Use selection sort, bubble sort, insertion sort or any O(n2) algorithm. Have you met this question in a real interview?  Yes

易水居 212

【系统分析师】2025年下半年真题:论文及解题思路

摘要 本文探讨软件测试技术的应用,重点关注静态测试与动态测试的比较。静态测试在不运行程序的情况下,通过审查、走查等方式分析需求、设计文档和代码,能早期发现高层次缺陷,降低修复成本。动态测试通过实际运行程序,使用单元测试、集成测试等方法验证功能性能,是发现运行时错误的唯一途径。二者在缺陷类型、介入阶段和修复成本上具有互补性,建议项目实践中结合使用以提升软件质量。

数据知道的博客 5789

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

QuickSort(快速排序)&&MergeSort(归并排序)的效率比较[搭配LeetCode例题]

QuickSort(快速排序)&&MergeSort(归并排序)的效率比较 QuickSort代码 void quickSort(vector<int>& nums,int left,int right){ if(left>=right) return; int r=rand()%(right-left+1)+left; int x=nums[r]; swap(nums[r],nums[right]); int

阿乐的博客 576

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Quick Sort & Merge Sort

两种排序均采用分治的思想:quick sort先整体有序,再局部有序。归并排序先局部有序,再整体有序。 目录: quick sort 和 merge sort 的比较 quick sort merge sort 1. quick sort 和 merge sort 的区别于联系 1). 时间复杂度:都是O(nlogn),但是快速排序是平均O(nlogn),归并排序是最好最坏都是O(nlogn)...

weixin_43551229的博客 609

廖雪峰Python教程[完整版]

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

深度学习工具包 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")

归并排序(MergeSort)和快速排序(QuickSort)

归并排序和快速排序 1.归并排序 归并排序(MergeSort)和快速排序(QuickSort)就是把数组的数,分为一个个有序的个体,再两两结合. 对给定数组排序升序:[8,4,5,6,2,1,7,3] 1.先将其分为一个个有序的个体:[8],[4],[5].[6].[2].[1],[7],[3] 2.两两合并并保持有序:[4,8],[5,6],[1,2],[3,7] 3.继续合并

Veng的博客 1223

Sort Integers

Given an integer array, sort it in ascending order. Use selection sort, bubble sort, insertion sort or any O(n2) algorithm.分析bubble sort1234567891011121314151617181920publicclassSolution{/**...

weixin_33894992的博客 150

QuickSort和MergeSort对比小结

1) QuickSort的时间复杂度平均是O(nlogn),但最坏情况下是O(n^2)。MergeSort的时间复杂度严格来说就是O(nlogn)。那为什么实际应用中QuickSort用得多呢?因为MergeSort需用分配额外的O(n)空间,当用到new函数的时候会消耗很多的系统时间。另外像JAVA里面还要garbage collection又消耗一些时间。所以总体上来说MergeSort的ov...

roufoo的博客 4046
上一篇: LeetCode 384. Shuffle an Array (Shuffle 数组最经典题!!!)
下一篇: LintCode148: Sort Colors (三指针法)
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值