2021-06-29

若让元素1、2、3入栈，则出栈次序不可能出现( ）。
A 3、2、1
B 2、1、3
C 3、1、2
D 1、3、2
参考答案： C

1.下面关于队列和栈的描述正确的是( ）。
A 栈内元素可以随机访问
B 队列是先进先出的数据结构
C 队列内的元素可以随机访问
D 栈是先进先出的数据结构
参考答案： B

将节点f删除。
下面代码是正确的是：
A e.next=f ; f.next=e
B e=e.next ; f.next=e
C f.next=e.next
D e.next=f.next
参考答案： D

用顺序存储（数组）实现栈，下标0的首元素作为栈顶还是栈底？
A 栈顶
B 都可以
C 都不可以
D 栈底
参考答案： B

从一个顺序队列删除元素时，首先需要使( ）。
A 队首指针循环加1
B 队尾指针循环加1
C 队首指针循环减1
D 68队尾指针循环减1
参考答案： A

栈和队列的共同特点是( ）。
A 只允许在端点处插入和删除元素
B 都是先进后出
C 都是先进先出
D 没有共同点
参考答案： A

栈的插入和删除操作在( )进行。
A 栈底
B 指定位置
C 栈顶
D 任意位置
参考答案： C

在一个顺序队列中，队首指针指向队首元素的( )位置。
A 前一个
B 当前
C 后一个
D 前两个
参考答案： B

队列是一种后进先出的线性结构数据表。
A) 正确
B) 错误
参考答案： B

树形结构中，所有节点均可以有多个直接后继节点，一个直接前驱节点。
A) 正确
B) 错误
参考答案： B

栈和队列的共同特点是受限型线性表，插入删除等运算在表的端点进行。
A) 正确
B) 错误
参考答案： A

问答题 证明：在非空二叉树中，第i层上最多有2^(i-1)个节点。
用数学归纳法证明，第一层21-1=20=1。第二层22-1=21=2。第三层:23-1=22=。由
上面的规律可以发现，这是一个首项为1、公比为2的等比数列，可以得到第n层的节点
数最多为2n-1。

问答题 证明：n个节点的完全二叉树的高度为[log2n]+1。
证明:由完全二叉树定义可得，高度为k的完全二叉树的前k-1层是高度为k-1的满二叉树，一共有2k-1-1个节点。由于完全二叉树高度为k，故第k层上还有若干个节点，因此，由该完全二叉树的节点个数n>2k-1-1可得2k-1-1<n<=2k-1;由于n为整数，可以推出2k-1<=n<2k,对不等式取对数可得k-1<=log2n<k，而k作为整数，因此k=[log2n]+1。

随机生成20个100内的数，直接插入排序。
class InsertSort(object):
def init(self,items):
self.items = items
def insertSort(self):
for i in range(1, len(self.items)):
temp = self.items[i]
j = i - 1
while j >= 0 and temp < self.items[j]:
self.items[j+1] = self.items[j]
j -= 1
self.items[j+1] = temp

if name==‘main’:
import random
arr = []
for j in range(0,20):
i = random.randint(0, 100)
arr.append(i)
select = InsertSort(arr)
select.insertSort()
print(arr)

转换进制
class Solution:
def translation(self, number):
stack = []
s = ‘’
while number:
stack.append(number % 8)
number //= 8
while stack:
s += str(stack.pop())
return s

if name == ‘main’:
t = Solution()
print(“请输入要转换的数字：”)
num = int(input())
print(t.translation(num))

循环链表尾插入法
class Node(object):
def init(self,val):
self.val = val
self.next = None
class CircleLinkedList(object):
def init(self):
self.head = None
self.tail = None

def empty(self):
    return self.head is None

def length(self):
    size = 0
    if self.empty():
        return size
    cur = self.head
    size += 1
    while cur.next is not self.head:
        size += 1
        cur = cur.next
    return size

def append(self,val):
    newNode = Node(val)
    if self.empty():
        self.head = newNode
        self.tail = newNode
    else:
        self.tail.next = newNode
        self.tail = newNode
        self.tail.next = self.head
def traversal(self):
    if self.empty():
        raise IndexError("链表为空")
    cur = self.head
    while cur.next is not self.head:
        print(cur.val,end = " ")
        cur = cur.next
    print(cur.val)

if name == ‘main’:
cl = CircleLinkedList()
print(":", end=" “)
for i in range(10):
key = int(input())
cl.append(key)
print(“查看:”,end=” ")
cl.traversal()

直插法
import random
a=[]
for i in range(0,20):
b=random.randint(0,200)
a.append(b)
for i in range(1,len(a)):
if a[i-1] > a[i]:
temp = a[i]
index=i
while index > 0 and a[index - 1] > temp:
a[index] = a[index-1]
index -= 1
a[index] =temp
print(a)

class BinarySearch(object):
def binary_search(self, array, data):
if len(array) == 0:
return False
mid_index = len(array) // 2
if array[mid_index] == data:
return True
return self.binary_search(array[mid_index + 1:], data) if data > array[mid_index] else
self.binary_search(array[:mid_index], data)

if name == ‘main’:
BinarySearch()

循坏单链表尾插入
class sq(object):
def init(self,max):
self.max = max
self.date = [None for i in range(self.max)]
self.front = 0
self.rear =0
def empty(self):
return self.front == self.rear
def push(self,val):
if (self.rear + 1)%self.max == self.front:
raise IndexError(‘list is full’)
self.date[self.rear] = val
self.rear = (self.rear+1)%self.max
def pop(self):
if self.empty():
raise IndexError(‘list is empty’)
cur = self.date[self.front]
self.front = (self.front+1) % self.max
return cur
def peek(self):
if self.empty():
raise IndexError(‘list is empty’)
return self.date[self.front]
if name ==‘main’:
c = sq(5)
c.push(1)
c.push(2)
c.push(3)
c.push(4)
print(c.peek())
c.pop()
print(c.peek())
c.push(6)
print(c.peek())

class SS(object):
def init(self,max):
self.max=max
self.top = -1
self.stack = [None for i in range(self.max)]

def empty(self):
    return self.top is -1

def push(self,value):
    if self.top ==self.max-1:
        raise IndexError("SeqStack is full")
    else :
        self.top +=1
        self.stack[self.top]=value

def peak(self):
    if self.empty():
        raise IndexError("SeqStack is empty")
    else :
        return self.stack[self.top]

def pop(self):
    if self.empty():
        raise IndexError("SeqStack is empty")
    else :
        cur = self.stack[self.top]
        self.top -= 1
        return cur

二进制的话把while下面的8都改成2
if name ==“main”:
a = SS(10)
print(“input a number”)
n = int(input())

s = 1
while n>8:
    n1 = n%8
    a.push(n1)
    n = (n - n1)/8
    s +=1
a.push(n)
b1 = 0
for i in range(s):
    b2 = a.peak()
    a.pop()
    b2=b2*(10**(s-i-1))
    b1=b1 +b2
print("八进制",b1)