当前位置：文档库 › 堆栈和队列-外文翻译.doc

堆栈和队列-外文翻译.doc

本科毕业设计（论文）外文参考文献译文及原文

学院应用数学学院

专业信息与计算科学

（信息安全方向）

年级班级2013级（1）班

学号xxxxx

学生姓名 xxx

指导老师 xxx

2017年6 月

1 堆栈和队列（译文） (1)

1.1堆栈、堆栈的实现以及STACK类 (1)

1.1.1堆栈的操作 (1)

1.1.2Stack类的实现 (2)

1.2STACK类 (3)

1.2.1Stack构造器方法 (3)

1.2.2主要的堆栈操作 (3)

1.2.3Peek方法 (4)

1.2.4Clear方法 (4)

1.2.5Contains方法 (4)

1.2.6CopyTo方法和ToArray方法 (5)

1.2.7Stack类的实例：十进制向多种进制的转换 (5)

1.3队列、QUEUE类以及QUEUE类的实现 (6)

1.3.1队列的存=操作 (6)

1.3.2Queue的实现 (7)

1.3.3Queue类：实例应用 (7)

1.3.4用队列存储数据 (8)

1.3.5源自Queue类的优先队列 (10)

1.4小结 (11)

2 STACKS AND QUEUES（原文） (12)

2.1STACKS,A STACK IMPLEMENTATION AND THE STACK CLASS (12)

2.1.1 Stack Operations (12)

2.1.2 A Stack Class Implementation (13)

2.2THE STACK CLASS (14)

2.2.1 The Stack Constructor Methods (14)

2.2.2 The Primary Stack Operations (15)

2.2.3 The Peek Method (16)

2.2.4 The Clear Method (16)

2.2.5 The Contains Method (16)

2.2.6 The CopyTo and ToArray Methods (17)

2.2.7 A Stack Class Example: Decimal to Multiple-Bases Conversion (17)

2.3QUEUES,THE QUEUE CLASS AND A QUEUE CLASS IMPLEMENTATION (18)

2.3.1 Queue Operations (18)

2.3.2 A Queue Implementation (19)

2.3.3 The Queue Class: A Sample Application (19)

2.3.4 Sorting Data With Queues (21)

2.3.5 Priority Queues: Deriving From the Queue Class (22)

2.4SUMMARY (23)

1 堆栈和队列（译文）

数据像表一样自然地组织起来。此前已经采用Array类和ArrayList类来把数据像表一样组织在一起。尽管其他的数据结构也可以把数据按照便利的形式组织起来进行处理，但是这些结构对于实际地设计并实现问题的解决方法都不提供真正的抽象。

堆栈和队列是两种面向表的数据结构，它们都提供了易于理解的抽象。堆栈中的数据只能在表的某一端进行添加和删除操作，反之队列中的数据则在表的一端进行添加操作而在表的另一端进行删除操作。堆栈被广泛用于从表达式计算到处理函数调用的任何编程语言的实现中。而队列则用在区分优先次序的操作系统处理以及模拟现实世界的事件方面，比如银行出纳柜台的队列，以及建筑物内电梯的操作。

C#语言为使用这些数据结构提供了两种类：Stack类和Queue类。本章将会讨论如何使用这些类并且介绍一些实用的例子。

1.1 堆栈、堆栈的实现以及STACK类

正如前面提到的那样，堆栈是最频繁用到的数据结构之一。这里把堆栈定义为数据项的列表，而且这些数据项只能从表的末端进行存取访问。可存取访问的这端被称为是栈顶。堆栈的标准模型是自助餐厅的盘子堆。人们始终要从顶部拿走盘子，而且当洗碗工或者杂工把盘子放回盘子堆的时候也是把它放在盘堆的顶部。堆栈是著名的后进先出（LIFO）数据结构。

1.1.1 堆栈的操作

堆栈最基本的两种操作就是向堆栈内添加数据项以及从堆栈中删除数据项。Push（进栈）操作是向堆栈内添加数据项。而把数据项从堆栈内取走则用Pop（出栈）操作。这些操作的实例说明可参见图1.1。

图1.1堆栈的进栈和出栈操作

堆栈的另外一种基本操作就是察看栈顶的数据项。Pop操作会返回栈顶的数据项，但是此操作也会把此数据项从堆栈中移除。如果只是希望察看栈顶的数据项而不是真的要移除它，那么在C#语言中有一种名为Peek（取数）的操作可以实现。当然，此操作在其他语言和实现中可能采用其他的名称（比如Top）。

进栈、出栈以及取数都是在使用堆栈时会执行的基本操作。但是，还有其他一些需要执行的操作以及需要检查的属性。从堆栈中移除全部数据项就是非常有用的操作。通过调用Clear（清除）操作可以把堆栈全部清空。此外，在任何时候都能知道堆栈内数据项的数量也是非常有用的。这可以通过调用Count（计数）属性来实现。许多实现都有StackEmpty方法。此方法会根据堆栈的状态返回一个真值或假值，但是也可以采用Count属性达到同样的目的。

.NET框架的Stack类实现了全部这些操作和属性，甚至还要更多。但是在讨论如何使用它们之前，还是先来看看如果没有Stack类，则需要如何实现一个堆栈。

1.1.2 Stack类的实现

Stack的实现需要采用一种潜在的结构来保存数据。既然在新数据项进栈的时候不需要担心调整表的大小，所以这里选择用ArrayList。

因为C#语言拥有如此强大的面向对象的编程特征，所以这里将把堆栈作为一个类来实现。此类被称为是CStack。这里还会包括一个构造器方法以及有关上述提及操作的方法。为了说明在C#语言中实现的过程，Count属性会作为一种属性来实现。首先从讨论类中需要的私有数据开始吧。

所需要的最重要的变量就是用来存储堆栈数据项的ArrayList对象。除此以外，另一个也需要关注的数据就是栈顶。这里将用一个简单的整型变量来处理以便提供类似索引的功能。当对一个新的CStack对象实例化时，会把此变量的初始值设为-1。每次把新的数据项压入堆栈时，变量就会自加1。

构造器方法只完成对索引变量初始化为-1的操作。第一种实现的方法是Push。程序调用ArrayLsit的Add方法，并且把传递给它的数值添加到ArrayList 里面。Pop方法完成三件事：调用RemoveAt方法来取走栈顶的数据项（脱离ArrayList），索引变量自减1操作，以及最终返回出栈的对象。

Peek方法是通过调用含有索引变量作为参数的Item方法来实现的。Clear

方法则简单地调用ArrayList类中同样的方法。既然不需要突发改变堆栈上数据项的数量，所以这里把Count属性写为只读的属性。

1.2 STACK类

Stack类是ICollection接口的一个实现。它代表了一个LIFO群集或一个堆栈。此类在.NET框架中是作为循环缓冲来实现的。这使得能动态地分配进栈数据项的空间。

Stack类包含进栈方法、出栈方法以及取值方法。此外，还有用于确定堆栈内元素数量的方法，清除堆栈全部数值的方法，以及把堆栈数值作为数组返回的方法。这里首先从讨论Stack类构造器的工作原理开始。

1.2.1 Stack构造器方法

这里有三种方法来实例化一个堆栈的对象。默认的构造器实例化成一个具有10个数值初始容量的空堆栈。调用默认构造器的方式如下所示：

Stack myStack = new Stack();

对常规堆栈进行实例化如下所示：

Stack myStack = new Stack();

每次堆栈达到满容量，就会把容量值翻倍。

第二个Stack构造器方法允许创建一个来自另一个群集对象的堆栈对象。例如，可以把构造器作为数组进行传递，并且用来自现有数组的元素构建成堆栈：string[] names = new string[] { "Raymond", "David", "Mike" };

Stack nameStack = new Stack(names);

执行Pop方法会首先把“Mike”从堆栈中移除。

当然，还可以实例化堆栈对象并且指明堆栈的初始容量。如果提前知道要存储在堆栈内的元素的数量，那么这个构造器就会派上用场。在用这种方法构造堆栈的时候，就会使程序更加有效。如果堆栈有20个元素且已达到总容量，那么添加一个新元素将会包含20+1条指令，因为要给新元素腾出空间，就需要移动堆栈内的每一个元素。

实例化带有初始容量的Stack对象的程序代码如下所示：

Stack myStack = new Stack(25);

1.2.2 主要的堆栈操作

对堆栈最主要的操作就是Push和Pop。用Push方法把数据添加到堆栈里面。用Pop方法把数据从堆栈中移除。下面通过用堆栈来计算简单的算术表达式的实例来了解一下这些方法。

这个表达式求值器采用了两个堆栈：一个用于运算数（数字），而另一个则用于运算符。算术表达式会作为字符串存储起来。利用For循环来读取表达式中的每个字符，并且把字符串解析成独立的记号。如果记号是数字，就把它压入数字堆栈内。如果记号是运算符，则把它压入运算符堆栈内。既然这里采用的是中缀算术运算，所以在执行一次操作之前要等到堆栈内压入两个运算数才行。一旦满足条件了，就把两个运算数和一个运算符出栈，并且执行指定的算术操作。接着，再把运算结果压回到堆栈内，而这个运算结果就变成下一次操作的第一个运算数了。继续反复这样的操作直到所有数字都执行完入栈和出栈操作为止。

1.2.3 Peek方法

Peek方法会让人们在不把数据项移出堆栈的情况下看到栈顶数据项的值。如果没有这种方法，那么就需要把数据项从堆栈内移除才会知道它的数值。当大家想在栈顶数据项出栈之前查看它的数值的时候，就可以采用这种方法：

if (IsNumeric(Nums.Peek()))

num = Nums.Pop();

1.2.4 Clear方法

Clear方法会把所有数据项从堆栈内移除，并且把数据项计数器设置为零。很难说清楚Clear方法是否会影响堆栈的容量。因为无法检查堆栈的实际容量，所以最好的办法就是假设堆栈的容量被重新设置为初始默认的10个元素的大小。

Clear方法的有效应用是在处理过程出现错误的情况下清除堆栈。例如，在上述表达式求值器中，如果遇到除以0的操作，这就是错误，需要清除堆栈：

if (oper2 == 0)

Nums.Clear();

1.2.5 Contains方法

Contains方法用来确定指定的元素是否在堆栈内。如果找到该元素，那么此

方法会返回True；否则就返回False。这种方法可以用来寻找堆栈内并非当前栈顶的数值。比如，堆栈内某个字符可能会导致处理错误的这种情况：

if (myStack.Contains(" "))

StopProcessing();

else

ContinueProcessing();

1.2.6 CopyTo方法和ToArray方法

CopyTo方法会把堆栈内的内容复制到一个数组中。数组必须是Object类型，因为这是所有堆栈对象的数据类型。此方法会取走两个参数：一个数组和开始放置堆栈元素的数组的起始索引。堆栈内元素按照LIFO的顺序进行复制操作，就好像对它们进行出栈操作一样。下面这段代码说明了CopyTo方法的调用：Stack myStack = new Stack();

for (int i = 20; i > 0; i--)

myStack.Push(i);

object[] myArray = new object[myStack.Count];

myStack.CopyTo(myArray, 0);

ToArray方法的工作原理与CopyTo方法类似。但是用户无法指定数组的起始索引位置，而是需要在赋值语句中创建新的数组。实例如下所示：

Stack myStack = new Stack();

for (int i = 0; i > 0; i++)

myStack.Push(i);

object[] myArray = new object[myStack.Count];

myArray = myStack.ToArray();

1.2.7 Stack类的实例：十进制向多种进制的转换

虽然在大多数商务应用中都采用十进制数，但是一些科学技术应用则要求把数表示成其他进制的形式。许多计算机系统应用程序要求数既可以表示成八进制的形式，也可以表示成二进制的形式。

用来把十进制数转化为八进制或二进制数的一种算法就是利用堆栈来实现的。下面列出了算法的步骤：

取十进制数

取要转换进制的基数

循环

把十进制数与基数相除的余数压入堆栈

把十进制数与基数相除的商赋值给新的十进制数

当十进制数不等于0时继续循环

一旦循环终止，就产生了被转换的数。把堆栈内独立的数字简单地出栈就可以看到结果了。

尽管堆栈是一种有用的数据结构，但是一些应用程序为了使自身更适合被模拟而采用了另外基于表的数据结构。例如，在杂货店或本地影碟租借店内形成的队伍。不同于后进先出的堆栈，在这些队伍内的第一个人应该最先出去（FIFO）。另外一个实例就是发送给网络（或本地）打印机的打印任务列表。打印机应该首先处理最先发送的任务。这里采用了一种基于表的数据结构来对这些实例进行模拟。这种结构被称为是队列。它是下一小节要讨论的主题。

1.3 队列、QUEUE类以及QUEUE类的实现

队列是一种把数据从表的末端放入并在表的前端移除的数据结构。队列会按照数据项出现的顺序来存储它们。队列是先进先出（FIFO）数据结构的实例。队列用来对提交给操作系统或打印池的任务进行排序，而模拟应用程序则用队列对用户等待队列进行模拟。

1.3.1 队列的存=操作

队列包含两种主要的操作。一个是给队列添加新的数据项，另一个则是把数据项从队列中移除。添加新数据项的操作被称为是Enqueue，而从队列中移除数据项的操作则被称为是Dequeue。Enqueue操作会在队列的末尾添加一个数据项，而Dequeue操作则会从队列的前端（或开始处）移除一个数据项。图1.2就举例说明了这些操作。

队列的另外一个主要操作就是查看起始数据项。就像在Stack类中的对应操作一样，Peek方法用来查看起始的数据项。这种方法仅仅返回数据项，而不会真的把数据项从队列中移除。

Queue类的其他的属性也会对编程有所帮助。然而，在讨论这些属性之前，

图1.2 队列操作

还是先来看看如何能实现一个Queue类。

1.3.2 Queue的实现

就像Stack类的实现所做的一样，Queue类的实现用ArrayList简直是毋庸置疑的。对于这些数据结构类型而言，由于它们都是动态内置的结构，所以ArrayList是极好的实现选择。当需要往队列中插入数据项时，ArrayList的Add 方法会把数据项放置在表的下一个自由元素上。当需要从队列中移除数据项时，ArrayList会在表中把每一个保留的数据项向前移动一个元素。这里不需要保留占位符，因为这样会导致代码内不易察觉的错误。

1.3.3 Queue类：实例应用

前面已经提到了用于Queue类的主要方法，而且还了解了这些方法在Queue 类中的实现。下面通过查看一个用Queue作为基本数据结构的实际编程问题来进一步讨论这些方法。但是，首先需要说明一下Queue对象的几个基本属性。在对一个新的Queue对象实例化的时候，队列默认的容量是32个数据项。根据定义，当队列已满时，其容量会双倍增长。这就意味着当队列最初达到满容量时，其新的容量值会变为64。但是大家可以不用受这些数值的限制。在实例化对队列时，大家可以指定一个不同的初始容量值。如下所示：

Queue myQueue = new Queue(100);

这个设置把队列的容量值设为了100个数据项。当然，大家也可以改变增长的倍

数。增长倍数是传递给构造器的第二个参数，如下所示：

Queue myQueue = new Queue(32, 3);

通用的Queue初始化如下所示：

Queue numbers = new Queue();

这一行指定增长倍数是默认初始容量的3倍。因为构造器会根据不同的信号来寻

找方法，所以即使指定的容量值和默认容量完全一样，也需要进行详细说明。

正如早前已经提到的那样，队列经常用来模拟人们排队的情况。用队列模拟

的假设之一就是在Elks Lodge举行的年度单身舞会。男士们和女士们进入会场并

且站成一排。舞池的场地狭小到只能同时容下三对舞者。当舞池内有空间的时候，

就把队列中第一位男士和第一位女士选作舞者。一旦一对舞者离开队列，那么下

一对舞者就会移动到队列的前端。

就像上面发生的操作一样，程序会宣布第一对舞者以及队伍中的下一对人

选。如果没有完整的一对舞者，那么就会宣布队伍中的下一个人。如果队伍中没

有人了，那么就把这种情况显示出来。

首先来看看用于模拟的数据：

F Jennifer Ingram

M Frank Optiz

M Terrill Beckerman

M Mike Dahly

F Beata Lovelace

M Raymond Williams

F Shirley Yaw

M Don Gundolf

F Bernica Tackett

M David Durr

M Mike McMillan

F Nikki Feldman

这里用一个结构来表示每一位舞者。两个简单的String类方法（Chars方法和Substring方法）用来构建舞者。

1.3.4 用队列存储数据

队列的另外一种应用就是存储数据。回顾计算的早期时代，那时的程序都是通过穿孔卡片录入到大型计算机内，其中每张卡片上存有单独一条程序语句。卡片用机械排序器进行存储，这种排序器采用了类似箱子的结构。这里可以用队列存储数据的方式来模拟此过程。这种排序方法被称为是基数排序。基数排序在编程的指令系统中不是最快的排序方法，但是它却能说明队列的另外一种有趣应用。

基数排序是通过对一组数据进行两遍排序来操作的。在这种情况下，整数的取值范围是从0到99。第一遍是基于个位上的数字进行排序，而第二遍则是基于十位上的数字进行排序。然后，根据这些位置上的每个数字来把每一个数放置在一个箱子内。假设有下列这些数：91、46、85、15、92、35、31、22。

在箱子结构中第一遍排序的结果是：

0号箱子：

1号箱子：91 31

2号箱子：92 22

3号箱子：

4号箱子：

5号箱子：85 15 35

6号箱子：46

7号箱子：

8号箱子：

9号箱子：

现在，把这些数按照它们在箱子中的位置排列起来，结果如下所示：91、31、92、22、85、15、35、46。

接下来，取上述列表，按照十位上的数字对这些数排序后放入适当的箱子内：

0号箱子：

1号箱子：15

2号箱子：22

3号箱子：31 35

4号箱子：46

5号箱子：

6号箱子：

7号箱子：

8号箱子：85

9号箱子：91 92

把这些数从箱子内取出，并且把它们放回到列表内。此时就是这组整数排序后的结枝：15、22、31、35、46、85、91、92。

用队列来表示这些箱子就可以实现这个算法。针对每一位数字一共需要九个队列。用取余运算和整除运算就可以确定个位上的数字以及十位上的数字。剩下的事情就是把数添加到适当的队列内，接着根据个位上的数字再把数从队列中取出进行重新排序，随后根据十位上的数字重复上述操作。最后的结果就是排序后的整数列表。

1.3.5 源自Queue类的优先队列

正如大家现在知道的那样，队列是一种先进先出的数据结构。这种行为的效果就是会最先移除结构内最早进入的数据项。然而，对于很多应用程序而言，需要一种可以把具有最高优先级的数据项最先移除的数据结构，即使这个数据项在结构中不是“最早进入的”一个。对于这类应用程序Queue有一种特殊的案例，那就是优先队列。

许多应用程序在操作中都利用到了优先队列。一个很好的实例就是在计算机操作系统内的进程处理。某些进程可能有高于其他进程的优先级，比如打印进程就具有典型的低优先级。进程（或任务）通常会根据优先级进行编号，Priority （优先级）为0的进程比Priority为20的任务具有更高的优先性。

通常会把存储在优先队列中的数据项作为键值对来构造，其中关键字就是指优先级别，而值则用来识别数据项。例如，可以按照如下形式对一个操作系统进程进行定义：

struct Process

{

int priority;

string name;

}

大家不能把未修改的Queue对象用于优先队列。DeQueue方法在被调用时只会把队列中的第一个数据项移除。但是，大家可以从Queue类派生出自己的优先队列类，同时覆盖DeQueue方法来实现自己的需求。

大家把这个类称为PQueue。所有Queue的方法都可以照常使用，同时覆盖Dequeue方法来移除具有最高优先级的数据项。为了不从队列前端移除数据项，首先需要把队列的数据项写入一个数组。然后遍历整个数组从而找到具有最高优先级的数据项。最后，根据标记的数据项，就可以在不考虑此标记数据项的同时对队列进行重新构建。

1.4 小结

学会适当且高效地使用数据结构是把编程专家从普通程序员中分离出来的技巧之一。编程专家会认识到把程序的数据按照适当的数据结构进行组织会使得数据的处理工作更加简单。事实上，用数据抽象来思考计算机编程问题会更容易最先得到解决问题的好的方案。

本章讨论了两种非常普通的数据结构，即堆栈和队列。堆栈可以用于解决计算机编程方面许多不同类型的问题，特别是诸如解释器和编译器这类系统编程领域的问题。此外，本章还说明了利用堆栈解决更通用问题的方法，比如确定单词是否为回文的问题。

队列也有许多的应用。操作系统用队列（通过优先队列）来对进程进行排序，而且队列还时常用于模拟现实世界的过程。最后，本章还用Queue类派生出一个用来实现优先队列的类。派生的新类的能力来自.NET框架类库内的类。这也是C#语言的.NET版重要的优势之一。

2 Stacks and Queues（原文）

Data organize naturally as lists.We have already used the Array and ArrayList classes for handling data organized as a list. Although those data structures helped us group the data in a convenient form for processing, neither structure provides a real abstraction for actually designing and implementing problem solutions.

Two list-oriented data structures that provide easy-to-understand abstractions are stacks and queues. Data in a stack are added and removed from only one end of the list, whereas data in a queue are added at one end and removed from the other end of a list. Stacks are used extensively in programming language implementations, from everything from expression evaluation to handling function calls. Queues are used to prioritize operating system processes and to simulate events in the real world, such as teller lines at banks and the operation of elevators in buildings.

C# provides two classes for using these data structures: the Stack class and the Queue class. We’ll discuss how to use these classes and look at some practical examples in this chapter.

2.1 STACKS, A STACK IMPLEMENTATION AND THE STACK CLASS

The stack is one of the most frequently used data structures, as we just mentioned. We define a stack as a list of items that are accessible only from the end of the list, which is called the top of the stack. The standard model for a stack is the stack of trays at a cafeteria. Trays are always removed from the top, and the when the dishwasher or busboy puts a tray back on the stack, it is placed on the top also. A stack is known as a Last-in, First-out (LIFO) data structure.

2.1.1 Stack Operations

The two primary operations of a stack are adding items to the stack and taking items off the stack. The Push operation adds an item to a stack. We take an item off the stack with a Pop operation. These operations are illustrated in Figure 1.1.

The other primary operation to perform on a stack is viewing the top item. The Pop operation returns the top item, but the operation also removes it from the stack.

We want to just view the top item without actually removing it. This operation is named Peek in C#, though it goes by other names in other languages and implementations (such as Top).

FIGURE1.1 Pushing and Popping a Stack

Pushing, popping, and peeking are the primary operations we perform when using a stack; however, there are other operations we need to perform and properties we need to examine. It is useful to be able to remove all the items from a stack at one time. A stack is completed emptied by calling the Clear operation. It is also useful to know how many items are in a stack at any one time. We do this by calling the Count property. Many implementations have a StackEmpty method that returns a true or false value depending on thestate of the stack, but we can use the Count property for the same purposes.

The Stack class of the .NET Framework implements all of these operations and properties and more, but before we exami ne how to use them, let’s look at how you would have to implement a stack if there wasn’t a Stack class.

2.1.2 A Stack Class Implementation

A Stack implementation has to use an underlying structure to hold data.We’ll choose an ArrayList since we don’t have to worry about resizing the list when new items are pushed onto the stack.

Since C# has such great object-oriented programming features, we’ll implement the stack as a class, called CStack. We’ll include a constructor method and methods for the above-mentioned operations. The Count property is implemented as a property in order to demonstrate how that’s done in C#.Let’s start by examining the private data we need in the class.

The most important variable we need is an ArrayList object to store the stack items. The only other data we need to keep track off is the top of the stack, which we’ll do with a simple Integer variable that functions as an index.The variable is initially set to ?1 when a new CStack object is instantiated. Every time a new item is pushed onto the stack, the variable is incremented by 1.

The constructor method does nothing except initialize the index variable to ?1. The first method to implement is Push. The code calls the ArrayList Add method and adds the value passed to it to the ArrayList. The Pop method does three things: calls the RemoveAt method to take the top item off the stack (out of the ArrayList), decrements the index variable by 1, and, finally, returns the object popped off the stack.

The Peek method is implemented by calling the Item method with the index variable as the argument. The Clear method simply calls an identical method in the ArrayList class. The Count property is written as a read-only property since we don’t want to accidentally change the number of items on the stack.

2.2 THE STACK CLASS

The Stack class is an implementation of the ICollection interface that represents a LIFO collection, or a stack. The class is implemented in the .NET Framework as a circular buffer, which enables space for items pushed on the stack to be allocated dynamically.

The Stack class includes methods for pushing, popping, and peeking values. There are also methods for determining the number of elements in the stack, clearing the stack of all its values, and returning the stack values as an array. Let’s start with discussing how the Stack class constructors work.

2.2.1 The Stack Constructor Methods

There are three ways to instantiate a stack object. The default constructor instantiates an empty stack with an initial capacity of 10 values. The default constructor is called as follows:

Stack myStack = new Stack();

A generic stack is instantiated as follows:

Stack myStack = new Stack();

Each time the stack reaches full capacity, the capacity is doubled.

The second Stack constructor method allows you to create a stack object from another collection object. For example, you can pass the constructor as an array and a stack is built from the existing array elements:

string[] names = new string[] {"Raymond", "David", "Mike"};

Stack nameStack = new Stack(names);

Executing the Pop method will remove “Mike” from the stack first.

You can also instantiate a stack object and specify the initial capacity of the stack. This constructor comes in handy if you know in advance about how many elements you’re going to store in the stack. You can make your program more efficient when you construct your stack this way. If your stack has 20 elements in it and it’s at total capacity, adding a new element will involve 20 + 1 instructions because each element has to be shifted over to accommodate the new element.

The code for instantiating a Stack object with an initial capacity looks like

this:

Stack myStack = new Stack(25);

2.2.2 The Primary Stack Operations

The primary operations you perform with a stack are Push and Pop. Data is added to a stack with the Push method. Data is removed from the stack with the Pop method. Let’s look at these methods in the context of using a stack to evaluate simple arithmetic expressions.

This expression evaluator uses two stacks: one for the operands (numbers) and another one for the operators. An arithmetic expression is stored as a string. We parse the string into individual tokens, using a For loop to read each character in the expression. If the token is a number, it is pushed onto the number stack. If the token is an operator, it is pushed onto the operator stack. Since we are performing infix arithmetic, we wait for two operands to be pushed on the stack before performing an

operation. At that point, we pop the operands and an operand and perform the specified arithmetic. The result is pushed back onto the stack and becomes the first operand of the next operation. This continues until we run out of numbers to push and pop.

2.2.3 The Peek Method

The Peek method lets us look at the value of an item at the top of a stack without having to remove the item from the stack.Without this method, you would have to remove an item from the stack just to get at its value. You will use this method when you want to check the value of the item at the top of the stack before you pop it off:

if (IsNumeric(Nums.Peek())

num = Nums.Pop():

2.2.4 The Clear Method

The Clear method removes all the items from a stack, setting the item count to zero. It is hard to tell if the Clear method affects the capacity of a stack, since we can’t examine the actual capacity of a stack, so it’s best to assume the capacity is set back to the initial default size of 10 elements.

A good use for the Clear method is to clear a stack if there is an error in processing. For example, in our expression evaluator, if a division by 0 operation occurs, that is an error and we want to clear the stack:

if (oper2 == 0)

Nums.Clear();

2.2.5 The Contains Method

The Contains method determines if a specified element is located in a stack. The method returns True if the element is found; False otherwise.We can use this method to look for a value in the stack but not currently at the top of the stack, such as a situation where a certain character in the stack might cause a processing error:

if (myStack.Contains(" "))

StopProcessing();

else

ContinueProcessing();

2.2.6 The CopyTo and ToArray Methods

The CopyTo method copies the contents of a stack into an array. The array must be of type Object since that is the data type of all stack objects. The method takes two arguments: an array and the starting array index to begin placing stack elements. The elements are copied in LIFO order, as if they were popped from the stack. Here’s a short code fragment demonstrating a CopyTo method call:

Stack myStack = new Stack();

for(int i = 20; i > 0; i--)

myStack.Push(i);

object [] myArray = new object[myStack.Count];

myStack.CopyTo(myArray, 0);

The ToArray method works in a similar manner. You cannot specify a starting array index position, and you must create the new array in an assignment statement. Here’s an example:

Stack myStack = new Stack();

for(int i = 0; i > 0; i++)

myStack.Push(i);

object [] myArray = new object[myStack.Count];

myArray = myStack.ToArray();

2.2.7 A Stack Class Example: Decimal to Multiple-Bases Conversion

Although decimal numbers are used in most business applications, some scientific and technical applications require numbers to be presented in other bases. Many computer system applications require numbers to be in either octal or binary format.

One algorithm that we can use to convert numbers from decimal to octal or binary makes use of a stack. The steps of the algorithm are listed as follows:

Get number

数据结构-堆栈和队列实验报告

实验二堆栈和队列实验目的： 1.熟悉栈这种特殊线性结构的特性； 2.熟练并掌握栈在顺序存储结构和链表存储结构下的基本运算； 3.熟悉队列这种特殊线性结构的特性； 3.熟练掌握队列在链表存储结构下的基本运算。实验原理：堆栈顺序存储结构下的基本算法；堆栈链式存储结构下的基本算法；队列顺序存储结构下的基本算法；队列链式存储结构下的基本算法；实验内容： 3-18链式堆栈设计。要求（1）用链式堆栈设计实现堆栈，堆栈的操作集合要求包括：初始化Stacklnitiate （S）, 非空否StackNotEmpty（S），入栈StackiPush（S,x）, 出栈StackPop （S,d）,取栈顶数据元素StackTop（S,d）; （2）设计一个主函数对链式堆栈进行测试。测试方法为：依次把数据元素1，2，3, 4，5 入栈，然后出栈并在屏幕上显示出栈的数据元素；（3）定义数据元素的数据类型为如下形式的结构体， Typedef struct { char taskName[10]; int taskNo; }DataType; 首先设计一个包含5个数据元素的测试数据，然后设计一个主函数对链式堆栈进行测试，测试方法为：依次吧5个数据元素入栈，然后出栈并在屏幕上显示出栈的数据元素。 3-19对顺序循环队列，常规的设计方法是使用対尾指针和对头指针，对尾指针用于指示当前的対尾位置下标，对头指针用于指示当前的対头位置下标。现要求：（1）设计一个使用对头指针和计数器的顺序循环队列抽象数据类型，其中操作包括：初始化，入队列，出队列，取对头元素和判断队列是否为空；（2）编写一个主函数进行测试。实验结果： 3-18 typedef struct snode { DataType data; struct snode *n ext; } LSNode; /* 初始化操作：*/

外文翻译

Load and Ultimate Moment of Prestressed Concrete Action Under Overload-Cracking Load It has been shown that a variation in the external load acting on a prestressed beam results in a change in the location of the pressure line for beams in the elastic range.This is a fundamental principle of prestressed construction.In a normal prestressed beam,this shift in the location of the pressure line continues at a relatively uniform rate,as the external load is increased,to the point where cracks develop in the tension fiber.After the cracking load has been exceeded,the rate of movement in the pressure line decreases as additional load is applied,and a significant increase in the stress in the prestressing tendon and the resultant concrete force begins to take place.This change in the action of the internal moment continues until all movement of the pressure line ceases.The moment caused by loads that are applied thereafter is offset entirely by a corresponding and proportional change in the internal forces,just as in reinforced-concrete construction.This fact,that the load in the elastic range and the plastic range is carried by actions that are fundamentally different,is very significant and renders strength computations essential for all designs in order to ensure that adequate safety factors exist.This is true even though the stresses in the elastic range may conform to a recognized elastic design criterion. It should be noted that the load deflection curve is close to a straight line up to the cracking load and that the curve becomes progressively more curved as the load is increased above the cracking load.The curvature of the load-deflection curve for loads over the cracking load is due to the change in the basic internal resisting moment action that counteracts the applied loads,as described above,as well as to plastic strains that begin to take place in the steel and the concrete when stressed to high levels. In some structures it may be essential that the flexural members remain crack free even under significant overloads.This may be due to the structures’being exposed to exceptionally corrosive atmospheres during their useful life.In designing prestressed members to be used in special structures of this type,it may be necessary to compute the load that causes cracking of the tensile flange,in order to ensure that adequate safety against cracking is provided by the design.The computation of the moment that will cause cracking is also necessary to ensure compliance with some design criteria. Many tests have demonstrated that the load-deflection curves of prestressed beams are approximately linear up to and slightly in excess of the load that causes the first cracks in the tensile flange.(The linearity is a function of the rate at which the load is applied.)For this reason,normal elastic-design relationships can be used in computing the cracking load by simply determining the load that results in a net tensile stress in the tensile flange(prestress minus the effects of the applied loads)that is equal to the tensile strength of the concrete.It is customary to assume that the flexural tensile strength of the concrete is equal to the modulus of rupture of the

栈和队列习题答案

第三章栈和队列习题答案一、基础知识题设将整数1，2，3，4依次进栈，但只要出栈时栈非空，则可将出栈操作按任何次序夹入其中，请回答下述问题： (1)若入、出栈次序为Push(1), Pop(),Push(2),Push(3), Pop(), Pop( ),Push(4), Pop( ),则出栈的数字序列为何(这里Push(i)表示i进栈，Pop( )表示出栈) (2)能否得到出栈序列1423和1432并说明为什么不能得到或者如何得到。 (3)请分析1，2 ，3 ，4 的24种排列中，哪些序列是可以通过相应的入出栈操作得到的。答：(1)出栈序列为：1324 (2)不能得到1423序列。因为要得到14的出栈序列，则应做Push(1),Pop(),Push(2),Push (3),Push(4),Pop()。这样，3在栈顶，2在栈底，所以不能得到23的出栈序列。能得到1432的出栈序列。具体操作为：Push(1), Pop(),Push(2),Push(3),Push(4),Pop(),Pop(),Pop()。 (3)在1，2 ，3 ，4 的24种排列中，可通过相应入出栈操作得到的序列是： 1234,1243,1324,1342,1432,2134,2143,2314,2341,2431,3214,3241,3421,4321 不能得到的序列是： 1423,2413,3124,3142,3412,4123,4132,4213,4231,4312 链栈中为何不设置头结点答：链栈不需要在头部附加头结点，因为栈都是在头部进行操作的，如果加了头结点，等于要对头结点之后的结点进行操作，反而使算法更复杂，所以只要有链表的头指针就可以了。循环队列的优点是什么如何判别它的空和满答：循环队列的优点是：它可以克服顺序队列的"假上溢"现象，能够使存储队列的向量空间得到充分的利用。判别循环队列的"空"或"满"不能以头尾指针是否相等来确定，一般是通过以下几种方法：一是另设一布尔变量来区别队列的空和满。二是少用一个元素的空间,每次入队前测试入队后头尾指针是否会重合，如果会重合就认为队列已满。三是设置一计数器记录队列中元素总数，不仅可判别空或满，还可以得到队列中元素的个数。设长度为n的链队用单循环链表表示，若设头指针，则入队出队操作的时间为何若只设尾指针呢答：当只设头指针时，出队的时间为1，而入队的时间需要n，因为每次入队均需从头指针开始查找，找到最后一个元素时方可进行入队操作。若只设尾指针，则出入队时间均为1。因为是循环链表，尾指针所指的下一个元素就是头指针所指元素，所以出队时不需要遍历整个队列。指出下述程序段的功能是什么 (1) void Demo1(SeqStack *S){ int i; arr[64] ; n=0 ; while ( StackEmpty(S)) arr[n++]=Pop(S); for (i=0, i< n; i++) Push(S, arr[i]); } .. // 设Q1已有内容，Q2已初始化过 while ( ! QueueEmpty( &Q1) ) { x=DeQueue( &Q1 ) ; EnQueue(&Q2, x); n++;} for (i=0; i< n; i++) { x=DeQueue(&Q2) ; EnQueue( &Q1, x) ; EnQueue( &Q2, x);} 答： (1)程序段的功能是将一栈中的元素按反序重新排列，也就是原来在栈顶的元素放到栈底，栈底的

外文翻译 - 英文

The smart grid Smart grid is the grid intelligent (electric power), also known as the "grid" 2.0, it is based on the integration, high-speed bidirectional communication network, on the basis of through the use of advanced sensor and measuring technology, advanced equipme nt technology, the advanced control method, and the application of advanced technology of decision support system, realize the power grid reliability, security, economic, efficient, environmental friendly and use the security target, its main features include self-healing, incentives and include user, against attacks, provide meet user requirements of power quality in the 21st century, allow all sorts of different power generation in the form of access, start the electric power market and asset optimizatio n run efficiently. The U.S. department of energy (doe) "the Grid of 2030" : a fully automated power transmission network, able to monitor and control each user and power Grid nodes, guarantee from power plants to end users among all the nodes in the whole process of transmission and distribution of information and energy bi-directional flow. China iot alliance between colleges: smart grid is made up of many parts, can be divided into:intelligent substation, intelligent power distribution network, intelli gent watt-hourmeter,intelligent interactive terminals, intelligent scheduling, smart appliances, intelligent building electricity, smart city power grid, smart power generation system, the new type of energy storage system.Now a part of it to do a simple i ntroduction. European technology BBS: an integration of all users connected to the power grid all the behavior of the power transmission network, to provide sustained and effective economic and security of power. Chinese academy of sciences, institute of electrical: smart grid is including all kinds of power generation equipment, power transmission and distribution network, power equipment and storage equipment, on the basis of the physical power grid will be modern advanced sensor measurement technology, network technology, communication

栈和队列的基本操作

《数据结构与算法》实验报告专业班级学号实验项目实验二栈和队列的基本操作。实验目的 1、掌握栈的基本操作：初始化栈、判栈为空、出栈、入栈等运算。 2、掌握队列的基本操作：初始化队列、判队列为空、出队列、入队列等运算。实验容题目1：进制转换。利用栈的基本操作实现将任意一个十进制整数转化为R进制整数算法提示： 1、定义栈的顺序存取结构 2、分别定义栈的基本操作（初始化栈、判栈为空、出栈、入栈等） 3、定义一个函数用来实现上面问题：十进制整数X和R作为形参初始化栈只要X不为0重复做下列动作将X%R入栈 X=X/R 只要栈不为空重复做下列动作栈顶出栈输出栈顶元素题目2：利用队列的方式实现辉三角的输出。算法设计分析（一）数据结构的定义 1、栈的应用实现十进制到其他进制的转换，该计算过程是从低位到高位顺序产生R进制数的各个位数，而打印输出一般从高位到低位进行，恰好与计算过程相反。因此，运用栈先进后出的性质，即可完成进制转换。栈抽象数据结构描述 typedef struct SqStack /*定义顺序栈*/ { int *base; /*栈底指针*/ int *top; /*栈顶指针*/ int stacksize; /*当前已分配存储空间*/ } SqStack;

2、队列的应用由于是要打印一个数列，并且由于队列先进先出的性质，肯定要利用已经进队的元素在其出队之前完成辉三角的递归性。即，利用要出队的元素来不断地构造新的进队的元素，即在第N行出队的同时，来构造辉三角的第N+1行，从而实现打印辉三角的目的。队列抽象数据结构描述 typedef struct SeqQueue { int data[MAXSIZE]; int front; /*队头指针*/ int rear; /*队尾指针*/ }SeqQueue; （二）总体设计 1、栈（1）主函数：统筹调用各个函数以实现相应功能 int main() （2）空栈建立函数：对栈进行初始化。 int StackInit(SqStack *s) （3）判断栈空函数：对栈进行判断，若栈中有元素则返回1，若栈为空，则返回0。 int stackempty(SqStack *s) （4）入栈函数：将元素逐个输入栈中。 int Push(SqStack *s,int x) （5）出栈函数：若栈不空，则删除栈顶元素，并用x返回其值。 int Pop(SqStack *s,int x) （6）进制转换函数：将十进制数转换为R进制数 int conversion(SqStack *s) 2、队列（1）主函数：统筹调用各个函数以实现相应功能 void main() （2）空队列建立函数：对队列进行初始化。 SeqQueue *InitQueue() （3）返回队头函数：判断队是否为空，若不为空则返回队头元素。 int QueueEmpty(SeqQueue *q) （4）入队函数：将元素逐个输入队列中。 void EnQueue(SeqQueue *q,int x) （5）出队函数：若队列不空，则删除队列元素，并用x返回其值。 int DeQueue(SeqQueue *q) （6）计算队长函数：计算队列的长度。 int QueueEmpty(SeqQueue *q) （7）输出辉三角函数：按一定格式输出辉三角。 void YangHui(int n)

外文翻译

Journal of Industrial Textiles https://www.wendangku.net/doc/c412825263.html,/ Optimization of Parameters for the Production of Needlepunched Nonwoven Geotextiles Amit Rawal, Subhash Anand and Tahir Shah 2008 37: 341Journal of Industrial Textiles DOI: 10.1177/1528083707081594 The online version of this article can be found at: https://www.wendangku.net/doc/c412825263.html,/content/37/4/341 Published by: https://www.wendangku.net/doc/c412825263.html, can be found at:Journal of Industrial TextilesAdditional services and information for https://www.wendangku.net/doc/c412825263.html,/cgi/alertsEmail Alerts: https://www.wendangku.net/doc/c412825263.html,/subscriptionsSubscriptions: https://www.wendangku.net/doc/c412825263.html,/journalsReprints.navReprints: https://www.wendangku.net/doc/c412825263.html,/journalsPermissions.navPermissions: https://www.wendangku.net/doc/c412825263.html,/content/37/4/341.refs.htmlCitations: - Mar 28, 2008Version of Record >>

实验二堆栈和队列基本操作的编程实现

实验二堆栈和队列基本操作的编程实现【实验目的】堆栈和队列基本操作的编程实现要求：堆栈和队列基本操作的编程实现（2学时，验证型），掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。也鼓励学生利用基本操作进行一些应用的程序设计。【实验性质】验证性实验（学时数：2H）【实验内容】内容：把堆栈和队列的顺序存储（环队）和链表存储的数据进队、出队等运算其中一部分进行程序实现。可以实验一的结果自己实现数据输入、数据显示的函数。利用基本功能实现各类应用，如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。【思考问题】 1.栈的顺序存储和链表存储的差异？ 2.还会有数据移动吗？为什么？ 3.栈的主要特点是什么？队列呢？ 4.栈的主要功能是什么？队列呢？ 5.为什么会有环状队列？【参考代码】（一）利用顺序栈实现十进制整数转换转换成r进制 1、算法思想将十进制数N转换为r进制的数，其转换方法利用辗转相除法，以N=3456，r=8为例转换方法如下： N N / 8 （整除）N % 8（求余） 3456 432 0 低 432 54 0 54 6 6 6 0 6 高所以：（3456）10 =（6600）8 我们看到所转换的8进制数按底位到高位的顺序产生的，而通常的输出是从高位到低位的，恰好与计算过程相反，因此转换过程中每得到一位8进制数则进栈保存，转换完毕后依次出栈则正好是转换结果。算法思想如下：当N>0时重复1，2 ①若N≠0，则将N % r 压入栈s中，执行2;若N=0，将栈s的内容依次出栈，算法结束。 ②用N / r 代替N 2、转换子程序

PTA第三章栈与队列练习题

1-1 通过对堆栈S操作:Push(S,1), Push(S,2), Pop(S), Push(S,3), Pop(S), Pop(S)。输出得序列为:123。(2分) T F 作者: DS课程组单位: 浙江大学 1-2 在用数组表示得循环队列中,front值一定小于等于rear值。(1分) T F 作者: DS课程组单位: 浙江大学 1-3 若一个栈得输入序列为{1, 2, 3, 4, 5},则不可能得到{3, 4, 1, 2, 5}这样得出栈序列。(2分) T F 作者: 徐镜春单位: 浙江大学 1-4 If keys are pushed onto a stack in the order {1, 2, 3, 4, 5}, then it is impossible to obtain the output sequence {3, 4, 1, 2, 5}、(2分) T F 作者: 徐镜春单位: 浙江大学 1-5 所谓“循环队列”就是指用单向循环链表或者循环数组表示得队列。(1分) T F 作者: DS课程组单位: 浙江大学 1-6 An algorithm to check for balancing symbols in an expression uses a stack to store the symbols、(1分) T F 2-1 设栈S与队列Q得初始状态均为空,元素a、b、c、d、e、f、g依次进入栈S。若每个元素出栈后立即进入队列Q,且7个元素出队得顺序就是b、d、c、f、e、 a、g,则栈S得容量至少就是: (2分) 1. 1 2. 2 3. 3 4. 4 作者: DS课程组

数据结构基础练习(栈和队列)

数据结构基础练习（栈和队列）学号姓名蓝礼巍班级 . 一、选择题 1．有5个元素a,b,c,d,e依次进栈，允许任何时候出栈，则可能的出栈序列是 c 。 A．baecd B．dceab C．abedc D．aebcd 2．下列有关递归的叙述，不正确的是 b 。 A．在计算机系统内，执行递归函数是通过自动使用栈来实现的。 B．在时间和空间效率方面，递归算法比非递归算法好。 C．递归函数的求解过程分为递推（进栈）和回推（出栈）两个阶段。 D．在递归函数中必须有终止递归的条件。 3．栈和队列均属于哪一种逻辑结构 A 。 A．线性结构B．顺序结构C．非线性结构D．链表结构4．设输入元素为1、2、3、P和A，输入次序为123PA，元素经过栈后得到各种输出序列，则可以作为高级语言变量名的序列有 d 种。 A．4 B．5 C．6 D．7 5．一个队列的入队序列为a，b，c，d，则该队列的输出序列是 b 。 A．dcba B．abcd C．adcb D．cbda 6．在一个链式队列中，假设f和r分别为队头和队尾指针，则插入s所指结点的运算是b 。 A. f->next=s; f=s; B. r->next=s; r=s; C. s->next=s; r=s; D. s->next=f; f=s; 7．如果5个元素出栈的顺序是1、2、3、4、5，则进栈的顺序可能是 c 。 A．3、5、4、1、2 B．1、4、5、3、2 C．5、4、1、3、2 D．2、4、3、1、5 8．若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为。 A．i B．n-i C．n-i+1 D．不确定二、填空题 1．栈和队列是一种特殊的线性表，其特殊性体现在是运算受限线性表。设现有元素e1,e2,e3,e4,e5和e6依次进栈，若出栈的序列是e2,e4,e3,e6,e5,e1，则栈S的容量至少是 3 。 2．顺序循环队列中，设队头指针为front，队尾指针为rear，队中最多可有MAX个元素，采用少用一个存储单元的方法区分队满与队空问题，则元素入队列时队尾指针的变化为 Rear=(rear+1)%MAX ；元素出队列时队头指针的变化为fort=(fotr+1)%MAX ；队列中的元素个数为 (rear-fort+MAX)%MAX 。若则可用表示队满的判别条件，队空的判别条件仍然为 rear==fort 。三、解答题

外文翻译中文版(完整版)

毕业论文外文文献翻译毕业设计（论文）题目关于企业内部环境绩效审计的研究翻译题目最高审计机关的环境审计活动学院会计学院专业会计学姓名张军芳班级09020615 学号09027927 指导教师何瑞雄

最高审计机关的环境审计活动 1最高审计机关越来越多的活跃在环境审计领域。特别是1993-1996年期间，工作组已检测到环境审计活动坚定的数量增长。首先，越来越多的最高审计机关已经活跃在这个领域。其次是积极的最高审计机关，甚至变得更加活跃：他们分配较大部分的审计资源给这类工作，同时出版更多环保审计报告。表1显示了平均数字。然而，这里是机构间差异较大。例如，环境报告的数量变化，每个审计机关从1到36份报告不等。 1996-1999年期间，结果是不那么容易诠释。第一，活跃在环境审计领域的最高审计机关数量并没有太大变化。“活性基团”的组成没有保持相同的：一些最高审计机关进入，而其他最高审计机关离开了团队。环境审计花费的时间量略有增加。二，但是，审计报告数量略有下降，1996年和1999年之间。这些数字可能反映了从量到质的转变。这个信号解释了在过去三年从规律性审计到绩效审计的转变（1994-1996年，20％的规律性审计和44％绩效审计;1997-1999：16％规律性审计和绩效审计54％）。在一般情况下，绩效审计需要更多的资源。我们必须认识到审计的范围可能急剧变化。在将来，再将来开发一些其他方式去测算人们工作量而不是计算通过花费的时间和发表的报告会是很有趣的。在2000年，有62个响应了最高审计机关并向工作组提供了更详细的关于他们自1997年以来公布的工作信息。在1997-1999年，这62个最高审计机关公布的560个环境审计报告。当然，这些报告反映了一个庞大的身躯，可用于其他机构的经验。环境审计报告的参考书目可在网站上的最高审计机关国际组织的工作组看到。这里这个信息是用来给最高审计机关的审计工作的内容更多一些洞察。自1997年以来，少数环境审计是规律性审计（560篇报告中有87篇，占16％）。大多数审计绩效审计（560篇报告中有304篇，占54％），或组合的规律性和绩效审计（560篇报告中有169篇，占30％）。如前文所述，绩效审计是一个广泛的概念。在实践中，绩效审计往往集中于环保计划的实施（560篇报告中有264篇，占47％），符合国家环保法律，法规的，由政府部门，部委和/或其他机构的任务给访问（560篇报告中有212篇，占38％）。此外，审计经常被列入政府的环境管理系统（560篇报告中有156篇，占28％）。下面的元素得到了关注审计报告：影响或影响现有的国家环境计划非环保项目对环境的影响;环境政策;由政府遵守国际义务和承诺的10％至20％。许多绩效审计包括以上提到的要素之一。 1本文译自：S. Van Leeuwen.(2004).’’Developments in Environmental Auditing by Supreme Audit Institutions’’ Environmental Management Vol. 33, No. 2, pp. 163–1721

栈和队列(必备)

栈和队列是操作受限的线性表，好像每本讲数据结构的数都是这么说的。有些书按照这个思路给出了定义和实现；但是很遗憾，这本书没有这样做，所以，原书中的做法是重复建设，这或许可以用不是一个人写的这样的理由来开脱。顺序表示的栈和队列，必须预先分配空间，并且空间大小受限，使用起来限制比较多。而且，由于限定存取位置，顺序表示的随机存取的优点就没有了，所以，链式结构应该是首选。栈的定义和实现 #ifndef Stack_H #define Stack_H #include "List.h" template class Stack : List//栈类定义 { public: void Push(Type value) { Insert(value); } Type Pop() { Type p = *GetNext(); RemoveAfter(); return p; }

Type GetTop() { return *GetNext(); } List ::MakeEmpty; List ::IsEmpty; }; #endif 队列的定义和实现 #ifndef Queue_H #define Queue_H #include "List.h" template class Queue : List//队列定义{ public: void EnQueue(const Type &value) { LastInsert(value); } Type DeQueue() {

Type p = *GetNext(); RemoveAfter(); IsEmpty(); return p; } Type GetFront() { return *GetNext(); } List ::MakeEmpty; List ::IsEmpty; }; #endif 测试程序 #ifndef StackTest_H #define StackTest_H #include "Stack.h" void StackTest_int() { cout << endl << "整型栈测试" << endl;

计算机专业基础综合数据结构(栈和队列)历年真题试卷汇编6

计算机专业基础综合数据结构（栈和队列）历年真题试卷汇编6 (总分：60.00，做题时间：90分钟) 一、单项选择题(总题数：14，分数：28.00) 1.为解决计算机主机与打印机之间速度不匹配问题，通常设置一个打印数据缓冲区，主机将要输出的数据依次写入该缓冲区，而打印机则依次从该缓冲区中取出数据。该缓冲区的逻辑结构应该是( )。【2009年全国试题1(2)分】 A.栈 B.队列√ C.树 D.图 2.设栈S和队列Q的初始状态均为空，元素a，b，c，d,e,j,g=g依次进入栈S。若每个元素出栈后立即进入队列Q，且7个元素出队的顺序是b，d，c，f，e，a，g，则栈S的容量至少是( )。【2009年全国试题2(2)分】 A.1 B.2 C.3 √ D.4 按元素出队顺序计算栈的容量。b进栈时栈中有a，b出栈，cd进栈，栈中有acd，dc出栈，ef进栈，栈中有aef,fea出栈，栈空，g进栈后出栈。所以栈S的容量至少是3。 3.若元素a，b，c，d,e，f依次进栈，允许进栈、退栈操作交替进行，但不允许连续三次进行退栈操作，则不可能得到的出栈序列是( )。【2010年全国试题1(2)分】 A.d,c，e，b，f,a B.c，b，d,a，e，f C.b，c，a，e，f，d D.a,f，e,d,c，b √ 4.某队列允许在其两端进行入队操作，但仅允许在一端进行出队操作。若元素a，b，c，d，e依次入此队列后再进行出队操作，则不可能得到的出队序列是( )。【2010年全国试题2(2)分】 A.b，a，c，d, e B.d,b，a，c，e C.d，b,c，a，e √ D.e，c，b，a，d a先入队，b和c可在a的任一端入队，选项A、B、D都符合要求，只有选项C不可能出现。双端队列出队结果的分析可参见四、36。 5.元素a，b，c，d,e依次进入初始为空的栈中，若元素进栈后可停留、可出栈，直到所有元素都出栈，则在所有可能的出栈序列中，以元素d开头的序列个数是( )。【2011年全国试题2(2)分】 A.3 B.4 √ C.5 D.6 元素d进栈时，元素a，b，c已在栈中，d出栈后，P可以在a，b，c任一元素的前面进栈并出栈，也可以在元素a后出栈，c，b，a必须依次出栈，所以元素d开头的序列个数是4。 6.已知循环队列存储在一维数组A[0．n-1]中，且队列非空时front和rear分别指向队头元素和队尾元素。若初始时队列为空，且要求第1个进入队列的元素存储在A[0]处，则初始时front和rear的值分别是( )。[2011年全国试题3(2)分】 A.0，0 B.0，n—1 √ C.n一1，0

外文翻译

华南理工大学广州学院本科毕业设计（论文）外文翻译外文原文名Marketing Strategy Adjustment and Marketing Innovation in the Experience Economy Era 中文译名体验经济时代的营销战略调整与营销创新学院管理学院专业班级2013级工商管理1班学生姓名潘嘉谊学生学号201330090184 指导教师罗玲苑讲师李巍巍填写日期2017年5月19日

外文原文版出处：.Marketing Strategy Adjustment and Marketing Innovation in the Experience Economy Era[J]. Contemporary Logistics,2012 (06) :230-267 译文成绩：指导教师（导师组长）签名：译文：体验经济时代的营销战略调整与营销创新吴青学摘要：从商品货物经济，到服务经济的的转移演化经历过程，经历了农业经济、工业经济，服务经济和体验经济。在服务经济时期，企业只是打包经验与传统的产品一起销售，而在促进经验经济的时期，企业要把最好产品为未来的潜在用户设计，让消费者心甘情愿支付购买产品。关键词：体验经济；市场营销战略；营销创新 1 介绍随着科学技术和信息行业的发展，人们的需要和欲望连同消费者支出模式开始发生转变，相应地对企业生产环境产生了一系列影响。经济社会发展由传统时期进入体验经济时期。从一个经济产品的转变，进而到经济体系经济模式的转变。由缓慢转变为激进经济模式。因此导致社会发展从一个经济时期到另一个经济时期，经济模式和经济体系的转变将不可避免地影响到交换关系的转化。这是关注体验的结果，是由人类社会的发展的规律所决定的生产水平的产物。一旦交流关系发生变化、营销模式必须做出相应的变化。 2 企业营销策略的选择方向在体验经济时代，企业不仅要理性思考高瞻远瞩，从客户的角度实施营销活动，更要重视与沟通客户，发现在他们内心的期望。我们自己的产品和服务代表企业的形象，产品要指向指定的客户体验。在当今时代，体验营销已成为营销活动最强大的秘密武器因此，这是非常重要的。而传统的营销策略，包括调整经验营销都已经不适应当前发展需求，迟早要被时代所淘汰。 2.1 建立营销思想的观念要求提高客户体验根据马斯洛需求层次理论，人的需要分为五个层次，分别是：生理的需要、安全的需要、归属于爱的需要、尊重的需要和自我实现的需要。随着经济的发展和消费者日益增强的购买能力变化，人们生理需求得到满足，个人需求将会上升心

建立堆栈和队列的库函数

建立堆栈和队列的库函数摘要堆栈是一种只允许在表的一端进行插入和删除运算的特殊的线性表。链式存储结构：栈的链式存储结构称为链栈，通常用单链表示。链栈的插入和删除操作只需处理栈顶的情况。每次进栈的数据元素都放在原当前栈顶元素之前成为新的栈顶元素，每次退栈的数据元素都是原当前栈顶元素，最后进入堆栈的数据元素总是最先退出堆栈。队列是允许在表的一端进行插入，而在表的另一端进行删除的特殊线性表。允许进行插入的一端称为队尾，允许进行删除的一端称为队头。用链式存储结构存储的队列称为链队列。链队列的基本操作的实现基本上也是单链表操作的简化。通常附设头结点，并设置队头指针指向头结点，队尾指针指向终端结点。插入数据时只考虑在链队列的尾部进行，删除数据时只考虑在链队列的头部进行。关键词：堆栈；队列；线性表；存储结构

第1章前言栈和队列是两种常用的数据结构，广泛应用在编译软件和程序设计，操作系统、事物管理等各类软件系统中。从数据结构角度看，栈和队列是受限制的线性表，栈和队列的数据元素具有单一的前驱和后继的线性关系；从抽象数据类型角度看，栈和队列又是两种重要的抽象数据类型。第2章堆栈和队列定义 2.1 定义栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。栈也称为后进先出表。队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。在队列这种数据结构中，最先插入的元素将是最先被删除的元素；反之最后插入的元素将是最后被删除的元素，因此队列又称为“先进先出”的线性表。 2.2 队列基本操作 2.2.1栈的建立和初始化： voidInitStack(SqStack * &s)

堆栈和队列-外文翻译.doc

数据结构-堆栈和队列实验报告

外文翻译

栈和队列习题答案

外文翻译 - 英文

栈和队列的基本操作

外文翻译

实验二 堆栈和队列基本操作的编程实现

PTA第三章栈与队列练习题

数据结构基础练习(栈和队列)

外文翻译中文版(完整版)

栈和队列(必备)

计算机专业基础综合数据结构(栈和队列)历年真题试卷汇编6

外文翻译

建立堆栈和队列的库函数

最新外文翻译模板精编版

实验二堆栈和队列基本操作的编程实现