用链接方式存储的队列在进行插入运算时

Ⅰ 为什么在顺序存储结构下，栈的插入和删除运算都不需要移动表中其他数据元素，如果在链式存储结构下会怎样

栈也被叫做"先进后出表",正是由于这种性质,让它可以不需要移动元素实现插入和删除.
栈的插入,其实就是压栈,它是被严格限制在栈顶进行的.由于栈顶也是表中最后一个元素,所以压栈也就相当于是在顺序表的最后追加一个元素,这显然不影响前面的元素,也就无需移动其他元素了.
删除也是同样的道理,弹栈(删除操作)也是被严格限制在栈顶进行,这时候删除一个元素只需要在顺序表中去除最后一个元素,自然也不影响之前的元素.

链式结构对于栈来说,同样不需要作任何其他元素的移动.事实上,链式结构的删除和插入操作本身就不需要移动其他元素,无论是对于栈来说还是对于一般的链表.

Ⅱ 用链接方式存储的队列，在进行插入运算时。。。（为什么选D请详细说明，谢谢！我会增加悬赏分的~）

不带头结点的队列进行插入或删除操作时都有可能将头尾指针修改，题目未明确说明带不带头节点，所以应该考虑这种情况，选D,我做的卷子上也是选D

Ⅲ java中的linklist有哪些用法，list.add,list.getFirst(),这些是什么意思

ArrayList Vector LinkedList 区别与用法

ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要设计到数组元素移动等内存操作，所以索引数据快插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快！

线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类。

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

Collection接口
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
Iterator it = collection.iterator(); // 获得一个迭代子
while(it.hasNext()) {
Object obj = it.next(); // 得到下一个元素
}
由Collection接口派生的两个接口是List和Set。

List接口
List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。
实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类
LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类
ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
和LinkedList一样，ArrayList也是异步的（unsynchronized）。

Vector类
Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出，因此必须捕获该异常。

Stack 类
Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

Set接口
Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

Map接口
请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

Hashtable类
Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
Hashtable numbers = new Hashtable();
numbers.put(“one”, new Integer(1));
numbers.put(“two”, new Integer(2));
numbers.put(“three”, new Integer(3));
要取出一个数，比如2，用相应的key：
Integer n = (Integer)numbers.get(“two”);
System.out.println(“two = ” + n);
由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。
如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
Hashtable是同步的。

HashMap类
HashMap和Hashtable类似，不同之处在于HashMap是异步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

WeakHashMap类
WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

总结
如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑异步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

同步性
Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的，因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销。
数据增长
从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。
使用模式
在ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？
这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的?O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。
最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的数组（Array）来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组(Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。

Ⅳ 设循环队列的存储空间为Q(1:35),初始状态为front=rear=35.现经过一系列入队与退队运算后，

答案是0或35。前提条件是：此循环队列的存储空间全部用于存储数据，而没有留出一个存储空间用于判别队满与队空。

在上述循环队列中，当front = rear时，

（1）有可能是队空：先入队15个元素，rear = 15；再出队15个元素，front = 15。

（2）有可能是队满：先入队15个元素，rear = 15；再出队15个元素，front =
15；最后再入队35个元素，rear指针循环一圈后再次等于15。

综上，队列中元素个数为0或35。

但应注意，上述的循环队列由于无法判别队满与队空，导致其产生二义性（即有歧义），可用性降低。因此，改进的方法是少用一个存储空间，即队列最大只存储34个元素，此时可用下列方法区分队满与队空：

（1）队满：（rear + 1）% MaxSize == front

（2）队空：rear == front

Ⅳ SJTU 《算法设计与分析》备考题

1、除根结点外，树上每个结点( )。
a. 可有一个孩子、任意多个双亲
b. 可有任意多个孩子、一个双亲
c. 只有一个孩子、一个双亲
d. 可有任意多个孩子、任意多个双亲
2、采用顺序查找方法查找长度为n的线性表时，每个元素的平均查找长度为（ ）。
a. (n+1)/2
b. n/2
c. (n-1)/2
d. n
3、采用二分查找方法查找长度为n的线性表时,每个元素的平均查找长度为（ ）。
a. O(log2n)
b. O(n2)
c. O(n)
d. O(nlog2n)
4、设顺序线性表中有n个数据元素，则删除表中第i个元素需向前移动（ ）个元素。
a. n-1-i
b. n-i
c. i
d. n+1-i
5、设顺序循环队列Q[0：M-1]的头指针和尾指针分别为F和R，头指针F总是指向队头元素的前一位置，尾指针R总是指向队尾元素的当前位置，则该循环队列中的元素个数为（ ）。
a. (R-F+M)％M
b. F-R
c. (F-R+M)％M
d. R-F
6、设输入序列是1、2、3、…、n，经过栈的作用后输出序列的第一个元素是n，则输出序列中第i个输出元素是（ ）。
a. n-1-i
b. 不能确定
c. n-i
d. n+1-i
7、设输入序列为1、2、3、4、5、6，则通过栈的作用后可以得到的输出序列为（ ）。
a. 5，3，4，6，1，2
b. 1，5，4，6，2，3
c. 3，1，2，5，4，6
d. 3，2，5，6，4，1
8、设用链表作为栈的存储结构，则退栈操作（ ）。
a. 必须判别栈是否为满
b. 必须判别栈是否为空
c. 对栈不作任何判别
d. 必须判别栈元素的类型
9、设用邻接矩阵A表示有向图G的存储结构，则有向图G中顶点i的入度为( )。
a. 第i列0元素的个数之和
b. 第i行0元素的个数之和
c. 第i列非0元素的个数之和
d. 第i行非0元素的个数之和
10、设某链表中最常用的操作是在链表的尾部插入或删除元素，则选用下列（ ）存储方式最节省运算时间。
a. 双向链表
b. 双向循环链表
c. 单向循环链表
d. 单向链表
11、设某棵二叉树的高度为10，则该二叉树上叶子结点最多有( )。
a. 1024
b. 256
c. 20
d. 512
12、设某棵二叉树的中序遍历序列为ABCD，先序遍历序列为CABD，则后序遍历该二叉树得到序列为( )。
a. CDAB
b. BADC
c. CBDA
d. BCDA
13、设某棵二叉树中有2000个结点，则该二叉树的最小高度为( )。
a. 9
b. 11
c. 12
d. 10
14、设某棵二叉树中只有度数为0和度数为2的结点，且度数为0的结点数为n，则这棵二叉树中共有( )个结点。
a. n+1
b. 2n
c. 2n+1
d. 2n-1
15、设某有向图的邻接表中有n个表头结点和m个表结点，则该图中有( )条有向边。
a. n-1
b. m
c. n
d. m-1
16、设某无向图有n个顶点，则该无向图的邻接表中有( )个表头结点。
a. 2n-1
b. n
c. n/2
d. 2n
17、设某无向图中有n个顶点e条边，则该无向图中所有顶点的度之和为( )。
a. 2e
b. n
c. e
d. 2n
18、设某无向图中有n个顶点e条边，则建立该图邻接表的时间复杂度为( )。
a. O(n\*e)
b. O(n+e)
c. O(n2)
d. O(n3)
19、设某数据结构的二元组形式表示为A=(D，R)，D={01，02，03，04，05，06，07，08，09}，R={r}，r={<01，02>，<01，03>，<01，04>，<02，05>，<02，06>，<03，07>，<03，08>，<03，09>}，则数据结构A是( )。
a. 图结构
b. 物理结构
c. 线性结构
d. 树型结构
20、设某强连通图中有n个顶点，则该强连通图中至少有( )条边。
a. n(n-1)
b. n
c. n+1
d. n(n+1)
21、设某完全无向图中有n个顶点，则该完全无向图中有( )条边。
a. n
b. n-1
c. n(n-1)
d. n(n-1)/2
22、设某哈夫曼树中有199个结点，则该哈夫曼树中有( )个叶子结点。
a. 99
b. 101
c. 100
d. 102
23、设某二叉树中度数为0的结点数为N0，度数为1的结点数为N1，度数为2的结点数为N2，则下列等式成立的是( )。
a. N0=N1+N2
b. N0=N2+1
c. N0=2N1+1
d. N0=N1+1
24、设有6个结点的无向图，该图至少应有( )条边才能确保是一个连通图。
a. 7
b. 6
c. 8
d. 5
25、设无向图G中有n个顶点，则该无向图的最小生成树上有（ ）条边。
a. 2n-1
b. n
c. n-1
d. 2n
26、设按照从上到下、从左到右的顺序从1开始对完全二叉树进行顺序编号，则编号为i结点的左孩子结点的编号为( )。
a. i/2
b. 2i+1
c. 2i
d. 2i-1
27、设指针变量top指向当前链式栈的栈顶，则删除栈顶元素的操作为（ ）。
a. top=top+1;
b. top->next=top;
c. top=top->next;
d. top=top-1;
28、设指针变量p指向双向链表中结点A，指针变量s指向被插入的结点X，则在结点A的后面插入结点X的操作序列为（ ）。
a. p->next=s； s->prior=p； p->next->prior=s； s->next=p->next；
b. s->prior=p； s->next=p->next； p->next=s； p->next->prior=s；
c. p->next=s； p->next->prior=s； s->prior=p； s->next=p->next；
d. s->prior=p；s->next=p->next；p->next->prior=s； p->next=s；
29、设指针变量p指向单链表中结点A，若删除单链表中结点A，则需要修改指针的操作序列为（ ）。
a. q=p->next；q->data=p->data；p->next=q->next；free(q)；
b. q=p->next；p->data=q->data；free(q)；
c. q=p->next；p->next=q->next；free(q)；
d. q=p->next；p->data=q->data；p->next=q->next；free(q)；
30、设指针变量front表示链式队列的队头指针，指针变量rear表示链式队列的队尾指针，指针变量s指向将要入队列的结点X，则入队列的操作序列为（ ）。
a. front->next=s；front=s；
b. rear->next=s；rear=s；
c. s->next=front；front=s；
d. s->next=rear；rear=s；
31、设指针q指向单链表中结点A，指针p指向单链表中结点A的后继结点B，指针s指向被插入的结点X，则在结点A和结点B插入结点X的操作序列为（ ）。
a. p->next=s->next；s->next=p；
b. p->next=s；s->next=q；
c. s->next=p->next；p->next=-s；
d. q->next=s； s->next=p；
32、设带有头结点的单循环链表的头指针为head，则其判空条件是（ ）。
a. head->next==head
b. head==NULL
c. head->next==NULL
d. head!= NULL
33、设哈夫曼树中的叶子结点总数为m，若用二叉链表作为存储结构，则该哈夫曼树中总共有( )个空指针域。
a. 4m
b. 2m-1
c. 2m+1
d. 2m
34、设二叉树的先序遍历序列和后序遍历序列正好相反，则该二叉树满足的条件是( )。
a. 任一结点无左孩子
b. 任一结点无右孩子
c. 高度等于其结点数
d. 空或只有一个结点
35、设一维数组中有n个数组元素，则读取第i个数组元素的平均时间复杂度为（ ）。
a. O(1)
b. O(n)
c. O(n2)
d. O(nlog2n)
36、设一组权值集合W={2，3，4，5，6}，则由该权值集合构造的哈夫曼树中带权路径长度之和为( )。
a. 40
b. 45
c. 30
d. 20
37、设一棵完全二叉树中有65个结点，则该完全二叉树的深度为( )。
a. 7
b. 6
c. 5
d. 8
38、设一条单链表的头指针为head，且该链表没有头结点，则其判空条件是（ ）。
a. head==NULL
b. head->next==head
c. head->next==NULL
d. head!=NULL
39、设F是由T1、T2和T3三棵树组成的森林，与F对应的二叉树为B，T1、T2和T3的结点数分别为N1、N2和N3，则二叉树B的根结点的左子树的结点数为( )。
a. N2+N3
b. N1-1
c. N1+N3
d. N2-1
40、若采用邻接表存储结构，则图的深度优先搜索类似于二叉树的（）
a. 层次遍历
b. 先根遍历
c. 中根遍历
d. 后根遍历
41、若采用邻接表存储结构，则图的广度优先搜索类似于二叉树的（）
a. 先根遍历
b. 后根遍历
c. 层次遍历
d. 中根遍历
42、若线性表最常用的操作是存取第i个元素及其前驱的值，则采用（ ）存储方式最节省时间。
a. 双向链表
b. 顺序表
c. 单链表
d. 单循环链表
43、若一组记录的关键码为（46，79，56，38，40，84），则利用快速排序的方法，以第一个记录为基准得到的第一趟结果为（ ）。
a. 40，38，46，56，79，84
b. 40，38，46，84，56，79
c. 38，40，46，56，79，84
d. 40，38，46，79，56，84
44、若一个图的边集为 {(A,B),(A,C),(B,D),(C,F),(D,E),(D,F)} ，则从顶点 A 开始对该图进行深度优先搜索，得到的顶点序列可能为（ ）。
a. A,B,C,F,D,E
b. A,C,F,D,E,B
c. A,B,D,F,E,C
d. A,B,D,C,F,E
45、若一个图的边集为 {(A,B),(A,C),(B,D),(C,F),(D,E),(D,F)} ，则从顶点 A 开始对该图进行广度优先搜索，得到的顶点序列可能为（ ）。
a. A,B,C,F,D,E
b. A,B,C,D,E,F
c. A,B,D,C,E,F
d. A,C,B,F,D,E
46、线性表若采用链式存储结构时，要求内存中可用存储单元的地址（ ）。
a. 连续或不连续都可以
b. 必须是连续的
c. 部分地址必须是连续的
d. 一定是不连续的
47、用链接方式存储的队列，在进行插入运算时（ ）。
a. 仅修改尾指针
b. 头、尾指针都要修改
c. 仅修改头指针
d. 头、尾指针都不要修改
48、用邻接表存储图所用的空间大小（ ）。
a. 只与图的边数有关
b. 与图的顶点数和边数都有关
c. 只与图的顶点数有关
d. 与边数的平方有关
49、树的后根遍历序列等同于该树对应的二叉树的( )。
a. 先序序列
b. 中序序列
c. 后序序列
d. 层次序列
50、树型结构最适合用来表示( )。
a. 无序数据元素
b. 有序数据元素
c. 元素之间无联系的数据
d. 元素之间具有分支层次关系的数据
51、栈。和队列的共同点是（ ）。
a. 只允许在端点处插入和删除元素
b. 都是先进后出
c. 都是先进先出
d. 没有共同点
52、数据结构是研究数据的（ ）以及它们之间的相互关系。
a. 理想结构，抽象结构
b. 物理结构，逻辑结构
c. 理想结构，物理结构
d. 抽象结构，逻辑结构
53、数据的最小单位是（ ）。
a. 数据元素
b. 数据项
c. 数据类型
d. 数据变量
54、已知一个有向图的边集为 {<a,b>,<a,c>,<a,d>,<b,d>,<b,e>,<d,e>} ，则由该图产生的一种可能的拓扑序列为( )。
a. a,b,c,d,e
b. a,c,b,e,d
c. a,b,d,e,b
d. a,c,d,b,e
55、对线性表进行二分查找时，要求线性表必须（ ）。
a. 以链接方式存储
b. 以链接方式存储，且结点按关键字有序排序
c. 以顺序方式存储，且结点按关键字有序排序
d. 以顺序方式存储
56、在长度为n的顺序存储的线性表中插入第i个元素(1≤i≤n)需向后移动（ ）个元素。
a. n-i
b. i
c. n-1-i
d. n-i+1
57、在用邻接表表示图时，对图进行深度优先搜索遍历的算法的时间复杂度为（ ）。
a. O(n2)
b. O(n+e)
c. O(n3)
d. O(n)
58、在有向图的邻接表存储结构中，顶点v在链表中出现的次数是( )。
a. 顶点v的度
b. 依附于顶点v的边数
c. 顶点v的入度
d. 顶点v的出度
59、在有向图G的拓扑序列中，若顶点Vi在顶点Vj之前，则下列情形不可能出现的是（ ）。
a. G中有一条从Vi到Vj的路径
b. G中有弧
c. G中没有弧
d. G中有一条从Vj到Vi的路径
60、在下列存储形式中，哪一个不是树的存储形式？( )
a. 孩子链表表示法
b. 顺序存储表示法
c. 孩子兄弟表示法
d. 双亲表示法
61、在一个单链表中，已知q所指结点是p所指结点的前驱结点，若在q和p之间插入s结点，则执行（ ）。
a. q->next = s；s->next = p；
b. s->next = p->next；p->next = s；
c. p->next = s->next；s->next = p；
d. p->next = s；s->next = q；
62、在一个具有n个顶点的无向图中，每个顶点度的最大值为（ ）
a. n-1
b. n+1
c. n
d. 2(n-1)
63、图的BFS生成树的树高比DFS生成树的树高（ ）。
a. 大或相等
b. 小
c. 小或相等
d. 大
64、含有n个结点的二叉树采用二叉链表存储时，空指针域的个数为( )。
a. n
b. n+1
c. n+2
d. n-1
65、关于无向图的邻接矩阵的说法中正确的是（ ）。
a. 矩阵中的非零元素个数等于图的边数
b. 矩阵中非全零元素的行数等于图中的顶点数
c. 第i行上非零元素个数和第i列上非零元素个数一定相等
d. 第i行上与第i列上非零元素总和等于顶点Vi的度数
66、二叉树的第k层的结点数最多为( )。
a. 2k
b. 2k -1
c.2k
d. 2k-1
67、二叉排序树按( )遍历可以得到一个从小到大的有序序列。
a. 后序
b. 中序
c. 层次
d. 先序
68、下面程序的时间复杂为（ ）。
for(i=1, s=0; i<=n; i++)
{ t=1;
for(j=1; j<=i; j++)
t=t*j; s=s+t;
}
a. O(n3)
b. O(n)
c. O(n2)
d. O(n4)
69、下面程序段的时间复杂度为（ ）。
s=i=0;
do { i=i+1; s=s+i;
} while(i<=n);
a. O(n)
b. O(nlog2n)
c. O(n2)
d. O(1)
70、下面关于线性表的叙述错误的是（ ）。
a. 线性表采用链式存储不必占用一片连续的存储空间
b. 线性表采用顺序存储必须占用一片连续的存储空间
c. 线性表采用顺序存储便于插入和删除操作的实现
d. 线性表采用链式存储便于插入和删除操作的实现
71、下述编码中哪一个不是前缀编码( )。
a. 0,10,110,111
b. 00,01,10,11
c. 1,01,000,001
d. 0,1,00,11
72、下列说法不正确的是（ ）。
a. 图的深度遍历不适用于有向图
b. 图的深度遍历是一个递归过程
c. 遍历的基本方法有两种：深度遍历和广度遍历
d. 图的遍历是从给定的源点出发每个顶点仅被访问一次
73、下列有关图遍历的说法中不正确的是（）。
a. 非连通图不能用深度优先搜索法
b. 连通图的深度优先搜索是一个递归过程
c. 图的遍历要求每一顶点仅被访问一次
d. 图的广度优先搜索中邻接点的寻找具有“先进先出”的特征
74、下列哪种图的邻接矩阵为对称矩阵? ( )
a. 带权有向图
b. 有向图
c. 无向图
d. 有向图或无向图
75、一个带权的无向连通图的最小生成树（ ）。
a. 只有一棵
b. 一定有多棵
c. 有一棵或多棵
d. 可能不存在
76、顺序表是线性表的（）
a. 链式存储结构
b. 顺序存储结构
c. 索引存储结构
d. 散列存储结构
77、线性表若采用链式存储结构时，要求内存中可用存储单元的地址（）
a. 必须是连续的
b. 部分地址必须是连续的
c. 一定是不连续的
d. 连续或不连续都可以
78、一个栈的入栈序列是a,b,c,d,e，则栈的不可能的输出序列是（）
a. e,d,c,b,a
b. d,e,c,b,a
c. d,c,e,a,b
d. a,b,c,d,e
79、在下列链表中，不能从任一结点出发访问到表中的所有结点的是（）
a. 单链表
b. 单向循环链表
c. 双向循环链表
d. 循环链表
80、二叉树结点度的集合为（）。
a. （1）
b. （0，1，2）
c. （1，2）
d. （0）
81、以二分查找方法查找一个线性表时，此线性表必须是（）。
a. 顺序存储的有序表
b. 链式存储的有序表
c. 链表
d. 顺序表
82、设哈夫曼树的叶子结点的个数为n，那么该树的结点总数为（）
a.2n
b.2n+1
c.2n-1
c.不能唯一确定
83、对二叉树来说，第i层上至多有（）个结点。
a. 2i
b. 2i-1
c. 2i-1
d. 2i-1-1
84、数据结构包括3个方面的内容，它们是（）。
a. 数据、数据元素、数据项
b. 数据元素、数据处理、算法实现
c. 数据元素、数据的逻辑结构、数据的存储结构
d. 数据的逻辑结构、数据的存储结构、数据的操作
85、数据在计算机存储器内表示时，存储结点连续存放且存储顺序与逻辑顺序相同，这种存储方式称为（）。
a. 索引存储方式
b. 顺序存储方式
c. 链式存储方式
d. 散列存储方式
86、冒泡排序属于（）。
a. 插入排序
b. 选择排序
c. 快速排序
d. 交换排序
87、下列程序段的时间复杂度为（）。
i=1;j=0;
while（i+j<=n）
{if（i>j）j++;
elsei++;
}
a. O（n）
b. O（nlog2n）
c. O（i*j）
d. O（i+j）
88、下面程序的时间复杂为（）。
for（i=1,s=0;i<=n;i++）
{t=1;for（j=1;j<=i;j++）t=t*j;s=s+t;}
a. O（n）
b. O（n2）
c. O（n3）
d. O（n4）
89、含有n个结点的二叉树采用二叉链表存储时，空指针域的个数为（）。
a. n-1
b. n
c. n+1
d. n+2
90、设某完全无向图中有n个顶点，则该完全无向图中有（）条边。
a. n（n-1）/2
b. n（n-1）
c. n
d. n-1

1、调用一次深度优先遍历可以访问到图中的所有顶点。（F）
2、分块查找的平均查找长度不仅与索引表的长度有关，而且与块的长度有关。（T）
3、冒泡排序在初始关键字序列为逆序的情况下执行的交换次数最多。（T）
4、满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。（T）
5、设一棵二叉树的先序序列和后序序列，则能够唯一确定出该二叉树的形状。（F）
6、线性表的顺序存储结构比链式存储结构更好。（F）
7、不论是入队列操作还是入栈操作，在顺序存储结构上都需要考虑“溢出”情况。（T）
8、完全二叉树中的叶子结点只可能在最后两层中出现。（T）
9、由树转化成二叉树，该二叉树的右子树不一定为空。（F）
10、线性表中的所有元素都有一个前驱元素和后继元素。（F)

1、head指向单链表的表头，p指向单链表的表尾结点，则执行p->next=head后，该单链表构成 循环链表
2、在单链表中，若p和s是两个指针，且满足p->next与s相同，则语句p->next=s->next的作用是 删除 s指向的结点。
3、在一个长度为n的顺序表中的第i(1≤i≤n＋1)个元素之前插入一个元素时，需向后移动的元素个数为 n-i+1 。
4、设顺序线性表中有n个数据元素，则删除表中第i个元素需向前移动 n-i 个元素。
5、衡量一个算法，除了正确性之外，主要考虑的两个方面是 时间复杂度 和 空间复杂度 。
6、在一个具有n个顶点的无向完全图中，包含 n(n-1)/2 条边。
7、对于一个具有n个顶点的图，若采用邻接矩阵表示，则矩阵大小为 n^2 。
8、采用顺序查找方法查找长度为n的线性表时，每个元素的平均查找长度为 (n+1)/2 。
9、树型结构最适合用来表示元素之间具有 分支层次关系 的数据。

1、已知一棵二叉树的先（前）序遍历序列为ABDEGCFH,中序遍历序列为DBGEACFH,请画出该二叉树,并写出该二叉树的后序序列。

2、画出一棵二叉树,使其：中序序列为DCBGEAHFIJK,后序序列：DCEGBFHKJIA

3、请写出对(53, 87, 12, 61,98,17, 97, 75, 53, 26)进行一次划分的过程。

4、有一结点序列为(7,19,2,6,32,3,21,10),要求以该序列作为带权二叉树中结点的权值,构造并画出一棵哈夫曼树,并计算其带权路径长度。

5、对下面所示的无向网,要求构造出一棵最小生成树（中间过程可以省略）,并计算该最小生成树的权。

6、下面所示为有向图的邻接表,试画出该有向图,并给出由顶点V1开始的深度优先遍历和广度优先遍历的结果。

7、有一结点序列为(45,24,53,12,28,90),要求构造并画出一棵二叉排序树,并输出以中序方式遍历该树的序列。