java后端笔试刷题总结

数据结构

数组

1、设有100个元素，用二分法查找时，最大比较次数是（7）
[log2n]向下取整再加1
公式：[log2n]+1
2、顺序表查找指的是在顺序存储结构上进行查找。（正确 ）
顺序表查找是指从第一个数据元素开始查找，一直找到最后一个为止。
3、二分查找
针对有序数组来查找的。
主要思想是：（设查找的数组期间为array[low, high]）
（1）确定该期间的中间位置K
（2）将查找的值T与array[k]比较。若相等，查找成功返回此位置；否则确定新的查找区域，继续二分查找。区域确定如下：
a.array[k]>T 由数组的有序性可知array[k,k+1,……,high]>T;故新的区间为array[low,……，K-1]
b.array[k]<T 类似上面查找区间为array[k+1,……，high]。每一次查找与中间值比较，可以确定是否查找成功，不成功当前查找区间缩小一半。递归找，即可。
**时间复杂度:**O(log2n);
代码实现:

    public int BinarySearch(int[] array, int T)
        {
            int low, high, mid;
            low = 0;
            high = array.Length - 1;
            while (low <= high)
            {
                mid = (low + high) / 2;
                if (array[mid] < T)
                {
                    low = mid + 1;
                }
                else if (array[mid]>T)
                {
                    high = mid - 1;
                }
                else 
                {
                    return mid;
                }
            }
            return -1;
        }   

4、快速排序
（1）选一个基准数，一般以数组中第一个元素为基准数，然后将大于基准数的元素交换放置基准数右边，将小于基准数的元素放置左边；
（2）设定两个变量i，j。可以将这两个变量看作指针，代指所对应的元素。首先让i指向序列d最左边（i0）,j指向序列的最右边（jlength-1），然后先让j向左移动找到第一个小于基准数的元素，从左到右找到第一个大于基准数的元素，将找到的两个元素交换。
（3）循环这样的过程直到i=j，i和j碰头。此后将基准数与i位置元素交换位置，相当于确定基准数的最终位置。这样就根据基准数划分为左右两个部分。
（4）再对这两个部分分别进行快排操作，直到正确的顺序。
平均时间复杂度： O(NlogN)

#include<cstdio>
#include<cstring>
int a[1100];
void  quicksort(int left,int right)
{
	int i,j,t,temp;
	if(left>right)
	return ;
	temp=a[left];//temp为基准数
	i=left;
	j=right;
	while(i!=j)//判断i和j是否碰头
	{
		while(a[j]>=temp&&i<j)//从右到左找到第一个小于基准数的元素
		 j--;
		while(a[i]<=temp&&i<j)//从左到右找到第一个大于基准数的元素
		 i++;
		 if(i<j)//将找到的两个元素交换
		 {
		 	t=a[i];
		 	a[i]=a[j];
		 	a[j]=t;
		 }
	}
	a[left]=a[i];//将基准数和i和j碰头的元素交换，相当于确定基准数的最终位置
	a[i]=temp;
quicksort(left,i-1);//递归变换位置后基准数两侧的子序列
	quicksort(i+1,right);
	return ;
}
int main()
{
	int n;
	while(scanf("%d",&n)!=EOF)
	
	{
		int i;
		for(i=1;i<=n;i++)
		 scanf("%d",&a[i]);
		 quicksort(1,n);
		for(i=1;i<=n;i++)
		 printf("%d\n",a[i]);
	}
	return 0;
}

5、插入排序
将一组数据分成两组，我分别将其称为有序组与待插入组。每次从待插入组中取出一个元素，与有序组的元素进行比较，并找到合适的位置，将该元素插到有序组当中。就这样，每次插入一个元素，有序组增加，待插入组减少。直到待插入组元素个数为0。当然，插入过程中涉及到了元素的移动。

  #include<stdio.h>
  void InsertionSort(int *num,int n) 
  {
  	int i = 0;
  	int j = 0;
  	int tmp = 0;
  	for(i = 1;i<n;i++)
  	{
      tmp = num[i];//从待插入组取出第一个元素。 
	  j = i-1; //i-1即为有序组最后一个元素（与待插入元素相邻）的下标 
	  while(j>=0&&tmp<num[j])  //注意判断条件为两个，j>=0对其进行边界限制。第二个为插入判断条件 
	  {
	    num[j+1] = num[j];//若不是合适位置，有序组元素向后移动 
		j--; 
	  }
	  num[j+1] = tmp;//找到合适位置，将元素插入。 
	}
  }
  int main() 
  {
  	int i = 0;
  	int num[8]={9,3,4,2,6,7,5,1};
  	InsertionSort(num,8); 
  	/*这个函数必须知道元素的个数，所以将元素个数传入。
	有心者可以在函数内部用sizeof求出元素个数 */
  	for(i=0;i<8;i++)
  	{
     	printf("%d ",num[i]);
	}
  	return 0;
  }

5、就平均查找速度而言，下列几种查找速度从慢至快的关系是___________。
顺序查找的时间复杂度为o(n)
分块查找的时间复杂度为o(log2n)到o(n)之间
二分查找的时间复杂度为o(log2n)
哈希查找的时间复杂度为o(1)
6、设顺序线性表的长度为30，分成5块，每块6个元素，如果采用分块查找 并且索引表和块内均采用顺序查找 ，则其平均查找长度为 ( ) 。
总的平均查找长度为：分块查找的平均长度+顺序查找的平均长度
7、二分查找要满足顺序存储、链存储、按value有序中的哪些条件？
顺序存储、按value有序
首先二分查找要求序列必须是有序的，其次序列可以随机访问任何有效范围内索引的值，链式存储不能随机访问，必须是顺序存储

8、For the following Java or C# code(3 Points)，What will my Array3[2][2] returns?
int [][] myArray3 =
new int[3][]{
new int[3]{5,6,2},
new int[5]{6,9,7,8,3},
new int[2]{3,2}
};
由于无Array3[2][2]这个数据项，所以overflow
每一行数据的声明为new int[]{};注意此种表示方法
9、 数组名就是数组的首地址，
对一个指针加1的结果是对该指针增加一个存储单元，对数组而言，地址会增加到下一个元素的地址。
C中的p[i]等同于p+i,它是指向数组a[i]的指针。
10、①线性表的顺序存储结构是一种 (随机存取 ) 的存储结构。用一组地址连续的存储单元依次存储线性表的数据元素(数组)，存入的时候是顺序的，前后位置关系在内存中也是固定的，取出的时候直接依据编号就可以找到，不需要遍历一遍，所以是随机取出的。
②线性表的链式存储结构，顺序存取。数据元素在内存中的位置是动态分配的无序的(链表)，所以取出的时候并不知道其具体位置，必须要从头开始遍历，是顺序取出的。
11、广义表
表头可以为表或单元素值
表尾是指除去表头后剩下的元素组成的表（即使只剩一个元素也视为表），可以为空表
12、和顺序栈相比,链栈有一个比较明显的优势是(通常不会出现栈满的情况)
因为顺序栈用数组实现，必须事先确定栈的大小，对内存的使用效率并不高，无法避免因数组空间用光而引起的溢出问题：而链栈因为动态申请内存，一般不会出现栈满情况，空栈还是会出现的
都是栈，栈先进后出，只能在栈顶进行插入和删除操作，所以链栈在这点对于顺序栈并无优势。
13、有一个 100 × 90 的稀疏矩阵，非 0 元素有 10 ，设每个整型数占 2 个字节，则用三元组表示该矩阵时，所需的字节数是66 。

10个非零元素：1032=60字节（i，j，元素值）
剩下的6个字节：分配给行数、列数、总元素数，即3*2=6字节
总字节数目：60+6=66字节
14、下列关于线性表中的链表描述正确的是ABCD
适用于数据项数量不能预知的情况。
逻辑相邻的2元素的存储空间可以是不连续的。
链表节点一般有数据元素和指针域两部分组成。
存储空间需要动态分配。
15、循环队列
队列空的条件：front==rear （front队头 rear队尾）
队列满的条件：(rear+1)%maxsize = front
队列中元素个数：(rear-front+maxsize)%maxsize
入队：rear=(rear+1) % maxsize ;
出队：front=(front+1) % maxsize ;
16、以下属于逻辑结构的是(有序表)
有序表中所有元素以递增或递减方式排列，对数据之间的关系进行了描述，是一种逻辑结构。
顺序表是指用一组地址连续的存储单元依次存储数据元素的线性结构。
哈希表用散列法存储的线性表叫散列表。
单链表用一组地址任意的存储单元存放线性表中的数据元素，均只是一种存取结构，不是逻辑结构。

树

1、设有一组初始记录关键字序列为(34，76，45，18，26，54，92)，则由这组记录关键字生成的二叉排序树的深度为（4）。

BST构造的时候，如果根节点为空，则首先序列的第一个作为根节点，然后第二个与根节点比较：小的放到左边，大的放到右边；根节点不为空的时候，待插入的节点跟根节点比较：小的往左子树去比较，大的往右子树去比较。比较过程中，待插入节点只作为某节点的左或右节点插入，而不会变动之前的节点位置。
2、平衡二叉树
平衡二叉树（AVL树）：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
https://blog.csdn.net/u010442302/article/details/52713585
左旋、右旋
1、单旋转

左左、右右情况
2、双旋转

针对于左右、右左情况
3、设有数组A[i,j],数组的每个元素长度为3字节，i的值为1到8，j的值为1到10，数组从内存首地址BA开始顺序存放，当用以列为主存放时，元素A[5,8]的存储首地址为(BA+180)。

**行优先: Loc(aij) = Loc(a11) +[（i-1）*n + j-1 ]*sizeof(元素)
列优先: Loc(aij) = Loc(a11) + [(j-1)m + i-1]sizeof(元素)
4、一棵有12个节点的完全二叉树，其深度是（4）
具有n个结点的完全二叉树（包括满二叉树）的高度为【log2 n】+1 或者（【log2 （n+1 ）】）

5、假设一棵完全二叉树含有456个结点，则度为0、1、2的结点个数分别为（ 228,1,227 ）
完全二叉树，度数为1的节点数要么1个，要么0个。
n2=n0+1；
n0+n1+n2=456
6、具有3个结点的二叉树有几种形态？ 5
C(n)=(1/(n+1))((2n)!/(n!*n!))
7、常见的遍历次序：
（1）先序遍历；A BDFE CGHI（根左右）
（1）访问根节点；
（2）采用先序递归遍历左子树；
（3）采用先序递归遍历右子树；

（2）中序遍历；（左根右）

（3）后序遍历。（左右根）DEFBHGICA

三种方法的遍历都是根左右，只是打印顺序不同

8、不含任何结点的空树（不是特指树和二叉树，即一个集合）可能是一棵二叉树;
树的节点数最少为1，而二叉树最小节点数可以为0.
9、二叉树是一种树形结构，每个节点至多有两颗子树，下列一定是二叉树的是（红黑树、AVL树）
（1）红黑树（Red Black Tree） 是一种自平衡二叉查找树
https://blog.csdn.net/zl1zl2zl3/article/details/83999542
（2）B树是一种平衡的多叉树。
B+ 树 是一种树数据结构，是一个n叉树
AVL树是自平衡二叉查找树。