剑指Offer 读书笔记 （Java实现）（更新中）

剑指Offer 读书笔记 (Java实现)

更新日志：

8.6 至面试题7

面试题2 - 实现Singleton模式

通过静态变量实现，此种解决方案较好

 package _02_singleton;/** * Created by pokerface_lx on 16/8/5. */public class SingletonCommon {    private static SingletonCommon instance = null;    private SingletonCommon() {    }    public SingletonCommon getInstance() {        if (instance == null) {            synchronized (SingletonCommon.class) {                if (instance == null) {                    instance = new SingletonCommon();                }            }        }        return instance;    }}

package _02_singleton;/** * Created by pokerface_lx on 16/8/5. */public class SingletonBetter {    private SingletonBetter instance = new SingletonBetter();    private SingletonBetter() {    }    public SingletonBetter getInstance() {        return instance;    }}

解决思路：使用static关键字

面试题3 - 二维数组中的查找

在一个二维数组中，每一行都是按照从左至右递增的顺序排序，每一列都是按照从上至下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数

package _03_find_in_partially_sorted_matirx;import java.util.Scanner;/** * Created by pokerface_lx on 16/8/5. */public class FindInPartiallySortedMatirx {    public static void main(String[] args) {        int[][] nums = {{1, 2, 8, 9}, {2, 4, 9, 12}, {4, 7, 10, 13}, {6, 8, 11, 15}};        int target;        Scanner scan = new Scanner(System.in);        while (scan.hasNext()) {            target = scan.nextInt();            findTarget(target, nums);        }    }    private static void findTarget(int target, int[][] nums) {        int currentX = 0;        int currentY = nums[0].length - 1;        while (currentX < nums.length && currentY >= 0) {            int current = nums[currentX][currentY];            if (current == target) {                System.out.println("exists, position:x=" + (currentX + 1) +                        ",y=" + (currentY + 1));                return;            }            if (current < target) {                ++currentX;            } else {                --currentY;            }        }        System.out.println("not exists");    }}

• 如果右上角的数>要查找的数，则删除此列
• 如果右上角的数<要查找的数，则删除此行

面试题4 - 替换空格

请实现一个函数，把字符串中的每个空格替换成“%20”

package _04_replace_blank;import java.util.Arrays;/** * Created by pokerface_lx on 16/8/5. */public class ReplaceBlank {    public static void main(String[] args) {        String str = " we are happy. ";        replaceBlankByArr(str);         replaceBlankBySB(str);    }    private static void replaceBlankByArr(String str) {        int blankNum = 0;        for (int i = 0; i < str.length(); i++) {            if (str.charAt(i) == ' ') {                blankNum++;            }        }        char[] chars = new char[str.length() + blankNum * 2];        int index = 0;        for (int i = 0; i < str.length(); i++) {            if (str.charAt(i) == ' ') {                chars[index++] = '%';                chars[index++] = '2';                chars[index++] = '0';            } else {                chars[index++] = str.charAt(i);            }        }        System.out.println(String.valueOf(chars));    }    private static void replaceBlankBySB(String str) {        String[] splStr = str.split(" ");        StringBuffer sb = new StringBuffer();        for (String s : splStr) {            sb.append(s).append("%20");        }        System.out.println(sb.toString());    }}

新建数组，拷贝

• 使用数组的方式实现比StringBuffer快，重复10000次用数组需要30毫秒，用StringBuffer需要180毫秒，大概快6倍

面试题5 - 从尾到头打印链表

输入一个链表的头结点，从尾到头反过来打印每个结点的值

package _05_invert_list_sout;import model.ListNode;import java.util.Stack;/** * Created by pokerface_lx on 16/8/5. */public class InvertedSequence {    public static void main(String[] args) {        ListNode rootNode = new ListNode(0);        // 初始化 此处省略        Stack<Integer> stack = new Stack<>();        ListNode currentNode = rootNode;        while (currentNode.getNextNode() != null) {            stack.add(currentNode.getKey());            currentNode = currentNode.getNextNode();        }        while (!stack.isEmpty()){            System.out.println(stack.pop());        }    }}

使用栈的数据结构

面试题6 - 重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含有重复的数字

package _06_construct_binary_tree;import java.util.Arrays;/** * Created by pokerface_lx on 16/8/6. */public class ConstructBinaryTree {    public static void main(String[] args) {        int[] prOrder = {1, 2, 4, 7, 3, 5, 6, 8};        int[] inOrder = {4, 7, 2, 1, 5, 3, 8, 6};        Node rootNode = new ConstructBinaryTree().constructByPreAndIn(prOrder, inOrder);        System.out.println();    }    private Node constructByPreAndIn(int[] preOrder, int[] inOrder) {        Node rootNode = new Node();        rootNode.data = preOrder[0];        int leftLength = 0;        for (int i = 0; i < inOrder.length; i++) {            if (inOrder[i] == preOrder[0]) {                leftLength = i;                break;            }        }        if(leftLength != 0) {            int[] leftPreOrder = Arrays.copyOfRange(preOrder, 1, leftLength+1);            int[] leftInOrder = Arrays.copyOfRange(inOrder, 0, leftLength);            rootNode.leftNode = constructByPreAndIn(leftPreOrder, leftInOrder);        } else {            rootNode.leftNode = null;        }        if (leftLength != inOrder.length-1) {            int[] rightPreOrder = Arrays.copyOfRange(preOrder, leftLength + 1, preOrder.length);            int[] rightInOrder = Arrays.copyOfRange(inOrder, leftLength + 1, inOrder.length);            rootNode.rightNode = constructByPreAndIn(rightPreOrder, rightInOrder);        }        return rootNode;    }}class Node {    int data;    Node leftNode;    Node rightNode;}

递归

面试题7 - 用两个栈实现队列

package _07_queue_with_two_stacks;import java.util.Stack;/** * Created by pokerface_lx on 16/8/6. */public class QueueWithTwoStacks {    private static Stack pushStack = new Stack();    private static Stack popStack = new Stack();    public static void main(String[] args) {        QueueWithTwoStacks queueWithTwoStacks = new QueueWithTwoStacks();        queueWithTwoStacks.push(1);        queueWithTwoStacks.push(2);        queueWithTwoStacks.pop();        queueWithTwoStacks.push(3);        queueWithTwoStacks.pop();        queueWithTwoStacks.pop();    }    private void push(Object o) {        pushStack.push(o);    }    private void pop() {        if (popStack.isEmpty()) {            if (pushStack.isEmpty()) {                return;            }            while (!pushStack.isEmpty()) {                popStack.push(pushStack.pop());            }        }        System.out.println(popStack.pop());;    }}