X32专项练习部分08

静态方法调用

	/*
    假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（）
    public class A{
        public int i;
        static String s;
        void method1(){}
        static void method2(){}
    }
    System.out.println(a.i);
    a.method1();
    A.method1();    // 类名只能调用静态方法
    A.method2();

    正确答案：C
    静态成员和静态方法，可以直接通过 类名 进行调用
    其他的成员和方法则需要进行实例化成对象之后，通过 对象 来调用

    static修饰的成员变量和方法
    既可以通过类调用也可以通过实例(也就是对象)
    无static修饰的只能通过实例(也就是对象)调用
     */

hashcode和equals

	/*
    下面论述正确的是（）？
    正确答案: D

    如果两个对象的hashcode相同，那么它们作为同一个HashMap的key时，必然返回同样的值
    如果a,b的hashcode相同，那么a.equals(b)必须返回true
    对于一个类，其所有对象的hashcode必须不同
    如果a.equals(b)返回true，那么a,b两个对象的hashcode必须相同

    那么equals()既然已经能实现对比的功能了
    为什么还要hashCode()呢？因为重写的equals()里一般比较的比较全面比较复杂
    这样效率就比较低，而利用hashCode()进行对比
    则只要生成一个hash值进行比较就可以了，效率很高

    那么hashCode()既然效率这么高为什么还要equals()呢
    因为hashCode()并不是完全可靠
    有时候不同的对象他们生成的hashcode也会一样（生成hash值得公式可能存在的问题
    所以hashCode()只能说是大部分时候可靠，并不是绝对可靠
    1、如果两个对象相等，那么他们一定有相同的哈希值（hash code）。
    2、如果两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（需要再通过equals来判断）

    所以我们可以得出：
    1.equals()相等的两个对象他们的hashCode()肯定相等，也就是用equals()对比是绝对可靠的。
    2.hashCode()相等的两个对象他们的equal()不一定相等，也就是hashCode()不是绝对可靠的。
    所有对于需要大量并且快速的对比的话如果都用equals()去做显然效率太低
    所以解决方式是，每当需要对比的时候
    
    首先用hashCode()去对比，如果hashCode()不一样
    则表示这两个对象肯定不相等（也就是不必再用equal()去再对比了）
    如果hashCode()相同，此时再对比他们的equals()
    如果equals()也相同，则表示这两个对象是真的相同
    这样既能大大提高了效率也保证了对比的绝对正确性
    
    补充这么多，再看选项
    A：在hashmap中，key值是不可能重复的
    由hashCode和equals方法共同判断key值是否相等
    即使两个对象的hashCode相同相等，也不能说他们的key值相等。
    B和D：如果x.equals(y)返回true,那么这两个对象的hashCode返回的整数结果必然相同
    如果x.equals(y)返回false,则不一定；
    反之，hashCode返回的值不相等，则equals方法返回值一定不相等。hashCode返回值相等，则不一定
    C:hashCode的值是可以相同的。
     */

链表查找平均复杂度

	/*
    从一个具有 n 个结点的单链表中查找其值等于 x 结点时，在查找成功的情况下，需平均比较（ ）个结点。
    正确答案: D
    n
    n/2
    (n-1)/2
    (n+1)/2

    最少1次  最多n次  平均(n+1)/2次
    （1+2+3+...+n）/n=（n（n+1）/2）/n=（n+1）/2
    匹配到每一个的概率是1/n，x可能在1.2.3.4.……n，有n（n+1）/2，再乘1/n，选d
    上面三行都是解出链表平均复杂度的方法
     */

倒立的栈

	/*
	例1
    设栈的存储空间为 S(1:60) ，初始状态为 top=61
    现经过一系列正常的入栈与退栈操作后， top=1 ，则栈中的元素个数为（ ）

    正确答案: A
    60
    59
    0
    1

    初始状态为top=61代表这个栈为空
    栈底为60 栈顶为1 栈顶也包括元素
    一共60个元素
    
    例2
    设栈的存储空间为 S(1:50) ，初始状态为 top=51
    现经过一系列正常的入栈与退栈操作后， top=50 ，则栈中的元素个数为（ ）

    正确答案: A
    1
    0
    50
    49
    
    和上面的解题方法一样
    51 - 50 = 1

	例3
	设栈的顺序存储空间为 S(0:49) ，栈底指针 bottom=49 ，栈顶指针 top=30 （指向栈顶元素）。则栈中的元素			 个数为（ ）。
	正确答案：C

	30
	29
	20
	19
     */

存储密度

	/*
    单链表的存储密度
    
    大于1
    等于1
    小于1
    不能确定
    
    正确答案：C
    存储密度 = 单链表数据项所占空间 / 结点所占空间
    单链表的存储结构是两个空间
    一个存放数据 一个作为指针指向下一个节点
    所以存储密度为 1 / 2
     */

链表合并

	/*
    已知两个长度分别为m 和 n 的升序链表，若将它们合并为一个长度为 m+n 的降序链表，则最坏情况下的时间复杂度是（ ）。

    O(n)
    O(m+n)
    O(min(m ,n))
    O(max(m,n))
    
    链表1和链表2顺序遍历,较小的放入结果链表后端
    结果链表要空间复杂度O(m+n)，时间复杂度O(m+n)
    
    所以说在遍历的时候就已经排好序了
    所以只有顺序遍历两个时间复杂度之和
     */

出栈序列

	/*
    3个数顺序(依次)进栈，出栈序列有（ ）种。

    正确答案: B
    4
    5
    6
    7

    假设入栈顺序是 3、2、1
    出栈顺序可以作如下推测：
    第一个出栈的数是 1，那么后两个数的组合可以是 23 或者 32，32 不可能
    第一个出栈的数是 2，那么后两个数的组合可以是 13 或者 31，两者都符合
    第一个出栈的数是 3，那么后两个数的组合可以是 12 或者 21，两者都符合
    所以一共有 5 种出栈顺序
     */

循环链表长度

	/*
    设循环队列的容量为50（序号从0到49），现经过一系列的入队和出队运算后
    有 front=16，rear=5（rear指向队尾元素的后一位置），当前循环队列中元素个数为
    
    11
    39
    40
    12
    
    求元素的长度公式：
    length = (rear - front + size) % size
    rear mains the next node of the last node
     */

总目录