点击进入龙8国际pt首页 当前位置:首页>点击进入龙8国际pt首页>正文

点击进入龙8国际pt首页

发布时间:2018-10-24

原标题:剑指offer面试题-Java版-持续更新

如遇【线上娱乐站】不能自动打开,请复制 http://da8.us 到浏览器,注册自动送8-88试 ̶̶̶̶̶̶̶̶̶̶玩 ̷̷̷̷̷̷̷̷̷̷金。体验各种类的线上PT/DT/MG/PNG ̶̶̶̶̶̶̶̶̶̶老 ̷̷̷̷̷̷̷̷̷̷虎 ̷̷̷̷̷̷̷̷̷̷机、 ̷̷̷̷̷̷̷̷̷̷真* ̷̷̷̷̷̷̷̷̷̷人* ̶̶̶̶̶̶̶̶̶̶百* ̶̶̶̶̶̶̶̶̶̶家 ̷̷̷̷̷̷̷̷̷̷*乐*游戏等免费试玩、优惠活动,7*24小时专业服务

不过,这些成绩中,最让章璇欣喜的,还是可惜不是你在Imusinetbsp; 身为公司元老级唱将,她上张专辑并没有赶上Imusic和万维的强强合作。

白金国际

所以难怪一些人得到了七彩原石会巴不得尽快交易出去,珍贵是够珍贵,稀有是够稀有,但是作用却等于零。
“上德不德是以有德。下德不失德是以无德……”不一时,三十八篇德经读完,悟空查探三个分身体内造化,汇总起来,仍是多了六百。原来这《道德经》上下两卷造化相同,三个分身亦不能带来更多造化。

“轰”一声,在平天下之剑的光芒下,这个绝世凶胎轰然炸裂,无数的血肉碎片,煞气黑烟散尽之后露出一个身长九尺,面色冷峻坚毅的淡金色面孔僵尸来——玄阴尸皇!

最近在用Java刷剑指offer(第二版)的面试题。书中原题的代码采用C++编写,有些题的初衷是为了考察C++的指针、模板等特性,这些题使用Java编写有些不合适。但多数题还是考察通用的算法、数据结构以及编程思想等,与语言本身无太大关系。因此在选择编程语言时,我还是选择了Java。好吧,主要是我C++不怎么会,仅仅是曾经学过俩月,使用Java顺手一些。后续可能再用Python刷一遍。

面试题3  数组中重复的数字

  题目一:找出数组中重复的数字

  • 描述:在长度为n的数组里所有数字都在0~n-1范围内。数组中某些数字是重复的,请找出任意一个重复的数字。如数组{2, 3, 1, 0, 2, 5, 3},输出的重复的数字为2或3。
  • 思路:利用数组的索引在0~n-1这个范围的性质,将数字i移至索引i的位置。
  • 考点:对数组的理解以及对问题的分析能力。

  题目二:不修改数组找出重复的数字

  • 描述:在长度为n+1的数组里所有数字都在1~n范围内。找出重复的数字,但不修改数组。
  • 思路:当然可完全利用题目一的方法,只是需要辅助空间。不需要辅助空间是最好的了。这里使用二分法,对数组进行计数,逐渐缩小重复的数字所处的范围。
  • 考点:对二分查找的灵活应用,毕竟写出正确无误的二分法时有些难度的。同时要重视与面试官的沟通,明确需求,如是否能更改数组,是否可以使用辅助空间等。
package sword_offer;
//page 39 数组中重复的数字

public class Solution3 {
    //题目1
    //输出数组中重复的数字,空间复杂度O(1),时间复杂度O(n)
    //数组长度为n,数字在0~n-1范围内
    public static int duplicate(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            //System.out.println(i);
            while (arr[i] != i) {
                if (arr[i] == arr[arr[i]])
                    return arr[i];
                else {
                    int temp = arr[i];
                    arr[i] = arr[temp];
                    arr[temp] = temp;
                    //System.out.println(Arrays.toString(arr));
                }
            }
        }
        return -1;
    }
    
    //题目2
    //输出数组中重复的数字,空间复杂度O(1),时间复杂度O(nlog(n))
    //数组长度为n+1,数字在1~n范围内,要求不修改数组,并不使用辅助空间
    public static int myGetDuplication(int[] arr) {
        int start = 1;
        int middle = arr.length / 2;
        int end = middle;
        while(end >= start) {
            //System.out.println("" + start + end);
            int count = 0;
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] >= start && arr[i] <= end) count++;
            }
            if (end == start) {
                if (count > 1)
                    return start;
                else
                    break;
            }
            if (count > end - start + 1) {
                middle = (start + end) / 2;
                end = middle;
            }
            else {
                start = middle + 1;
                end = arr.length - 1;
            }
        }
        return -1;
    }
    //输出数组中重复的数字,空间复杂度O(1),时间复杂度O(nlog(n))
    //数组长度为n+1,数字在1~n范围内,要求不修改数组,并不使用辅助空间
    //比上一个函数逻辑清晰一点
    public static int getDuplication(int[] arr) {
        int start = 1;
        int end = arr.length - 1;
        while(end >= start) {
            int middle = (end - start) / 2 + start;
            int count = getCount(arr, start, middle);
            if (end == start) {
                if (count > 1)
                    return start;
                else
                    break;
            }
            if (count > middle - start + 1) {
                end = middle;
            }
            else
                start = middle + 1;
        }
        return -1;
    }
    
    //计算数组arr元素处在[start, end]范围内元素个数
    private static int getCount(int[] arr, int start, int end) {
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >= start && arr[i] <= end) count++;
        }
        return count;
    }
    
    //测试
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 1};
        System.out.println(duplicate(arr));
        int[] arr2 = {2, 3, 5, 4, 3, 2, 6, 7};
        System.out.println(myGetDuplication(arr2));
        int[] arr3 = {2, 3, 5, 4, 3, 2, 6, 7};
        System.out.println(getDuplication(arr3));
    }
}

 

 面试题4  二维数组中的查找

  • 描述:二维数组中,数字按从左到右、从上到下的顺序递增。给定一个整数,判断该数组中是否含有该整数。
  • 思路:从数组的右上角或左下角开始进行查找数据,缩小可能包含该数的范围。
  • 考点:画图分析问题,寻求问题的突破口。并能正确编写程序,避免死循环等问题。

例如,从二维数组$left[ {egin{array}{*{20}{c}}
{1}&{2}&{8}&9 \ 
{1}&{4}&{9}&{12} \ 
{4}&{7}&{10}&{13} \ 
{6}&{8}&{11}&{15} 
end{array}} ight]$中寻找是否包含数字7。

从右上角查找时,逐渐向左下方缩小范围。红色的代表包含目标值7的区域,过程如下:

$$left[ {egin{array}{*{20}{c}}
{color{red}1}&{color{red}2}&{color{red}8}&9 \
{color{red}1}&{color{red}4}&{color{red}9}&{12} \
{color{red}4}&{color{red}7}&{color{red}{10}}&{13} \
{color{red}6}&{color{red}8}&{color{red}{11}}&{15}
end{array}} ight] oleft[ {egin{array}{*{20}{c}}
{color{red}1}&{color{red}2}&{8}&9 \
{color{red}1}&{color{red}4}&{9}&{12} \
{color{red}4}&{color{red}7}&{10}&{13} \
{color{red}6}&{color{red}8}&{11}&{15}
end{array}} ight] oleft[ {egin{array}{*{20}{c}}
{1}&{2}&{8}&9 \
{color{red}1}&{color{red}4}&{9}&{12} \
{color{red}4}&{color{red}7}&{10}&{13} \
{color{red}6}&{color{red}8}&{11}&{15}
end{array}} ight] oleft[ {egin{array}{*{20}{c}}
{1}&{2}&{8}&9 \
{1}&{4}&{9}&{12} \
{color{red}4}&{color{red}7}&{10}&{13} \
{color{red}6}&{color{red}8}&{11}&{15}
end{array}} ight]$$

从左下角查找时,逐渐向右上方缩小范围。过程如下:

$$left[ {egin{array}{*{20}{c}}
{1}&{color{red}2}&{color{red}8}&{color{red}9} \ 
{1}&{color{red}4}&{color{red}9}&{color{red}{12}} \ 
{4}&{color{red}7}&{color{red}{10}}&{color{red}{13}} \ 
{6}&{color{red}8}&{color{red}{11}}&{color{red}{15}} 
end{array}} ight] oleft[ {egin{array}{*{20}{c}}
{1}&{color{red}2}&{color{red}8}&{color{red}9} \ 
{1}&{color{red}4}&{color{red}9}&{color{red}{12}} \ 
{4}&{color{red}7}&{color{red}{10}}&{color{red}{13}} \ 
{6}&{8}&{11}&{15} 
end{array}} ight]$$

package sword_offer;
//page 44 二维数组中的查找

public class Solution4 {
    //从右上角的元素开始查找,逐渐缩小范围
    public static boolean findNum(int[][] arr, int target) {
        boolean found = false;
        int row = 0;
        int col = arr[0].length - 1;
        while (col > 0 && row <= arr.length) {
            int diff = arr[row][col] - target;
            if (diff == 0) {
                found = true;
                break;
            }
            else if (diff > 0) 
                col--;
            else 
                row++;
        }
        return found;
    }
    
    //测试
    public static void main(String[] args) {
        int[][] arr = {{1,2,8,9},{2,4,9,12},{4,7,10,13},{6,8,11,15}};
        System.out.println(findNum(arr, 9));
    }
}

 

面试题5  替换空格

  • 描述:将字符串中的每个空格替换成%20。如输入"we are fine",输出"we%20are%20fine"。
  • 思路:原题考察了C++中指针的操作。Java里数组不可变,因此本题变得没有难度了。利用String对象的.charAt函数遍历每个字符,并使用StringBuilder构建新的字符串。
  • 考点:对字符串的处理。
package sword_offer;
//page 51 替换空格

public class Solution5 {
    //在Java中字符串时不可变的,因而只能构造一个新的字符串。原文中该题的难点也无法体现出来了。
    public static String replaceBlank(String str) {
        StringBuilder strb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == " ") {
                strb.append("%20");
            }
            else 
                strb.append(str.charAt(i));
        }
        return strb.toString();
    }
    
    //测试
    public static void main(String[] args) {
        String str = "We are happr.";
        System.out.println(replaceBlank(str));
    }
}

 

面试题6  从尾到头打印链表

  • 描述:输入一个链表的头节点,从尾到头打印每个节点的值。
  • 思路:从尾到头打印,即为“先进后出”,则可以使用栈来处理;考虑递归的本质也是一个栈结构,可递归输出。
  • 考点:对链表、栈、递归的理解。
package sword_offer;
//page 58 从尾到头打印链表
import java.util.Stack;

//链表类
class ListNode{
    ListNode next = null;
    int value;
}

public class Solution6 {
        
    //方法1:使用Stack栈的先push后pop
    public static void printListReverse(ListNode listNode) {
        Stack<ListNode> stack = new Stack<ListNode>();
        while(listNode != null) {
            stack.push(listNode);
            listNode = listNode.next;
        }
        while(!stack.isEmpty()) {
            System.out.println(stack.pop().value);
        }
    }
    
    //方法2:使用递归的方式,相当于从内部往外部推
    public static void printListReverse_rec(ListNode listNode) {
        if(listNode != null) {
            if (listNode.next != null)
                printListReverse_rec(listNode.next);
            System.out.println(listNode.value);
        }
    }
    
    //测试
    public static void main(String[] args) {
        ListNode ln1 = new ListNode();
        ListNode ln2 = new ListNode();
        ListNode ln3 = new ListNode();
        ln1.next = ln2;
        ln2.next = ln3;
        ln1.value = 1;
        ln2.value = 2;
        ln3.value = 3;
        printListReverse_rec(ln1);
        printListReverse(ln1);        
    }
}

 

面试题7  重建二叉树

  • 描述:输入某二叉树的前序遍历和中序遍历结果,重建该二叉树。假设前序遍历或中序遍历的结果中无重复的数字。
  • 思路:前序遍历的第一个元素为根节点的值,据此将中序遍历数组拆分为左子树+root+右子树,前序遍历数组拆分为root+左子树+右子树。再对左右子树进行同样的操作。
  • 考点:对二叉树不同遍历方法的掌握。

package sword_offer;
//page 62 重建二叉树

//二叉树类,包含左右子树,以及用于查看的方法
class BinaryTreeNode {
    int value;
    BinaryTreeNode leftNode;
    BinaryTreeNode rightNode;
    //中序遍历输出查看
    public void printList() {
        if (leftNode != null)
            leftNode.printList();
        System.out.println(value);
        if (rightNode != null)
            rightNode.printList();
    }
}

public class Solution7 {
    //重建二叉树函数
    public static BinaryTreeNode rebultTree(int[] preorder, int[] inorder) {
        BinaryTreeNode root = rebultTree(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
        return root;
    }
    //重写函数
    private static BinaryTreeNode rebultTree(int[] preorder, int startPre, int endPre, int[] inorder, int startIn,
            int endIn) {
        if (startPre > endPre || startIn > endIn)
            return null;
        BinaryTreeNode root = new BinaryTreeNode();
        root.value = preorder[startPre];
        for (int i = startIn; i <= endIn; i++) {
            if (inorder[i] == preorder[startPre]) {
                root.leftNode = rebultTree(preorder, startPre + 1, startPre + i - startIn, inorder, startIn, i - 1);
                root.rightNode = rebultTree(preorder, startPre + i - startIn + 1, endPre, inorder, i + 1, endIn);
            }
        }
        return root;
    }
    //测试
    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 root = rebultTree(preorder, inorder);
        //System.out.println(root.leftNode.rightNode.value);
        root.printList();
    }
}

 

 面试题8  二叉树的下一个节点

  • 描述:给定一棵二叉树和其中的一个节点,找出中序遍历序列的下一个节点。树中应定义指向左节点、右节点、父节点的三个变量。
  • 思路:该节点若存在右节点,右子树的最左节点则为下一节点;若不存在右节点,则向上遍历,直至找到是父节点的左节点的那个节点,该节点的父节点则为下一节点。
  • 考点:对中序遍历的理解。
package sword_offer;
//page 65 二叉树的下一个节点

//定义二叉树类,包含左右子树、父节点,以及用于查看的函数
class TreeNode {
    char value;
    TreeNode left;
    TreeNode right;
    TreeNode father;
    
    //中序遍历输出查看
    public void printList() {
        if (left != null)
            left.printList();
        System.out.println(value);
        if (right != null)
            right.printList();
    }
}

public class Solution8 {
    public static TreeNode findNext(TreeNode node) {
        //有右节点,找到右子树的最左节点
        if (node.right!= null) {
            node = node.right;
            while(node.left != null) node = node.left;
            return node;
        }
        
        //无右节点,则向上遍历,直至找到节点为父节点的左子节点
        while(node.father != null) {
            if (node.father.left == node) return node.father;
            node = node.father;
        }
        return null;
    }
    public static void main(String[] args) {
        //建立一个二叉树节点的数组,并tree[i].value赋值
        TreeNode[] tree = new TreeNode[9];
        char[] chars = {"a", "b", "c", "d", "e", "f", "g", "h", "i"};
        for (int i = 0; i < tree.length; i++) {
            tree[i] = new TreeNode();
            tree[i].value = chars[i];
        }
        /*
         *        a
         *      /   
         *     b     c
         *    /    / 
         *   d   e  f  g
         *      / 
         *     h   i
         */
        //左右节点关系
        tree[0].left = tree[1];
        tree[0].right = tree[2];
        tree[1].left = tree[3];
        tree[1].right = tree[4];
        tree[2].left = tree[5];
        tree[2].right = tree[6];
        tree[4].left = tree[7];
        tree[4].right = tree[8];
        //父节点关系
        tree[1].father = tree[0];
        tree[2].father = tree[0];
        tree[3].father = tree[1];
        tree[4].father = tree[1];
        tree[5].father = tree[2];
        tree[6].father = tree[2];
        tree[7].father = tree[4];
        tree[8].father = tree[4];
        
        tree[0].printList();
    }
}

 

 面试题9  两个栈实现队列

  • 描述:使用两个栈实现一个队列。队列中实现尾部插入和头部删除函数。
  • 思路:栈结构“先进后出”,插入数据时进入第一个栈;删除数据时,将第一个栈的所有数据都弹出到第二个栈,这时原先先插入的数据位于栈的顶端。即可满足队列的“先进先出”。
  • 考点:对栈和队列的理解;对泛型的使用等。

 

package sword_offer;
//page 68 两个栈实现队列
import java.util.Stack;

//队列类,包含两个栈、两个操作队列的方法
class Queue <T>{
    Stack<T> stack1 = new Stack<>();
    Stack<T> stack2 = new Stack<>();
    //插入节点
    public void appendTail(T element) {
        stack1.push(element);
    }
    //删除节点
    public T deleteHead(){
        if (stack2.isEmpty()) {
            while(!stack1.isEmpty()) {
                T data = stack1.pop();
                stack2.push(data);
            }
        }
        //为空时,输出异常
        if (stack2.isEmpty())
            throw new IllegalArgumentException("queue is empty");
        return stack2.pop();
        
    }
}
public class Solution9 {
    //测试
    public static void main(String[] args) {
        Queue<Integer> queue = new Queue<>();
        queue.appendTail(1);
        queue.appendTail(2);
        queue.appendTail(3);
        System.out.println(queue.deleteHead());
        System.out.println(queue.deleteHead());
        queue.appendTail(4);
        System.out.println(queue.deleteHead());
        System.out.println(queue.deleteHead());
        System.out.println(queue.deleteHead());
    }
}

编辑:安辛密

发布时间:2018-10-24 00:41:23

当前文章:http://www.6066655.cn/3WXxUrr/2017/1021/906495076.html

菲律宾金盛网上娱乐 比基尼国际娱乐 海蓝博娱乐 菲律宾太阳玩场娱乐 会员登录三维娱乐 2017注册娱乐 8彩城娱乐 kb88.com真人娱乐

78860 10037 14876 11815 26450 3893586799 82731 17875

责任编辑:徒王陵戏

随机推荐