剑指offer题目--Java实现

一、简单

1.1 斐波那契数列–数组

描述：

 现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。n ≤ 39

①递归

分析：

 斐波那契数列的公式：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=3，n∈N*）

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

复杂度：

 时间复杂度：O（2^n）
 空间复杂度：O（1）

②优化递归

 递归会重复计算大量相同的数据，用数组把结果存起来

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

复杂度：

 时间复杂度：O（n）
 空间复杂度：O（n）

1.2 从尾到头打印链表–链表

描述：

 输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。

示例1：

 输入：{1,2,3}
 返回值：[3,2,1]

示例2：

 输入：{67,0,24,58}
 返回值：[58,24,0,67]

①非递归

 listNode是链表，输入时从头到尾，输出时从尾到头，“先进后出”–栈

 ArrayList 中有个方法是 add(index,value)，可以指定 index 位置插入 value 值

 所以在遍历 listNode 的同时将每个遇到的值插入到 list 的 0 位置，最后输出 listNode 即可得到逆序链表

import java.util.ArrayList;
public class Solution {
   
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
   
        ArrayList<Integer> list = new ArrayList<>();
        ListNode temp = listNode;
        while(temp != null){
   
            list.add(0,temp.val);
            temp = temp.next;
        }
        return list;
    }
}

复杂度：

 时间复杂度：O（n）
 空间复杂度：O（n）

②递归

 借助系统的“栈”帮忙打印

import java.util.ArrayList;
public class Solution {
   
    ArrayList<Integer> list = new ArrayList();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
   
        if(listNode != null){
   
            printListFromTailToHead(listNode.next);
            list.add(listNode.val);
        }
        return list;
    }
}

复杂度：

 时间复杂度：O（n）
 空间复杂度：O（n）

1.3 用两个栈实现队列–栈

描述：

 用两个栈来实现一个队列，分别完成在队列尾部插入整数(push)和在队列头部删除整数(pop)的功能。 队列中的元素为int类型。保证操作合法，即保证pop操作时队列内已有元素。

示例：

 输入：[“PSH1”,“PSH2”,“POP”,“POP”]
 返回值：1,2

解析：

 “PSH1”:代表将1插入队列尾部
 “PSH2”:代表将2插入队列尾部
 "POP“:代表删除一个元素，先进先出=>返回1
 "POP“:代表删除一个元素，先进先出=>返回2

分析：

栈：先进后出；队列：先进先出

 当我们向模拟的队列插入数 a,b,c 时，假设插入的是 stack1，此时的栈情况为：

• 栈 stack1：{a,b,c}
• 栈 stack2：{}

 当需要弹出一个数，根据队列的"先进先出"原则，a 先进入，则 a 应该先弹出。但是此时 a 在 stack1 的最下面，将 stack1 中全部元素逐个弹出压入 stack2，现在可以正确的从 stack2 中弹出 a，此时的栈情况为：

• 栈 stack1：{}
• 栈 stack2：{c,b}

 继续弹出一个数，b 比 c 先进入"队列"，b 弹出，注意此时 b 在 stack2 的栈顶，可直接弹出，此时的栈情况为：

• 栈 stack1：{}
• 栈 stack2：{c}

 此时向模拟队列插入一个数 d，还是插入 stack1，此时的栈情况为：

• 栈 stack1：{d}
• 栈 stack2：{c}

 弹出一个数，c 比 d 先进入，c 弹出，注意此时 c 在 stack2 的栈顶，可直接弹出，此时的栈情况为：

• 栈 stack1：{d}
• 栈 stack2：{c}

根据上述例子可得出结论：

 当插入时，直接插入 stack1
 当弹出时，当 stack2 不为空，弹出 stack2 栈顶元素，如果 stack2 为空，将 stack1 中的全部数逐个出栈入栈 stack2，再弹出 stack2 栈顶元素

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.size() <= 0){
   
            while(stack1.size() != 0){
   
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
}

复杂度：

 push时间复杂度：O（1）
 pop空间复杂度：O（1）

1.4 旋转数组的最小数字–二分

描述：

 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。

 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。

 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

示例：

 输入：[3,4,5,1,2]
 返回值：1

①遍历数组，不断更新保存最小值变量

import java.util.ArrayList;
public class Solution {
   
    public int minNumberInRotateArray(int [] array) {
   
        if(array.length == 0){
   
            return 0;
        }
        int tmp = array[0];
        for(int i = 1;i < array.length;i++){
   
            tmp = Math.min(tmp,array[i]);
        }
        return tmp;
    }
}

 时间复杂度：O（n）

②二分法，不断更新存在于两个子数组中的下标–待了解

import java.util.ArrayList;
public class Solution {
   
    public int minNumberInRotateArray(int [] array) {
   
        if(array.length == 0){
   
            return 0;
        }
        int l = 0;
        int r = array.length-1;
        while(l < r-1){
   
            int mid = (l + r) >> 1;
            if(array[mid] >= array[l]){
   
                l = mid;//说明mid所在的位置是第一个非递减子数组中
            }else if(array[mid] <= array[r]){
   
                r = mid;//说明mid所在的位置是第二个非递减子数组中
            }
        }
        return array[r];
    }
}

 时间复杂度：O（log（n））

1.5 跳台阶–递归（与斐波那契数列类似）

描述：

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

示例1：

 输入：2
 返回值：2

示例2：

 输入：7
 返回值：21

分析：

 与斐波那契数列类似，

①递推实现（不推荐）

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

 时间复杂度：O（2^n）

②自底向上循环求解（面试推荐）

public class Solution {
   
    public int jumpFloor(int target) {
   
        int a=1,b=1;
        for(int i = 2;i <= target;i++){
   
            //求f[i]=f[i-1]+f[i-2]
            a = a+b;//这里求得的f[i]可以用于下次循环求f[i+1]
            //f[i-1]=f[i]-f[i-2]
            b = a-b;//这里求得的f[i-1]可以用于下次循环求f[i+1]
        }
        return a;
    }
}

 时间复杂度：O（n）

1.6 跳台阶扩展问题（变态跳台阶）–递归、动态规划

描述：

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

示例：

 输入：3
 返回值：4

• f(n)=f(n-1)+f(n-2)+…+f(1)
• f(n-1)=f(n-2)+…f(1)
• 得：f(n)=2*f(n-1)

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

1.7 合并两个排序的链表–链表

描述：

 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

示例：

 输入：{1,3,5},{2,4,6}
 返回值：{1,2,3,4,5,6}

①遍历两个链表，按大小顺序拼接

public class Solution {
   
    public ListNode