精华内容
下载资源
问答
  • 你怎么称呼老师 如果老师最后没有总结一节课的重点的难点你是否会认为老师的教学方法需要改进 你所经历的课堂讲座式还是讨论式 教师的教鞭 不怕太阳晒也不怕那风雨狂只怕先生骂我笨没有学问无颜见爹娘 太阳当空照...
  • Front队首,Rear队尾,很明显这个空间已经满了,现在依次删除队首元素: 可以发现随着队列内元素越来越少,没有用到的空间越来越大,且总空间大小不变,所以说到最后这段空间就算废了。 为了让这段空间可持续...

    如果对队列还有些疑问的可以线看一看我上一个博客:用Java描述数据结构之栈和队列,以及栈和队列的常用方法
    当我们只有一段固定大小空间去存一个队列时像这样:
    在这里插入图片描述

    Front是队首,Rear是队尾,很明显这个空间已经满了,现在依次删除队首元素:
    在这里插入图片描述

    可以发现随着队列内元素越来越少,没有用到的空间越来越大,且总空间大小不变,所以说到最后这段空间就算是废了。

    为了让这段空间可持续利用,我们其实可以这样:
    在这里插入图片描述
    在这里插入图片描述
    就是每次头删之后将队列中所有元素向前移,这就很好的解决了问题,完美的提升了空间的利用。可是,每头删一个元素都依次将后续元素前移这个操作无疑增加了时间复杂度。
    所以为了降低时间复杂度我们可以设置一段检测队列大小和数组大小关系的代码,只有满足这个条件的时候在将有效数据依次前移,这样就不必每次头删都要前移,在一定程度上降低了时间复杂度。

    当然还有另外一个方案解决,就是我们根本不必前移元素,只用改变以下头尾指针(就比喻为指针了)的用法,让队列在逻辑上看起来像个环就行了,这就是我们今天的主角——循环队列:

    在这里插入图片描述
    这是一个空队列,现在加入元素(下面环形队列图中的Rear指向有错,Rear应该指向队尾的下一个,就是空的第一个):
    在这里插入图片描述
    继续加入:
    在这里插入图片描述
    在这里插入图片描述

    现在队列满了,我们头删元素:
    在这里插入图片描述
    可以看到,我们头删之后队列既多出空间插入新的元素,也不必前移元素,那么怎么去实现逻辑上是个环的这个循环队列呢?其实只需更灵活的使用头尾指针就可以。

    我们结合LeetCode第622题来看
    LeetCode.622.
    现在来讨论它的具体实现:

    public class MyCircularQueue {
        //数组实现循环队列
        private int[] queueArray;
        //记录队首位置
        private int frontIndex;
        //记录队尾位置
        private int rearIndex;
        //记录队列长度
        private int size;
    
        //构造方法
        public MyCircularQueue(int k) {
            queueArray = new int[k];
            frontIndex = 0;
            rearIndex = 0;
            size = 0;
        }
    
        //插入新元素
        public boolean enQueue(int value) {
            if(size == queueArray.length){
                return false;
            }
                queueArray[rearIndex] = value;
                size++;
                rearIndex = (rearIndex + 1) % queueArray.length;
                return true;
        }
    
        //删除元素
        public boolean deQueue() {
            if (size == 0){
                return false;
            }
            frontIndex = (frontIndex + 1) % queueArray.length;
            size--;
            return  true;
        }
    
        //从队首获取元素,如果队列为空返回-1
        public int Front() {
            if(size == 0){
                return -1;
            }
            return queueArray[frontIndex];
        }
        //获取队尾元素,如果队列为空,返回-1
        public int Rear() {
            if(size == 0){
                return -1;
            }
            //rearIndex始终指向第一个空的下标,
            //所以要取队尾元素,就得取rearIndex前一个下标内的元素
            //为了防止rearIndex指向0号下标
            //做以下操作
            int index = (rearIndex - 1 + queueArray.length) % queueArray.length;
            return queueArray[index];
        }
        //判断队列是否为空
        public boolean isEmpty() {
            return size == 0;
        }
        //判断队列是否满
        public boolean isFull() {
            return size == queueArray.length;
        }
    }
    
    

    以上就是对循环及其实现的简单介绍,如果理解有偏差,还望看官在评论区指正,谢谢

    展开全文
  • 一、是什么 JavaScript在设计之初便是单线程,即指程序运行时,只有一个线程存在,同一时间只能做一件事 为什么要这么设计,跟JavaScript的应用场景有关,JavaScript 初期作为一门浏览器脚本语言,通常用于操作 DOM ...

    一、是什么

    JavaScript在设计之初便是单线程,即指程序运行时,只有一个线程存在,同一时间只能做一件事
    为什么要这么设计,跟JavaScript的应用场景有关,JavaScript 初期作为一门浏览器脚本语言,通常用于操作 DOM ,如果是多线程,一个线程进行了删除 DOM ,另一个添加 DOM,此时浏览器该如何处理?

    为了解决单线程运行阻塞问题,JavaScript用到了计算机系统的一种运行机制,这种机制就叫做事件循环(Event Loop)

    事件循环(Event Loop)

    在JavaScript中,所有的任务都可以分为

    同步任务:立即执行的任务,同步任务一般会直接进入到主线程中执行

    异步任务:异步执行的任务,比如ajax网络请求,setTimeout定时函数等

    从上面我们可以看到,同步任务进入主线程,即主执行栈,异步任务进入任务队列,主线程内的任务执行完毕为空,会去任务队列读取对应的任务,推入主线程执行。上述过程的不断重复就是事件循环

    二、宏任务与微任务
    如果将任务划分为同步任务和异步任务并不是那么的准确,举个例子:

    console.log(11)
    
    setTimeout(()=>{
        console.log(22)
    }, 0)
    
    new Promise((resolve, reject)=>{
        console.log('new Promise')
        resolve()
    }).then(()=>{
        console.log('then')
    })
    
    console.log(33)
    

    如果按照上面流程图来分析代码,我们会得到下面的执行步骤:

    console.log(11),同步任务,主线程中执行
    setTimeout() ,异步任务,放到 Event Table,0 毫秒后console.log(22)回调推入 Event Queue 中
    new Promise ,同步任务,主线程直接执行
    .then ,异步任务,放到 Event Table
    console.log(33),同步任务,主线程执行
    所以按照分析,它的结果应该是 11 => 'new Promise' => 33 => 22 => 'then'
    
    但是实际结果是:11=>'new Promise'=> 33 => 'then' => 22
    

    出现分歧的原因在于异步任务执行顺序,事件队列其实是一个“先进先出”的数据结构,排在前面的事件会优先被主线程读取

    例子中 setTimeout回调事件是先进入队列中的,按理说应该先于 .then 中的执行,但是结果却偏偏相反

    原因在于异步任务还可以细分为微任务与宏任务

    微任务

    一个需要异步执行的函数,执行时机是在主函数执行结束之后、当前宏任务结束之前

    常见的微任务有:

    Promise.then
    
    MutaionObserver
    
    Object.observe(已废弃;Proxy 对象替代)
    
    process.nextTick(Node.js)
    

    宏任务

    宏任务的时间粒度比较大,执行的时间间隔是不能精确控制的,对一些高实时性的需求就不太符合
    常见的宏任务有:

    script (可以理解为外层同步代码)
    setTimeout/setInterval
    UI rendering/UI事件
    postMessage、MessageChannel
    setImmediate、I/O(Node.js)
    

    按照这个流程,它的执行机制是:

    执行一个宏任务,如果遇到微任务就将它放到微任务的事件队列中
    当前宏任务执行完成后,会查看微任务的事件队列,然后将里面的所有微任务依次执行完
    回到上面的题目

    console.log(1)
    setTimeout(()=>{
        console.log(2)
    }, 0)
    new Promise((resolve, reject)=>{
        console.log('new Promise')
        resolve()
    }).then(()=>{
        console.log('then')
    })
    console.log(3)
    

    流程如下

    // 遇到 console.log(1) ,直接打印 1
    // 遇到定时器,属于新的宏任务,留着后面执行
    // 遇到 new Promise,这个是直接执行的,打印 'new Promise'
    // .then 属于微任务,放入微任务队列,后面再执行
    // 遇到 console.log(3) 直接打印 3
    // 好了本轮宏任务执行完毕,现在去微任务列表查看是否有微任务,发现 .then 的回调,执行它,打印 'then'
    // 当一次宏任务执行完,再去执行新的宏任务,这里就剩一个定时器的宏任务了,执行它,打印 2
    

    三、async与await

    async 是异步的意思,await则可以理解为等待

    放到一起可以理解async就是用来声明一个异步方法,而 await是用来等待异步方法执行

    async

    async函数返回一个promise对象,下面两种方法是等效的

    function f() {
        return Promise.resolve('TEST');
    }
    
    // asyncF is equivalent to f!
    async function asyncF() {
        return 'TEST';
    }
    

    await

    正常情况下,await命令后面是一个 Promise对象,返回该对象的结果。如果不是 Promise对象,就直接返回对应的值

    async function f(){
        // 等同于
        // return 123
        return await 123
    }
    f().then(v => console.log(v)) // 123
    不管await后面跟着的是什么,await都会阻塞后面的代码
    
    async function fn1 (){
        console.log(1)
        await fn2()
        console.log(2) // 阻塞
    }
    
    async function fn2 (){
        console.log('fn2')
    }
    
    fn1()
    console.log(3)
    

    上面的例子中,await 会阻塞下面的代码(即加入微任务队列),先执行 async外面的同步代码,同步代码执行完,再回到 async 函数中,再执行之前阻塞的代码

    所以上述输出结果为:1,fn2,32
    
    四、流程分析
    

    通过对上面的了解,我们对JavaScript对各种场景的执行顺序有了大致的了解

    这里直接上代码:

    async function async1() {
        console.log('async1 start')
        await async2()
        console.log('async1 end')
    }
    async function async2() {
        console.log('async2')
    }
    console.log('script start')
    setTimeout(function () {
        console.log('settimeout')
    })
    async1()
    new Promise(function (resolve) {
        console.log('promise1')
        resolve()
    }).then(function () {
        console.log('promise2')
    })
    console.log('script end')
    

    分析过程:

    执行整段代码,遇到 console.log(‘script start’) 直接打印结果,输出 script start
    遇到定时器了,它是宏任务,先放着不执行
    遇到 async1(),执行 async1 函数,先打印 async1 start,下面遇到await怎么办?先执行 async2,打印 async2,然后阻塞下面代码(即加入微任务列表),跳出去执行同步代码
    跳到 new Promise 这里,直接执行,打印 promise1,下面遇到 .then(),它是微任务,放到微任务列表等待执行
    最后一行直接打印 script end,现在同步代码执行完了,开始执行微任务,即 await下面的代码,打印 async1 end
    继续执行下一个微任务,即执行 then 的回调,打印 promise2
    上一个宏任务所有事都做完了,开始下一个宏任务,就是定时器,打印 settimeout

    所以最后的结果是:script start、async1 start、async2、promise1、script end、async1 end、promise2、settimeout
    
    展开全文
  • 边学边做教程 信息工程学院 第三章 Java程序的流程控制 3.1java语句和程序结构有多少种(视频31) 3.2顺序程序设计(视频32) 3.3分支程序设计(视频33) 3.4循环程序设计(视频34) 任务6循环程序及java循环设计语句使用...
  • Problem Description Roy has just moved into a new apartment. Well, actually the apartment itself is not very new, even dating back to the days before people had electricity in their houses....
  • 一、引 JavaScript 最大特点,同时也最大的缺点就是 ...JavaScript 的设计为单线程很大原因就是它要对浏览器进行操作。作为浏览器脚本语言, JavaScript 的主要用途与用户互动,以及操作DOM。这决定了它只能...

    一、引

    JavaScript 最大特点,同时也是最大的缺点就是 单线程 ,这就导致了,同一个时间它只能做一件事。那么,为什么 JavaScript 不能有多个线程呢?这样能提高效率啊?其实我一开始也是很迷惑的。但是原因很简单:

    JavaScript 的设计为单线程很大原因就是它是要对浏览器进行操作。作为浏览器脚本语言, JavaScript 的主要用途是与用户互动,以及操作DOM。这决定了它只能是单线程,否则会出现逻辑问题。比如,假定同时存在又两个线程,一个线程在某个DOM节点上添加内容,另一个线程删除节点上的内容,这时浏览器应该以哪个线程为准?

    所以,为了避免复杂性,从一诞生, JavaScript 就是单线程,这已经成了这门语言的核心特征,将来也不会改变。

    但是,在HTML5里提出Web Worker标准,允许 JavaScript 脚本创建多个线程,但是子线程完全受主线程控制,且不得操作DOM。导致这个新标准并没有改变 JavaScript 单线程的本质。

    看个例子:接下来解答

    console.log('start')
    setTimeout(function(){
        console.log('hello world')
    },0)
    console.log('end')
    // start
    // end
    // hello world
    

    二、任务队列

    由于 JavaScript 是单线程的,所以所有的任务都要进入队列进行排队,等待前一个任务结束了再执行下一个任务。这样就出现了问题,如果前任务“又臭又长”,那么后面的任务就得耐心的等下去。

    任务常分为 IO 密集型和计算密集型。当任务是计算密集型那也还好,等的人无所谓。但是如果前任务是 IO 密集型,在等待键盘的输入完成或者在等到 AJAX 的回调结果。那么后面的任务就很难受了,看着 CPU 空闲着,就是不给你用。

    于是 JavaScript 就把任务分为了俩种,同步任务和异步任务。这样的话,任务队列也就拆分成了 同步任务队列(主线程) 和 异步任务队列(任务队列)。在同步任务队列中,即是主线程上排队执行的任务,只有前一个任务执行完毕,才能执行后一个任务;在异步任务队列中的任务,只有"任务队列"通知主线程,某个异步任务可以执行了,该任务才会进入主线程执行。

    总结下就是下面这样:

    1.所有的同步任务形成一个执行栈。
    2.任务队列放除了同步任务的异步任务,运行有结果了,就在任务队列中放一个通知事件。
    3.执行栈运行完栈内任务,就去任务队列中读取通知事件,调入执行栈执行。
    4.循环123,直至俩个队列全空。
    

    JavaScript 中有这几种异步任务,会被放到任务队列

    1.定时器
    2.事件绑定
    3.大部分的 AJAX(可这是为非异步)
    4.回调函数
    

    这里回答上面的问题,为什么是先打印出 end 后再打印出 hello world 呢,因为 setTimeout 是异步任务,读取这个任务的时候,会被直接存入任务队列,当执行栈中的任务执行完才会去执行任务队列中的任务,所以当俩个打印任务完成后,去读取任务队列中的定时任务,间隔为0秒,则立马打印出 hello world。不难…

    三、事件循环

    执行栈中执行 -> 执行栈空 -> 任务队列调取事件到执行栈 -> 执行栈执行 -> … -> 执行栈空、任务队列空。这个机制就是事件循环( Event Loop )

    alt 事件循环

    这张图来自网络。解释下其中的名词:

    heap:堆:      (用来存常量、变量什么的)
    stack:执行栈 
    callback queue:回调队列
    

    四、Node.js中的事件循环

    在另一篇文章中详细解答了,可以查看。

    展开全文
  • Python 一个设计优美的解释型高级语言,它提供了很多能让程序员感到舒适的功能特性。但有的时候 Python 的一些输出结果对于初学者来说似乎并不是那么一目了然。 GitHub 有个仓库收集 Python 中那些难以理解和...

    Python 是一个设计优美的解释型高级语言,它提供了很多能让程序员感到舒适的功能特性。但有的时候 Python 的一些输出结果对于初学者来说似乎并不是那么一目了然。

    GitHub 有个仓库收集 Python 中那些难以理解和鲜为人知的功能特性,并尝试讨论这些现象背后真正的原理!

    虽然有些例子并不一定会让你觉得“卧槽”(WTF),但它们依然有可能会告诉你一些你所不知道的 Python 有趣特性。我觉得这是一种学习编程语言内部原理的好办法,而且我相信你也会从中获得乐趣!

    如果你是一位经验比较丰富的 Python 程序员,你可以尝试挑战看是否能一次就找到例子的正确答案。你可能对其中的一些例子已经比较熟悉了,那这也许能唤起你当年踩这些坑时的甜蜜回忆。

    for 循环怎么会事儿?

    some_string = "wtf"
    some_dict = {}
    for i, some_dict[i] in enumerate(some_string):
        pass
    

    Output:

    >>> some_dict # 创建了索引字典.
    {0: 'w', 1: 't', 2: 'f'}
    

    说明:
    Python 语法[1] 中对 for 的定义是:

    for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
    

    其中 exprlist 指分配目标. 这意味着对可迭代对象中的每一项都会执行类似 {exprlist} = {next_value} 的操作.

    一个有趣的例子说明了这一点:

    for i in range(4):
        print(i)
        i = 10
    

    Output:

    0
    1
    2
    3
    

    你可曾觉得这个循环只会运行一次?

    说明:

    由于循环在Python中工作方式, 赋值语句 i = 10 并不会影响迭代循环, 在每次迭代开始之前, 迭代器(这里指 range(4)) 生成的下一个元素就被解包并赋值给目标列表的变量(这里指 i)了.
    在每一次的迭代中, enumerate(some_string) 函数就生成一个新值 i (计数器增加) 并从 some_string 中获取一个字符. 然后将字典 some_dict 键 i (刚刚分配的) 的值设为该字符. 本例中循环的展开可以简化为:

    >>> i, some_dict[i] = (0, 'w')
    >>> i, some_dict[i] = (1, 't')
    >>> i, some_dict[i] = (2, 'f')
    >>> some_dict
    
    展开全文
  • 什么是设计设计的本质是什么

    千次阅读 2014-01-30 00:05:25
    我刚进大学时,韩国教授问我们,为什么要做设计。那时候的我心里说「因为我喜欢设计」。教授说设计为了赚钱。那时候的我接受了这个想法。 后来,我越做设计,就越发现设计不是为了赚钱。 设计可以让更多生命得到...
  • js | label是什么,在循环中有什么用

    千次阅读 2018-07-28 16:40:21
    在看《JavaScript高级程序设计》第三版的第三章时发现label语句,在平常学习js基本没有遇见,经过学习和练习,label与break、continue结合可以节省一些步骤,废话不多说直接上码。 先来一个正常的for循环: var ...
  • 什么是循环什么要使用循环;5.1 循环的基本概念;5.1循环的基本概念续;5.1 循环的基本概念续;5.1循环的基本概念完;5.2 while循环控制 ;语句一般格式 while 表达式 {语句组} ;当表达式为真 语句;例如;算法和程序;...
  • 【问】js中事件循环是什么?宏任务和微任务又是什么? 事件循环 【答】js的特点是单线程,即同一时间只能干一件事情,当然这是基于他的主要运行环境是浏览器而这样设计的(创立js之初,主要运行在浏览器。其一这样...
  • c++标准库中为什么把list设计为带头节点的双向循环链表? 在c++标准库中list被设计为带头节点的双向循环链表。 1.为什么是带头节点? 我们在使用list创建一个对象时,比如list< int > L(4,3),此时链表中含有4...
  • C Programming 第五章 5.1 概述 什么是循环什么要使用循环 问题1 问题2:求学生平均成绩 分数相加后除以课数 在许多问题中需要用到循环控制循环结构结构化程序设计的基本结构之一它和顺序结构选择结构共同作为...
  • 循环结构和顺序结构、选择结构结构化程序设计的3中基本结构。 5.2 用while语句实现循环 while语句先判断是否符合条件,若符合,则执行while后面的语句(称为循环体)。 while语句的一般形式如下...
  • 一、什么是循环结构 ⑴分类 循环语句分为三组基本类型 while型循环,do–while型循环,for型循环 三者各有长处与劣势,在编写代码时应择优使用,灵活运用。 ⑵应用 循环语句一般用于解决具有一定循环规律操作的...
  • 今天,小编我将为大家讲述C语言中的循环语句,那什么是循环语句那,在我们了解这个问题前,我们先要知道,为什么我们需要循环控制语句。那因为在日常生活中或是在程序处理的问题中常常遇到需要重复处理的问题。...
  • 3、阅读下面的程序,程序的功能是什么? 上文中程序,缩进有错误,正确 程序如下图所示 功能:判断101-200中所有奇数是否是素数,把是素数的打印出来,10个为1行。 4、从键盘输入 5 组数,每组有 6 个数,求
  • 循环计算 log x 2 这个log2x错哪了 套路 计算之前先保存原始的 值后可能有 这些值怎么定的 为什么从0开始 为什么是>1 计数循环 int count =100; while ( count >=0 ) { count --; 如果要模拟运 printf%d\n,count; ...
  • 循环结构程序设计.zip

    2021-03-07 10:55:55
    一直放到64格(国际象棋棋盘8×8=64格),我就感恩不尽,其他我什么也不要了.”国王想:“这有多少,还不容易!”让人扛来一袋小麦,但不到一会儿全用没了,再来一袋很快又没有了,结果全印度的粮食全部用完还不够...
  • 5.1 为什么需要循环控制 ...循环结构和顺序结构、选择结构结构化程序设计的3中基本结构。 5.2 用while语句实现循环 while语句先判断是否符合条件,若符合,则执行while后面的语句(称为循环体)。 whil...
  • 设计循环队列(C++)

    2019-07-23 20:33:53
    一、为什么要用循环队列 循环队列一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处我们可以利用这个队列之前用...
  • 它的主要内容是什么? 点我看视频讲解+可运行代码 记得收藏视频,一键三连 结构化程序设计(structured programming,简称SP)是进行以模块功能和处理过程设计为主的详细设计的基本原则。其概念最早由E.W.Dijikstra...
  • 定义一个二维数组,输入一句话,然后以字符串的形式把每个单词分别存储在数组的每一行,这个循环该 怎么写,判断结束的标准是什么(不清楚单词多少和大小),但知道它的限制。
  • 什么是 OODA 循环?美国空军自第一次世界大战以来一直在研究空战。多年来,有关空战的不同理论层出不穷,不断取得进步,其中 John Boyd 的 OODA 循环理论的发展更堪称一大高峰。图 1. OODA 循环 图 1 显示了循环中...
  • 1. 什么是循环依赖? 2. 循环依赖并不能彻底解决,就算非构造方法注入也不能,为什么? 3. “二级缓存”如何解决循环依赖? 4. Spring为什么用“三级缓存”去解决循环依赖? 5. 总结“三级缓存”的精妙之处 bean的...
  • 编写程序猜测计算机脑子里想的是什么数可以编写一个程序,让计算机随机产生一个0到100之间且包含0和100的整数程序提示用户连续输入一个数字直到它和计算机产生的数字相匹配为止对用户每次输入的数字程序都要告诉用户...
  • 与其它大型框架不同的,Vue 被设计为可以自底向上逐层应用。Vue 的核心库只关注视图层,不仅易于上手,还便于与第三方库或既有项目整合。另一方面,当与现代化的工具链以及各种支持类库结合使用时,Vue 也完全能够...
  • 需求方要提供详细的需求文档(requestdoc),需求有变更需要被记录(changerequestdoc)、接受需求后进入内部流程并交付产出物给开发团队(一堆doc,视觉都需要文档化),开发团队依据设计文档交付版本,QA部依据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,844
精华内容 1,137
关键字:

循环设计是什么