1734人阅读
algorithm（86）
& & &看本文之前，推荐本博客的，熟悉一下STL中序列容器的接口以及内部实现结构。
& & &我先谈一谈栈和队列的基本情况：栈是一种后进先出的结构，STL里面为我们编好了栈，但是我们也可以自己实现。通常有两种实现方式，一种是静态数组或者动态数组的实现方式（在这里，实现的时候，注意如果栈空间满了以后，我们提供扩从容量的策略会比较好），第二种是同过链表的实现方式。运用到栈的算法有哪些呢：括号匹配问题，中缀表达式转后缀表达式问题，迷宫路径搜索问题，非递归遍历问题，回溯搜索问题，递归转非递归。
& & &再谈谈队列：队列是一种先进先出的结构，队列有双端队列，优先级队列，循环队列。队列也有两种简单的实现方式，一种是通过静态数组或者动态数组，一种是通过链表实现。那么队列被哪些算法用到了：杨式三角，迷宫最短路径搜索（注意这里是最短路径，而用栈的话只能搜索路径，不一定是最短），广度优先遍历问题，层次遍历问题（其实这是广度优先的一个特例），进程调度（优先级队列，堆），
& & &本文搜集了一下关于栈和队列的一些算法。
（1）用两个栈构成一个队列。
& & &算法很简单，一个栈负责“插入”，一个栈负责“弹出”。当弹出的栈没有元素的时候，要从插入的栈把元素全部搬过来。
class MyQueue{
stack&int& insertS
stack&int& popS
int Dequeue(){
if(popStack.empty()){
if(insertStack.empty())
throw new runtime_error(&Null Queue&);
while(!insertStack.empty()){//把元素挪过来
popStack.push(insertStack.top());
insertStack.pop();
int result = popStack.top();
popStack.pop();
void Enqueue(int elem){
insertStack.push(elem);
& & &我这里只是简单的实现了pop和push两种操作，没有去实现STL里面关于队列的其他接口。详细参见本博客：
& & &记得在“July微软面试百题系列”里面有个在多线程下实现队列的pop和push操作。我的理解是在pop和push操作的时候需要“加锁”。 &
（2）两个队列实现一个栈
& & &这个算法需要用两个队列来回倒腾。下面简单的实现以下。看不懂的话同样可以参考：
class MyStack{
queue&int& q1;
queue&int& q2;
int Pop(){
if(q1.empty() && q2.empty())
throw new runtime_error(&Null Stack&);
if(q1.empty()){
while(q2.size() != 1){
q1.push(q2.front());
result = q2.front();
if(q2.empty()){
while(q1.size() != 1){
q2.push(q1.front());
result = q1.front();
void Push(int elem){
if(q1.empty() && q2.empty()){//两者都为空，随便插进那个都无所谓
q1.push(elem);
else if(q1.empty())
q2.push(elem);
q1.push(elem);
（3）包含min函数的栈（剑指offer）
& & & 剑指offer上给出的解答是构造一个辅助的栈去存储最小值，同样，在编程之美上也给出了同样的答案，只不过编程之美上给出的答案是保持最小值的索引。下面简单的实现了下：
template&class T&
class MinStack{
void Push(T t){
st.push(t);
if(minst.empty() || (t&minst.top()))//要求T重载了&&&
minst.push(t);
minst.push(minst.top());
if(!st.empty()){
popNum = st.top();
minst.pop();
throw new runtime_error(&Empty Stack&);
return popN
T GetMin(void)const{
return minst.top();
T IsEmpty()const{
return st.empty();
（4）包含min函数的队列（编程之美）
&& &其实队列和栈和上面是一样的，我们不能简单的用上面的这种方案来解答。想想就知道了。对此编程之美给出了两种答案：
& & &第一种方案：构造一个特殊的最大堆，但是这个堆包含有队列的指针，能够以o(lgn)去插入和删除，得到最小值时间复杂度为o(1)；
& & &第二种方案：利用上面的构造含有min函数的栈来构造这个特殊的队列。
template&class T&
class MinStack{
void Push(T t){
st.push(t);
if(minst.empty() || (t&minst.top()))//要求T重载了&&&
minst.push(t);
minst.push(minst.top());
if(!st.empty()){
popNum = st.top();
minst.pop();
/*throw std::runtime_error(&Empty Stack&);*/
cout&&&Null Stack&&&
return popN
T GetMin(void)const{
return minst.top();
T IsEmpty()const{
return st.empty();
template&class T&
class MinQueue{
MinStack&T&
MinStack&T&
T GetMin()const{
if(sta.IsEmpty() && stb.IsEmpty())
throw new runtime_error(&Null Stack&);
else if(!sta.IsEmpty() && stb.IsEmpty())
return sta.GetMin();
else if(sta.IsEmpty() && !stb.IsEmpty())
return stb.GetMin();
else return min(sta.GetMin(),stb.GetMin());
void Enqueue(T t){
sta.Push(t);
T Dequeue(){
if(stb.IsEmpty()){
while(!sta.IsEmpty()){
stb.Push(sta.Pop());
return stb.Pop();
（4）打印堆栈
#include &iostream&
#include &stack&
void PrintStack(stack&int&& st)
if(st.empty())
int top = st.top();
cout&&top&&& &;
PrintStack(st);
st.push(top);
int main()
stack&int&
st.push(1);
st.push(2);
st.push(3);
PrintStack(st);
PrintStack(st);//打印两遍，验证堆栈有没有被改变
system(&pause&);
（5）给堆栈中的元素排序
& && 啥也不说了，直接看程序。当然这里可以转化为非递归的方法去实现。
#include &iostream&
#include &stack&
void PrintStack(stack&int&& st)
if(st.empty())
int top = st.top();
cout&&top&&& &;
PrintStack(st);
st.push(top);
void SortStack(stack&int&& st)
if(st.empty())
int topNum = st.top();
SortStack(st);//顶元素弹出，将下面的排好
stack&int& tempSt;
while(!st.empty() && st.top()&topNum){
tempSt.push(st.top());
st.push(topNum);
while(!tempSt.empty()){
st.push(tempSt.top());
tempSt.pop();
int main()
stack&int&
st.push(1);
st.push(4);
st.push(3);
PrintStack(st);
SortStack(st);
PrintStack(st);//打印两遍，验证堆栈有没有被改变
system(&pause&);
& & &按照第五题的思路，我们平时还应该碰到这个问题，用递归的方法去写插入排序。那么我们很快就能写出代码：
#include &iostream&
#include &stack&
#include &cassert&
void PrintArr(int arr[],int len){
assert(arr && len&=0);
for(int i=0; i& ++i){
cout&&arr[i]&&& &;
void InsertSortRecursively(int arr[],int index){
assert(arr && index&=0);
if(index == 0)
int base = arr[index];
InsertSortRecursively(arr,index-1);//我们假设前面排好序了
int i = index-1;
while(i&=0 && arr[i]&base){
arr[i+1] = arr[i];
arr[i+1] =
int main()
const int LEN = 4;
int arr[LEN] = {3,2,4,5};
PrintArr(arr,LEN);
InsertSortRecursively(arr,LEN-1);
PrintArr(arr,LEN);
system(&pause&);
（6）栈的逆序问题（准确的说是不能用额外的栈作为辅助空间）
#include &iostream&
#include &stack&
void PrintStack(stack&int&& st)
if(st.empty())
int top = st.top();
cout&&top&&& &;
PrintStack(st);
st.push(top);
void MoveButtomToTop(stack&int&& st)//将栈底部元素挪到顶部
if(st.empty())
int top1 = st.top();//接下来把栈顶元素弹出
if(!st.empty()){
MoveButtomToTop(st);//这里我们假设将栈底部元素挪上来了
int top2 = st.top();
st.push(top1);
st.push(top2);//此时将top1和top2交换就完成了我们的操作
st.push(top1);
void ReverseStack(stack&int&& st)
if(st.empty())
MoveButtomToTop(st);
int topNum = st.top();
ReverseStack(st);
st.push(topNum);
int main()
stack&int&
st.push(1);
st.push(4);
st.push(3);
PrintStack(st);
ReverseStack(st);
PrintStack(st);
system(&pause&);
（7）将栈顶元素移到栈底部（借鉴上面的算法）
#include &iostream&
#include &stack&
void PrintStack(stack&int&& st)
if(st.empty())
int top = st.top();
cout&&top&&& &;
PrintStack(st);
st.push(top);
void MoveTopToButtom(stack&int&& st){
if(st.empty())
int firstTop = st.top();
if(!st.empty()){
int secondTop = st.top();
st.push(firstTop);
MoveTopToButtom(st);
st.push(secondTop);
st.push(firstTop);
int main()
stack&int&
st.push(1);
st.push(4);
st.push(3);
PrintStack(st);
MoveTopToButtom(st);
PrintStack(st);
system(&pause&);
（8）栈的逆序问题（准确的说是不能用额外的栈作为辅助空间）
& & & 上面第（6）题其实已经实现了一个栈的翻转，但是本题想借鉴（7）来实现栈的翻转。
#include &iostream&
#include &stack&
void PrintStack(stack&int&& st)
if(st.empty())
int top = st.top();
cout&&top&&& &;
PrintStack(st);
st.push(top);
void MoveTopToButtom(stack&int&& st){
//把栈顶元素挪到栈底部
if(st.empty())
int firstTop = st.top();
if(!st.empty()){
int secondTop = st.top();
st.push(firstTop);
MoveTopToButtom(st);
st.push(secondTop);
st.push(firstTop);
void ReverseStack(stack&int&& st){
if(st.empty())
int topNum = st.top(); //先将顶部元素弹出
ReverseStack(st);//假设除了顶部元素外，其他都被翻转了
st.push(topNum);//把栈顶元素压进去
MoveTopToButtom(st);//接下来的工作就是把栈顶元素挪到栈的底部
int main()
stack&int&
st.push(1);
st.push(2);
st.push(3);
PrintStack(st);
ReverseStack(st);
PrintStack(st);
system(&pause&);
（9）给定栈的入栈序列，判断给定的序列是否可能是该序列的出栈序列。（剑指offer134页）
& & & &这个题用辅助栈来解答。
#include &iostream&
#include &stack&
#include &cassert&
#include &string&
bool IsPopOrder(int pushSeq[],int popSeq[],int len)
assert(pushSeq && popSeq && len&0);
stack&int&
int i,j = 0;
for(i=0; i& ++i){
int popNum = popSeq[i];
while(st.empty() || st.top()!=popNum){
st.push(pushSeq[j++]);
if(j == len)
if(st.top() != popNum)
if(st.empty() && i==len)
int main()
const int SIZE = 5;
int pushSeq[SIZE] = {1,2,3,4,5};
int popSeq[SIZE] = {4,5,3,2,1};
string result = IsPopOrder(pushSeq,popSeq,SIZE)?&True&:&False&;
cout&&result&&
system(&pause&);
这里说明一下：给定栈的入栈序列，出栈的序列可能有多少种。（这是一个卡特兰数）类似的问题，包括给定前序遍历，中序遍历的有多少种？括号匹配问题。1,2,5......详细参考：
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：774122次
积分：10887
积分：10887
排名：第1437名
原创：185篇
转载：554篇
评论：110条
阅读：9890
阅读：14006
文章：16篇
阅读：29362
(1)(19)(2)(2)(3)(3)(16)(10)(12)(20)(21)(6)(2)(14)(5)(9)(7)(17)(9)(9)(12)(11)(17)(21)(7)(7)(8)(12)(12)(11)(6)(4)(8)(21)(9)(2)(8)(24)(72)(88)(44)(35)(56)(25)(32)(1)1686人阅读
数据结构及算法（26）
package none002;
import java.util.*;
import java.io.*;
//数据结构栈，利用栈实现字符串逆序输出
public class ReverseApp {
* @param args
public static void main(String[] args) throws IOException{
// TODO Auto-generated method stub
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
sx=new Stack(20);
System.out.println(&please input words or sentence you want to reverse:&);
String s=br.readLine();
for(int i=0;i&s.length();i++){
sx.push(s.charAt(i));
System.out.println(&The result is that:&);
while(!sx.isEmpty()){
System.out.print(sx.pop());
class Stack{
char[] arrayS
arrayStack=new char[s];
public void push(char value){
if(items==s-1) System.out.println(&栈已经等于最大值了。&);
else arrayStack[++items]=
public char pop(){
return arrayStack[items--];
public boolean isEmpty(){
return items==-1;
public char peek(){
if(items==-1) return 0;
else return arrayStack[items];
public boolean isFull(){
return items==s-1;
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：125137次
积分：2415
积分：2415
排名：第14998名
原创：114篇
转载：12篇
评论：24条
(3)(5)(121)第三章栈和队列；掌握程度；1、考点:栈和队列的定义特点,循环队(队空队满)；2、重点掌握在顺序栈和链栈上实现的栈的基本运算，；3、重点掌握在循环队列和链队列上实现的基本运算，；顺序栈,链栈,循环队列,顺序栈；?初始化（栈置空）操作?判栈空函数?进栈操作?出；voidInit_SeqStack(SeqSta；s-&top=0;；}//初始化（栈置空）操作
第三章 栈和队列
1、考点: 栈和队列的定义特点,循环队(队空队满)条件,根据栈队定义判断插入删除元素的位置,以及出入栈出入队的顺序(选择填空概率较大).有可能和第二章链表部分出算法题.(如链栈链队等)
2、重点掌握在顺序栈和链栈上实现的栈的基本运算，特别注意栈满和栈空的条件及它们的描述。
3、重点掌握在循环队列和链队列上实现的基本运算，特别注意队满和队空的描述方法。
顺序栈,链栈,循环队列, 顺序栈
? 初始化（栈置空）操作 ? 判栈空函数
? 进栈操作 ? 出栈函数
? 读栈顶元函数
Init_SeqStack(SeqStack *s) {
s-&top= 0;
}//初始化（栈置空）操作
int Empty_SeqStack(SeqStack *s) {
if (s-&top== 0)
return 0; }//判栈空函数
int Push_SeqStack (SeqStack *s, int
/* 入栈*/ {
if (s-&top==MAXSIZE)
return 0; /*栈满不能入栈*/
s-&data[s-&top]=x;
/*栈顶上移*/
} }//进栈操作
Pop_SeqStack(SeqStack *s, int *x) {
(s-&top== 0)
return 0; /*栈空不能出栈 */
*x=s-&data[s-&top];
}/*栈顶元素存入*x，返回*/ }//出栈函数
Top_SeqStack(SeqStack *s) {
if (s-&top== 0)
else return (s-&data[s-&top-1] ); }//读栈顶元函数 链栈
? 初始化操作 ? 进栈操作 ? 出栈操作
Init_LinkStack（StackNode *
top=NULL; }//初始化操作
StackNode *
Push_LinkStack（StackNode *
top, int x）
s=(StackNode * )malloc（sizeof（StackNode））;
s-&data=x;
}//进栈操作
StackNode *
Pop_LinkStack (StackNode *
if （top= =NULL） return NULL;
*x = top-&
top = top-&
}//出栈操作
? 初始化操作的实现 ? 判队空函数 ? 判队满 ? 入队列操作 ? 出队列操作
Init_SeQueue(c_SeQueue *q) {
q-&front=q-&rear=0; }//初始化操作的实现
Empty_SeQueue(c_SeQueue
(q-&rear == q-&front)
else return 0; }//判队空函数
int Full_SeQueue(c_SeQueue
/*判队满*/ {
((q-&rear+1) % MAXSIZE== q-&front)
else return 0; }//判队满
int In_SeQueue(c_SeQueue *q ,int x) /*入队列*/ {
if ( (q-&rear+1) % MAXSIZE== q-&front)
printf(&队满&);
return -1;
/*队满不能入队*/
q-&rear=(q-&rear+1) % MAXSIZE;
q-&data[q-&rear]=x;
/*入队完成*/
}//入队列操作
int Out_SeQueue(c_SeQueue *q ,int *x) /*出队列*/ {
if(q-&rear == q-&front)
printf(&队空&);
return -1;
/*队空不能出队*/
q-&front=(q-&front+1)%MAXSIZE;
*x=q-&data[q-&front]; /*读出队头元素*/
/*出队完成*/
}//出队列操作
三.习题答案
书P131----四.简答题
1. 什么是栈?什么是队列?试分别举两个应用实例.
答：栈(Stack) 是限制仅在表的一端进行插入和删除操作的线性表。 队列是限定只能在表的一端进行插入，在表的另一端进行删除的线性表. 栈: 进制转换,表达式求值,递归乘方.
队列: 迷宫最短路径,待打印文档,系统进程. 2. 说明线性表,栈和队列的异同点.
答：相同点：
逻辑结构相同，都是线性的；都可以用顺序存储或链表存储；
栈和队列是两种特殊的线性表，即受限的线性表（只是对插入、删除运算加以限制）。 不同点：
① 运算规则不同：
线性表为随机存取；
而栈是只允许在一端进行插入和删除运算，因而是后进先出表LIFO；
队列是只允许在一端进行插入、另一端进行删除运算，因而是先进先出表FIFO。 ② 用途不同：
线性表比较通用；
堆栈用于函数调用、递归和简化设计等；
队列用于离散事件模拟、操作系统作业调度和简化设计等。
3. 设有编号为1,2,3,4的四辆列车,顺序进入一个栈式结构的车站,具体写出这四辆列车开
出车站的所有可能的顺序. 答：有14种。
①全进之后再出情况，只有1种：4，3，2，1
② 进3个之后再出的情况，有3种，3,4,2,1
3,2,1,4 ③ 进2个之后再出的情况，有5种，2,4,3,1
2,1,3,4 ④ 进1个之后再出的情况，有5种，1,4,3,2
根据卡特兰数特点本题符合及可用公式算出一共有
C2nn/(n+1)=
C8/(4+1)=14(种)
结点进栈与出栈问题实质是一个中序遍历二叉树的过程。求N个结点的不同形态的二叉树数目,其个数即为上卡特兰数结果. 4. 假设正读和反读都相同的字符序列为“回文”，例如，‘abba’和‘abcba’是回文，‘abcde’
和‘ababab’则不是回文。假设一字符序列已存入计算机，请分析用线性表、堆栈和队列等方式正确输出其回文的可能性？
答：线性表是随机存储，可以实现，靠循环变量（j--）从表尾开始打印输出； 堆栈是后进先出，也可以实现，靠正序入栈、逆序出栈即可； 队列是先进先出，不易实现。
哪种方式最好，要具体情况具体分析。若正文在机内已是顺序存储，则直接用线性表从后往前读取即可，或将堆栈栈顶开到数组末尾，然后直接用POP动作实现。（但堆栈是先减后压还是??）
若正文是单链表形式存储，则等同于队列，需开辅助空间，可以从链首开始入栈，全部压入后再依次输出。
顺序队的“假溢出”是怎样产生的？如何知道循环队列是空还是满？
答：一般的一维数组队列的尾指针已经到了数组的上界，不能再有入队操作，但其实数组中还有空位置，这就叫“假溢出”。 采用循环队列是解决假溢出的途径。 另外，解决队满队空的办法有三： ① 设置一个布尔变量以区别队满还是队空； ② 浪费一个元素的空间，用于区别队满还是队空。 ③ 使用一个计数器记录队列中元素个数（即队列长度）。 我们常采用法②，即队头指针、队尾指针中有一个指向实元素，而另一个指向空闲元素。 判断循环队列队空标志是： f=rear
队满标志是：f=(r+1)%N 6. 设循环队列的容量为40（序号从0到39），现经过一系列的入队和出队运算后，有
① front=11，rear=19;
② front=19，rear=11；问在这两种情况下，循环队列中各有元素多少个？
答：用队列长度计算公式：
(N＋r－f)% N ①
L=（40＋19－11）% 40=8
② L=（40＋11－19）% 40=32 7. 试述栈的基本性质.
答：栈(Stack) 是限制仅在表的一端进行插入和删除操作的线性表。后进先出(LIFO)或先进后出（FILO）
8. 设输入元素为1,2,3,P和A,输入次序为123PA,元素设输入元素为1、2、3、P和A，输
入次序为123PA。元素经过栈后达输出序列，当所有元素均到达输出序列后，有哪些序列可以作为高级语言的变量名。
答:一般说，高级语言的变量名是以字母开头的字母数字序列。AP321,PA321,P3A21,P32A1,P321A。
9. 内存中一片连续空间（不妨假设地址从1到m）提供给两个栈S1和S2使用，怎样分配
这部分存储空间，使得对任一个栈，仅当这部分空间全满时才发生上溢。
答: S1和S2共享内存中一片连续空间（地址1到m），可以将S1和S2的栈底设在两端，
两栈顶向共享空间的中心延伸，仅当两栈顶指针相邻（两栈顶指针值之差的绝对值等于1）时，判断为栈满，当一个栈顶指针为0，另一个栈顶指针m+1时为两栈均空。 10. 计算表达式”6*3/2-5*1”,要求绘出堆栈的处理过程.
三亿文库包含各类专业文献、生活休闲娱乐、专业论文、高等教育、外语学习资料、95第三章栈和队列整理软件08505班等内容。　
　栈和队列的算法_计算机软件及应用_IT/计算机_专业资料。内蒙古科技大学信息工程...文件夹命 名方式为:软件 12-1 班 3,表示软件 12-1 班第 3 个项目的实验... 　软件学院班级: 191 学号: 数据结构 18 实验报告级 软件工程姓名: 2016 ～2017 学年 第一 学期 专业 孟国元 实验二 栈和队列的模拟操作一、实验... 　第三章栈和队列习题_理学_高等教育_教育专区。学号___ 姓名___ 班级___ 成绩___ 第三章栈和队列习题一、 判断 1. 队列中所有的插入操作都发生在表的一端... 　用C语言实现栈与队列的操作_计算机软件及应用_IT/计算机_专业资料。用c语言实现...栈的操作 作业批次: 第三次 */ /* */ /* 主要内容: 栈的输入、输出 等... 　实验二栈和队列实验报告---停车场问题_计算机软件及应用_IT/计算机_专业资料。数据结构实验报告 实验二 班级:计 12-2 栈和队列实验 学号
姓名:毛... 　实验五 栈和队列验证实验报告_计算机软件及应用_IT/计算机_专业资料。班级:计算机...三、设计与编码 #include&iostream& const int StackSize... 　实验二:栈与队列应用_计算机软件及应用_IT/计算机_专业资料。天津理工大学数据结构第二次实验 实验报告学院(系)名称:计算机与通信工程学院 姓名 班级 课程名称 = ... 　数据结构第3章栈和队列自测题答案_工学_高等教育_教育专区。数据结构第3章栈和队列自测题答案一、填空题 二、1. 向量、栈和队列都是 线性 对于栈只能在 除元... 　链式栈和队列_计算机软件及应用_IT/计算机_专业资料。链式结构 struct Node { ...第三章 栈和队列 39页 免费 栈和队列答案 21页 免费 第3章 栈和队列 new...算法（10）
上次有说明如何删除栈中指定位置的元素并且不破坏栈结构。主题思想是递归的压出栈顶元素，直到压出指定位置的元素，然后把存贮在递归过程中堆区的栈顶元素依次压回栈，最后返回删除的元素的值。
详情请通过该链接查看
栈的逆序可以利用该函数（get_stack()）来实现。
例：1,2,3,4。栈顶元素是4。
反转1,2,3,4。相当于，取出(get_stack())栈底元素1,将2,3,4反转为4,3,2。然后压入1。
反转2,3,4。相当于，取出(get_stack())栈底元素2,将3,4反转为4,3。然后压入2。
反转3,4。相当于，取出(get_stack())栈底元素3,将4反转为4。然后压入3。
反转4。相当于，取出(get_stack())栈底元素4,此时栈空。
依次压入4，压入3,压入2，压入1。栈反转结束。
上述思路可以用递归来实现。
先贴上流程图，以1,2,3,4。4为栈顶元素为例。
下面是代码：
函数1：获取、删除栈底元素。
int get_stack(stack&int &&a){
int result=a.top();
if(a.empty())
int i=get_stack(a);
a.push(result);
函数2：递归反转。
void reverse(stack&int &&a){
if(a.empty())
int i=get_stack(a);
reverse(a);
a.push(i);
调试：这里是4,3,2,1。 1为栈顶。
运行结果：
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：15095次
排名：千里之外
原创：32篇
(13)(2)(1)(2)(4)(2)(1)(1)(2)(3)(4) 上传我的文档
 下载
 收藏
该文档贡献者很忙，什么也没留下。
 下载此文档
正在努力加载中...
《算法设计与分析》课后习题(54页)
下载积分：3000
内容提示：《算法设计与分析》课后习题(54页)
文档格式：DOC|
浏览次数：11|
上传日期： 09:26:30|
文档星级：
全文阅读已结束，如果下载本文需要使用
 3000 积分
下载此文档
该用户还上传了这些文档
《算法设计与分析》课后习题(54页)
官方公共微信}