剑指Offer刷题全集 --V1 版本

前言

仓库地址：https://github.com/Damaer/CodeSolution
在线文档：https://damaer.github.io/CodeSolution/

题目基本来源于牛客网，或许有个别题目没有，或许解法不够优，这些日后遇到会再更新。现在面试基本都需要算法，如果没有时间刷Leetcode，把剑指Offer先刷了也是一种不错的选择，基本能覆盖大部分公司的考察。

算法，我们大部分人在工作中是用不上的，普通人也几乎不会创造出一个多厉害的算法，不必为之太过焦虑，这个时代已经足够焦虑了。你可以把算法当成兴趣，或者看到文章感兴趣的时候，去看看，去试试。如果对某个题目不感兴趣，大可略过不看。

很早之前听过一句话，算法题，可以锻炼一个人知难不退的心态，能够沉下心来思考，不会觉得枯燥，当然，也是有益思维锻炼，但是它不是万能药，不能解决所有的问题，也不是一日之功。

正所谓，冰冻三尺非一日之寒，滴水石穿非一日之功,这是第一版文档，之后会增加解法或者纠正存在的错误。

【作者简介】：
秦怀，公众号【秦怀杂货店】作者，技术之路不在一时，山高水长，纵使缓慢，驰而不息。个人写作方向：Java源码解析，JDBC，Mybatis，Spring，redis，分布式，剑指Offer，LeetCode等，认真写好每一篇文章，不喜欢标题党，不喜欢花里胡哨，大多写系列文章，不能保证我写的都完全正确，但是我保证所写的均经过实践或者查找资料。遗漏或者错误之处，还望指正。

关注公众号领取pdf！!！

1.二维数组中的查找

题目描述

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

例子

输入一个数组：

num[ 3 ][ 4 ] = [  
1 , 4 , 6 , 28 ,  
2 , 7 , 32 , 30 ,  
10 , 11 , 67 , 79  
]

需要查找一个数字 32 ，则返回 true。

思路 & 解答

暴力破解

直接暴力遍历，但是在最坏的情况是遍历完所有的元素才能获取结果。如果这个数组规模是 n * m，那么时间复杂度就是 O(n × m)，没有借助其他的空间，空间复杂度为 O(1)。

比较查找法

但是我们换一种思路，我们选定左下角的10 ( num[2][0], i = 2, j = 0 )作为起点，如果大于10 ,那么 i + 1 ,如果小于 10 ，则 j + 1 ，则下一个查找的数字是 11 ,我们知道 32 仍然比 11 大，则往右找到 67 ，继而 32 比 67 小，我们应该往上找，找到了 32 。
如果找 28 ，则是最坏的结果，查找知道数组的右上角结束，这样一来，最坏的结果就是 O（n+m）。

代码如下：

public class Solution {
   
    public boolean Find(int target, int [][] array) {
   
			int size=array.length;
        	int length=array[0].length;
        	int i,j;
        	for(i=size-1,j=0;i>=0&&i<size&&j>=0&&j<length;){
   
                if(array[i][j]==target){
   
                    return true;
                }
                if(array[i][j]<target){
   
					j++;
                    continue;
                }
                if(array[i][j]>target){
   
                    i--;
                    continue;
                }
            }
        return false;
    }
}

2.替换空格

题目描述

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

思路 & 解答

调用API函数

java里面有可以直接使用的函数replace()，直接写成下面这样即可通过，但是这样真的没有意思啊。🤣🤣🤣

public String replaceSpace(StringBuffer str) {
   
    String result = str.toString().replace(" ","%20");
    return result;
}

自实现

于是乎，决定自己实现，不直接调用 api.思路如下：

• 1.将字符串转换成为字符数组，遍历一次，统计出空格的个数。
• 2.构建出新的字符数组，初始化的大小=原来的字符数组长度+空格长度x2
• 3.遍历一次，复制，当不为空格时直接复制，当为空格时，则把%20这三个字符复制过去。

代码如下：

public class Solution {
   
    public String replaceSpace(StringBuffer str) {
   
        // 转换成为字符数组
        char[] originChars= str.toString().toCharArray();
        int spaceNum = 0;
        // 计算出空格的个数
        for (int i = 0; i < originChars.length; i++) {
   
            if (originChars[i] == ' ') {
   
                spaceNum++;
            }
        }
        // 新字符数组的长度
        int newCharsLength = originChars.length + 2 * spaceNum;
        char[] newChars = new char[newCharsLength];
        int newStrIndex = 0;
        for (int index= 0; index<=originChars.length - 1; index++) {
   
            if(originChars[index] != ' '){
   
                // 直接复制
                newChars[newStrIndex++] = originChars[index];
            }else {
   
                // 空格则需要复制三个字符
                newChars[newStrIndex++] = '%';
                newChars[newStrIndex++] = '2';
                newChars[newStrIndex++] = '0';
            }
        }
        // 转成字符串
        return new String(newChars);
    }
}

c++实现

c++实现差不多，主要是复制的时候从后面往前面开始复制，这样就可以节省一定空间，直接在原来的数组上操作。不需要重新创建一个空间。

class Solution {
   
public:
    	void replaceSpace(char *str,int length) {
   
		if(str == NULL || length <= 0){
   
            return;
        }
        int originalLength = 0;
        int spaceNum = 0;
        int i;
        while(str[i++] != '\0'){
   
            ++originalLength;
            if(str[i] == ' '){
   
                ++spaceNum;
            }
        }

        int newCharsLength = originalLength + 2 * spaceNum;
        
        int indexOriginal = originalLength-1;
        int index = newCharsLength-1;
        
        while(indexOriginal >= 0 && index > indexOriginal){
   
            if(str[indexOriginal] == ' '){
   
                str[index--] = '0';
                str[index--] = '2';
                str[index--] = '%';
            }
            else{
   
                str[index--] = str[indexOriginal];
            }
            --indexOriginal;
        }
    }
};

3.从尾到头打印链表

题目描述

输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

思路 & 解答

🙋‍♂️🙋‍♂️首先我们需要想用哪些解法可以解，大概有如下：

• 使用栈
• 使用递归调用
• 头插法

借助栈实现

先把元素里面的元素从头到尾遍历取出放在栈里面，然后再把栈的元素去出来放在ArraList里面。主要利用了栈的先进后出的规则，这样就可以实现倒序的功能。show you the code：

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
   
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
   
        Stack<Integer> stack = new Stack<>();
        while (listNode != null) {
   
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        ArrayList<Integer> results = new ArrayList<>();
        while (!stack.isEmpty()) {
   
            results.add(stack.pop()); 
        }
        return results;
    }
}

递归调用

前面我们能想到栈，那么我们何必自己实现呢？其实方法的调用过程，就是一个天然的栈调用的过程呀，只需要判断当前节点是不是为空，为空则不输出，不为空则递归下一个节点，对下一个节点处理之后，把结果使用ArrayList.addAll()加到结果中，再把自身加到结果中，emmmmm有道理，说码就码：

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
   
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
   
        ArrayList<Integer> results = new ArrayList<>();
        if(listNode!=null){
   
            // 对后面的元素进行处理
            results.addAll(printListFromTailToHead(listNode.next));
            // 最后添加自身
            results.add(listNode.val);
        }
        return results;
    }
}

头插法

我们遍历每一个节点，然后把它插入到头部，这样一直遍历到尾的时候，就相当于将整个链表都反转一遍了，然后再从头到尾遍历放到ArryList即可。

import java.util.ArrayList;
import java.util.Stack;
public class Solution {
   
    public  ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
   
        ListNode head = new ListNode(-1);
        while(listNode!=null){
   
            // 先把当前node的next保存起来
            ListNode temp = listNode.next;
            // 把当前节点的next指针指向head的下一个节点
            listNode.next = head.next;
            // 把head的next指向当前节点
            head.next = listNode;
            // 将遍历的指针指向了遍历的下一个元素
            listNode = temp;
        }
        ArrayList<Integer> results = new ArrayList<>();
        head = head.next;
        // 遍历输出
        while(head!=null){
   
            results.add(head.val);
            head = head.next;
        }
        return results;
    }
}

4.重建二叉树

题目描述

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

思路 & 解答

我们看上面的图片，首先数据保证了正确性，那么前序的第一个肯定是root节点，也就是1，那么我们需要在中序遍历中找到1的位置，左边就是这个root的左子树，右边就是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 (pre == null || pre.length == 0 || in == null || in.length == 0) {
   
            return null;
        }
        TreeNode root = constructBinaryTree(pre, 0, pre.length - 1, in, 0, in.length-1);
        return root;
    }

    TreeNode constructBinaryTree(int[] pre, int startPre, int endPre, int[] in, int startIn, int endIn) {
   
        // 不符合条件直接返回null
        if (startPre > endPre || startIn > endIn) {
   
            return null;
        }
        // 构建根节点
        TreeNode root = new TreeNode(pre[startPre]);
        for (int index = startIn; index <= endIn; index++) {
   
            if (in[index] == pre[startPre]) {
   
                // 左子树
                root.left = constructBinaryTree(pre, startPre + 1, startPre + (index - startIn), in, startIn, index - 1);
                // 右子树
                root.right = constructBinaryTree(pre, (index - startIn) + startPre + 1, endPre, in, index + 1, endIn);
                break;
            }
        }
        return root;
    }
}

5.旋转数组的最小数字

题目描述

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

思路 & 解答

• 直接遍历，当出现后面的数比前面的数小的时候，就是找到了最小的数。
• 使用二分查找，在已经排序过的数组中常用的算法。

直接遍历

import java.util.ArrayList;
public class Solution {
   
    public int minNumberInRotateArray(int [] array) {
   
        if(array==null||array.length==0){
   
            return 0;
        }
        if(array.length==1){
   
            return array[0];
        }
        int max = array[0];
        for(int i=1;i<array.length;i++){
   
            if(array[i]>max){
   
                max = array[i];
            }
            if(array[i]<max){
   
                return array[i];
            }
        }
        return 0;
    }
}

二分法

旋转之后的数组其实就是分成两段，比如{3,4,5,1,2},可以看到，3,4,5是递增的，但是5之后1就是比之前的数小的，这样就可以找到最小值1。

取出中间元素，和最右边元素比较，如果中间元素大于最右边元素，则证明，最小值存在于中间元素到最右边元素之间的一段。如果中间元素小于最右边元素，则证明，最小值在最左边元素到中间元素之间的一段中。

有一种特殊情况，就是相同元素，这样我们没有办法判断最小的元素位于哪一段，所以只能将右边的边界向左移动，即high--。

public class Solution {
   
    public static int minNumberInRotateArray(int[] array) {
   
        if (array == null || array.length == 0) {
   
            return 0;
        }
        if (array.length == 1) {
   
            return array[0];
        }
        int low = 0, high = array.length - 1;
        while (high - low > 1) {
   
            int mid = (low + high) / 2;
            if (array[mid] > array[high]) {
   
                low = mid;
            } else if (array[mid] < array[high]) {
   
                high = mid;
            } else {
   
                high--;
            }
        }
        return Math.min(array[low], array[high]);
    }
}

6.斐波那契数列

题目描述

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。(n<=39)

思路 & 解答

斐波那契数列大家都知道：

直接暴力

思路很直接，利用函数进行递归即可。

public class Solution {
   
    public int Fibonacci(int n) {
   
        if(n==0){
   
            return 0;
        }else if(n==1){
   
            return 1;
        }else{
   
            return Fibonacci(n-1)+Fibonacci(n-2);
        }
    }
}

重复利用结果(动态规划)

直接递归会造成很多重复的计算，要是我们把计算结果先存起来，使用的时候再调用，那就可以优化。

public class Solution {
   
    public int Fibonacci(int n) {
   
        if (n == 0) {
   
            return 0;
        }
        if (n == 1) {
   
            return 1;
        }
        int[] nums = new int[n + 1];
        nums[0] = 0;
        nums[1] = 1;
        for (int i = 2; i <= n; i++) {
   
            nums[i] = nums[i - 1] + nums[i - 2];
        }
        return nums[n];
    }
}

7.跳台阶

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

思路 & 解答

暴力递归

使用递归即可,首先第0级台阶是0次，第1级台阶是1次，跳上第二级台阶可以选择从0直接跳到2，也可以从1跳到2。其他情况，我们可以归纳出，要想跳到n级台阶，最后一步有两种跳法，一种是从n-1级一次跳一级，一种是从n-2级一次跳两级。

$$f(n)=\{\begin{array}{l}0,n=0\\ 1,n=1\\ 2,n=2\\ f(n-1)+f(n-2),n>2\end{array}$$

public class Solution {
   
    public int JumpFloor(int target) {
   
        if (target == 0) {
   
            return 0;
        } else if (target == 1) {
   
            return 1;
        } else if (target == 2) {
   
            return 2;
        } else {
   
            return JumpFloor(target - 1) + JumpFloor(target - 2);
        }
    }
}

动态规划

上面的解法会需要多次重复计算，我们可以利用数组将前面的结果存起来，计算的时候直接取出。

public class Solution {
   
    public int JumpFloor(int target) {
   
        int[] nums = new int[target + 1];
        if (target == 0) {
   
            return 0;
        } else if (target == 1) {
   
            return 1;
        } else if (target == 2) {
   
            return 2;
        }
        nums[0] = 0;
        nums[1] = 1;
        nums[2] = 2;
        for (int i = 3; i <= target; i++) {
   
            nums[i] = nums[i - 1] + nums[i - 2];
        }
        return nums[target];
    }
}

8.两个栈实现一个队列

题目描述

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

思路 & 解答

• 栈的特性是先进后出
• 队列的特性是先进先出

有两个栈stack1,stack2；
如果有新的数据进入，那么我们可以直接push到stack1；
如果需要取出数据，那么我们优先取出stack2的数据，如果stack2里面数据是空的，那么我们需要把所有的stack1的数据倒入stack2。再从stack2取数据。

例如：
(1). push 1–> push 2

(2). pop 1

(3). push 3 --> push 4

(4).pop 2

import java.util.Stack;
public class Solution {
   
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();

    public void push(int node) {
   
        stack1.push(node);
    }

    public int pop() {
   
        if(!stack2.isEmpty()){
   
            return stack2.pop();
        }else{
   
            while(!stack1.isEmpty()){
   
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
}

9.跳台阶变态版

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

思路 & 解答

首先青蛙一次可以跳 1 , 2 , 3 到 n 级。假设函数是f(n)，则：

• 青蛙跳到第一级是f（1）=1，只有一种跳法。
• 青蛙跳到第二级，可以是直接跳到第二级，也可以是从第一级直接跳。所以f(2)=f(1)+1
• 青蛙跳到第三级，可以从第0级跳，也可以从第1级跳，也可以从第2级跳。所以f(3) =f(1)+f(2)+1;
• 依次类推，青蛙跳到第n级，可以是从0,1,2,3…(n-1)级跳，所以f(n)=f(1)+f(2)+f(3)...+f(n-1)+1;

因此我们需要双层for循环即可完成。

public class Solution {
   
    public int JumpFloorII(int target) {
   
        if (target <= 0) {
   
            return 0;
        }
        int[] nums = new int[target];
        nums[0] = 1;
        for (int i = 0; i < target; i++) {
   
            int sum = 1;
            for (int j = 0; j < i; j++) {
   
                sum += nums[j];
            }
            nums[i]=sum;
        }
        return nums[target - 1];
    }
}

完成之后我们可以顺便推一下公式：
$$\begin{gathered} f(n)=f(1)+f(2)+...+f(n-2)+f(n-1)+1; \\ f(n-1)=f(1)+f(2)+...+f(n-2)+1; \\ f(n)-f(n-1)=f(n-1); \\ f(n)=2\ast f(n-1); \end{gathered}$$

所以最后我们可以推倒出:
$$f(n)=2^{n-1}$$

show you the code:

public class Solution {
   
    public int JumpFloorII(int target) {
   
        return (int) Math.pow(2, target - 1);
    }
}

10.矩形覆盖

题目描述

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

比如n=3时，2*3的矩形块有3种覆盖方法：

思路 & 解答

递归实现

先说思路，基本是递归，首先如果n为1，那么肯定只有一种，f(1)=1,如果n=2，f(2)=2

但是n>2的时候呢？那么我们的思路就可以分为第一次切分长度为1，和切分长度为2来计算，也就是剩下的是f(n-1)和f(n-2)，两者加起来即可。
$$f(n)=\{\begin{array}{l}0,n<=0\\ 1,n=1\\ 2,n=2\\ f(n-1)+f(n-2),n>2\end{array}$$

递归写法代码如下：

public class Solution {
   
    public int RectCover(int target) {
   
        if(target<=0){
   
            return 0;
        }else if(target==1){
   
            return 1;
        }else if(target==2){
   
            return 2;
        }else {
   
            return RectCover(target-1)+RectCover(target-2);
        }
    }
}

非递归实现

如果我不想使用递归呢？那么直接不断地把前面两个数加起来赋值给当前的数字即可。

public class Solution {
   
    public int RectCover(int target) {
   
        if (target <= 0) {
   
            return 0;
        } else if (target < 3) {
   
            return target;
        } else {
   
            int num1 = 1;
            int num2 = 2;
            int result = 0;
            for (int i = 3; i <= target; i++) {
   
                result = num1 + num2;
                num1 = num2;
                num2 = result;
            }
            return result;
        }
    }
}

11.二进制中1的个数

题目描述

输入一个整数，输出该数32位二进制表示中1的个数。其中负数用补码表示。

思路 & 解答

错误解答（不考虑负数）

首先说一个错误的解法，很多人可能会想到，那就是不断对2取余数。但是这种做法有个致命的缺陷，那就是忽略了负数，负数使用补码表示的时候，是取反之后加一，而且

public class Solution {
   
    public int NumberOf1(int n) {
   
        int num = 0;
        while (n != 0) {
   
            int tmp = n % 2;
            if (tmp == 1||tmp==-1) ++num;
            n /= 2;
        }
        return num;
    }
}

位移算法

移位算法，把整数当成二进制，不断向右移位和1进行与计算。利用了所有数和1进行与计算，结果为1则证明最后一位是1。
于是我们代码可以写成这样,但是这样也是有问题的！！！：

public class Solution {
   
    public int NumberOf1(int n) {
   
        int num=0;
        while (n != 0) {
   
            if ((n & 1)==1){
   
                ++num;
            }
            n = n>>1;
        }
        return num;
    }
}

上面代码的问题在于忽略了负数右移，其实第一位还是会补1，所以还是负数。就是说-1其实右移动之后还是-1，这样判断是无效的，而且会死循环。

既然输入的n没办法右移，那么我们把1左移是不是就解决这个问题了呢？是的！

正确代码如下：

public class Solution {
   
    public int NumberOf1(int n) {
   
        int num = 0, flag = 1;
        while (flag != 0) {
   
            if ((n & flag) != 0) {
   
                num++;
            }
            flag <<= 1;
        }
        return num;
    }
}

除此之外，还有其他做法么？还有一种做法的不断把最右边的1变成0，那就是利用n=n&(n-1)，比如7的二进制是111，那么7&6=111&110=110=6，就完美把最后一位1变成0了，6的二进制是110,6&5=110&101=100=4，也把最后一位1变成了0.

负数可不可以？可以！比如：

32位-7 = 11111111111111111111111111111001 ，
32位-8 = 11111111111111111111111111111000，
-7&-8  = 11111111111111111111111111111000

所以这种思路针对负数也是正确的：

public class Solution {
   
    public int NumberOf1(int n) {
   
        int num = 0;
        while (n != 0) {
   
            num++;
            n &= (n - 1);
        }
        return num;
    }
}

API调用(不推荐)

还有一种思路那就是直接调用java的api把整数，转成字符串，遍历一次获取1的个数,可以但是不提倡，因为本题考查的是位运算，而不是api使用和for循环。

public class Solution {
   
    public int NumberOf1(int n) {
   
        int t = 0;
        String str = Integer.toBinaryString(n);
        for (int i = 0; i < str.length(); i++) {
   
            if (str.charAt(i) == '1') {
   
                t++;
            }
        }
        return t;
    }
}

12. 数值的整数次方

题目描述

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。保证base和exponent不同时为0。

思路 & 解答

首先题目中的double类型应该不能拆解，但是int类型的整数exponet我们可以做点文章，我们平时求次方的时候，假设有个x的4次方，我们通常是求出一个x的平方数x^2，然后两个x^2相乘就可以得出x^4。

这里思路也一样，使用递归，同时考虑边界条件。
如果指数是负数，则先取反，最后取结果的倒数即可。

$$Power(base,ex)=\{\begin{array}{l}base\ast Power(base,ex-1),ex取余2=1\\ Power(base,ex/2)\ast Power(base,ex/2),ex取余2=0\end{array}$$

    public double Power(double base, int exponent) {
   
        if (exponent == 0) {
   
            // 指数为0则直接返回1
            return 1;
        }
        if (base == 0) {
   
            //底数为0直接返回0
            return 0;
        }
        // 判断指数是否为负数
        boolean isNegative = false;
        if (exponent < 1) {
   
            exponent = -exponent;
            isNegative = true;
        }
        double result;
        if (exponent % 2 == 1) {
   
            result = base * Power(base, exponent - 1);
        } else {
   
            double temp = Power(base, exponent / 2);
            result = temp * temp;
        }
        return isNegative ? (1.0 / result) : result;
    }

13.调整数组顺序使奇数位于偶数前面

题目描述

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

思路 & 解答

空间换时间

用空间换时间做法，就是新建一个数组，copy一份，先计算出奇数的个数，也就是能够知道第一个偶数应该放在数组的哪一个位置，然后再遍历一次，依次放到对应的位置即可。

public class Solution {
   
    public void reOrderArray(int[] nums) {
   
        // 奇数个数
        int oddCnt = 0;
        for (int x : nums)
            if (x % 2 == 1)
                oddCnt++;
        int[] copy = nums.clone();
        int i = 0, j = oddCnt;
        for (int num : copy) {
   
            if (num % 2 == 1)
                nums[i++] = num;
            else
                nums[j++] = num;
        }
    }
}

冒泡

第二种做法，时间复杂度为O(n²),类似冒泡，将找到的奇数不断往前面冒泡，直到前面排好奇数的位置。

public class Solution {
   
    public void reOrderArray(int [] array) {
   
        // 已经摆好的奇数个数
        int numOfOdd = 0;
        for (int i = 0; i < array.length; i++) {
   <