本文为您带来遍历的英文翻译，包括遍历用英语怎么说，遍历用英语怎么说，遍历的英语造句，遍历的英文原声例

本文为您带来遍历的英文翻译，包括遍历用英语怎么说，遍历用英语怎么说，遍历的英语造句，遍历的英文原声例句，遍历的相关英语短语等内容。

遍历的英文翻译，遍历的英语怎么说？

遍历的英语网络释义

网络地址转换遍历(NAT-T)：使 IPSec

于是就可以分类输出，当然还需要对serialize进行分割(explode()）、遍历（foreach）..

反过来看，对于这样建立起来的一张图，原始序列其实就是对该图进行深度优先遍历（Depth First Search）的结果。

l中序遍历(Inorder)：根据二叉查找树的性质，中序遍历将按排列顺序输出树中的所有关键字。

遍历的汉英大词典

遍历[biàn lì]

• {数} ergodic
• 短语:
  • 遍历定理 ergodic theorem;
  • 遍历过程 ergodic process;
  • 遍历假设 ergodic hypothesis;
  • 遍历理论 ergodic theory;
  • 遍历信源 ergodic source

遍历的英语短语

遍历的英文例句

我要定义一个类，特别要做的是，遍历它所表示的内容。

I'm going to define a class, and in particular, what I'm going to do, is to walk through what that says.

如果不是由于这个小小的优化，我们将遍历每个元素两次。

If not for this small optimization, we would go through every element twice.

您必须遍历不相关事件的日志，以找到所需的内容，这在活动服务器上可能很棘手。

You have to go through logs of unrelated events to find what you need, which can be a nightmare on a live server.

跟踪由鼠标引起的焦点遍历行为。

You can track focus traversal activity originated by the mouse.

针对管理安全功能的遍历权限。

Traverse permission to the administration secured function.

这无疑比我所讨论的遍历方法更方便。

This is certainly more convenient than the traversal methods I discussed.

针对内容管理页面的执行和遍历权限。

Execute and traverse permission to the content administration page.

这当然比上面所讨论的遍历方法方便。

This is certainly more convenient than the traversal methods we discussed above.

图1总结了常用的遍历函数。

Figure 1 summarizes the commonly used traversal functions.

在这个步骤中，您将遍历源文件系统树。

In this step, you will traverse the source file system tree.

遍历当前工作目录下的所有文件。

Loop over files in the current working directory.

递归式遍历JSF组件树。

Traversing the JSF component tree recursively.

遍历网络堆栈，以寻找出站调用。

Traverse the network stack for the outbound invocation.

它遍历整个列表并提到正确的位置。

It goes through and puts ones in the right place.

遍历网络堆栈，以接受入站请求。

Traverse the network stack to accept the inbound request.

遍历网络堆栈，以处理返回值。

Traverse the network stack to process the return value.

遍历网络堆栈，以发送返回值。

Traverse the network stack to send the return value.

为此，遍历文档中的工作空间元素。

To do that, loop through the workspace elements in the document.

不幸的是，无法直接遍历参数。

Unfortunately, there is no direct way you can iterate over the arguments.

您可以遍历文档树、删除节点或者嫁接新节点。

You can traverse the document tree, prune nodes, or graft on new ones.

接着，它遍历本地存储中的所有数据。

Next, it iterates over all of the data in local storage.

对列表的遍历也采用同样的工作方式。

Traversing any list works in the same way.

在向索引添加文件时，可以遍历目录。

You can recurse across directories when you add files to an index.

用一个文档遍历转换过程。

Run through your conversion with one document.

从访问提示节点开始，遍历每一个节点。

Start by accessing the Suggestions nodes and iterating through each one.

此代码的未来改进中应考虑遍历这些值。

A future refinement of this code should consider looping through those values.

使用站点地图引导爬行器遍历您的站点。

Use a site map to lead the crawler around your site.

例如，遍历一个对象集合。

Take walking across a collection of objects, for example.

创建迭代器以遍历ddo。

Create an iterator to go through the DDO.

然后循环遍历这些设置。

We then loop through them.

遍历的原声例句

You'll also notice that this thing goes through the entire list, even if the list is sorted before it gets partway through.

你也能注意到，它始终会遍历列表,甚至列表在排序之前,就是有序的也是这样。

And because, as long as this collection is finite, this thing is just going to walk through. All right?

这个操作就会遍历完它的，对不对？,那么，如果我给大家看看，例如？

I just go down the list selecting the smallest person at a time and then I repeat, repeat, repeat but when we actually did out the math or kind of reason through it, the running time, the asymptotic running time of bub-- of Selection Sort was also what?

只需要遍历列表，每次找出最小的元素,然后重复上述步骤，但从数学角度看,选择排序的时间复杂度,又是多少呢？

In other words it doesn't just return when it finds one, it's going to run through all of them. All right?

但是它将会继续运行,换句话来说当它找到一个结果时,它不会立刻返回结果它会先遍历所有的内容？

OK? So you can see that, it's just walking through it, and in fact if I look at a couple of another-- another couple of examples, it's been a long day, again, you can see that property.

恩，其实你能看到,他就是遍历列表，你要有空的话,可以再看很多很多其他的例子,你能够看到这个属性。

google Imagine you want to search through Google to find a particular page. You want to do it in a second. And you're going to just do it the brute force way, assuming you could even reach all of those pages in that time.

假设你想通过,搜索一个特定的网页,你想在1秒内得到结果,然后你就只管去做了,认为能在1秒内遍历遍所有的网页。

In the second case, I found in the next smallest element and moved here, taking what was there and moving it on, in this case I would swap the 4 and the 8, and in next case I wouldn't have to do anything.

在第二次遍历中，我找到了,第二小的元素，把它移到这里,把这里原来的元素移到哪里,在这一次遍历中，我会把8和4交换,然后一次遍历，不会做任何事情。

Well basically, all I'd have to do is go through and find every place I checked the constraint, and change it. To incorporate the new constraint.

比较简单，在最上方，基本上,我做的所有事情就是遍历，整段代码然后找到我对比。

The better way to think about this is, suppose, rather than starting at the beginning, I just grabbed some spot at random, like this one.

不从数组的头开始遍历，我随即的从数组中抓一个元素，比如这个，我去看看这个元素的值。

If it was an unordered list, we were basically stuck with linear search. Got to walk through the whole list to see if the thing is there.

如果是一个未排序的列表,基本上我们就只能使用线性搜索了,通过遍历整个列表来查看。

Now you might say, wait a minute. Thing's ordered, if I stop part way through and I throw away half the list, doesn't that help me? And the answer is yes, but it doesn't change the complexity.

如果我在半路上停下来,然后不去遍历剩下的数组了,这会有帮助么？答案是有帮助，但这没法改变算法的复杂度，因为我们之前怎么说来着？

So what would I want to do? I'd like to somehow walk down each of the digits one at a time and add them up. Ah, that's a looping mechanism, right? I need to have some way of walking through them.

去取这个数的,每个数字然后把他们加起来,啊，这是个循环机制对不对？,我得找到一个遍历它们的方法,一种简单的方法可能。

I'm walking along the list once, taking two things and saying, make sure the biggest one is next.

我遍历一次列表，每次取两个值,确认最大的元素在后面一个。

So in the first case, I didn't have to do any swaps because 1 was the smallest thing.

所以在第一次遍历中，我没有做,任何的交换因为1就是最小的。

Suppose I want to find all the divisors of some integer, I want to figure out what all the divisors are that go evenly into it.

也就是遍历所有的整数来寻找,一个数的平方根，让我们再来看一个例子吧,为了找出另外一种的解决方法。

Figure out what I'm trying to walk through What's the collection of things I'm trying to walk through. Figure out what I want to do at each stage. Figure out what the end test is.

弄清楚需要遍历的东西,弄清楚我需要遍历的东西的集合,弄清楚我在每一步该做什么,弄清楚终结测试。

I, somehow if, I want to walk through some sequence of data structures, gathering up or doing the same thing, adding ages in until I get a total age and then divide by the number faculty.

我想，以某种方法，来遍历,一些数据结构，把它们相同的属性加到一起，就是一直的把年龄加到一起一直到,得到了一个年龄总数,然后除以员工的数目。

And that you might look at, for example, that first example, and say, man by this stage it was already sorted, yet it had to go through and check that the third element was in the right place, and then the fourth and then the fifth and then the six.

你可能会去看看例如第一个例子，然后要抱怨，到这里,它已经是排好序的了,但他还是得去遍历查看,第三个元素是不是在正确的位置,然后第四个，第五个，第六个。

Well let's see. My fall back is, I could just do linear search, walk down the list one at a time, just comparing those things. OK. So that's sort of my base. But what if I wanted, you know, how do I want to get to that sorted list? All right?

我只能做线性搜索了,一次遍历一遍列表，一个一个比较，但如果我想要,那怎样得到有序的列表呢？,现在的一个问题是，我们排序之前？

Think about this compared to a linear search.

线性查找总是从开头开始遍历。

And what it's saying semantically is, using that variable as my placeholder, have it walk through this collection, starting at the first thing, execute that code, then the next thing, execute that code, and so on.

它的语义意思就是，把这个变量应用为我的占位符，用它来遍历这个集合，从第一个元素开始，执行代码，然后下一个元素，再执行代码。

I'm walking down the list.

算法遍历了一遍数组。

So the first one here is something called insertion sort which amounts to going through the list, taking the first thing that you see and inserting that element into its correct place, - then moving on to the next one, dealing with what element-- whatever element you're given and putting it in its right place.

首先是插入排序,在此算法中，需要遍历整个列表,将你遇到的第一个元素放在其正确的位置，然后移动到下一个元素，继续处理-,不管是什么元素,都将其插入到合适的位置。

So this isn't-- OK. And you're also close. It's going to be linear but how many times do I go through this?

每次能丢掉一半，所以这里不是-,好的，但你也很接近了,他可能是线性的，但我得遍历多少次呢？

How do I figure that out? Well I'm looping down the list, right? I'm walking down the list.

怎么算出来的呢？我在循环遍,历这个列表对吧？那要遍历这个列表。

I shouldn't say list, those two tuples, and walk through them to find the pieces that match up.

除数数组进行对比，我不该说数组的，是元组,遍历这两个元组找到相同的元素。

So it's going to look at the rest of the list, walking along, and what does it do?

所以它会查看列表剩下部分，遍历它们，那它要做什么呢？

It was as if, when we went through this search tree, we never remembered what we got at the bottom, and we just re-computed things over and over.

如果当我们遍历完这棵树，我们不可能，记得我们在最下面得到什么结果,我们只是不断地重复计算，所以这让。

What's this thing doing? It's walking along the list looking for the smallest thing in the back end of the list, keeping track of where it came from and swapping it with that spot in the list. All right?

这是在做什么？是在遍历列表,找列表后端最小的元素,跟踪它从哪里来的,然后同当前点的元素交换，明白了么？

遍历的网络释义

遍历 所谓遍历(Traversal)，是指沿着某条搜索路线，依次对树（或图）中每个节点均做一次访问。访问结点所做的操作依赖于具体的应用问题， 具体的访问操作可能是检查节点的值、更新节点的值等。不同的遍历方式，其访问节点的顺序是不一样的。遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。当然遍历的概念也适合于多元素集合的情况，如数组。

以上关于遍历的英语翻译来自英汉大词典，希望对您学习遍历的英语有帮助。