2013.9.2 校招准备 tips + 各种数据结构

x&(x-1)表达式的意义

求下面函数的返回值(微软) -- 统计1的个数
-------------------------------------
int func(int x)
{
    int countx = 0;
    while(x)
    {
        countx++;
        x = x&(x-1);
    }
    return countx;
}

假定x = 9999
10011100001111
答案: 8

思路: 将x转换为2进制,看是否包含1的个数。

注意:每执行一次x = x&(x-1)，会将x用二进制表示时最右边的一个1变为0，因为x-1将会将该位(x用二进制表示时最右边的一个1)变为0。

其实就是每次把最右边的1变为0 之后 & 操作之后得到的 没有1的全都是0 这样最后就能统计有多少个1 了。

判断一个数(x)是否是2的n次方
-------------------------------------
#include <stdio.h>

int func(int x)
{
    if( (x&(x-1)) == 0 )
        return 1;
    else
        return 0;
}

int main()
{
    int x = 8;
    printf("%d\n", func(x));
}


注:
(1) 如果一个数是2的n次方，那么这个数用二进制表示时其最高位为1，其余位为0。

(2) == 优先级高于 &

最大堆/最小堆

　堆的定义是：n个元素的序列{k₁,k₂,…,k_n}，当且仅当满足如下关系时被成为堆

　　 　(1)K_i <= k_2i 且 k_i <= k_2i-1        

　　或 (2) K_i >= k_2i 且 k_i >= k_2i-1 

　　　　　　　　　　(i = 1,2,…[n/2])

当满足(1)时，为最小堆，当满足(2)时，为最大堆。

 

　　若将此序列对应的一维数组堪称是一个完全二叉树，则2i和2i+1个节点分别是节点i的左右子节点。

如下为一个最大堆：

 

下面以最小堆为例说明堆的输出：

 

　　图1为一个最小堆，当最小节点根节点13输出后，将最后一个节点97作为根节点，移到顶端，如图2. 然后要对堆进行调整。比较此完全树的根节点与其两个子节点大小，因为27 < 38 < 97，所以27是三个节点里最小的，将节点27与根节点97交换。此时以97替代27而产生的右子树为一个新的堆，再以97为根节点，对此最小堆进行调整，同理，知道要将97与49交换，得到图3的完全树。此时以97代替49为根节点的右子树为一个新堆，再对此堆做同样的操作，因为此完全树已经是最小堆，所以可以停止操作，堆的调整完毕。此时再将根节点，对的最小值输出，并进行同样的调整，可以得到如图4的新堆。这个过程被称为“筛选”。

 

同样以最小堆说明堆的初始化：

　　从一个无序序列初始化为一个堆的过程就是一个反复“筛选”的过程。由完全二叉树的性质可以知，一个有n个节点的完全二叉树的最后一个非叶节点是节点[n/2]，堆的初始化过程就从这个[n/2]节点开始。上图为如下无序数组的初始化：

　　　　{49,38,65,97,76,13,27,50}

　　首先，未处理的数组对应的堆为图1模样。从第四个节点开始（[8/2]=4），因为50 < 97，故要交换两节点，交换后还要继续对其新的左子树进行类似输出后那样的筛选。易见其左子树只有节点97，已经为最佳情况，故可以继续堆的初始化，如图2。再考虑第三个节点，因为13 < 27 < 65，即节点13为当前的最小节点，故与节点65交换，并对新的左子树进行筛选，其也为最佳情况，故可继续堆的初始化，结果如图3。然后考虑第二个节点，因为38 < 50 < 76，故已经为最优情况，不用调整。最后再考虑第一个节点，根节点。因为 13 < 38 < 49，故需要将根节点49与其右孩子节点13交换，交换后还要继续对其新的右子树进行类似输出后那样的筛选，可见右子树还需要调整，因为 27 < 49 < 65,故将节点49与节点27交换。此时已经处理完了根节点，初始化结束。最终结果如图5.

　　本文参考了严蔚敏的《数据结构》

题目：如何判断单项链表有死循环？
    答案：定义两个指针p、q，然后让p、q同时从链表头向后查找，注意他们移动的步幅是不同的分别为a
、b，例如p指针每次执行一次【p = p->next;】q每次执行两次【q = q->next;】，如果q先到链尾【if(q->next == NULL)】则没有死循环（这里假设q比p的移动速度要快），如果p、q在此之前相遇了则有死环。

问题1. 一个单向链表，请设计算法判断该链表中有没有环？

思路1：声明一个指向链首的指针和一个足够大的int数组(或hash表，用于保存地址)，逐个节点地遍历链表；遍历过程中，先判断该节点的地址是否已经在数组中存在了，如果不存在，则将该地址加入数组并让指针指向下一个节点；如果存在，则证明链表中有环。这种方法需要用数组来保存地址，并反复遍历该数组，效率很低，伪代码如下：
1Node* ptr= head;//链首
2int i[100000];
3int len=0;
4while(ptr!=null)
5{
6    int address= ptr;
7    if(address alreadyin i)
8    {
9         print'链表中存在环';
10     exit();
11     }
12     i[len]= ptr;
13     ptr= ptr->next;
14}
15print'链表中没有环'
16exit();

思路2：如果链表中有环的话，则整个链表呈6、9、或0字形；可以声明两个指向链首的指针，其中一个指针每次移动一个节点，另一个指针每次移动两个节点，如果两个指针指向同一个节点，则表示链表中存在环(类似与小学数学中的追击问题=_=)，否则不存在环。伪代码如下：

1Node* ptr1 = head;
2Node* ptr2= head;
3if(ptr1!=null)
4     ptr1= ptr1->next;
5if(ptr1== ptr2)//考虑链表中只有一个元素，且构成一个环的情况
6{
7     print'链表中存在环';
8     exit();
9}
10ptr2= ptr2->next->next;//或者ptr1->next;
11while(true)
12{
13    if(ptr1==null|| ptr2==null)
14    {
15         print'链表中没有环';
16        break;
17     }
18    if(ptr1==ptr2)
19    {
20         print'链表中存在环';
21        break;
22     }
23     ptr1= ptr1->next;
24    if(ptr2->next!=null)
25         ptr2= ptr2->next->next;
26}
27exit();

  支持思路二 更加优化~

1、在段页式存储管理中，其虚拟地址空间是（）

A、一维                               B、二维                                C、三维                            D、层次

答案：B

2、采用( )不会产生内部碎片(“内零头”)
A、分页式存储管理                                                             B、分段式存储管理
C、固定分区式存储管理                                                      D、段页式存储管理
答案：B
3、段页式管理每取一数据，要访问（）次内存。

A、1                      B、2                                C、3                                D、4

答案：C

4、分段管理提供（B）维的地址结构。

A、1                      B、2                                C、3                                D、4

二维逻辑地址：段号+段内地址
分页与分段的主要区别：
1）、段是信息的逻辑单位，它是根据用户的需要划分的，因此段对用户是可见的；页是信息的物理单位，是为了管理主存的方便而划分的，对用户是透明的。
2）、页的大小固定不变，由系统决定。段的大小是不固定的，它由其完成的功能决定。
3）、段式向用户提供的是二维地址空间，页式向用户提供的是一维地址空间，其页号和页内偏移是机器硬件的功能。
4）、由于段是信息的逻辑单位，因此便于存贮保护和信息的共享，页的保护和共享受到限制。

分页与分段存储管理系统虽然在很多地方相似，但从概念上讲，两者是完全不同的，它们之间的区别如下：
  ①页是信息的物理单位。分页的目的是实现离散分配，减少外部碎片，提高内存利用率。段是信息的逻辑单位。每一段在逻辑上是一组相对完整的信息集合。
  ②分页式存储管理的作业地址空间是一维的，而分段式存储管理的作业地址空间是二维的。
  ③页的大小固定且由系统确定，是等长的。而段的长度不定。
  ④分页的优点体现在内存空间的管理上，而分段的优点体现在地址空间的管理上。

5、（）存储管理方式提供二维地址结构。

A、固定分区                    B、分页                            C、分段                           D、可变分区

答案：C

6、（）存储管理方式提供一维地址空间。

A、固定分区           B、分段                   C、分页                  D、分段和段页式

答案：A
7、下列（）存储管理方式能使存储碎片尽可能少，而且使内存利用率较高。

A、固定分区                B、可变分区                C、分页管理             D、段页式管理

答案：D

 8、分页管理每取一数据，要访问( )次内存。

A、1         B、2          C、3          D、4

答案：B

9、通道是一种( )。

A、I／O端口           B、数据通道                C、I／O专用处理机                      D、软件工具

答案：C

10、磁盘与主机之间的数据传送方式是( )

A、无条件                B、程序查询                 C、中断方式                 D、DMA方式

答案：D

 11、在一个请求页式存储管理中，一个程序的页面走向为4、3、2、1、3、5、4、3、2、1、5，并采用LRU算法。设分配给该程序的存储块数M分别为3和4，在该访问中发生的缺页次数F和缺页率f 是(C )

A. ①M=3，F=8、f≈67％ ②M=4，F=5、f≈42％

B．①M=3，F=10、f=83％ ②M=4，F=8、f≈67％

C．①M=3，F=9、f≈75％ ②M=4，F=9、f≈75％

D．①M=3，F=7、f≈58％ ②M=4，F=6、f=50％

12、进程和程序的本质区别是( D)

A、存储在内存和外存                                    B、顺序和非顺序执行机器指令

C、分时使用和独占使用计算机资源              D、动态和静态特征

13、系统感知进程的唯一实体是(C )

A、JCB                    B、FCB               C、PCB                D、SJT

14、SPOOLING技术利用于( B)

A、外设概念                  B、虚拟设备概念                C、磁带概念                    D、存储概念

15、( A)是直接存取设备。

A、磁盘                 B、磁带         C、打印机           D、键盘显示终端

16、采用假脱机技术，将磁盘的一部分作为公共缓冲区以代替打印机，用户对打印机的操作实际上是对磁盘的存储操作，用以代替打印机部分是指（）

A、独占设备           B、共享设备             C、虚拟设备           D、一般物理设备

答案：C

17、在可变分区存储管理中的移动技术优点在于（）
A、增加主存容量          B、缩短访问周期                      C、加速地址转换             D、集中空闲区
答案：D
18、位示图的用处为（）

A、主存空间的共享              B、文件的保护和加密             C、磁盘空间的管理                 D、文件目录的查找
答案：C
19、虚拟设备中，当用户作业要进入系统时，由SPOOLing系统的预输入程序将作业信息从物理输入设备上送到( )
A、内存                                   B、输入井                                         C、输出井                                         D、通道
答案：B

20、设在内存中有P1、P2、P3三道程序，并按照P1、P2、P3的优先次序运行，其内部计算和I/O操作时间由下图给出：
P1：计算 60ms----------------I/O 80ms-----------------计算 20ms
P2：计算 120ms--------------I/O 40ms-----------------计算 40ms
P3：计算 40ms----------------I/O 80ms-----------------计算 40ms
调度程序的执行时间忽略不计，完成这三道程序比单道运行节省的时间是(C )
A、80ms           B、120ms            C、160ms           D、200ms
解析：首先P1计算60ms，然后I/O 80ms，在这80ms中，P2也同步开始计算，等P1的I/O运行完了，CPU停止P2的计算，转去做P1后期那20ms的运算，至此所花时间为60+80+20=160ms；然后CPU再去接着运算P2，40ms，然后p2I/O运行40ms,在此期间，cpu去计算p3,正好也是40ms，算完之后接着算p2的后期部分，40ms，在此期间，因为p3的前40ms已经计算完成，可以进行i/o操作，所以同时p3的i/o也开始运行，运行80ms，这80ms中，前40msCPU在算P2，后40msCPU在算P3,所以是：40+40+40+80=200ms，加上前面的160，为360ms。
而如果是单道运行，则时间花费为：60+80+20+120+40+40+40+80+40=520ms,相差为520-360=160ms ，选C

 产生死锁的原因主要是：
（1） 因为系统资源不足。
（2） 进程运行推进的顺序不合适。
（3） 资源分配不当等。
产生死锁的四个必要条件：
（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

博主原文:

http://blog.csdn.net/Hackbuteer1/article/details/6787354#comments