17 计学

1.按行优先存储的四维数组A=array[1:10,1:5,1:7,1:8],设每个数据元素占2个存储单元，基地址为10，则A[3,4,5,6]的存储位置=（）。
答：1540.
10+2*(2578+378+48+5)=1540
规律：对于A[i][j][k][l]的四维数组.
按行优先=ij_sizek_sizel_size+jk_sizel_size+kl_size+l。如果数组下标从1开始，则i，j,k,l换成i-1,j-1,k-1,l-1。
按列优先(倒过来)=lk_sizej_sizei_size+kj_sizei_size+ji_size+i

2.A和B是长度为n的两个数组。设计一个算法，该算法输出长度为n的数组C。要求1：数组C中的每一个元素C[i]=||{A[j]|A[j]<=B[i],1<=j<=n}||，其中||S||表示集合S中的元素个数。例如：下表给出了长度为4的两个数组A和B，以及满足要求的数组C；要求2：所设计算法的时间复杂度低于O(n²)。

i	1	2	3	4
A[i]	6	17	9	10
B[i]	8	2	17	13
C[i]	1	0	4	3

答：
思路：C[i]=A中小于等于B[i]的个数。因为时间复杂度要低于o(n²)所以，先将A数组排序，然后再循环一次，确定每个b[i]在A中的位置，所处位置的下标就是小于等于它的个数。小于n2的排序算法只有堆排序，合并排序，希尔排序。这里用合并排序。最后查找的时候用二分查找。

void Merge(int a[],int low,int mid,int high)
{  //low~mid是一个有序表，mid+1~high是一个有序表，两表归并为一个有序表
	int b[maxsize];
	int i,j,k;
	for(i=low;i<=high;i++)
		b[i]=a[i];
	for(i=low,j=mid+1,k=low;i<=mid&&j<=high;k++)
	{
		if(b[i]<=b[j])//前一个表的值和后一个表的值比较，谁小存谁的
			a[k]=b[i++];
		else
			a[k]=b[j++];
	}
	while(i<=mid)a[k++]=b[i++];//后面的存完了前面没存
	while(j<=high)a[k++]=b[j++];//前面存完了，后面没存完
}
void Merge_sort(int a[],int low,int high)
{
	if(low<high)
	{
		int mid=(low+high)/2;
		Merge_sort(a,low,mid);
		Merge_sort(a,mid+1,high);
		Merge(a,low,mid,high);
	}
}
int binarySearch(int a[],int n,int key)
{
	int low=1,high=n,mid;
	while(low<=high)
	{
		mid=(low+high)/2;
		if(a[mid]>key)
			high=mid-1;
		else
			low=mid+1;
	}
	return high;
}
void getC(int a[],int b[],int c[],int n)
{
	Merge_sort(a,1,n);//对A排序
	for(int i=1;i<=n;i++)
		c[i]=binarySearch(a,n,b[i]);
}

2.二叉树的宽度定义为具有结点数最多的那一层上的结点总数。如下图所示，以a为根的二叉树宽度为3。假设二叉树以链接结构存储，指针T指向二叉树的根，数中结点的结构为（left,data,right）,写出求二叉树宽度的非递归算法。
思路：用层次遍历遍历每一层的结点，每遍历一层，就将max与当前层的结点数作比较。

typedef struct node
{
	int data;
	struct node *left,*right;
}*BiTree;
int Tree_width(BiTree T)
{
	BiTree p,queue[maxsize];
	int front,rear;
	int max;
	max=0;
	front=rear=0;
	if(T==NULL)
		return 0;
	queue[rear]=T;
	rear=(rear+1)%maxsize;
	while(front!=rear)
	{
		int len=rear-front;//当前队列的大小就是层的宽度
		if(max<len)max=len;
		while(len>0)
		{
			p=queue[front];//出队
			front=(front+1)%maxsize;
			len--;
			if(p->left)
			{
				queue[rear]=p->left;
				rear=(rear+1)%maxsize;
			}
			if(p->right)
			{
				queue[rear]=p->right;
				rear=(rear+1)%maxsize;
			}
		}
	}
	return max;
}