C和C++程序员面试秘笈之⑧
本系列博客基于董山海的
第八章：数据结构
文章目录
- 1、面试题1
- 2、面试题2
- 3、面试题3
- 4、面试题4
- 5、面试题5
- 6、面试题6
- 7、面试题7
- 8、面试题8
- 9、面试题9
- 10、面试题10
- 11、面试题11
- 12、面试题12
- 13、面试题13
- 14、面试题14
- 15、面试题15
- 16、面试题16
- 17、面试题17
- 18、面试题18
- 19、面试题19
- 20、面试题20
- 21、面试题21
- 22、面试题22
- 24、面试题24
- 25、面试题25
- 26、面试题26
- 27、面试题27
- 28、面试题28
- 29、面试题29
- 28、面试题28
1、面试题1
编程实现一个单链表的建立：
#include 使用 while 循环每次从终端读入一个整型数据，并调用 malloc 动态分配链表节点内存存储这个整型数据，然后插到单链表的末尾。最后，当数据为 0 时表示插入数据结束。此时把末尾节点的 next 指针置为 NULL。
2、面试题2
编程实现一个单链表的测长：
#include 3、面试题3
编程实现一个单链表的打印
#include 4、面试题4
编程实现一个单链表节点的查找：
#include 5、面试题5
编程实现一个单链表节点的插入：
#include 向单链表中某个位置（第 pos 个节点）之后插入节点，分为插入链表首部、插入到链表中间、以及链表尾端3种情况。
6、面试题6
编程实现一个单链表节点的删除：
#include 7、面试题7
实现一个单链表的逆置：
#include 遍历一遍链表，利用一个辅助指针，在存储的过程中当前指针指向的下一个元素，然后将当前节点元素的指针反转后，利用已经存储的指针往后继续遍历。
8、面试题8
寻找单链表的中间元素：
#include 假设 mid 指向当前已经扫描的子链表的中间元素，cur 指向当前已扫描链表的末节点，那么继续扫描移动 cur 到 cur->next，这时只需要判断一下应不应该移动 mid 到 mid ->next 就行了。
9、面试题9
单链表的正向排序：
#include 10、面试题10
判断链表是否存在环形链表的问题：
#include 设置两个指针 p1、p2。每次循环 p1 向前走一步， p2 向前走两步。直到 p2 碰到 NULL 指针或者两个指针相等时结束循环。如果两个指针相等，则说明存在环。
11、面试题11
有序单链表的合并：
已知两个链表 head1 和 head2 各自有序，请把它们合并成一个链表，依然有序。使用非递归方法以及递归方法。
#include 这里 insert_node() 函数是有序的插入节点，传入的参数是 node指针类型。然后在 merge() 函数中循环把短链表中所有节点插入到长链表之中。
链表1：1->3->5
链表2：2->4->6
下面介绍递归方法：
- 比较链表1和链表2的第一个节点数据。由于1<2，因此把结果链表头节点指向链表1中第一个节点，即数据1所在的节点；
- 对剩余的链表1（3->5）和链表2再调用本过程，比较得到结果链表的第二个节点，即2与3比较得到2。此时合并后的链表节点为1->2。
如此递归，直到两个链表的表头都被加到结果链表中。
#include 12、面试题12
循环链表的操作：：
编号为1,2…,N的N个人按顺时针方向围坐一圈，每个人持有一个密码(正整数)，一开始任选一个正整数作为报数上限值 M，从第一个人开始按顺时针方向自1开始按顺序报数，报到M时停止报数。报M的人出列，将他的密码作为新的M值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直到所有人全部出列为止，求出列顺序。
思路：
显然当有人退出圆圈后，报数的工作要从下一个人开始继续，而剩下的人仍然是围成一个圆圈的，因此可以使用循环单链表。由于退出圆圈的工作对应着表中节点的删除工作，对于这种删除操作频繁的情况，选用效率较高的链表结构。为了程序指针每一次都指向一个具体的代表一个人的结点而不需要判断。链表不带头节点。所以，对于所有人围成的圆圈所对应的数据结构采用一个不带头节点的循环链表描述。设头指针为p，并根据具体情况移动。
为了记录退出的人的先后顺序，采用一个顺序表进行存储。程序结束后再输出依次退出的人的编号顺序。由于只记录各个节点的data值就可以了，所以定一个整型一维数组。如 int quit[n]；n 为一个根据实际问题定义一个足够大的整数。
#include 13、面试题13
编程实现一个双向链表：
#include 14、面试题14
编程实现一个双向链表的测长：
使用 right 指针进行遍历，直到遇到 NULL 为止。
#include 15、面试题15
编程实现一个双向链表的打印：
#include 16、面试题16
编程实现双向链表节点的查找：
#include 17、面试题17
编程实现双向链表的插入：
节点 p 后插入一个节点：
分为两种情况：
- 插入位置在中间；
- 插入位置在末尾；
不同：插入位置在中间时需要把 p 的原后继节点的前驱指针指向新插入的节点；
#include 18、面试题18
编程实现一个双向链表节点的删除：
删除头节点、删除中间节点以及删除末节点。
#include 19、面试题19
实现有序双向循环链表的插入操作：
#include 20、面试题20
删除两个双向循环链表的相同结果：
有两个双向循环链表A，B，知道其头指针分别为 pHeadA，pHeadB。请写一个函数，将两链表中 data 值相同的节点删除。
解析：
- 把 A 中含有的与 B 中相同的数据节点抽出来，组成一个新的链表，如
链表A：1 2 3 4 2 6 4
链表B：10 20 3 4 2 10
新建链表C：2 3 4 - 遍历链表 C，删除 A 和 B 的所有节点。如果 A 含有数据相等的节点（A 有两个 4），且 B 也含有此数据节点（B 也有4），则 A 中数据相等的节点全部被删除。
这个代码还未理解透，稍后补吧！
21、面试题21
编程实现队列的入队、出队、测长、打印：
队列的实现可使用链表和数组，我们本题中使用单链表来实现队列。
#include 构造空的队列：
//构造一个空的队列
MyQueue *CreateMyQueue() {
MyQueue *q = (MyQueue *)malloc(sizeof(MyQueue));
q->front = NULL; //队首置空
q->rear = NULL; //队尾指针置空
return q;
}
入队、出队、测长、打印：
#include 22、面试题22
队列和栈的区别：
队列：入队和出队；队列在队尾入队，队头出队；FIFO，先进先出
栈：入栈和出栈；入栈和出栈都在栈顶，无法对栈底进行操作；LIFO，后进先出；
24、面试题24
使用单链表实现栈：
class MyStack {
public:
MyStack() :top(NULL) {} //默认构造函数
void push(MyData data); //进栈
void pop(MyData *pData); //出栈
bool IsEmpty(); //是否为空栈
MyData *top; //栈顶
};
class MyData {
public:
MyData():data(0),next(NULL){} //默认构造函数
MyData(int value):data(value),next(NULL){} //带参数的构造函数
int data; //数据域
MyData *next; //下一个节点
};
//进栈
void MyStack::push(MyData data) {
MyData *pData = NULL;
pData = new MyData(data.data); //生成新的节点
pData->next = top; //与原来的栈顶节点相连
top = pData; //栈顶节点为新加入的节点
}
//判断栈是否为空栈
bool MyStack::IsEmpty() { //如果 top 为空，则返回1，否则返回0
return (top == NULL);
}
//出栈，返回栈顶节点内容
void MyStack::pop(MyData *data) {
if (IsEmpty()) { //如果为空，则直接返回
return;
}
data->data = top->data; //给传出的参数赋值
MyData *p = top; //临时保存原栈顶节点
top = top->next; //移动栈顶，指向下一个节点
delete p; //释放原栈顶节点内存
}
使用栈实现队列：
stack：先进后出；
queue：先进先出；
#include 25、面试题25
用 C++ 实现一个二叉排序树：
二叉排序树（Binary Sort Tree）:二叉查找树（Binary Search Tree）。满足：
- 若它的左子树为空，则左子树上所有节点值均小于根节点的值；
- 若它的右子树非空，则它右子树上所有节点的值均大于根节点的值；
- 左、右子树本身又是一个二叉排序树；
#include 下面着重介绍每个函数：
创建二叉排序树：首先生成根节点，然后循环调用插入节点的方法对二叉树进行插入操作。
#include 使用非递归方法插入节点：
#include 使用递归方法插入节点：
#include 查找节点：
//递归查找方法
Node* Tree::searchNode(Node* current, int data) {
//如果data小于当前节点数据，则递归搜索其左子树
if (data < current->data) {
if (current->left == NULL) { //如果不存在左子树，则返回NULL
return NULL;
}
return searchNode(current->left, data);
}
//如果data大于当前节点数据，则递归搜索其左子树
else if (data > current->data) {
//如果不存在右子树，则返回NULL
if (current->right == NULL) {
return NULL;
}
return searchNode(current->right, data);
}
//相等，则返回current
return current;
}
删除节点：
//删除数据为data的节点及其子树
void Tree::deleteNode(int data) {
Node *current = NULL;
//查找节点
current = searchNode(data);
if (current != NULL) {
deleteNode(current); //删除节点及其子树
}
}
//删除current节点及其子树的所有节点
void Tree::deleteNode(Node *current) {
if (current->left != NULL) { //删除左子树
deleteNode(current->left);
}
if (current->right != NULL) { //删除右子树
deleteNode(current->right);
}
if (current->parent == NULL) { //如果current是根节点，把root置空
delete current;
root = NULL;
return;
}
//将current父亲节点的相应指针置空
if (current->parent->data > current->data) //current为其父节点的左子节点
current->parent->left = NULL;
else
current->parent->right = NULL; //current为其父节点的右子节点
//最后删除此节点
delete current;
}
26、面试题26
使用递归和非递归方法实现中序遍历：
中序遍历：左节点–>根节点–>右节点
中序遍历，递归解法：
//中序遍历，递归解法
void Tree::InOrderTree(Node* current) {
if (current != NULL) {
InOrderTree(current->left);
cout << current->data << " ";
InOrderTree(current->right);
}
}
中序遍历，非递归解法：
- 先将根节点入栈，遍历左子树（左子树全部进栈）；
- 遍历完一个一个左子树返回时（不是全部出去），栈顶元素应为根节点，此时出栈，并打印节点数据；
- 再中序遍历右子树；
//中序遍历，非递归解法
void Tree::InOrderTreeUnRec(Node *root) {
stack<Node *> s;
Node *p = root; //根节点
while (p != NULL || !s.empty()) {
while (p != NULL) { //遍历左子树
s.push(p); //根节点先入栈，再把遍历的节点全部压栈
p = p->left;
}
//
if (!s.empty()) {
p = s.top(); //得到栈顶内容
s.pop(); //出栈
cout << p->data << " "; //打印
p = p->right; //指向右子节点，下一次循环就会遍历右子树
}
}
}
27、面试题27
使用递归和非递归方法实现先序遍历：
先序遍历：根节点–>左节点–>右节点
递归解法：
void Tree::PreOrderTree(Node* current) {
if (current != NULL) {
cout << current->data << endl;
PreOrderTree(current->left);
PreOrderTree(current->right);
}
}
非递归解法：
void Tree::PreOrderTree(Node* root) {
stack<Node *> s;
Node *p = root;
while (p != NULL || !s.empty()) {
while (p != NULL) {
cout << p->data << " ";
s.push(p);
p = p->left;
}
//
if (!s.empty()) {
p = s.top();
s.pop();
p = p->right;
}
}
}
28、面试题28
使用递归和非递归方法实现后序遍历：
递归方法：
void Tree::PostOrderTree(Node* current) {
if (current != NULL) {
PostOrderTree(current->left); //遍历左子树
PostOrderTree(current->right); //遍历右子树
cout << current->data << " "; //打印根节点
}
}
非递归方法：
假设T为要遍历树的根指针，后序遍历要求在遍历完左、右子树后再访问根。需要判断根节点的左、右子树是否均遍历过。
我们采用标记法，节点入栈时候，需要一个标志 tag 一同入栈（tag 为 0 表示遍历左子树前的现场保护，tag 为1表示右子树前的现场保护）。
首先将 T 和 tag (为0)入栈，遍历左子树；返回时，修改栈顶 tag 为1，遍历右子树，最后访问根节点。
void Tree::PostOrderTreeUnRec(Node* root) {
stack<Node *>s;
Node *p = root;
//
while (p != NULL || !s.empty()) {
while (p != NULL) {
s.push(p); //根节点入栈
p = p->left; //左子树入栈
}
//
if (!s.empty()) {
p = s.top(); //得到栈顶元素
if (p->tag) { //tag为1时
cout << p->data << " "; //打印节点数据
s.pop(); //出栈
p = NULL; //第二次访问标志其右子树已经遍历
}
else {
p->tag = 1; //修改tag为1
p = p->right; //指向右节点，下次遍历其左子树
}
}
}
}
29、面试题29
层次遍历算法：
用队列实现，出队！
void Tree::LevelOrderTree(Node* root) {
queue<Node *>q; //定义队列q，它的元素为Node* 型指针
Node *ptr = NULL;
q.push(root);
while (!q.empty()) {
ptr = q.front(); //根节点入队
q.pop(); //出队
cout << ptr->data << " ";
if (ptr->left != NULL) {
q.push(ptr->left);
}
if (ptr->right != NULL) {
q.push(ptr->right);
}
}
}
28、面试题28
判断给定的二叉树是否是二叉排序树：
中序遍历的结果就是排序二叉树的排序输出：
这段程序的核心就是：使用一个 lastvalue 来记录上一个节点的数据。如果出现 lastvalue 大于或者等于当前出队的节点值，则返回 false；否则一直入队和出队。如果 lastValue 始终小于当前出队的节点值，则是升序排序，返回 true。
//使用中序遍历二叉树是否为排序二叉树
bool IsSortedTree(Tree tree) {
int lastValue = 0;
stack<Node *>s;
Node *p = tree.root;
//
while (p != NULL || !s.empty()) {
while (p != NULL) {
s.push(p); //遍历左子树
p = p->left; //把遍历的左节点全部压栈
}
//
if (!s.empty()) {
p = s.top(); //得到栈顶内容
s.pop(); //出栈
if (lastValue == 0 || lastValue < p->data) {
lastValue = p->data; //如果是第一次弹出或者lastvalue小于
}
else if (lastValue >= p->data) {
//如果lastvalue大于当前节点值，则返回false
return false;
}
p = p->right; //指向右子节点，下一次循环就会中序遍历右子树
}
}
return true;
}