剑指offer_知识迁移

前言：当前内容只用来回忆复习，java编写，代码尽可能带注释，部分题目附上解题思路。如有错误，请指出，谢谢。

感悟：刷题重在思路以及巩固知识点，而不是刷题进度。

重点：滑动窗口的思路，递归退出条件

1、数字在排序数组中出现的次数

题目描述
统计一个数字在排序数组中出现的次数。

1.1 hashmap

import java.util.HashMap;
public class Solution {
    public int GetNumberOfK(int [] array , int k) {
       // 排除空指针或空数组
        if(array == null || array.length == 0)
            return 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        // 生成元素和出现次数map
        for(int i = 0; i < array.length; i++){
            if(map.containsKey(array[i]) ){
                int val = map.get(array[i]);
                val += 1;
                map.put(array[i], val);
            }
            else{
                map.put(array[i], 1);
            }
        }
        // 查找指定元素次数
        if(map.containsKey(k) ){
            return map.get(k);
        }
        return 0;
    }
}

2、二叉树的深度

题目描述
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

2.1 递归一定要注意递归退出条件

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

    public TreeNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public int TreeDepth(TreeNode root) {
        // 排除空指针异常
        if(root == null)
            return 0;
        // 递归查找树的深度
        return Math.max(TreeDepth(root.left)+1, TreeDepth(root.right)+1 );
    }
}

3、平衡二叉树

题目描述
输入一棵二叉树，判断该二叉树是否是平衡二叉树。
在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树

3.1 递归退出条件，空树也被认为是平衡二叉树

public class Solution {
    public boolean IsBalanced_Solution(TreeNode root) {
        // 排除空指针异常,空树也被认为是平衡二叉树
        if(root == null)
            return true;
        // 只有根节点也是平衡二叉树
        if(root.left == null && root.right == null)
            return true;
        // 判断是否平衡二叉树，要看各个子树是否也是平衡二叉树
        // 判断平衡二叉树要分别判断左右子树的深度
        if(Math.abs(TreeDepth(root.left) - TreeDepth(root.right) ) > 1){
            return false; // 左右子树深度差超过1，是非平衡二叉树
        }
        return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
    }
           
    public int TreeDepth(TreeNode root) {
        // 排除空指针异常
        if(root == null)
            return 0;
        // 递归查找树的深度
        return Math.max(TreeDepth(root.left)+1, TreeDepth(root.right)+1 );
    }
}

4、数组中只出现一次的数字

题目描述
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

4.1 两次遍历+hashmap

//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
import java.util.HashMap;
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        // 排斥空指针异常
        if(array == null)
            return;
        // 用hashmap存储数字与出现次数
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < array.length; i++){
            if(map.containsKey(array[i])){
                map.put(array[i], 2); // 这里已经事先知道出现两次
            }
            else{
                map.put(array[i], 1);
            }
        }
        // 第二次遍历找出出现一次的数字
        int count = 0;
        for(int j = 0; j < array.length; j++){
            if(map.get(array[j]) == 1){
                if(count == 0){
                    num1[0] = array[j];
                    count++;
                }
                else{
                    num2[0] = array[j];
                    return;
                }
            }
        }
        return;
    }
}

4.2 两个相同数异或结果为0，左移不需要考虑符号位，右移就需要考虑

//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
            int xor1 = 0;
            for(int i=0; i < array.length; i++)
                xor1 = xor1^array[i];
            //在xor1中找到第一个不同的位对数据进行分类，分类为两个队列对数据进行异或求和找到我们想要的结果
            int index = 1;
            while((index & xor1)==0)
                index = index <<1;//因为可能有多个位为1所以需要求一下位置，说明的是，左移不用担心符号位进位
            int result1 = 0;
            int result2 = 0;
            for(int i=0; i < array.length; i++){
                if((index & array[i]) == 0) // 利用元素的特定一位是否为0，可以将数组分为两部分，至于两部分的个数是否相等不重要
                    result1 = result1^array[i];
                else
                    result2 = result2^array[i];
            }
            num1[0] = result1;
            num2[0] = result2;
    }
}

5、和为S的连续正数序列

题目描述
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

输出描述:
输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

5.1 借助滑动滑窗，注意列表元素添加的引用问题

import java.util.ArrayList;
public class Solution {
    public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
        ArrayList<ArrayList<Integer> > ret = new ArrayList<ArrayList<Integer> >();
       // 至少两个数,那么最小的两个连续正数为1,2,sum不能低于3
        if(sum < 3)
            return ret;
        // 使用滑动滑窗，两边收紧，滑窗内累积和为目标值则保存
        // 滑窗start,end最大范围均小于目标值的一半,start>=1
        int start = 1;
        int endScope = (int)Math.ceil(sum/2.f); // 右滑窗的最大值
        int end = endScope; // 初始化右滑窗
        // 序列中至少有两个数
        while(start < end){
            ArrayList<Integer> list = new ArrayList<Integer>(); // ret中必须每次添加一个副本，而不能重用一个
            int target = 0;
            for(int i = start; i <= end; i++){
                list.add(i);
                target += i;
            }
            if(target > sum){
                end--;
            }
            else if(target < sum){
                start++;
                end = endScope; // 重置右滑窗
            }
            else{
                // 恰好等于就保存
                ret.add(list);
                start++; // start加一，接着查询下一个满足的序列
            }
        }
        return ret;
    }
}

6、和为S的两个数字

题目描述
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

输出描述:
对应每个测试案例，输出两个数，小的先输出。

6.1 滑动窗口

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
        ArrayList<Integer> ret = new ArrayList<Integer>();
        // 判断空指针异常或数组为空或只有只有一个元素，都直接返回
        if(array == null || array.length <2)
            return ret;
        // 分析，查找和为S的两个数，选择滑动窗口。
        // 若递增排序数组全为正数 或全为负数，那么如果存在多对数字的和等于S，乘积最小的那一对一定是最外边一对
        // 特别的，递增排序数组可能存在负数，画图，乘积最小的一对仍是最外边一对
        int start = 0;
        int end = array.length -1;
        while(start < end){
            int target = 0;
            target += array[start];
            target += array[end];
            if(target < sum){
                start++;
            }
            else if(target > sum){
                end--;
            }
            else{
                ret.add(array[start]);
                ret.add(array[end]);
                return ret; // 第一次从最外边找到即返回
            }
        }
        return ret;
    }
}

7、左旋转字符串

题目描述
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

7.1 自己写的方法，有些累赘，判断异常、边界也没考虑最简

public class Solution {
    public String LeftRotateString(String str,int n) {
        String ret = new String();
        // 排除异常情况，空指针或空字符串或左移次数小于0
        if(str == null || str.length() == 0 || n < 0)
            return ret;
        // 循环左移字符串，那么每左移一次，左移出去的字符就在最右边
        // 注意，String字符串无法修改，那么改用StringBuilder
        StringBuilder sb = new StringBuilder(str);
        while(n-- != 0){
            Character c = sb.charAt(0); // 取首字符创
            sb.deleteCharAt(0); // 移除首字符
            sb.append(c); // 末尾添加字符
        }
        ret = sb.toString();
        return ret;
    }
}

7.2 改进方法，直接拼接字符串更为简洁，循环左移负数应该也是可以的

public class Solution {
    public String LeftRotateString(String str, int n) {
        // 空指针 或空字符串 或移动等于0次直接返回
        int len = str.length();
        if (str == null || len == 0 || n == 0) {
            return str;
        }
        //左旋字符串（循环左移字符串）：左移串长length位后和原来一样，所以正真需要左移的是n % str.length()位
        // 这里左移负数应该也是可以的，所以要考虑取模
        int trueSet = Math.floorMod(n, len);
        return str.substring(trueSet) + str.substring(0, trueSet);
    }
}

8、翻转单词顺序列

题目描述
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

8.1 巨大陷阱，如果字符串为非空字符串，但里面有很多空格的处理情况

public class Solution {
    public String ReverseSentence(String str) {
        // 排除空指针 或空字符串
        if(str == null || str.length() ==0  )
            return str;
        // 分析，只是单词顺序颠倒了而已，从右往左遍历单词，添加即可
        StringBuilder sb = new StringBuilder();
        String[] s = str.split(" ");
        // 这里有个巨大陷阱，空指针异常，如果字符串为非空字符串，但里面有很多空格，需要直接返回
        if(s.length == 0)
            return str;
        int i = s.length-1;
        for(; i > 0; i--){
            sb.append(s[i] + " ");
        }
        sb.append(s[i]); // 异常原因在这
        return sb.toString();
    }
}