剑指offer学习笔记

最新推荐文章于 2020-08-10 10:59:20 发布

Java-Talk

最新推荐文章于 2020-08-10 10:59:20 发布

阅读量328

点赞数

分类专栏：算法和数据结构文章标签：剑指offer 反转链表对称二叉树斐波那契

本文链接：https://blog.csdn.net/jack1liu/article/details/101170151

版权

算法和数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一跳台阶

1.1 题目描述

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

1.2 题目分析

第1阶有只能1级，一种跳法；
第2阶可以两次1级、一次2级两种跳法；
若楼梯阶级 k = 3
- 跳 2 步到 3：剩下的是第1步没跳，起始跳到第1步只有一种；
- 跳 1 步到 3：剩下的是第2步没跳，起始跳到第2步有两种。

通过分类讨论，问题规模就减少了:

若楼梯阶级 k = n
- 跳 2 步到 n：剩下的是第 n - 2 步没跳，起始跳到第 n - 2 步跳法；
- 跳 1 步到 n：剩下的是第 n - 1 步没跳，起始跳到第 n - 1 步跳法。

总结来说：n 级台阶跳法就相当于 n-1 级再跳一次1阶的跳法和 n-2 级再跳一次2阶的总和。

1.3 题目求解

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

二斐波那契数列

2.1 题目描述

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

2.2 题目分析

0项	1项	2项	......	n项
0	1	1	......	（n-1）项+（n-2）项

2.3 题目求解

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

三用两个栈实现队列

3.1 题目描述

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

3.2 题目分析

队列的特性是：先入先出。

栈的特性是：先入后出。

3.3 题目求解

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

四变态跳台阶

4.1 题目描述

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

4.2 题目分析

(1) - (2) 得到：

f(n) = 2 * f(n-1) (n>=1)

4.3 题目求解

public class Solution {
    public int JumpFloorII(int target) {
        if(target<=1) {
            return target;
        }
        return 2*JumpFloorII(target-1);
    }
}

五从尾到头打印链表

5.1 题目描述

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

5.2 题目分析

listNode 是链表，只能从头遍历到尾，但是输出却要求从尾到头，这是典型的“先进后出"，我们可以想到栈！
ArrayList 中有个方法是 add(index,value)，可以指定 index 位置插入 value 值，index + 1之后的元素都往后移动一位。

5.3 题目求解

栈实现

/**
*    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 list = new ArrayList();
        Stack stack = new Stack();
        while (listNode != null) {
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        while (!stack.empty()) {
            list.add(stack.pop());
        }
        return list;
    }
}

add(index,value) 实现

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

六反转链表

6.1 题目描述

输入一个链表，反转链表后，输出新链表的表头。

6.2 题目分析

1 这块牵涉到三个链表节点，前一个节点 preNode，当前节点 head 和后一个节点 nextNode。

2 要想实现链表反转，这块需要操作四步：

第一步 nextNode 存储 head 指向的下一个节点；
第二步 head 指向 preNode；
第三步 preNode 往前移动；
第四步 head 往前移动；

6.3 题目求解

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode preNode = null;
        ListNode nextNode = null;
        while(head != null) {
            nextNode = head.next;
            head.next = preNode;
            
            preNode = head;
            head = nextNode;
        }
        return preNode;
    }
}

七链表中倒数第 K 个节点

7.1 题目描述

输入一个链表，输出该链表中倒数第k个结点。

7.2 题目分析

为了实现只遍历链表一次就能找到倒数第 k 个结点，我们可以定义快慢指针，通过两个步骤实现：

第一个步骤：快指针从链表的头指针开始遍历向前走 k-1步，慢指针保持不动；

第二个步骤：从第 k 步开始，快指针往前走，慢指针也开始从链表的头指针开始遍历。由于快慢指针的距离保持在 k-1 ，当快指针到达链表的尾结点时，慢指针正好是倒数第 k 个结点。

7.3 题目求解

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if(head == null || k < 1) {
            return null;
        }
        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;
    }
}

八合并两个排序的链表

8.1 题目描述

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

8.2 题目分析

遍历解法

同时不断遍历两个链表，取出小的追加到新的头节点后，直至两者其中一个为空，再将另一者追加的新链表最后。

递归解法

递归的核心方法是将问题规模不断缩小化，合并两个长度为 n 和 m 的链表，在 value(n) < value(m) 可以将规模缩减为合并长度为 (n-1) 和 m 的链表。

8.3 题目求解

遍历解法

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        ListNode head = new ListNode(-1);
        ListNode current = head;
        while(list1 != null && list2 != null) {
            if(list1.val < list2.val) {
                current.next = list1;
                list1 = list1.next;
            } else {
                current.next = list2;
                list2 = list2.next;
            }
            current = current.next;
        }
        if(list1 != null) {
            current.next = list1;
        }
        
        if(list2 != null) {
            current.next = list2;
        }
        return head.next;
    }
}

递归解法

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if (list1 == null) return list2;
        if (list2 == null) return list1;
        if (list1.val < list2.val) {
            list1.next = Merge(list1.next, list2);
            return list1;
        } else {
            list2.next = Merge(list1, list2.next);
            return list2;
        }
    }
}

九对称二叉树

9.1 题目描述

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

9.2 题目求解

递归

1.只要 pRoot.left 和 pRoot.right 是否对称即可。

2.左右节点的值相等且对称子树 left.left， right.right ; left.rigth, right.left 也对称。

public boolean isSymmetrical(TreeNode pRoot) {
    if(pRoot == null) {
        return true;
    }

    isSymmetrical(pRoot.left, pRoot.right);
}

public boolean isSymmetrical(TreeNode left, TreeNode right) {
    if(left == null && right == null) {
        return true;
    }
    if(left == null || right == null) {
        return false;
    }

    return left.val == right.val && isSymmetrical(left.left, right.right) && isSymmetrical(left.right, right.left);
}

非递归

/===================非递归算法，利用DFS和BFS=============================//
/*
* DFS使用stack来保存成对的节点

* 1.出栈的时候也是成对成对的，

1.若都为空，继续；

2.一个为空，返回false;

3.不为空，比较当前值，值不等，返回false；

* 2.确定入栈顺序，每次入栈都是成对成对的，如left.left， right.right ;left.rigth,right.left
*/

boolean isSymmetrical(TreeNode pRoot) {
    if(pRoot == null) {
        return true;
    }
    Stack<TreeNode> stack = new Stack<>();
    stack.push(pRoot.left);
    stack.push(pRoot.right);
    while(!stack.empty()) {
        TreeNode right = stack.pop();
        TreeNode left = stack.pop();
        if(right == null && left == null) {
            continue;
        }
        
        if(right == null || left == null) {
            return false;
        }
        
        if(right.val != left.val) {
            return false;
        }
        
        stack.push(left.left);
        stack.push(right.right);
        stack.push(left.right);
        stack.push(right.left);
    }
    return true;
}

*
* BFS使用Queue来保存成对的节点，代码和上面极其相似

* 1.出队的时候也是成对成对的

1.若都为空，继续；

2.一个为空，返回false;

3.不为空，比较当前值，值不等，返回false；

* 2.确定入队顺序，每次入队都是成对成对的，如left.left， right.right ;left.rigth,right.left
*/

boolean isSymmetricalBFS(TreeNode pRoot) {
    if(pRoot == null) {
        return true;
    }
    
    Queue<TreeNode> s = new LinkedList<>();
    s.offer(pRoot.left);
    s.offer(pRoot.right);
    while(!s.isEmpty()) {
        TreeNode left= s.poll();//成对取出
        TreeNode right= s.poll();
        if(left == null && right == null) {
            continue;
        }

        if(left == null || right == null) {
            return false;
        }

        if(left.val != right.val) {
            return false;
        }
        //成对插入
        s.offer(left.left);
        s.offer(right.right);
        s.offer(left.right);
        s.offer(right.left);
    }
    return true;
}

十统计一个数字在排序数组中出现的次数

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

10.1 直接比较统计，O(N)的时间复杂度。

public class Solution {
    public int GetNumberOfK(int[] a, int key) {
        int count = 0;
        for(int i:a) {
            if(i == key) {
                count++;
            }
        }
        return count;
    }
}

10.2 利用二分查找，分别找出最先出现和最后出现的位置，再统计出现的次数即可，时间复杂度为O(logN)。

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
        int length = array.length;
        if(length == 0){
            return 0;
        }
        int firstK = getFirstK(array, k, 0, length-1);
        int lastK = getLastK(array, k, 0, length-1);
        if(firstK != -1 && lastK != -1){
             return lastK - firstK + 1;
        }
        return 0;
    }
    //递归写法
    private int getFirstK(int [] array , int k, int start, int end){
        if(start > end){
            return -1;
        }
        int mid = (start + end) >> 1;
        if(array[mid] > k){
            return getFirstK(array, k, start, mid-1);
        }else if (array[mid] < k){
            return getFirstK(array, k, mid+1, end);
        }else if(mid-1 >=0 && array[mid-1] == k){
            return getFirstK(array, k, start, mid-1);
        }else{
            return mid;
        }
    }
    //循环写法
    private int getLastK(int [] array , int k, int start, int end){
        int length = array.length;
        int mid = (start + end) >> 1;
        while(start <= end){
            if(array[mid] > k){
                end = mid-1;
            }else if(array[mid] < k){
                start = mid+1;
            }else if(mid+1 < length && array[mid+1] == k){
                start = mid+1;
            }else{
                return mid;
            }
            mid = (start + end) >> 1;
        }
        return -1;
    }
}

Java-Talk

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
剑指offer学习笔记

目录一题目描述二题目分析三题目求解一题目描述一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。二题目分析第1阶有只能1级，一种跳法；第2阶可以两次1级、一次2级两种跳法；若楼梯阶级 k= 3 跳 2 步到 3：剩下的是第1步没跳，起始跳到第1步只有一种；跳 1 ...
复制链接

扫一扫