某知名网校笔试题精选 - 9.2

9.2 晚做了某个著名网校的笔试，有几题感觉不错就分享出来了，看完应该会有点收获的

---

小题目：
（顺序有点打乱了，我只挑了我认为值得一看的题目分享）

（1）假设32位计算机程序：

short a = 32767*2;

unsigned short b = a;  //cout<<b<<endl;

判断b的输出？

有点搞不明白这个题目的意图，是想问有没有溢出，还说想说有符号到无符号数的转变？我觉得就是b=a，一样一样的

（2）a的值最后是多少？

int a;

a=5?0:1;

cout<<a;

最后是0，这里很容易把a误解成5了，这是对三目运算符的考察

（3）x=9999的输出值

 int func(int x)
{
int count=0;
while(x)
{
	count++;
	x=x&(x-1);
}
return count;
 }

输出值是8，其实x=x&(x-1)相当于是检查x换算成二进制的位数

（4）先序序列为a,b,c,d的不同二叉树的个数是多少？

（5）这段代码一共循环了多少次？

    int k=2000;
    int c=0;
    while(k>1)
    {
    	k=k>>1;
    	c++;
	}
	cout<<c;

输出是10，>>右移相当于是除2

（6）判断这段程序的输出：

#include <iostream>

using namespace std;

int main()
{
	int a=1,b=2,c=3,d=0;
	
	if(a==1 && b++ ==2)
	   if(b!=2 || c--!=3)
	   	    cout<<a<<b<<c;
       else
       		cout<<a<<b<<c;
	else
	    cout<<a<<b<<c;
	
	return 0;
}

这需要注意一个点： 对于||语句来说，如果前面的条件正确，那么后面的判断就不执行了

---

两道编程题：

第一题

给定一个整数链表，输出不含重复数字的链表，链表包含负数，比较绝对值，并且输出的元素都是绝对值

分析：
这个题目，看似和链表有关，其实给的输入就是一串数字，而已，所有和链表的处理并没有关系啦，我这里才用了数组下标来做是否有重复的判断，然后在按序输出即可！
我把数组大小设置为一个给定的值，因为感觉数据量也不会太大（题目没有说明边界），然后真的直接AC了

AC代码

/*********************
typedef struct node {
      int data;
      struct node  *link;
} NODE;
 

typedef NODE* PNODE;

**********************/

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int maxn=10000+10;

int main()
{
    int n;
    int a[maxn]={0};

    while(scanf("%d",&n)!=EOF)
    {
        if(n<0)
            n=abs(n);
        if(a[n]==0)
        {
            cout<<n<<" ";
            a[n]++;
        }
    }
   
    return 0;
}

第二题

假设今年网校有N个校招生以及笔试对应的分数，寻找这前TopN 0.1%（向上取整），假设网校的校招的总人数不超过100 0000
输入：
校招总人数
分数
输出：
top0.1%的分数

分析：
该题一看，便知道了是对N个分数进行排序的问题；题目要求了必须是C语言编写，且提示了用堆，题目的数据量较大，因此我这里就才用堆排序的方法，找出前TopN的分数

（因为时间有限，当时没有把这道题目完整得A出来，只过了测试用例的百分之67，我猜测应该是没有向上取整的问题）

##AC代码

#include <stdio.h>
#include <stdlib.h>

int a[1000000+10];

void swap(int *arr,int i, int k) 
{
    int temp = arr[i];
    arr[i] = arr[k];
    arr[k] = temp;
}


void max_heapify(int *arr, int start, int end) 
{
    //建立父节点下标和子节点下标
    int dad = start;

    int son = dad * 2 + 1;

    while (son <= end) 
    {   //若子节点下标在范围内才做比较
        if (son + 1 <= end && arr[son] < arr[son + 1]) //先比较两个子节点大小，选择最大的
        {
            son++;
        
        }

        if (arr[dad] > arr[son]) //如果父节点大于子节点代表调整完毕,直接跳出
        {
            return;
        }   
        else 
        {   //否则交换父子节点的值再继续左右子节点值得比较
            swap(arr,dad, son);
           // printf("dad=%d--son=%d\n",dad,son);
            dad = son;
            son = dad * 2 + 1;
        }
            
    }
}

void heap_sort(int *arr, int len) 
{
    int i;
    //初始化，i从最后一个父节点开始调整
    for (i = len / 2 - 1; i >= 0; i--)
    {
        max_heapify(arr, i, len - 1);
        
    }

    for (i = len - 1; i > 0; i--) 
    {
        swap(arr,0, i);

        max_heapify(arr, 0, i - 1);
    }
}



int main(int argc, char const *argv[])
{
    // int arr[] = {5,3,8,1,6};

    //int len = sizeof(arr) / sizeof(int);

    int n; scanf("%d",&n);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d",&a[i]);
    }

    heap_sort(a, n);

    int top = n*0.001;

    for (int i = 0; i < top; i++)
    {
        printf("%d\n", a[i]);
    }
        
    printf("\n");
    
    return 0;
}