剑指offer 前篇

图片 1
锡伯杜与罗尔-邓将在前几日境遇

刷题啦刷题啦,剑指offer好像相比知名,所以就在牛客网上刷这一个啊~
btw,刷了有些题发现编程之美的题好典型啊!!有成千上万都在笔试碰到过或者是专门出名在此之前做过的题。后悔没早点刷T
T

  迪拜时间七月10日,据日媒体报道,自由球员鲁尔-邓前几日和森林狼队司令官汤姆(Tom)-希伯杜进行了会面。

1.二维数组中的查找

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

思路就是从右上角起首,比target大就向左移一位找小一些的,比target小就向下移找大一点的,直到找到结束。

public class Solution {

    public boolean Find(int target, int [][] array) {
        if(array.length == 0 || array[0].length == 0){
            return false;
        }

        int row = array.length;
        int col = array[0].length;

        for(int i = 0, j = col - 1; i < row && j >= 0;){

            if(target == array[i][j]){
                return true;
            }
            else if(target > array[i][j]){
                i++;
                continue;
            }
            else{
                j--;
                continue;
            }      

        }

        return false; 
    }   
}

  一周前,鲁尔-邓与湖人队达到合同买断,这使得邓成为了一名非受限自由球员。邓在这笔买断中放任了730万先令。

2.替换空格

请实现一个函数,将一个字符串中的空格替换成“%20”。例如,当字符串为We
Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

public class Solution {
    public String replaceSpace(StringBuffer str) {

        StringBuffer sb = new StringBuffer();
        for(int i = 0; i < str.length(); i++){
            if(' ' == str.charAt(i)){
                sb.append("%20");
            }else{
                sb.append(str.charAt(i));
            }
        }

        return sb.toString();

    }
}

  随后就流传音讯称森林狼队有意签下邓。

3.从尾到头打印链表

输入一个链表,从尾到头打印链表每个节点的值。

有二种解法:
先是种是正序链表元素并设有list后反转list;

public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<Integer>();

        ListNode head = listNode;
        while(head != null){
            list.add(head.val);
            head = head.next;
        }

        int num = list.size();
        for(int i = 0; i < num/2; i++){
            int temp = list.get(i);
            list.set(i,list.get(num-1-i));
            list.set(num-1-i,temp);
        }

        return list;

    }
}

第二种是利用栈,入栈再出栈就会使原顺序反向;

public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {

        ArrayList<Integer> list = new ArrayList<Integer>();
        Stack<Integer> stack = new Stack<Integer>();

        ListNode head = listNode;

        while(head != null){
            stack.push(head.val);
            head = head.next;
        }

        while(!stack.empty()){
            list.add(stack.pop());
        }

        return list;
    }
}

其二种方法是用递归。

public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {

        ArrayList<Integer> list = new ArrayList<Integer>();

        ListNode head = listNode;

        if(head != null){
            list = printListFromTailToHead(head.next);
            list.add(head.val);
        } 

        return list;
    }
}

  众所周知,汤姆(Tom)-希伯杜曾在公牛队任教过邓,而且六人一贯保持着很好的涉及。

4.重建二叉树

输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假诺输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历系列{1,2,4,7,3,5,6,8}和中序遍历系列{4,7,2,1,5,3,8,6},则重建二叉树并回到。

事先分析二叉树的帖子已经写过五回了,这一次再写发现root.right那一行递归中最后一个参数(阐明此时前序中的root地方)很容易写错。index-inFrom是在中序中当前左子树的结点数目,preIndex是指从此刻的前序root算起。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if(null == pre || pre.length == 0) return null;

        return construct(pre, in, 0, in.length - 1, 0);

    }



    public TreeNode construct(int [] pre, int [] in, int inFrom, int inTo, int preIndex){

        if(inFrom > inTo) return null; 

        TreeNode root = new TreeNode(pre[preIndex]);


        int index = inFrom;

        for(; index <= inTo; index++){
            if(in[index] == pre[preIndex]){
                break;
            }
        }


        root.left = construct(pre, in, inFrom, index - 1, preIndex + 1);
        root.right = construct(pre, in, index + 1, inTo, preIndex + index - inFrom + 1);

        return root;

    }
}

  明日,邓和Tom-希伯杜举办了会晤,双方估计将研讨潜在的合同。

5.用多少个栈实现队列

用六个栈来实现一个系列,完成队列的Push和Pop操作。
队列中的元素为int类型。

栈这篇作品分析过,记得挺简单的就不再写了。

  自从成为森林狼队总司令兼篮球主管以来,希伯杜已经引进了多位前公牛队球员,包括:吉姆(吉姆(Jim))-巴特勒、塔基-吉布森(Gibson)和Derek-Rose。

6.旋转数组的很小数字

把一个数组最最先的若干个元素搬到数组的末尾,我们称之为数组的旋转。
输入一个非递减排序的数组的一个转悠,输出旋转数组的小不点儿元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转,该数组的最小值为1。
NOTE:给出的保有因素都大于0,若数组大小为0,请再次回到0。

卓绝二分法,分三种情景探讨就行。要注意的是当元素变为2个的时候是个与众不同情形,如果不拿出来单独探究就会陷在low=mid<high这一个轮回里了。

很奇怪的是,这段代码在自己要好给的多少个测试用例还有leetcode下都是对的,可是牛客网上不对,不清楚为什么。

public class Solution {
    public int minNumberInRotateArray(int [] array) {

        if(array.length == 0) return 0;

        int low = 0;
        int high = array.length - 1;
        int mid;

        while(low < high){

            if(low == high - 1) return array[low] > array[high] ? array[high] : array[low];

            mid = (low + high) / 2;
            if(array[low] <= array[high]){
                return array[low];
            }
            else{
                if(array[low] <= array[mid]){
                    low = mid;
                }else{
                    high = mid;
                }

            }
        }

        return array[low];

    }
}

7.斐波那契数列

public int Fibonacci(int n) {

        if(n == 0) return 0;
        if(n == 1) return 1;

        return Fibonacci(n-2) + Fibonacci(n-1);

}

8.跳台阶

一只青蛙四回可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有稍许种跳法。

早就面试问到过这题,我还很傻地说我做过这题,然后就换了一道自己不会的……
思路想驾驭了就很简短,要求跳n级台阶的跳法f(n),最终一步如若跳1级,跳法是f(n-1);假设跳2级,跳法是f(n-2),总跳法就是他们相加。

public int JumpFloor(int target) {

        if(target == 1) return 1;
        if(target == 2) return 2;

        return JumpFloor(target - 1) + JumpFloor(target - 2);
    }

9.变态跳台阶

一只青蛙一遍可以跳上1级台阶,也足以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有微微种跳法。

遵照地方一样的思路,只是需要把所有情状增长起来。

    public int JumpFloorII(int target) {

        if(target == 0 || target == 1) return 1;

        int res = 0;
        for(int i = 0; i < target; i++){
            res += JumpFloorII(i);
        }

        return res;
    }

10.矩形覆盖

俺们得以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形,总共有微微种办法?

跟跳台阶相似,f(n) = f(n-1) +
f(n-2)。f(n-1)情状是加一块竖矩形,f(n-2)意况是加两块横矩形。

public int RectCover(int target) {

        if(target == 0) return 0;
        if(target == 1) return 1;
        if(target == 2) return 2;

        return RectCover(target-1) + RectCover(target-2); 
    }

11.二进制中1的个数

输入一个平头,输出该数二进制表示中1的个数。其中负数用补码表示。

(n-1) & n 会让从左往右第一个1变为0,一向操作直到所有数为0。

public int NumberOf1(int n) {

    int count = 0;

    while(n != 0){
        count++;
        n = (n-1) & n;
    }

    return count;
}

12.数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

重点是考虑到exponent为负的意况。

public double Power(double base, int exponent) {

    if(exponent == 0) return 1;

    if(exponent < 0){
        return  1/base * Power(base,exponent + 1);
    }    

    return base * Power(base,exponent - 1);
}

13.调动数组顺序使奇数位于偶数前边

输入一个整数数组,实现一个函数来调动该数组中数字的一一,使得所有的奇数位于数组的前半有的,所有的偶数位于位于数组的后半局部,并保管奇数和奇数,偶数和偶数之间的相对地点不变。

先是个做法是采纳一个新数组,遍历原数组按顺序把奇数储存在新数组中,再遍历原数组把偶数储存在后边,最后复制新数组给原数组。

    public void reOrderArray(int [] array) {

        int[] a = new int[array.length];

        int j = 0;
        for(int elem : array){
            if(elem % 2 != 0){
                a[j++] = elem;
            }
        }

        for(int elem : array){
            if(elem % 2 == 0){
                a[j++] = elem;
            }
        }

        for(int i = 0; i < array.length; i++){
            array[i] = a[i];
        }


    }

第二种方法是采取插入排序的想想。

    public void reOrderArray(int [] array) {

        for(int i = 1; i < array.length; i++){
            if(array[i] % 2 != 0){
                int odd = array[i];
                int j = i - 1;
                for(; j >= 0; j--){
                    if(array[j] % 2 == 0){
                        array[j+1] = array[j];
                    }else{
                        break;
                    }
                }
                array[j+1] = odd;
            }              
        }
    }

还可以够利用冒泡排序的笔触,然则大多啦。

14.链表中倒数第k个结点

输入一个链表,输出该链表中最后多少个第k个结点。

可以用速度结点的合计,让快结点先走k步,然后快慢同时走,快结点到头了慢结点也就到倒数第k了。要留心k可没确保是毋庸置疑的,可能比链表结点数要大,所以在先走k步时就要时时判null了。

public ListNode FindKthToTail(ListNode head,int k) {

        ListNode fast = head;
        ListNode slow = head;

        for(int i = 0; i < k; i++){
            if(fast == null) return null;
            fast = fast.next;
        }

        while(fast != null){
            fast = fast.next;
            slow = slow.next;
        }

        return slow;

    }

15.反转链表

输入一个链表,反转链表后,输出链表的享有因素。

public ListNode ReverseList(ListNode head) {

    if(head == null || head.next == null) return head;

    ListNode prev = head;
    ListNode curr = head.next;

    prev.next = null;

    while(curr != null){
        ListNode next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }

    ListNode p = prev;
    while(p != null){
        System.out.println(p.val);
        p = p.next;
    }

    return prev;
}

16.合并多少个排序的链表

输入几个干燥递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满意单调不减规则。

事先写过iterative版本的,相比冗长,用recursive版本更短更好精晓。

public ListNode Merge(ListNode list1,ListNode list2) {

    if(list1 == null) return list2;
    if(list2 == null) return list1;

    ListNode head = null;
    if(list1.val < list2.val){
        head = list1;
        head.next = Merge(list1.next, list2);
    }else{
        head = list2;
        head.next = Merge(list1,list2.next);
    }

    return head;  
}

17.树的子结构

输入两棵二叉树A,B,判断B是不是A的子结构。(ps:大家约定空树不是不管三七二十一一个树的子结构)

牛客网的概念不是很领会,我以为应该再加上两点:1.社团同样且对应地点的值也一致;2.树[1,2]是树[1,2,3]的子结构。
即便参照leetcode上判subtree这道题:

Given two non-empty binary trees s and t, check whether tree t has
exactly the same structure and node values with a subtree of s. A
subtree of s is a tree consists of a node in s and all of this node’s
descendants. The tree s could also be considered as a subtree of
itself.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean isSubtree(TreeNode root1, TreeNode root2) {
        if(root2 == null || root1 == null) return false;
        if(sameTree(root1, root2)) return true;

        return isSubtree(root1.left, root2) || isSubtree(root1.right, root2);
    }

    public boolean sameTree(TreeNode root1, TreeNode root2){
        if(root1 == null && root2 == null) return true;
        if(root1 != null && root2 != null && root1.val == root2.val) return sameTree(root1.left, root2.left) && sameTree(root1.right, root2.right);
        return false;  
    }
}

比方是牛客网上的思绪,应该把判相同的函数改为判子结构函数,当对应地点子结构没了而复结构不必然没了,依旧为真。

public class Solution {
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {

        if(root2 == null || root1 == null) return false;  
        return isSubTree(root1, root2) || HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);

    }
    public boolean isSubTree(TreeNode root1, TreeNode root2){

        if(root2 == null) return true;
        if(root1 == null) return false;
        if(root1.val == root2.val) {
            return isSubTree(root1.left, root2.left) && isSubTree(root1.right, root2.right);
        }

        return false;    
    }
}

18.二叉树的镜像

二叉树里写过隐瞒了。

19.顺时针打印矩阵

结构一个数组step来记录上下左右的单位偏移量,用相应的multiple来记录偏移量数目,count%4看成数组索引。这样让前后左右在代码中都能比量齐观。但是不对,也没调出去结果,先贴在这里吧。

public static ArrayList<Integer> printMatrix(int [][] matrix) {

    ArrayList<Integer> list = new ArrayList<Integer>();
    if(matrix.length == 0 || matrix[0].length == 0) return list;

    int[] step = {1,1,-1,-1}; //right, down, left, up
    int[] limit = {matrix[0].length, matrix.length, 0, 0}; //jHigh, iHigh, jLow, iLow
    int count = 0;
    int i = 0, j = 0;

    while(limit[2] < limit[0] || limit[3] < limit[1]){

        int[] multiple = {0,0,0,0};
        multiple[count]++;

        while(i >= limit[3] && i < limit[1] && j >= limit[2] && j < limit[0]){
            //System.out.println("i = " + i + ", j = " + j);
            list.add(matrix[i][j]);

            i += step[1]*multiple[1] + step[3]*multiple[3];
            j += step[0]*multiple[0] + step[2]*multiple[2];         
        }            

        limit[count%4] -= step[count%4];

        count = (count+1) % 4;
  }

    return list;     
}

20.饱含Min函数的栈
栈的帖子中写过,笔试题也遭受过。

public class Solution {

    Stack<Integer> stack = new Stack<Integer>();
    Stack<Integer> minStack = new Stack<Integer>();

    public void push(int node) {
        stack.push(node);
        if(minStack.empty() || node < minStack.peek()) minStack.push(node);
        else minStack.push(minStack.peek());
    }

    public void pop() {
        stack.pop();
        minStack.pop();
    }

    public int top() {
        return minStack.peek();
    }

    public int min() {
        return minStack.peek();

    }
}

21.栈的压入、弹出行列

输入六个整数连串,第一个连串表示栈的压入顺序,请判断第二个系列是否为该栈的弹出各样。假使压入栈的具备数字均不等于。例如连串1,2,3,4,5是某栈的压入顺序,系列4,5,3,2,1是该压栈序列对应的一个弹出行列,但4,3,5,1,2就无法是该压栈连串的弹出行列。(注意:这四个连串的长度是十分的)

又是在栈小说里面写过的题,重新写了一回,简化了一个步骤:可以不用先把popA里面元素Push进去再与popA相比较,而是径直相比较当前的popA和pushA元素,相等就一贯跳过。

public boolean IsPopOrder(int [] pushA,int [] popA) {

    Stack<Integer> stack = new Stack<Integer>();

    int j = 0;
    for(int i = 0; i < pushA.length;i++){
        if(popA[j] == pushA[i]){
           j++;
        }else{
            stack.push(pushA[i]);
        }
    }

    while(j < popA.length){
        if(stack.pop() != popA[j++]) return false;
    }

    return true;
}

22.从上往下打印二叉树

层序遍历(广度优先),二叉树里写过的,本次两分钟三遍经过!

public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {


    ArrayList<Integer> list = new ArrayList<Integer>();       
    if(root == null) return list;

    Queue<TreeNode> queue = new LinkedList<TreeNode>(); 
    queue.offer(root);

    while(queue.peek() != null){
        int len = queue.size();
        for(int i = 0; i < len; i++){
            TreeNode temp = queue.poll();
            list.add(temp.val);

            if(temp.left != null) queue.offer(temp.left);
            if(temp.right != null) queue.offer(temp.right);
        }

    }

    return list;         
}

23.二叉搜索树的存续遍历

输入一个平头数组,判断该数组是不是某二叉搜索树的后序遍历的结果。假诺是则输出Yes,否则输出No。假如输入的数组的妄动五个数字都互不相同。

因为是后序遍历,所以最终一个数是根节点。根节点比左子树所有结点大,比右子树所有结点小,所以先找到首个比根结点大的结点,以此职务分别左子树和右子树,左子树已经保证了都比根小了,再一个个断定左边是不是都比根结点大,虽然不是,肯定是false。再递归对左子树和右子树判断。

public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence.length == 0) return false;
        return isPostOrder(sequence, 0, sequence.length - 1);
    }

    //end inclusive
    public boolean isPostOrder(int[] postOrder, int start, int end){

        if(start < end){

            int root = postOrder[end];
            int index = start;
            for(; index < end; index++){
                if(root < postOrder[index]){
                    break;
                }
            }

            for(int i = index + 1; i < end; i++){
                if(root > postOrder[i]) return false;
            }

            return isPostOrder(postOrder, start, index - 1) && isPostOrder(postOrder, index, end - 1);

        }
        return true;
    }
}

24.二叉树中和为某一值的门径

输入一颗二叉树和一个平头,打印出二叉树中结点值的和为输入整数的所有途径。路径定义为从树的根结点先河往下间接到叶结点所经过的结点形成一条途径。

用递归解决,临界条件是叶节点刚好等于某值,表明那是一条有效途径,所以开一个新list添加进结果;递归时不停把路子上的点加到list最后面(combine函数)。

public class Solution {
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {

        ArrayList<ArrayList<Integer>> l = new ArrayList<ArrayList<Integer>>();

        if(root == null) return l;
        if(root.val == target && root.left == null && root.right == null){
            ArrayList<Integer> temp = new ArrayList<Integer>();
            temp.add(root.val);
            l.add(temp);
            return l;
        }

        ArrayList<ArrayList<Integer>> left = combine(root.val, FindPath(root.left, target - root.val));
        ArrayList<ArrayList<Integer>> right = combine(root.val, FindPath(root.right, target - root.val));

        l.addAll(left);
        l.addAll(right);

        return l;
    }

    public ArrayList<ArrayList<Integer>> combine(int first, ArrayList<ArrayList<Integer>> l){
        for(int i = 0; i < l.size(); i++){
            l.get(i).add(0, first);
        }

        return l;
    }

}

25.复杂链表的复制

输入一个扑朔迷离链表(每个节点中有节点值,以及多个指针,一个对准下一个节点,另一个特种指针指向任意一个节点),再次来到结果为复制后复杂链表的head。(注意,输出结果中请不要回来参数中的节点引用,否则判题程序会直接再次回到空)

首倘若random指向任意一个节点,所以不可能按原链表节点的random值新建它。先利用HashMap建立原链表主链(不含random)节点和对应复制的链表结点之间的映照,再遍历链表通过HashMap来确定各节点的random。

/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}
*/

public RandomListNode Clone(RandomListNode pHead){

    if(pHead == null) return null;
    HashMap<RandomListNode,RandomListNode> map = new HashMap<RandomListNode,RandomListNode>();

    RandomListNode newHead = new RandomListNode(pHead.label);
    RandomListNode r = newHead;
    RandomListNode p = pHead;
    map.put(p,r);

    while(p.next != null){
        r.next = new RandomListNode(p.next.label);
        p = p.next;
        r = r.next;     
        map.put(p,r);
    }

    p = pHead;
    r = newHead;
    while(p != null){
        r.random = map.get(p.random);
        p = p.next;
        r = r.next;
    }

    return newHead;
}

26.二叉招来树与双向链表

输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。要求无法成立任何新的结点,只好调整树中结点指针的针对性。

函数再次来到的是链表头结点(最小值),依照二叉搜索树的特色,递归得出右子树的很小值应紧跟在在根结点后。左子树有些不等同,递归得出的是左子树的细小值,而我辈应找到左子树最大值,调整指针让它在根结点前。所以再用一个函数求最大值结点。
要注意是先convert后调整指针指向,否则convert的目标是一棵已被毁损的树。

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public TreeNode Convert(TreeNode pRootOfTree) {

        TreeNode res = pRootOfTree;

        if(pRootOfTree == null || (pRootOfTree.left == null && pRootOfTree.right == null)) return res;

        if(pRootOfTree.left != null){
            res = Convert(pRootOfTree.left);
            TreeNode big = biggest(pRootOfTree.left);
            big.right = pRootOfTree;
            pRootOfTree.left = big;             
        }

        if(pRootOfTree.right != null){
            TreeNode small = Convert(pRootOfTree.right);
            pRootOfTree.right = small;
            small.left = pRootOfTree; 
        }      
        return res;
    }


    public TreeNode biggest(TreeNode root){
        if(root.right == null) return root;
        return biggest(root.right);
    }
}

27.字符串的排列

输入一个字符串,按字典序打印出该字符串中字符的享有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的富有字符串abc,acb,bac,bca,cab和cba。

又是全排列…….注意这一次要字典顺序而且结果不另行。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Collections;

public class Solution {
    public ArrayList<String> Permutation(String str) {
       if(str == null || str.length() == 0) return new ArrayList<String>();
       ArrayList<String> res = new ArrayList(new HashSet(helper(str.toCharArray(),0)));
       Collections.sort(res);
       return res; 

    }

    public void swap(char[] array, int i, int j){
        char temp = array[i];
        array[i] = array[j];
        array[j] = temp;

    }

    public ArrayList<String> helper(char[] array, int start){   

        ArrayList<String> list = new ArrayList<String>();

        if(start == array.length - 1){
            list.add(String.valueOf(array[start]));
        }

        for(int i = start; i < array.length; i++){
            swap(array,start,i);
            ArrayList<String> temp = helper(array, start + 1);
            list.addAll(combine(array[start],temp));  
            swap(array,start,i);
        }

        return list;
    }

    public ArrayList<String> combine(char ch, ArrayList<String> list){
        for(int i = 0; i < list.size(); i++){
            list.set(i, String.valueOf(ch) + list.get(i));
        }
        return list;
    }
}

28.数组中出现次数抢先一半的数字

数组中有一个数字出现的次数领先数经理度的一半,请找出这多少个数字。例如输入一个尺寸为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中冒出了5次,超过数老板度的一半,因而输出2。假设不设有则输出0。

import java.util.HashMap;
import java.util.Map;

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {

        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();

        for(int elem: array){
            if(map.containsKey(elem)){
                int count = map.get(elem);
                map.put(elem,map.get(elem) + 1);
            }else{
                map.put(elem,1);
            }
        }

        for(Map.Entry<Integer,Integer> entry: map.entrySet()){
            if(entry.getValue() > array.length / 2) return entry.getKey();
        }

        return 0;
    }
}

29.最小的k个数

输入n个整数,找出里面很小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字,则小小的的4个数字是1,2,3,4,。

冒泡排序的前k次排序即可。算法复杂度O(kn)。
public ArrayList<Integer> GetLeastNumbers_Solution(int []
input, int k) {

    ArrayList<Integer> list = new ArrayList<Integer>();

    if(k > input.length) return list;

    for(int i = 0; i < k; i++){
        for(int j = input.length - 1; j > i; j--){
            if(input[j] < input[j - 1]){
                int temp = input[j];
                input[j] = input[j - 1];
                input[j - 1] = temp;
            }
        }
        list.add(input[i]);
    }  
    return list;
}

31.总是子数组的最大和

HZ偶尔会拿些专业问题来忽悠那一个非总结机专业的同室。前几日测试组开完会后,他又说道了:在古老的一维情势识别中,平时需要统计连续子向量的最大和,当向量全为正数的时候,问题很好解决。不过,假若向量中蕴含负数,是否应该包含某个负数,并期望旁边的正数会弥补它吧?例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个起来,到第3个了断)。你会不会被他忽悠住?(子向量的长度至少是1)

32.平头中1油但是生的次数

求出113的整数中1出现的次数,并算出1001300的平头中1冒出的次数?为此他专门数了一下1~13中隐含1的数字有1、10、11、12、13因而共出现6次,可是对于背后问题他就没辙了。ACMer希望你们帮帮她,并把问题越来越普遍化,能够很快的求出任意非负整数间距中1油但是生的次数。

脑袋都要想破了,有点点麻烦的一道题。
思路是先统计个位数出现1的次数,再总结十位数出现1的次数……
while循环里每便对一个位数总结,要专注的是quotient2%10乘除的是当位数的数字,假诺过量1,要加一个位数的满轮次;假诺等于1,不满一个位数但有剩余,要独立算出这一个extra。

public int NumberOf1Between1AndN_Solution(int n) {

    int num = 0;
    int quotient1 = -1;
    int count = 0;
    while(quotient1 != 0){

        int dividend2 = (int)Math.pow(10.0,(double)count++);
        int dividend1 = 10 * dividend2;
        quotient1 = n/dividend1;
        int quotient2 = n/dividend2;

        int extra = 0;
        int extra1 = 0;

        if(quotient2%10 == 1){
            extra = n % dividend2 + 1;
        }else if(quotient2%10 != 0){
            extra1 = 1;
        }

        num += (quotient1 + extra1) * dividend2 + extra;

    }

    return num;
}

33.把数组排成最小的数

输入一个正整数数组,把数组里富有数字拼接起来排成一个数,打印能凑合出的保有数字中幽微的一个。例如输入数组{3,32,321},则打印出这六个数字能排成的小小数字为321323。

就排前排后而言,这一个数以内是有相对大小的。对五个数而言,把她们东拼西凑起来,拼在后边更小表明这些数更“小”。Arrays有一个
sort(T[] a, Comparator<? super T> c)
函数,可以经过自定义compare方法来排序a。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class Solution {
    public String PrintMinNumber(int [] numbers) {
        String s = "";
        if(numbers == null || numbers.length == 0) return s;

        String[] sArray = new String[numbers.length];
        for(int i = 0; i < numbers.length; i++){
            sArray[i] = String.valueOf(numbers[i]);
        }

        Arrays.sort(sArray, new Comparator<String>(){
            public int compare(String s1, String s2){
                return (s1+s2).compareTo(s2+s1);
            }
        });

        for(String elem: sArray){
            s += elem;
        }

        return s;
    }
}
admin

网站地图xml地图