剑指offer总结（16-26）

最新推荐文章于 2022-12-24 12:15:01 发布
最新推荐文章于 2022-12-24 12:15:01 发布
阅读量107 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaopinglee/article/details/106987382
版权

剑指offer（16-26）

前言

【代码的规范性、完整性、鲁棒性】

  1. 代码的基本功能（功能测试）
  2. 输入边界值是否能得到正确处理（边界测试）
  3. 能否判断输入是否合乎规范，并对不符合规范的输入予以合适的处理（负面测试）
16. 数值的整数次方

【题目】

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

保证base和exponent不同时为 0，不得使用库函数，同时不需要考虑大数问题

【思路】

注意：base = 0 的情况要处理，exponent 为负数时要另外处理

public class Solution {
    public double Power(double base, int exponent) {
        if(exponent == 0){
            return 1.0;  // 0的0次方在数学上无意义，为 0 或 1 都可以
        }
        if(exponent == 1){
            return base;
        }
        boolean isNegative = false;
        if(exponent < 0){
            if(base == 0.0){
                throw new RuntimeException();
            }
            isNegative = true;
            exponent = -exponent;
        }
        double pow = Power(base, exponent >> 1) * Power(base, exponent >> 1); // 位运算替代与2为底的运算
        if((exponent & 1) != 0){ // 与 1 & 判断 奇偶
            pow *= base;
        }
        return isNegative ? 1 / pow : pow;
  }
}
17. 打印从 1 到最大的 n 位数

【题目】

输入数字n，按顺序打印出从1到最大的n位十进制数。

比如输入3，则打印出1、2、3一直到最大的3位数即999.

【思路】大数问题用字符串或者char数组存储

由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用char数组。

使用回溯法得到所有解。

result = []
def backtrack(已选择参数，待选择参数):
     可以需要将参数处理成已选择内容和待选择内容;

     排除不合法选择
    
     if 满足结束条件:
     	result.add(已选择内容)
     	return
    
     for 选择 in 待选择内容:
     	排除不合法选择
     	做选择，记录选择
        backtrack(已选择参数，待选择参数) //继续选择
		撤销选择，删除记录

public class Solution {
    public void print1ToMax(int n){
        if (n <= 0){
            return;
        }
        char[] number = new char[n];
    }
    
    private void backtrack(char[] number, int length){
        //结束条件
        if(length == number.length){
            printNumber(number);
        }
        for(int i = 0; i < 10; i ++){
            number[length] = (char) (i + '0');
            backtrack(number, length++);
        }
    }
    
    private void printNumber(char[] number){
        int index = 0;
        while(index < number.length && number[index] == '0'){
            index++;
        }
        while(index < number.length){
            System.out.print(number[index++]);
        }
        System.out.println();
    }
}
18.1 在 O(1) 时间内删除链表节点

【题目】

给定单链表的头指针和一个节点指针，定义一个函数在O(1)的时间内删除该节点

【思路】

  1. 如果该节点不是尾节点，则直接将下一个节点的值赋给该节点，然后令该节点的指向下下个节点，然后删除下个节点（O(1)）
  2. 如果该节点没有下一个节点，则需要重头找到其上一个节点
  3. 假设要进行 n 次操作，第一种情况为 (n - 1) * 1，第二种为 n，平均为 （2n - 1）/ n，所以为 O(1)
public class Solution {
    public ListNode deleteNode(ListNode head, ListNode tobeDelete){
        //链表为空或只有一个节点
        if(head == null || tobeDelete == null || head.next == null){
            return null;
        }
        //有下一个节点
        if(tobeDelete.next != null){
            tobeDelete.value = tobeDelete.next.value;
            tobeDelete.next = tobedelete.next.next;
        }else {
            ListNode cur = head;
            while(cur.next != tobeDelete){
                cur = cur.next;
            }
            cur.next = tobeDelete.next
        }
        return head;
    }
}
18.2 删除链表中重复的结点

【题目】

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。

例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

【思路】

双指针，辅助头

img

  1. 加一个辅助头节点（令其值不等于原头节点）
  2. 双指针
  3. q找变化点和终点；p与q之间判断变化点和终点前 q 的是否有重复值
/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if (pHead == null || pHead.next == null){
            return pHead;
        }
        //辅助头节点
        ListNode head = new ListNode(pHead.val - 1); // 保证和第一个节点不相等；
        head.next = pHead;
        //双指针
        ListNode pre = head;
        ListNode cur = head.next;
        while(cur != null){
            while(cur.next != null && cur.val == cur.next.val){ // 寻找值的变化点 或 终点
                cur = cur.next;
            }
            if(pre.next == cur){ //变化点或终点前相等的 cur 只有一个，比较的不是值，而是对象地址
                pre = cur;
                cur = cur.next;
            }else {
                pre.next = cur.next;
                cur = pre.next;
            }
        }
        return head.next; //记得去掉辅助头节点
    }
}
19. 正则表达式匹配

【题目】

请实现一个函数用来匹配包括 ’ . ’ 和 ’ * ’ 的正则表达式。模式中的字符 ’ . ’ 表示任意一个字符，而 ’ * ’ 表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。

例如，字符串 “a a a” 与模式 “a . a” 和 “ab * a c * a” 匹配，但是与 “a a . a” 和 “a b * a” 均不匹配

【思路】

回溯法

匹配条件：两个都到结尾处

主要分成两种情况：

  1. 第二个字符是‘ * ’
    1. 第一个字符匹配或为‘ . ‘
      1. ’ * ‘ 表示 0
      2. ’ * ‘ 表示 1
      3. ’ * ‘ 表示多个
    2. 第一个字符不匹配
  2. 第二个字符不是 ‘ * ’
public class Solution {
    public boolean match(char[] str, char[] pattern)
    {
        if(str == null || pattern == null){
            return false;
        }
        return matchChar(str, pattern, 0, 0);
    }
    
    private boolean matchChar(char[] str, char[] pattern, int s, int p){
        //满足结束条件
        if(s >= str.length && p >= pattern.length){
            return true;
        }
        if(s < str.length && p >= pattern.length){
            return false;
        }
        
        //做选择 backtrack
        if((p + 1) < pattern.length && pattern[p + 1] == '*'){
            if(s < str.length && (str[s] == pattern[p] || pattern[p] == '.')){
                return (matchChar(str, pattern, s + 1, p + 2) || matchChar(str, pattern, s, p + 2) || matchChar(str, pattern, s + 1, p));
            }else{
                return matchChar(str, pattern, s, p + 2);
            }
        }else if(s < str.length && (str[s] == pattern[p] || pattern[p] == '.')){
            return matchChar(str, pattern, s + 1, p + 1);
        }else {
            return false;
        }
    }
}
20. 表示数值的字符串

【题目】

请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。

例如，字符串 “+100”, “5e2”, “-123”, “3.1416” 和 “-1E-16” 都表示数值。 但是 “12e”, “1a3.14”, “1.2.3”, “±5” 和 “12e+4.3” 都不是。

【思路】

正则表达式

public class Solution {
    public boolean isNumeric(char[] str) {
        if(str == null){
            return false;
        }
        return new String(str).matches("[+-]?[0-9]*(\\.[0-9]*)?([eE][+-]?[0-9]+)?");
    }
}
21. 调整数组顺序使奇数位于偶数前面

【题目】

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

【思路】

不稳定：首尾双指针

稳定

//不稳定 O(N)+O(1)
public class Solution {
    public void reOrderArray(int [] array) {
        if(array == null || array.length == 0 || array.length == 1){
            return;
        }
        int begin = 0;
        int end = array.length - 1;
        while(begin < end){
            if(!isOdd(array[begin]) && isOdd(array[end])){
                swap(array, begin++, end--);
                continue;
            }else if (isOdd(array[begin])){
                begin++;
            }else if (!isOdd(array[end])){
                end--;
            }
        }
    }
    
    private boolean isOdd(int value){
        return (value & 1) == 1? true : false;
    }
    
    private void swap(int[] arr, int i, int j){
        arr[i] = arr[i] + arr[j];
        arr[j] = arr[i] - arr[j];
        arr[i] = arr[i] - arr[j];
    }
}

//稳定 O(N)+O(N)
public class Solution {
    public void reOrderArray(int [] array) {
        if(array == null || array.length < 2){
            return;
        }
        int[] res = new int[array.length];
        int begin = 0, end = array.length - 1;
        for(int i = 0, j = array.length - 1; i < array.length; i++, j--){
            if(isOdd(array[i])){
                res[begin++] = array[i];
            }
            if(!isOdd(array[j])){
                res[end--] = array[j];
            }
        }
        for(int i = 0; i < array.length; i++){
            array[i] = res[i];
        }
    }
    
    private boolean isOdd(int val){
        return (val & 1) == 1;
    }
}
22. 链表中倒数第 K 个结点

【题目】

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

【思路】

双指针

//我的
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if(head == null || k == 0){ // 【错误】：没有考虑到倒数第0个
            return null;
        }
        ListNode p1 = head;
        ListNode p2 = head;
        for(int i = 1; i < k; i++){
            if(p2.next != null){
                p2 = p2.next;
            }else {
                return null;
            }
        }
        while(p2.next != null){
            p1 = p1.next;
            p2 = p2.next;
        }
        return p1;
    }
}
//简洁版
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        ListNode p = head, q = head;
        int i = 0;
        while(q != null){
            if(i >= k){
                p = p.next;
            }
            q = q.next;
            i++;
        }
        return i >= k ? p : null;
    }
}
23. 链表中环的入口结点

【题目】

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

【思路】

双指针：快慢指针

相遇则有环，将快指针指向头节点变慢指针，等待下一次相遇

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

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        if(pHead == null){
            return null;
        }
        ListNode p1 = pHead, p2 = pHead;
        while(p2 != null && p2.next != null){
            p1 = p1.next;
            p2 = p2.next.next;
            if(p1 == p2){
                p2 = pHead;
                while(p1 != p2){
                    p1 = p1.next;
                    p2 = p2.next;
                }
                return p2;
            }
        }
        return null;
    }
}
24. 反转链表

【题目】

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

【思路】

pre 记录前一个节点，初始化为 null，

cur 记录当前节点，初始化为head，

next 用于暂时存储cur的下一个

//单链表
/*
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){
            return head;}
        ListNode pre = null, cur = head, next = null;
        while(cur != null){
            next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}
//双链表
public class Solution{
    public ListNode ReverseBiList(ListNode head){
        ListNode pre = null, cur = head, next = null;
        while(cur != null){
            next = cur.next;
            cur.next = pre;
            cur.prior = next;
            pre = cur;
            cur = next;
        }
    }
}
25. 合并两个排序的链表

【题目】

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

【思路】

面对头节点不确定问题：辅助头节点

/*
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;
        }
        ListNode preHead = new ListNode(-1);
        ListNode pre = preHead;
        while(list1 != null && list2 != null){
            if(list1.val <= list2.val){
                pre.next = list1;
                pre = pre.next;
                list1 = list1.next;
            }else{
                pre.next = list2;
                pre = pre.next;
                list2 = list2.next;
            }
        }
        while(list1 != null){
            pre.next = list1;
            break;  // 【错误处】：没有结束循环
        }
        while(list2 != null){
            pre.next = list2;
            break;
        }
        return preHead.next;
    }
}
25. 树的子结构

【题目】

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

【思路】

二叉树的问题一般都用递归求解

重点是确定最终成功与否的最终状态，即结束条件（递归出口）

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

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        if(root1 == null || root2 == null) return false;
        return doesTree1HasTree2(root1, root2);
    }
    
    private boolean doesTree1HasTree2(TreeNode root1, TreeNode root2){
        //满足结束条件
        if(root2 == null){
            return true;
        }
        if(root1 == null){
            return false;
        }
        
        // 做选择
        if(root2.val == root1.val){
            if (doesTree1HasTree2(root1.left, root2.left) && doesTree1HasTree2(root1.right, root2.right)){
                return true;   //【错误点】：直接return 结果，显示出错，用if正确
            }
        }
        return (doesTree1HasTree2(root1.left, root2) || doesTree1HasTree2(root1.right, root2));
    }
}

1, root2);
}

private boolean doesTree1HasTree2(TreeNode root1, TreeNode root2){
    //满足结束条件
    if(root2 == null){
        return true;
    }
    if(root1 == null){
        return false;
    }
    
    // 做选择
    if(root2.val == root1.val){
        if (doesTree1HasTree2(root1.left, root2.left) && doesTree1HasTree2(root1.right, root2.right)){
            return true;   //【错误点】：直接return 结果，显示出错，用if正确
        }
    }
    return (doesTree1HasTree2(root1.left, root2) || doesTree1HasTree2(root1.right, root2));
}

}
pinger.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer系列——剑指 Offer 58 - II. 左旋转字符串（C/C++/Java语言）
未见花闻的博客
09-10 967
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。 剑指 Offer 58 - II. 左旋转字符串（C语言）
剑指offer:17-20
12-22
【知识点详解】 ...总结，以上三个问题涵盖了数据结构（二叉树和矩阵）和算法（树的遍历、镜像操作、矩阵打印），以及Python编程的基本技巧。理解和掌握这些知识点对于解决更复杂的编程问题至关重要。
LeetCode剑指offer刷题总结---回溯法2
pnnngchg的博客
01-26 371
上一篇写了使用回溯法解决的几道题，这几天又把其他的回溯法的题做了一下。在这里总结一下。由于题目较多，就单独沾代码了，开链接直接看。 从题目要求上来说，主要分为三类： 查找，这类题一般要我们找出所有满足条件的情况，返回一个集合。结果集合作为递归函数的一个参数进行传递。如51. N-Queens，131. Palindrome Partitioning，93. Restore IP Addresse...
剑指 Offer 总结 - leetcode 剑指offer系列
随便发挥的博客
08-31 2828
剑指 Offer 系列完结撒花!! ???????? 本篇文章是对整个系列的精华总结, 对系列的每篇文章进行了分类, 并用一句话概括每道题的思路, 方便大家理解和记忆, 当然也包含原文完整链接供大家参考 总的来说, 写这个系列耗费了我不少精力, 不过我也很开心能和大家分享, 真心希望能对大家有所帮助, 也希望大家能够多多点赞转发和分享, 让更多人看到, 谢谢~ 接下来我需要休整一段时间来准备新的系列了, 中间也可能会有一些不定期更新. 至于新系列是什么呢? 大家敬请期待 ???? P.S.
剑指offer所有编程练习总结分析
热门推荐
张彦峰的博客
07-25 168万+
给出剑指offer所有题目描述和对应的解题思路，并且在最有给出对应的代码展示和测试内容 由于牛客剑指Offer题目经过整理和筛选，是面试备考的经典资源之一，因此它的重要性在面试准备过程中是很高的。做这些题目可以帮助面试者熟悉常见的面试题型、巩固基础知识、提升编程能力，为应对面试提供了很好的准备。然而，还需注意不仅仅局限于做题，理解背后的原理和思想同样重要，以便能够在面试时灵活运用和展示自己的能力。
LeetCode刷题总结 - 剑指offer系列 - 持续更新
qq_45464560的博客
12-24 4431
LeetCode刷题总结
剑指offer-题型总结
ZHE
08-15 810
文章目录数据结构类题目LinkedListTreeStack & QueueHeapHash Table图具体算法类题目搜索算法全排列动态规划回溯排序位运算其他算法 数据结构类题目 LinkedList 003-从尾到头打印链表 014-链表中倒数第k个结点 015-反转链表 016-合并两个或k个有序链表 025-复杂链表的复制 036-两个链表的第一个公共结点 ...
剑指offer--替换空格
_ACME_的博客
04-13 1097
题目： 请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如， 当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。 这个题目其实很简单，没有绕的地方。 但是，做的过程中，发现使用java string的replaceAll方法居然比自己实现的要快很多，接下来就是要深挖一下这个坑。 注：以下分析只针对java，其它语言，例如C/C++可能不适用 ...
剑指Offer学习总结-反转链表
那远远的云端
01-19 1245
剑指Offer学习总结-反转链表 本系列为剑指Offer学习总结，主要是代码案例的分析和实现： 书籍链接：http://product.dangdang.com/24242724.html 原作者博客：http://zhedahht.blog.163.com/blog/static/254111742011101624433132/ 原作者博客链接有完整的项目代码下载。 反转链表
剑指Offer学习总结-重建二叉树
那远远的云端
01-16 811
剑指Offer学习总结-重建二叉树 本系列为剑指Offer学习总结，主要是代码案例的分析和实现： 书籍链接：http://product.dangdang.com/24242724.html 原作者博客：http://zhedahht.blog.163.com/blog/static/254111742011101624433132/ 原作者博客链接有完整的项目代码下载。 重建二
剑指Offer学习总结-替换空格
那远远的云端
01-15 1681
剑指Offer学习总结-替换空格 本系列为剑指Offer学习总结，主要是代码案例的分析和实现： 书籍链接：http://product.dangdang.com/24242724.html 原作者博客：http://zhedahht.blog.163.com/blog/static/254111742011101624433132/ 替换空格 题目 题目： 请实现一个函数， 把
剑指offer--java版1--10源码及解析总结.zip
07-08
《剑指Offer——Java版1-10源码及解析总结》是一份针对《剑指Offer》这本书中前10个编程题目的Java实现及解析的资料合集。《剑指Offer》是许多程序员面试必备的参考书，它涵盖了大量经典的算法和数据结构问题，旨在...
牛客网剑指offer——Java题解.pdf
09-07
本资源总结了牛客网剑指offer Java题解的关键知识点，涵盖了Java基本概念、数据结构和算法等方面的知识。 JZ1 二维数组中的查找 * 题目描述：在一个二维数组中查找指定的整数。 * 解题思路：使用双指针，从右上角...
秒达开源多功能中文工具箱源码：自部署 全开源 轻量级跨平台 GPT级支持+高效UI+Docker
最新发布
09-09
【秒达开源】多功能中文工具箱源码发布：自部署、全开源、轻量级跨平台，GPT级支持+高效UI，Docker/便携版任选，桌面友好+丰富插件生态 这是一款集大成之作，专为追求高效与便捷的用户量身打造。它不仅支持完全自部署，还实现了彻底的开源，确保每一位开发者都能深入了解其内核，自由定制与扩展。 【秒达开源工具箱】以其轻量级的架构设计，实现了在各类设备上的流畅运行，包括ARMv8架构在内的全平台支持，让您无论身处何地，都能享受到同样的便捷体验。我们深知用户需求的多样性，因此特别引入了类似GPT的智能支持功能，让您的操作更加智能、高效。 与此同时，我们注重用户体验，将高效UI与工具箱功能高度集成，使得界面简洁直观，操作流畅自然。为了满足不同用户的部署需求，我们还提供了Docker映像和便携式版本，让您可以根据实际情况灵活选择。 值得一提的是，我们的工具箱还支持桌面版应用，让您在PC端也能享受到同样的强大功能。此外，我们还建立了丰富的开源插件库，不断扩展工具箱的功能边界，让您的工具箱永远保持最新、最全。 【秒达开源】多功能中文工具箱，作为一款永远的自由软件，我们承诺将持续更新、优化，为
双极 AMI 的加扰以及 B8ZS 和 HDB3 加扰simulink.rar
09-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。
C项目开发资源.docx
09-09
对于C/C++项目开发，有许多资源和工具可以帮助开发者提高效率、保证代码质量以及实现项目的自动化构建和部署。以下是一些具体的资源和工具： 1. **集成开发环境(IDE)**: - **CLion**: 专为C和C++开发设计的跨平台IDE，提供了代码分析、调试、版本控制集成等功能。 - **Eclipse CDT**: 基于Eclipse的C/C++开发工具，支持代码补全、调试和项目管理。 - **Visual Studio**: Windows平台上功能强大的IDE，提供了丰富的C++开发支持。 - **Code::Blocks**: 开源的C/C++ IDE，体积小且可定制。 - **KDevelop**: 另一个功能丰富的开源IDE，主要针对Linux平台。 2. **代码编辑器**: - **Visual Studio Code**: 通过C/C++扩展插件，如C/C++插件包，提供智能感知、代码调试等功能。 - **Sublime Text**: 轻量级的文本编辑器，支持大量插件，包括C/C++编译和语法高亮。 3. **编译
基于ssm的在线购物系统的设计与实现设计与实现.docx
09-09
基于ssm的在线购物系统的设计与实现设计与实现.docx
python-对Excel数据处理做可视化分析.zip
09-09
灵敏度分析
《剑指Offer》精华思路总结：42道经典算法题
"《剑指offer》思路汇总---简化版的原书思路共42页，涵盖了数组、字符串、链表、树与二叉树、栈和队列、递归与循环六大主题的算法题目及解题思路，旨在帮助求职者准备面试和提升编程能力。" 这篇文档是《剑指Offer...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值