题目1：设计一个类，我们只能生成该类的一个实例
//双检锁/双重校验锁（DCL，即 double-checked locking）
public class Singleton {
private volatile static Singleton sInstance = null;
private Singleton() {
}
public static Singleton getInstance() {
if (sInstance == null) {
synchronized (Singleton.class) {
if (sInstance == null) {
sInstance = new Singleton();
}
}
}
return sInstance;
}
}
题目2：找出数组中的重复数字，时间复杂度O(n)
//对于一维数组排序满足O（n）时间复杂度，优先考虑hashmap
private static int findDuplicateNumber(int[] list) {
int number = -1;
//以数组的数作为key，如果key有重复，value递增
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int i=0; i<list.length; i++) {
if (map.containsKey(list[i])) {
map.put(list[i], map.get(list[i]) + 1);
} else {
map.put(list[i], 1);
}
}
//便利hashmap，找出value大于1对应的key值
for (Map.Entry<Integer, Integer> entry: map.entrySet()) {
if (entry.getValue() > 1) {
number = entry.getKey();
}
}
return number;
}
题目3：实现一个函数，把字符串每中的每个空格替换成“%20”。例如输入“we are happy.”，则输出“we%20are%20happy.”
public static void main (String[] args) {
String str = "We are happy!";
replaceBlank(str.toCharArray());
}
private static void replaceBlank(char[] arr) {
int count = 0;
int lenth = 0;
//计算新数组长度，等于原长度加上空格数*2
for (int i=0; i<arr.length; i++) {
if (arr[i] == ' ') {
count ++;
}
}
lenth = arr.length + count * 2;
//设置两个指针p1,p2，如果p1遇到空格，p2 后三位赋值%20，p1后移一位
char[] list = new char[lenth];
int p1=0, p2=0; //p1原数组指针，p2 新数组指针
while (p1<arr.length && p2<lenth) {
if (arr[p1] == ' ') {
list[p2++] = '%';
list[p2++] = '2';
list[p2++] = '0';
p1++;
} else {
list[p2++] = arr[p1++];
}
}
System.out.print(String.valueOf(list));
}
题目4：有两个排序的数组A1和A2，内存在A1的末尾有足够多的空余空间容纳A2.请实现一个函数，把A2中的所有数字插入A1中，并且所有的数字是排序的。
public static void main(String[] args) {
int[] A1 = {1, 3, 6, 7, 10, 23};
int[] A2 = {2, 6, 8, 24};
merged(A1, A2);
}
private static void merged(int[] A1, int[] A2) {
int indexA1 = A1.length - 1;
int indexA2 = A2.length - 1;
int mergedIndex = A1.length + A2.length - 1;
int[] mergedA = new int[A1.length + A2.length];
//从后往前插入，也可以从前往后插入
while (indexA1>=0 && indexA2>=0) {
if (A1[indexA1] >= A2[indexA2]) {
mergedA[mergedIndex--] = A1[indexA1--];
} else {
mergedA[mergedIndex--] = A2[indexA2--];
}
}
while (indexA1>=0) {
mergedA[mergedIndex--] = A1[indexA1--];
}
while (indexA2>=0) {
mergedA[mergedIndex--] = A2[indexA2--];
}
for(int i=0; i<mergedA.length; i++) {
System.out.print(mergedA[i] + ", ");
}
}
题目5：输入一个链表的头结点，从尾到头反过来打印每个节点的值
//链表节点定义
static class ListNode {
int data;
ListNode next;
}
public static void main(String[] args) {
ListNode listNode = new ListNode();
ListNode listNode2 = new ListNode();
ListNode listNode3 = new ListNode();
ListNode listNode4 = new ListNode();
ListNode listNode5 = new ListNode();
listNode.data = 1;
listNode.next = listNode2;
listNode2.data = 5;
listNode2.next = listNode3;
listNode3.data = 10;
listNode3.next = listNode4;
listNode4.data = 15;
listNode4.next = listNode5;
listNode5.data = 20;
//打印链表
printListNode(listNode);
System.out.print("\n----------------------------\n");
//使用堆反向打印链表
printListReversByStack(listNode);
System.out.print("\n----------------------------\n");
//使用递归反向打印堆栈
printListReversByRecursive(listNode);
}
//顺序打印链表
private static void printListNode(ListNode node) {
if (node == null) {
return;
}
while (node != null) {
System.out.print(node.data);
node = node.next;
if (node != null) {
System.out.print(" --> ");
}
}
}
//使用堆反向打印链表
private static void printListReversByStack(ListNode node) {
Stack<ListNode> stack = new Stack<ListNode>();
while (node != null) {
stack.push(node);
node = node.next;
}
while (!stack.isEmpty()) {
System.out.print(stack.pop().data);
if (!stack.isEmpty()) {
System.out.print(" --> ");
}
}
}
//使用递归反向打印堆栈
private static void printListReversByRecursive(ListNode node) {
if (node != null) {
if (node.next != null) {
printListReversByRecursive(node.next);
}
}
System.out.print(node.data);
}
题目5：重构二叉树
public static class BinaryTreeNode {
int value;
BinaryTreeNode left;
BinaryTreeNode right;
}
public static void main(String[] args) {
int[] preOrder = {1,2,4,7,3,5,6,8};
int[] inOrder={4,7,2,1,5,3,8,6};
BinaryTreeNode node = reConstruct( preOrder, inOrder );
printTree( node );
}
private static BinaryTreeNode reConstruct (int[] prOrder, int[] inOrder) {
if (prOrder == null || inOrder == null || prOrder.length != inOrder.length || prOrder.length < 1) {
return null;
}
return constrct(prOrder, 0, prOrder.length-1, inOrder, 0, inOrder.length-1);
}
/*
* @param preOrder 前序遍历序列
* @param preBegin 前序遍历开始位置
* @param preEnd 前序遍历结束位置
* @param inOrder 中序遍历序列
* @param inBegin 中序遍历序列开始位置
* @param inEnd 中序遍历序列结束位置
* */
private static BinaryTreeNode constrct (int[] preOrder, int preBegin, int preEnd, int[] inOrder, int inBegin, int inEnd) {
if (preBegin > preEnd) return null;
int root = preOrder[preBegin];
int index = inBegin;
while (index <= inEnd && inOrder[index] != root) {
index ++;
}
if (index > inEnd) {
throw new RuntimeException( "invalid input index: " + index);
}
BinaryTreeNode node = new BinaryTreeNode();
node.value = root;
node.left = constrct( preOrder, preBegin+1, preBegin+index-inBegin, inOrder, inBegin, index-1 );
node.right = constrct( preOrder, preBegin+index-inBegin+1, preEnd, inOrder, index+1, inEnd );
return node;
}
/*
* 中序遍历递归打印
* */
private static void printTree (BinaryTreeNode node) {
if (node != null) {
printTree( node.left );
System.out.print( node.value + " " );
printTree( node.right );
}
}
