数据结构与算法面试题

1.
应用场景：
1）数据比较少
2）经常做的运算是按序号访问数据元素
面试题
选择题：
1）对于长度为n的线性表，建立其对应的单链表的时间复杂度为（）。
O(1)
O(log2n)
O(n)
O(n^2)
2）下列哪些不是线性表？
队列
栈
关联数组
链表
3）稀疏矩阵一般的压缩存储方法有两种,即()
二维数组和三维数组
三元组和散列
Node dummyHead = new Node(0)；
Node p = head;
dummyHead.next = head;
//p的值不小于下一节点元素考察下一节点
while (p.next != null) {
if (p.value <= p.next.value) {
p = p.next;
面试题
选择题：
1）在一个单链表中，q的前一个节点为p，删除q所指向节点，则执行（）。
delete q
q->next=p->next;delete p
p->next=q->next;delete p
p->next=q->next;delete q
delete p
q->next=p->next;delete q
q = q.next;
temp.next = q.next;
//重新连接链表注意else的过程并没有改变p指针的位置
q.next = temp;
}
}
return dummyHead.next;
}
3.
应用场景：
1）数制转换
2）括号匹配检验
3）迷宫求解
4）表达式求值&中缀表达式转后缀表达式
5）二叉树的非递归遍历
p->next=q->next;
q->next=p->next; delete q;
p->data=p->next->data; p->next=p->next->next; delete p->next;
temp = p->next; p->next=temp->next; p->data=temp->data; delete temp;temp=NULL;
2）已知一个单链表求倒数第N个节点
思路：
快慢指针法，让快指针先走n-1步后，然后让慢指针出发。快慢指针每次都只移动一个位置，当快指针移动到链表末尾的时候，慢指针就正处于倒数第N个节点的位置。
3）删除单链表的倒数第n个节点
思路：
想操作链表的某个节点(添加，删除)还必须知道这个节点的前一个节点。所以我们删除倒数第n个元素就要找到倒数第n + 1个元素。然后将倒数第n + 1个元素p的next指针p.next指向p.next.next。
当前反转的节点为null的时候，保存的上一个节点即翻转后的链表头结点
5）单链表的归并排序
代码：
private Node merge(Node l, Node r) {
//创建临时空间
Node aux = new Node();
Node cur = aux;
//由于链表不能方便的拿到链表长度所以一般使用while l == null表示链表遍历到尾部
2）输入一个整型数组，数组里有正数也有负数。数组中一个或连续的多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)
思路：
Step1.从头到尾逐个累加数组中的每个数字，初始化和为0；（nCurrSum=0，nGreatestNum=int.MinValue）
Step2.首先加上第一个数字，从第二个数字开始累加，依次将累加和保存到一个临时变量（nCurrSum）中；
思路：
两个指针i和j分别指向数组的首尾，然后从两端同时向中间遍历。
7）给定含有n个元素的整型数组a，其中包括0元素和非0元素，对数组进行排序，要求：
排序后所有0元素在前，所有非零元素在后，且非零元素排序前后相对位置不变，且不能使用额外存储空间
思路：
从尾部开始设置两个指针，last指针指向后面第一个出现0的位置，first指向last前面的第一个非0元素，如果first是非0，则将值赋给last，然后last++，first++；如果first指向0，则继续前进first++。
while (l != null && r != null) {
if (l.value < r.value) {
cur.next = l;
cur = cur.next;
l = l.next;
} else {
cur.next = r;
cur = cur.next;
r = r.next;
}
}
//当有一半链表遍历完成后另外一个链表一定只剩下最后一个元素（链表为基数）
} else {
//p指向4
Node temp = p.next;
Node q = dummyHead;
p.next = p.next.next;
//从头遍历链表找到比当前temp值小的第一个元素插入其后边整个位置一定在头节点与q节点之间
while (q.next.value < temp.value && q.next != q)
通常不会出现栈满的情况
通常不会出现栈空的情况
插入操作更容易实现
删除操作更容易实现
5）某指针变量p指向双向链表中结点A，指针变量s指向被插入的结点X，则在结点A的后面插入结点X的操作序列为（）。
p->right=s；s->left=p；p->right->left=s；s->right=p->right；
2）从表中任意一个节点出发可以依次访问到表中其他所有节点的结构是（）
线性单链表
双向链表
循环链表
线性链表
3）若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点，则采用存储方式最节省运算时间。
单链表
给出表头指针的单循环链表
双链表
带头结点的双循环链表
4）和顺序栈相比,链栈有一个比较明显的优势是()
if (l != null) {
cur.next = l;
} else if (r != null) {
cur.next = r;
}
return aux.next;
}
6）单链表的插入排序
代码：
public Node insertionSortList(Node head) {
if (head == null || head.next == null) return head;
a[i] < b[j]，则i增加1，继续比较
a[i] == b[j]，则i和j皆加1，继续比较
a[i] < b[j]，则j加1，继续比较
重复以上过程直到i或j到达数组末尾。
6）给定两个有序整型数组a和b，各有n个元素，求两个数组中满足给定和的数对，即对a中元素i和b中元素j，满足i + j = d(d已知)
s->left=p；s->right=p->right；p->right=s；p->right->left=s；
p->right=s；p->right->left=s；s->left=p；s->right=p->right；
s->left=p；s->right=p->right；p->right->left=s；p->right=s；
j（j-1）/2+i
j（j-1）/2+i-1
i（i-1）/2+j-1
6）若有定义:
int c[4][5],( *pc)[5];
pc=c;
那么，下列对数组C的元素引用正确的是( )。
pc+1
* (pc+3)
* (pc+1) +3
* (*pc+2)
问答题：
1）数组和链表的区别
思路：
从逻辑结构上来看，数组必须实现定于固定的长度，不能适应数据动态增减的情况，即数组的大小一旦定义就不能改变。当数据增加是，可能超过原先定义的元素的个数；当数据减少时，造成内存浪费；链表动态进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。
从内存存储的角度看；数组从栈中分配空间（用new则在堆上创建），对程序员方便快速，但是自由度小；链表从堆中分配空间，自由度大但是申请管理比较麻烦。
从访问方式类看，数组在内存中是连续的存储，因此可以利用下标索引进行访问；链表是链式存储结构，在访问元素时候只能够通过线性方式由前到后顺序的访问，所以访问效率比数组要低。
6）
某单链表有5个元素，设单链表的节点结构为(data,next)，5个元素的data依次为（1、2、3、4、5），已知指针q指向节点3，指针p指向节点4，那么下面操作能将链表变为data依次为（1、2、3、5）的是____。（其中temp为节点类型指针，默认指向NULL）
q=p->next;
p=q->next;
三元组和十字链表
散列和十字链表
4）将10阶对称矩阵压缩存储到一维数组A中，则数组A的长度最少为
100
40
55
80
5）
设A是n*n的对称矩阵，将A的对角线及对角线上方的元素以列为主的次序存放在一维数组B[1..n（n+1）/2]中，对上述任一元素aij (1≤i，j≤n，且i≤j)在B中的位置为（）