Java刷题总结

选择题

• 一个栈的输入序列为1 2 3 4 5，则下列序列中不可能是栈的输出序列的是（D）
  A.1 5 4 3 2
  B.2 3 1 4 5
  C.2 3 4 1 5
  D.5 4 1 3 2
• 循环队列的存储空间为 Q(1:40) ，初始状态为 front=rear=40 。经过一系列正常的入队与退队操作后， front=rear=15 ，此后又退出一个元素，则循环队列中的元素个数为（A ）。
  A.39，或0且产生下溢错误
  B.14
  C.40
  D.15
  解析：
  front=tail时，队列可能空，也可能满！
• 循环队列的存储空间为 Q(1:100) ，初始状态为 front=rear=100 。经过一系列正常的入队与退队操作后， front=rear=99 ，则循环队列中的元素个数为（ D）
  A.1
  B.2
  C.99
  D.0或100
  解析：
  
• 数组Ｑ［0…m-1］用来表示一个循环队列， 用front指向队头元素，rear指向队尾元素的后一个位置 ，则当前队列中的元素数是。（队列总的元素数不会超过队列大小）（A）
  A.(rear-front+m)% m
  B.rear-front+1
  C.rear-front-1
  D.rear-front
• 在非空双向循环链表中q所指的结点后插入一个由p所指的链结点的过程依次
  为: rlink§<-rlink (q)；rlink(q)<-p；Ilink§<-q; (C )
  A.rlink(q)<-p
  B.rlink(llink§)<-p
  C.llink(rlink§)<-p
  D.rlink(rlink§)<-p
  解析：
  
• 下面关于二分查找的叙述中正确的是：（D）
  A.表必须有序,表可以顺序方式存储,也可以链表方式存储
  B.表必须有序且表中数据必须是整型,实型或字符型
  C.表必须有序,而且只能从小到大排列
  D.表必须有序,且表只能以顺序方式存储
  解析：
  二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。
  它的算法要求是必须是顺序存储结构，必须有序排列
• 执行（）操作时，需要使用队列作为辅助存储空间。（B）
  A.查找哈希（hash）表
  B.广度优先搜索图
  C.先序（根）遍历二叉树
  D.深度优先搜索图
  解析：
  BFS（广度优先搜索图）需要队列的辅助，DFS(深度优先搜索图)需要栈的辅助。
• 若数组A[0…m-1][0…n-1]按列优先顺序存储，则aij地址为（ A）。
  A.LOC(a00)+[jm+i]
  B.LOC(a00)+[jn+i]
  C.LOC(a00)+[(j-1)*n+i-1]
  D.LOC(a00)+[(j-1)*m+i-1]
  解析：
  以0开始，下标是几就是多少个，从1开始，下标减1
• 需要分配较大空间，插入和删除不需要移动元素的线性表，其存储结构是 。( B)
  A.单链表
  B.静态链表
  C.线性链表
  D.顺序存储结构
  解析：
  静态链表：定义一个较大的结构数组作为备用结点空间(即存储池)。当申请结点时，每个结点应含有两个域：data域和cur域。data域用来存放结点的数据信息，需注意的是，此时的cur域不再是指针而是游标指示器，游标指示器指示其后继结点在结构数组中的相对位置(即数组下标)。
• 关于 int a[10]; 问下面哪些不可以表示 a[1] 的地址？（A）
  A.a+sizeof(int)
  B.&a[0]+1
  C.(int*)&a+1
  D.(int*)((char*)&a+sizeof(int))
  解析：
  A. a+sizeof(int)
  // 不正确， 在32位机器上相当于指针运算 a + 4
  B. &a[0]+1
  // 正确，数组首元素地址加1，根据指针运算就是a[1]的地址
  C. (int*)&a+1
  // 正确，数组地址被强制类型转换为int*，然后加1，这样和B表示的一个意思
  D. (int*)((char*)&a+sizeof(int))
  // 正确，数据地址先被转换为char*，然后加4，根据指针运算公式，向前移动4 * sizeof(char)，之后被转换为int*，显然是a[1]的地址

编程题

• 反转句中单词。

public class reverseWords {
	public static void main(String[] args) {
		String s="Let's take LeetCode contest";
		System.out.println(reverseWords(s));
	}
	public static String reverseWords(String s) {
		String[] a=s.split(" ");
		String str="";
		for(int i=0;i<a.length;i++){
			str+=getreverse(a[i])+" ";
		}
		return str.trim();
		
		/*String [] words=s.split(" ");
        StringBuilder res=new StringBuilder();
        for(String word:words){
            res.append(new StringBuilder(word).reverse().append(" "));
        }
        System.out.println(res);
        return res.toString().trim();*/
    }
	private static String getreverse(String str) {
		char temp;
		char[] s=str.toCharArray();
		int len=s.length;
		for(int i=0;i<len/2;i++){
			temp=s[i];
			s[i]=s[len-1-i];
			s[len-1-i]=temp;
		}
		return String.valueOf(s);
	}
}

• 反转句子。

public class reverseString {
	public static void main(String[] args) {
		String s="hello";
		System.out.println(reverseString(s));
	}
	public static String reverseString(String s) {
		if (s == null || s.length() <= 1) {
            return s;
        }
        char[] arr = s.toCharArray();
        int length = arr.length;
        for (int i=0;i<length/2;i++) {
            char temp=arr[i];
            arr[i]=arr[length-i-1];
            arr[length-i-1]=temp;
        }
        return String.valueOf(arr);

        //return new StringBuilder(s).reverse().toString();
	}
}