数据结构自测十题

1. 设顺序存储的线性表（如数组或向量）有n个元素，访问元素和随机增加、删除元素的时间复杂度分别为多少？（O(1)还是O(n)？）

O（1）， O（n）, O（n）

2. 设链表有n个元素，访问节点和随机增加、删除节点的时间复杂度分别为多少？（O(1)还是O(n)？）

O（n）, O（1）, O（1）

3、设一个有序的单链表中有n个结点，现要求插入一个新结点后使得单链表仍然保持有序，则该操作的时间复杂度为？（O(1)还是O(n)？）。

O（n）

5. 设有一个数组共享栈S[0：n-1]，其中第一个栈顶指针top1的初值为-1，第二个栈顶指针top2的初值为n，则判断共享栈满的条件是?  

Top2=top1+1

6. 中缀表达式3+9/3^2+(2+3*3)的后缀表达式是?   

3932^/+233*++

7.  在一个单链表以HL为首节点的单链表中，若要向表头插入一个由指针p指向的节点，执行什么操作？

p->next＝HL；HL=p

8. 设顺序循环队列Q[0：M-1]的头指针和尾指针分别为F和R，头指针F总是指向队头元素的前一位置，尾指针R总是指向队尾元素的当前位置，则该循环队列中的元素个数为?    

(R-F+M)％M

9.  下列函数执行什么功能？

template <typename T>

void function2(list<T> &aList)

{

	T currValue;

	list<T>::iterator curr, p;

	curr = aList.begin();

	while (curr != aList.end())

	{
		currValue = *curr;

		p = curr;
		p++;

		while (p != aList.end())

			if (*p == currValue)

				aList.erase(p++);

			else
				p++;

		curr++;
	}
}
   

功能：删除链表中重复元素

10 编程题：

编写一个子函数，依次读入无序数组中的数据，放进链表中，数组中的元素全部放入链表之后，链表中的元素为由小到大排列。最后返回该链表的首节点。（节点头文件已定义好）

如数组A为3， 7， 1， 2,， 9，则链表最后形成后，存储的依次是1， 2， 3， 7， 9。

节点头文件
template <typename T>
class node
{
public:
	T nodeValue;		// data held by the node
	node<T> *next;		// next node in the list
	node() : next(NULL) // 构造函数
	{
	}
	node(const T &item, node<T> *nextNode = NULL) : nodeValue(item), next(nextNode)
	{
	}
};


函数 
template <typename T>
node<T> *InputToList(T A[], int n) /// A表示数组，n表示数组元素个数
{
	node<T> *front = NULL;
	for (int m = 0; m < n; m++)
	{
		T avalue = A[m];
		node<T> *newnode = new node<T>(A[m]);
		node<T> *currentnode, *prevnode;
		if (m == 0) /// 添加第一个节点
		{
			front = newnode;
		}
		else // 添加第二个节点及其后面的所有节点
		{
			currentnode = front;
			prevnode = front;
			while (currentnode != NULL && newnode->nodeValue > currentnode->nodeValue)
			{
				prevnode = currentnode;
				currentnode = currentnode->next;
			}
			if (currentnode == front)
			{
				newnode->next = currentnode;
				front = newnode;
			}
			else
			{
				prevnode->next = newnode;
				newnode->next = currentnode;
			}
		}
	}
	return front;
}

时间复杂度分析：

一共有n个元素，每次元素放入有序链表中的平均时间复杂度为 m/2 (m是当前链表的元素个数)，而m最大为n-1。因此时间复杂度为O(n^2)。当然也可以在当前数组中把元素先从小到大或从大到小排序好，再依次放入链表中，时间复杂度也是O(n^2)。