剑指offer全集系列(1)

news2024/11/24 14:09:27

目录

JZ3 数组中重复的数字

JZ4 二维数组中的查找

JZ5 替换空格

JZ6 从尾到头打印链表

JZ18 删除链表的节点

JZ22 链表中倒数最后k个结点

题目为剑指offer top100题目, 欢迎大家来学习😘

JZ3 数组中重复的数字

数组中重复的数字_牛客题霸_牛客网在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道。题目来自【牛客题霸】https://www.nowcoder.com/practice/6fe361ede7e54db1b84adc81d09d8524?tpId=265&tqId=39207&rp=1&ru=/exam/oj/ta&qru=/exam/oj/ta&sourceUrl=%2Fexam%2Foj%2Fta%3FtpId%3D13&difficulty=undefined&judgeStatus=undefined&tags=&title=

 解法1: 暴力循环

        也就是说, 直接开始从最左边的2开始遍历整个数组, 如果发现有重复的, 就直接返回这个数字, 如果没有重复的, 就选中下一个数字3, 然后开始遍历整个数组. 以此类推, 如果一直到数组最后一个数都没有重复的话就返回-1, 否则返回重复的数.

        此方法没有使用额外的空间, 所以空间复杂度为O(1)
        此方法经历了两层for循环, 每次循环的长度都为数组的长度n, 因此时间复杂度为O(n^2)

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * @param numbers int整型一维数组 
     * @return int整型
     */
    public int duplicate (int[] numbers) {
        for(int i = 0; i < numbers.length; i++) {
            int tem = numbers[i];
            for(int j = i + 1; j < numbers.length; j ++) {
                if (tem == numbers[j]) {
                    return tem;
                }
            }
        }
        return -1;
    }
}

 解法2: 集合Set

        创建一个集合对象, 从0下标开始遍历数组, 每次遍历的时候, 看这个数是否在集合中已经存在, 如果不存在就将这个数添加到集合当中, 如果这个数在集合中已经存在, 就直接返回这个数. 如果遍历完整个数组的时候, 还没有在集合中找到重复的数, 那么就返回-1.

        此方法创建了一个集合, 最坏的情况下需要存储数组里面所有的元素, 因此空间复杂度为O(n)
        此方法只需要遍历一次数组即可, 因此时间复杂度为O(n)

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * @param numbers int整型一维数组 
     * @return int整型
     */
    public int duplicate (int[] numbers) {
        Set<Integer> set = new TreeSet<>();
        for(int i = 0; i < numbers.length; i++) {
            int tem = numbers[i];
            if (set.contains(tem)) {
                return tem;
            }
            set.add(tem);
        }
        return -1;
    }
}

解法3 : 排序和遍历

        根据题目所给的数组的长度为n, 然后这个数组里面的数的取值范围又是[0, n - 1], 也就是说, 如果这个数组里面没有重复的, 那么将这个数组从小到大排序之后, 如果不存在重复的, 那么数组里面的元素大小就应该和它的下标相等, 如果不等, 则说明存在重复的.

        此方法没有使用额外的空间, 因此空间复杂度为O(1)
        此方法需要遍历一次集合或者是排序时间复杂度为O(n)

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param numbers int整型一维数组 
     * @return int整型
     */
    public int duplicate (int[] numbers) {
        if (numbers.length == 0) {
            return -1;
        }
        Arrays.sort((numbers));
        int dele = numbers[0];
        for(int i = 0; i < numbers.length; i++) {
            if ((i + dele) != numbers[i]) {
                return numbers[i];
            }
        }
        return -1;
    }
}

JZ4 二维数组中的查找

二维数组中的查找_牛客题霸_牛客网 (nowcoder.com)https://www.nowcoder.com/practice/abc3fe2ce8e146608e868a70efebf62e?tpId=265&tqId=39208&rp=1&ru=/exam/oj/ta&qru=/exam/oj/ta&sourceUrl=%2Fexam%2Foj%2Fta%3FtpId%3D13&difficulty=undefined&judgeStatus=undefined&tags=&title=

 

 解法1 : 暴力搜索

        一个很简单的方法, 就是, 把里面所有的元素全部都遍历一次, 查找里面是否存在target这个元素, 如果不存在那么就返回false, 如果存在就返回true. 

        由于没有用到额外的空间, 所以空间复杂度为O(1)
        需要遍历整个二维数组, 所以空间复杂度为O(n * m)

此外,对于每一行, 我们除了直接从左到右进行搜索, 还可以进行二分查找, 因为每一行都是有序的.
使用二分查找:
        时间复杂度：O(Mlog N )  时间复杂度将进一步缩小
        空间复杂度：O(1)

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param target int整型 
     * @param array int整型二维数组 
     * @return bool布尔型
     */
    public boolean Find (int target, int[][] array) {
        for(int i = 0; i < array.length; i++) {
            for(int j = 0; j < array[0].length; j++) {
                if (target == array[i][j]) {
                    return true;
                }
            }
        }
        return false;
    }
}

 解法2 : 线性搜索

         建立如图的坐标系, target放在左下角进行搜索, 如图, 假设现在target为7, 从左下角第一个元素6开始比较, target比6大, 往右一个元素继续比较, 也就是继续和8比较, 现在target = 7 比8小, 所以往上一个元素, 也就是和7进行比较, target = 7, 于是返回true.  假设target为3, 根据上图搜索, 依次比较的元素为: 6 -> 4 -> 2 -> 4 -> 2 -> 8, 比较完后, 最后遇到比较的元素的下标出了数组的边界, 也就是变成了-1的时候, 就结束比较.

  • 时间复杂度：O(m+n)，遍历矩阵的时候，最多经过矩阵的一行一列
  • 空间复杂度：O(1)，常数级变量，无额外辅助空间
import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param target int整型 
     * @param array int整型二维数组 
     * @return bool布尔型
     */
    public boolean Find (int target, int[][] array) {
        if (array[0].length == 0) {
            return false;
        }
        // 空间复杂度o(1), 时间复杂度O(m + n)
        int x = 0;
        int y = array.length - 1;
        while (x != array[0].length && y != -1) {
            int now = array[y][x];
            if (target > now) {
                x++;
            } else if (target < now) {
                y--;
            } else {
                return true;
            }
        }
        return false;
    }
}

JZ5 替换空格

替换空格_牛客题霸_牛客网 (nowcoder.com)https://www.nowcoder.com/practice/0e26e5551f2b489b9f58bc83aa4b6c68?tpId=265&tqId=39209&rp=1&ru=/exam/oj/ta&qru=/exam/oj/ta&sourceUrl=%2Fexam%2Foj%2Fta%3FtpId%3D13&difficulty=undefined&judgeStatus=undefined&tags=&title=

        依次遍历字符串, 从字符串的第一个字符开始, 然后新建一个StringBuilder  sb, 如果遍历的字符不是空格则直接将其添加到sb中, 如果是空格, 就添加 %20 到sb中去. 然后返回sb.toString();

  • 时间复杂度O(n)
  • 空间复杂度O(n)
import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param s string字符串 
     * @return string字符串
     */
    public String replaceSpace (String s) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == ' ') {
                sb.append("%20");
            } else {
                sb.append(s.charAt(i));
            }
        }
        return sb.toString();
    }
}

JZ6 从尾到头打印链表

从尾到头打印链表_牛客题霸_牛客网 (nowcoder.com)https://www.nowcoder.com/practice/d0267f7f55b3412ba93bd35cfa8e8035?tpId=265&tqId=39210&rp=1&ru=/exam/oj/ta&qru=/exam/oj/ta&sourceUrl=%2Fexam%2Foj%2Fta%3FtpId%3D13&difficulty=undefined&judgeStatus=undefined&tags=&title= 

方法一: 使用数组来记录链表里面所有的元素, 然后新建一个链表, 将数组里面的元素反向添加到新建的链表中去.

  • 空间复杂度为O(n)
  • 时间复杂度为O(n)
import java.util.*;
/**
*    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) {
        int[] arr = new int[10000];
        int size = 0;
        ListNode tem = listNode;
        while (tem != null) {
            arr[size++] = tem.val;
            tem = tem.next;
        }
        ArrayList<Integer> list = new ArrayList<>();
        for(int i = size - 1; i >= 0; i--) {
            list.add(arr[i]);
        }
        return list;
    }
}

 方法二: 使用堆栈, 其实总体上的思想其实和方法一差不多的, 只是换了一个形式.

  • 时间复杂度为O(n)
  • 空间复杂度为O(n)
import java.util.*;
/**
*    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) {
        Stack<Integer> stack = new Stack<>();
        ListNode tem = listNode;
        while (tem != null) {
            stack.push(tem.val);
            tem = tem.next;
        }
        ArrayList<Integer> list = new ArrayList<>();
        while (!stack.isEmpty()) {
            int topElement = stack.pop();
            list.add(topElement);
        }
        return list;
    }
}

方法三: 递归, 既然我们正向不能直接得出结果, 那我们就可以使用递归, 先将标记结点递归到最后一位, 然后从最后一位开始反方向遍历元素:

  • 时间复杂度为O(n) 
  • 空间复杂度为O(n)
import java.util.*;
/**
*    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<Integer> list = new ArrayList<>();
        function(list, listNode);
        return list;
    }

    public static void function(ArrayList<Integer> list, ListNode node) {
        if (node == null) {
            return;
        }
        function(list, node.next);
        list.add(node.val);
    }
}

JZ18 删除链表的节点

删除链表的节点_牛客题霸_牛客网 (nowcoder.com)https://www.nowcoder.com/practice/f9f78ca89ad643c99701a7142bd59f5d?tpId=265&tqId=39280&rp=1&ru=/exam/oj/ta&qru=/exam/oj/ta&sourceUrl=%2Fexam%2Foj%2Fta%3FtpId%3D13&difficulty=undefined&judgeStatus=undefined&tags=&title= 

        这题比较简单, 我们直接使用遍历 然后删除结点即可, 也就是使用双指针的形式, 一个指针用来记录后面的结点, 方式丢失, 一个指针用来连接记录结点. 但是要注意空指针的问题. 以及元素比较少的时候该怎么判断.

  • 时间复杂度O(n)
  • 空间复杂度O(1)
import java.util.*;

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

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @param val int整型 
     * @return ListNode类
     */
    public ListNode deleteNode (ListNode head, int val) {
        ListNode l = head;
        ListNode r = head.next;
        if (l.val == val) {
            return head.next;
        }
        while (r != null) {
            if (r.val == val) {
                l.next = r.next;
                break;
            }
            r = r.next;
            l = l.next;
        }
        return head;
    }
}

JZ22 链表中倒数最后k个结点

链表中倒数最后k个结点_牛客题霸_牛客网 (nowcoder.com)https://www.nowcoder.com/practice/886370fe658f41b498d40fb34ae76ff9?tpId=265&tqId=39224&rp=1&ru=/exam/oj/ta&qru=/exam/oj/ta&sourceUrl=%2Fexam%2Foj%2Fta%3FtpId%3D13&difficulty=undefined&judgeStatus=undefined&tags=&title= 

方法一: 直接遍历, 利用性质, 先遍历出链表里面所有的元素的总个数, 然后再计算出需要走的步数, 

import java.util.*;

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

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    public ListNode FindKthToTail (ListNode pHead, int k) {
        int size = 0;
        ListNode tem = pHead;
        while (tem != null) {
            size ++;
            tem = tem.next;
        }
        if (size < k) {
            return null;
        }
        for(int i = 0; i < size - k; i++) {
            pHead = pHead.next;
        }
        return pHead;
    }
}

 方法二: 快慢指针, 一个快一个慢:

import java.util.*;

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

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    public ListNode FindKthToTail (ListNode pHead, int k) {
        ListNode slow = pHead;
        ListNode fast = pHead;
        if (slow == null) {
            return null;
        }
        for(int i = 0; i < k; i++) {
            fast = fast.next;
            if (i != k - 1 && fast == null) {
                return null;
            }
        }
        while (fast != null) {
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

方法三 : 使用堆栈, 将所有的结点, 从pHead开始, 全部压入栈中, 然后取出第k个结点, 就是倒数第k个结点了:

import java.util.*;

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

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    public ListNode FindKthToTail (ListNode pHead, int k) {
        // write code here
        Stack<ListNode> stack = new Stack<>();
        while (pHead != null) {
            stack.push(pHead);
            pHead = pHead.next;
        }
        if (stack.isEmpty()) {
            return null;
        }
        ListNode result = null;
        for(int i = 0; i < k; i++) {
            result = stack.pop();
            if (i != k - 1 && stack.isEmpty()) {
                return null;
            }
        }
        return result;
    }
}

剑指offer 的图像结果

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/904577.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

centos7安装virtualbox

centos7安装virtualbox

在线安装 vi /etc/yum.repos.d/virtualbox.repo&#xff0c;复制后将下面内容编辑保存。 [virtualbox] nameOracle Linux / RHEL / CentOS-$releasever / $basearch - VirtualBox baseurlhttp://download.virtualbox.org/virtualbox/rpm/el/$releasever/$basearch enabled1 …
阅读更多...
DeFINE：用于神经序列建模的深度分解输入令牌嵌入

DeFINE：用于神经序列建模的深度分解输入令牌嵌入

一、说明 DeFINE&#xff0c;是华盛顿大学和艾伦人工智能开发的自然语言处理工具&#xff0c;可以处理的范围是&#xff1a;NLP、语言模型、LM、神经机器翻译、NMT、变压器、变压器-XL等&#xff1b;本文对token-bedding进行生成。 借助DeFINE&#xff0c;Transformer-XL可以在…
阅读更多...
【深度学习评价指标】多标签分类，如何计算准确率，精确率，召回率，F1-Score？

【深度学习评价指标】多标签分类，如何计算准确率，精确率，召回率，F1-Score？

from&#xff1a; https://zhuanlan.zhihu.com/p/420436876
阅读更多...
RHCE——三、远程连接服务器

RHCE——三、远程连接服务器

远程连接服务器 一、远程连接服务器1、概念2、功能3、分类文字接口图形接口 二、文字接口连接服务器:三、连接加密技术简介密钥解析 四、SSH工作过程1、版本协商阶段2、密钥和算法协商阶段3、认证阶段(两种认证方法) 五、SSH服务配置1、安装ssh2、配置文件分析 六、ssh实验1、实…
阅读更多...
Linux系统简介

Linux系统简介

文章目录 1. UNIX与Linux发展史1.1 UNIX发展史1.2 Linux发展史1.2.1 Linux内核版本1.2.2 Linux主要发行版本 2. 开源软件简介2.1 典型的开源软件2.2 开源软件的特点2.3 支撑互联网的开源技术 3. Linux应用领域3.1 基于Linux的企业服务器3.2 嵌入式应用3.3 Linux在电影娱乐业 4.…
阅读更多...
在线SHA1加密工具--在线获取哈希值又称摘要

在线SHA1加密工具--在线获取哈希值又称摘要

具体请前往&#xff1a; 在线计算Sha1摘要工具
阅读更多...
使用open cv进行角度测量

使用open cv进行角度测量

使用open cv进行角度测量 用了一点初中数学的知识&#xff0c;准确度&#xff0c;跟鼠标点的准不准有关系&#xff0c;话不多说直接上代码 import cv2 import mathpath "test.jpg" img cv2.imread(path) pointsList []def mousePoint(event, x, y, flags, param…
阅读更多...
Python批量爬虫下载PDF文件代码实现

Python批量爬虫下载PDF文件代码实现

本文的背景是&#xff1a;大学关系很好的老师问我能不能把Excel中1000个超链接网址对应的pdf文档下载下来。虽然可以手动一个一个点击下载&#xff0c;但是这样太费人力和时间了。我想起了之前的爬虫经验&#xff0c;给老师分析了一下可行性&#xff0c;就动手实践了。    没…
阅读更多...
第一讲：BeanFactory和ApplicationContext接口

第一讲：BeanFactory和ApplicationContext接口

BeanFactory和ApplicationContext接口 1. 什么是BeanFactory?2. BeanFactory能做什么&#xff1f;3.ApplicationContext对比BeanFactory的额外功能?3.1 MessageSource3.2 ResourcePatternResolver3.3 EnvironmentCapable3.4 ApplicationEventPublisher 4.总结 1. 什么是BeanF…
阅读更多...
docker的资源控制及数据管理

docker的资源控制及数据管理

docker的资源控制及docker数据管理 一.docker的资源控制 1.CPU 资源控制 1.1 资源控制工具 cgroups&#xff0c;是一个非常强大的linux内核工具&#xff0c;他不仅可以限制被 namespace 隔离起来的资源&#xff0c; 还可以为资源设置权重、计算使用量、操控进程启停等等。 …
阅读更多...
面试汇总-testcase

面试汇总-testcase

朋友圈点赞的测试用例 功能测试 1点赞后是否显示结果 2.点赞后是否可以取消; 3.点赞取消后是否可以重复点赞; 4.共同好友点赞后&#xff0c;是否有消息提醒; 5.非共同好友点赞后&#xff0c;是否有消息提醒; 6.点击点赞人昵称&#xff0c;是否可以跳转到他/她的主页; 7.自己能…
阅读更多...
对象头的结构

对象头的结构

一、对象头的结构(32位虚拟机) 1、普通对象 普通对象头占用64 bits &#xff0c;其中Mark word占32 bits &#xff0c;Klass Words 占32bits。Klass Words 可以理解为指针&#xff0c;指向类对象。Mark Word下面会详解。 2、数组对象 数组对象增加了4个字节的空间&#xff0c;…
阅读更多...
百度许少辉著Baidu《乡村振兴战略下传统村落文化旅游设计》图书馆新书通报

百度许少辉著Baidu《乡村振兴战略下传统村落文化旅游设计》图书馆新书通报

百度许少辉著Baidu《乡村振兴战略下传统村落文化旅游设计》图书馆新书通报
阅读更多...
【C语言学习】二维数组

【C语言学习】二维数组

二维数组 int[3][5];//通常理解为a是一个3行5列的矩阵二维数组的遍历 for(i0; i<3; i){for(j0; j<5; j){a[i][j] i*j;} }
阅读更多...
删除链表中的节点（力扣）

删除链表中的节点（力扣）

目录 题目&#xff1a; 看着花里胡哨&#xff0c;小卡拉米四行代码秒杀&#xff01; 示例&#xff1a; 思路&#xff1a; 代码&#xff1a; 题目&#xff1a; 看着花里胡哨&#xff0c;小卡拉米四行代码秒杀&#xff01; 示例&#xff1a; 思路&#xff1a; 把后一个节点的…
阅读更多...
多线程实现与管理

多线程实现与管理

进程与线程 进程 &#xff1a; 进程是操作系统进行资源分配的最小单位&#xff0c;每执行一个程序、一条命令操作系统都会启动一个进程&#xff0c;进程是一个程序的执行过程&#xff0c;当程序启动时&#xff0c;操作系统会把进程的代码加载到内存中&#xff0c;并为新进程分配…
阅读更多...
Python爬虫——scrapy_日志信息以及日志级别

Python爬虫——scrapy_日志信息以及日志级别

日志级别&#xff08;由高到低&#xff09; CRITICAL&#xff1a; 严重错误 ERROR&#xff1a; 一般错误 WARNING&#xff1a; 警告 INFO&#xff1a; 一般警告 DEBUG&#xff1a; 调试信息 默认的日志等级是DEBUG 只要出现了DEBUG或者DEBUG以上等级的日志&#xff0c;那么这些…
阅读更多...
开集输出和开漏输出

开集输出和开漏输出

​​​​​​ 首先指明一下以下8中GPIO输入输出模式&#xff1a; GPIO_Mode_AIN 模拟输入&#xff1b; GPIO_Mode_IN_FLOATING 浮空输入&#xff1b; GPIO_Mode_IPD 下拉输入&#xff1b; GPIO_Mode…
阅读更多...
JVM面试题-2

JVM面试题-2

1、有哪几种垃圾回收器&#xff0c;各自的优缺点是什么&#xff1f; 垃圾回收器主要分为以下几种&#xff1a;Serial、ParNew、Parallel Scavenge、Serial Old、Parallel Old、CMS、G1&#xff1b; Serial:单线程的收集器&#xff0c;收集垃圾时&#xff0c;必须stop the worl…
阅读更多...
RPM包的概念以及制作过程

RPM包的概念以及制作过程

RPM包的概念以及制作过程 1. 软件包管理工具的背景介绍2. RPM&#xff08;Red-Hat Package Manager&#xff09;2.1 rpm包的命名规范2.2 rpm的基础命令2.3 安装与卸载 3. RPM包的制作3.1 源码包的制作3.2 .spec配置文件的构建3.3 rpmbuild命令编译验证 4. 软件仓库制作4.1 安装…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023