X32专项练习部分06

带链队列操作

	/*
    某带链的队列初始状态为 front=rear=NULL
    经过一系列正常的入队与退队操作后， front=rear=10
    该队列中的元素个数为（ ）
    1
    0
    1或0
    不确定
    
    带链的队列，
    带链队列为空时，front = rear= NULL
    插入第1个元素时，rear+1 =1，front+1 = 1
    插入第2个元素时，rear+1 =2，front不变
    删除第2个元素时，front+1 = 2，rear=2，即 front = rear= 2
    就这么一直插入删除
    最后带链队列也就只有一个元素
    就是最开始插入的元素
     */

顺序容器的增删操作

/*
    NumberList是一个顺序容器，以下代码执行后，NumberList里的元素依次为：

    List<int> NumberList = new List<int>(){2,4,1,3,5};
    for(int i = 0;i<NumberList.Count;++i)
    {
        int v = NumberList[i];
        if(v%2 = = 0)
        {
            NumberList.Remove(v);//删除的是元素，而非下标
        }
    }
    正确答案: C

    2,4,1,3,5
    2,1,3,5
    4,1,3,5
    1,3,5

    初始时，{2,4,1,3,5}
    v=NumberList[0]=2;
    2是偶数，删除2。
    {4,1,3,5}

    v=NumberList[1]=1;
    1为奇数，NumberList不变。

    v=NumberList[2]=3
    3为奇数，NumberList不变。

    v=NumberList[3]=5
    5为奇数，NumberList不变。
    最后NumberList中的元素为{4,1,3,5}

    注意读题：NumberList是顺序容器
    也就是删除里面的元素
    数组的下标前移
    这道题需要画图去做
     */

链表基础知识巩固

	/*
    关于链表，以下说法正确的是 （ ）
    正确答案: B C
    需经常修改线性表Ｌ中的结点值适合采用链式结构
    需不断对线性表Ｌ进行删除插入适合采用链式结构
    带头结点的单链表，在表的第一个元素之前插入一个新元素与链表长度无关
    删除单链表中的最后一个元素，与链表长度无关

    选B是因为
    如果不采用链表而采用顺序表的话，每删除或增加一个元素
    其后面的所有元素都要后移或前移，使用链表则不需要
    选C是因为
    单链表在第一个元素前加元素
    只需要改变头结点的后驱结点
    和原第一个元素的前驱结点就可以
    A和D选项明显错误
     */

覆盖节点内容实现链表节点删除

	/*
    设指针变量 p 指向单链表中结点 A
    若删除单链表中结点 A ，则需要修改指针的操作序列为

    正确答案: A   你的答案: B (错误)
    q=p->next；p->data=q->data；p->next=q->next；free(q)；
    q=p->next；q->data=p->data；p->next=q->next；free(q)；
    q=p->next；p->next=q->next；free(q)；
    q=p->next；p->data=q->data；free(q)；

    说明：
    实际删除的是A的后继结点B：先将A的后继结点B复制到A中
    且A的后继改为原来B的后继，再将B删除。作用等同于删除A
    不同于以往的删除后面节点的方式
    q作为辅助节点的存在
    p+1节点覆盖掉了p节点的data
    本题目删除节点p
    是个好题
     */

文件分配表

/*
    文件分配表FAT是管理磁盘空间的一种数据结构
    用在以链接方式存储文件的系统中
    记录磁盘分配和跟踪空白磁盘块
    整个磁盘仅设一张FAT表
    如果文件块号为2，查找FAT序号为2的内容得知物理块2的后继物理块是5；
    再查FAT序号为5的内容得知物理块5的后继物理块是7；
    接着继续查FAT序号为7的内容为“^”，
    即该文件结束标志，所以该文件由物理块2、5、7组成。

    假设磁盘物理块大小为1KB，并且FAT序号以4bits为单位向上扩充空间
    请计算下列两块磁盘的FAT最少需要占用多大的存储空间？
    1）一块540MB的硬盘
    2）一块1.2GB的硬盘

    1M 3M
    1.2M 3.15M
    1.35M   3.6M
    1.3M   3.15M

	选C
    前面7行说了一堆废话，就是了解有这么一个东西
    盘块数量：540MB/1KB = 540K = 540000
    2^19<540000<2^20,所以每个盘块号需要20位二进制才能存下
    需要被2的幂次方表
    FAT序号以4bits为单位向上扩充空间：二进制位需要是4的倍数，20满足条件
    每个盘块需要的存储空间(需要转化成字节)：20/8 = 2.5B
    总共需要的存储空间：2.5B * 540000 = 1350KB

    1.2GB，即1200K个分区，2^20 < 1200K < 2^21，
    也就是需要21个bit才能存储，但是序号只能是4个倍数，所以需要24个bit，也就是3B的空间。
    1.2GB需要1200K * 3B = 3600KB即3.6M
     */

URL类

/*
        URL u =new URL("http://www.123.com");。如果www.123.com不存在，则返回______。
        正确答案: A
        http://www.123.com
        ””
        null
        抛出异常

        写代码测试即可
        不管网址是否存在
        在控制台都会打印输出该网址
        点击即可访问
         */
        try {
            URL url = new URL("https://www.baidu.com");
            System.out.println(url);
            URL url1 = new URL("https://123456789.com");
            System.out.println(url1);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }

静态变量

	/*
    请问下列该程序的输出结果

    因为x的修饰符为 static 所以x为类变量
    即对于所有的实例来说，他们访问的x为同一个x
    类变量存储在方法区，不属于每个实例的私有
    
    调用hs1.x++   x为101;
    调用hs2.x++   x为102;
    调用hs1.x++   x为103 (此时hs1指向了一个新的HasStatic实例，但是依然访问的是同一个X)
    调用HasStatic.x--  x为102
     */
    public static void main(String args[]) {
        HasStatic hs1 = new HasStatic();
        hs1.x++;
        HasStatic hs2 = new HasStatic();
        hs2.x++;
        hs1 = new HasStatic();
        hs1.x++;
        HasStatic.x--;
        System.out.println("x=" + x); // 102
    }

字符转换成字符串

		char myChar = 'g';
        String myStr = Character.toString(myChar);
        System.out.println("String is: "+myStr); // g
        myStr = String.valueOf(myChar);
        System.out.println("String is: "+myStr); // g
        /*
        String.valueOf方法重载
        toString调用的就是String.valueOf方法
        // Character.java
        public static String toString(char c) {
            return String.valueOf(c);
        }
        所以结果一样
         */
        boolean bool = true;
        String s = String.valueOf(bool);
        System.out.println(s);

静态链表和动态链表的区别

		/*
        静态链表和动态链表的区别
            静态链表是用类似于数组方法实现的，是顺序的存储结构，在物理地址上是连续的
            而且需要预先分配地址空间大小
            所以静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅需修改指针

            动态链表在C语言中是用内存申请函数（malloc/new）动态申请内存的，所以在链表的长度上没有限制
            动态链表因为是动态申请内存的，所以每个节点的物理地址不连续，要通过指针来顺序访问
			
			例题：
			用数组r存储静态链表,结点的next域指向后继,工作指针j指向链中结点,使j沿链移动的操作为()？
			正确答案: A
			j=r[j].next
			j=j+1
			j=j->next
			j=r[j]->next
         */

单链表插入新节点并保持有序的时间复杂度

		/*
        在一个具有 n 个结点的有序单链表中插入一个新结点并仍然保持有序的时间复杂度是 。
        正确答案: B
        O（1）
        O（n）
        O（n2）
        O（nlog2n）

        单链表插入时间应该是O(1)，但要维持有序状态
        就应该从头结点开始逐个进行比较扫描，也就是遍历
        最好情况O(1)，最坏O(N)，平均情况O(N/2)
         */

满足下列操作的数据结构

		/*
        假设要存储一个数据集，数据维持有序
        对其的操作只有插入、删除和顺序遍历，综合存储效率和运行速度
        下列哪种数据结构是最适合的是
        正确答案: B
        数组
        链表
        哈希表
        队列

        数组增删操作需要大量元素的位移，平均移动n/2，效率低
        哈希表离散分布，无法实现顺序遍历
        队列只可以在队尾插入队头删除，不可以实现中间插入和删除，不满足条件
         */

总目录