您的位置:js12345金沙官网登入 > 网络编程 > 剑指offer 前篇

剑指offer 前篇

2019-10-02 10:01

本文按照牛客网的顺序,牛客网剑指offer刷题网址:https://www.nowcoder.com/ta/coding-interviews

刷题啦刷题啦,剑指offer好像比较有名,所以就在牛客网上刷这个吧~
btw,刷了一些题发现编程之美的题好典型啊!!有不少都在笔试遇到过或者是特别有名之前做过的题。后悔没早点刷T T

本篇涉及的题目有:1、二进制中1的个数2、链表中的倒数第K个节点3、反转链表4、合并两个排序的链表5、树的子结构6、二叉树的镜像

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; 
    }   
}

问题描述输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。

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();

    }
}

思路解析考虑二进制1100,减1之后变为1011 1100&1011 为 1000,也就是说n和n-1的与运算,结果是将n的最后一位变成了0

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;
    }
}

代码实现java

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;

    }
}
public class Solution { public int NumberOf1 { int count = 0; while  { ++ count; n =  & n; } return count; }}

5.用两个栈实现队列

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

栈那篇文章分析过,记得挺简单的就不再写了。

python

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];

    }
}
def NumberOf1: # write code here count = 0 while n: n =  & n count = count + 1 return count

7.斐波那契数列

public int Fibonacci(int n) {

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

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

}

问题描述输入一个链表,输出该链表中倒数第k个结点。

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);
    }

思路解析假设链表中的节点数大于等于k个,那么一定会存在倒数第k个节点,那么我们首先使用一个快指针往前走k步,然后使用一个慢指针随快指针一起每次往前走一步,两个指针之间始终有k的距离,当快指针走到末尾变为Null时,慢指针所在的位置就是倒数第k个节点。

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;
    }

代码实现java

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); 
    }
/*public class ListNode { int val; ListNode next = null; ListNode { this.val = val; }}*/public class Solution { public ListNode FindKthToTail(ListNode head,int k) { if(head==null) return null; ListNode fast = head; int t = 0; while(fast != null && t < k){ t += 1; fast = fast.next; } if  return null; ListNode slow = head; while (fast != null){ fast = fast.next; slow = slow.next; } return slow; }}

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;
}

python

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);
}
# -*- coding:utf-8 -*-# class ListNode:# def __init__:# self.val = x# self.next = Noneclass Solution: def FindKthToTail(self, head, k): # write code here if not head or k<=0: return None p = head t = 0 while p!=None and t<k: p = p.next t = t + 1 # 判断有没有k个节点 if t < k: return None q = head while p!=None: p = p.next q = q.next return q 

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;
}

代码实现java

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;  
}
/*public class ListNode { int val; ListNode next = null; ListNode { this.val = val; }}*/public class Solution { public ListNode ReverseList(ListNode head) { if(head == null) return null; ListNode dummy = new ListNode; dummy.next = head; ListNode p = head; ListNode q = p; while{ q = p.next; p.next = dummy.next; dummy.next = p; p = q; } head.next = null; return dummy.next; }}

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;    
    }
}

python

18.二叉树的镜像

二叉树里写过不说了。

本文由js12345金沙官网登入发布于网络编程,转载请注明出处:剑指offer 前篇

关键词: