【Java版本】剑指offer所有面试题(完整版题解3)

已于 2022-04-25 08:55:21 修改
阅读量701 收藏 1
点赞数
分类专栏： java 数据结构 算法 文章标签： 算法 数据结构 java
于 2022-04-24 16:47:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43167873/article/details/124386574
版权
java 同时被 3 个专栏收录
90 篇文章 31 订阅
订阅专栏
算法
33 篇文章 1 订阅
订阅专栏
数据结构
29 篇文章 3 订阅
订阅专栏
本文介绍了多种链表操作，包括调整数组顺序使奇数位于偶数前面，链表中倒数第k个节点的查找，检测链表环的入口节点，链表的反转以及合并两个已排序链表。同时，还涵盖了矩阵的顺时针打印和一个支持min功能的栈实现。
摘要由CSDN通过智能技术生成

文章目录

第二十一题-调整数组顺序使奇数位于偶数

image-20220413083641931

public class Test14 {
    public static void reorderOddEven(int[] arr){
        if(arr == null || arr.length < 2) return;
        int start = 0;
        int end = arr.length-1;
        while(start < end){
            while(start <end && arr[start] % 2 !=0)
                start ++;
            while(start < end && arr[end] %2==0)
                end --;
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }
    public static void  printArray(int[] arr){
        if (arr == null || arr.length == 0) return;
        for(int i : arr){
            System.out.print(i + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] array = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        reorderOddEven(array);
        printArray(array);
    }
}

第二十二题-链表中倒数第k个节点

image-20220413085431626

public class Test15 {
    public static ListNode findKthToTail(ListNode head,int k){

        if(k < 1 || head==null) return null;
        ListNode node1 = head;
        ListNode node2 = head;
        for(int i = 0;i<k-1;i++){
            if(node1 != null)
                node1 = node1.next;
            else return null;
        }
        while(node1.next != null){
            node1 = node1.next;//找到最后一个节点的位置
            node2 = node2.next;
        }
        return node2;
    }

    public static void main(String[] args) {


        ListNode head = new ListNode();
        head.val = 1;

        head.next = new ListNode();
        head.next.val = 2;

        head.next.next = new ListNode();
        head.next.next.val = 3;

        head.next.next.next = new ListNode();
        head.next.next.next.val = 4;

        ListNode middle = head.next.next.next.next = new ListNode();
        head.next.next.next.next.val = 5;

        head.next.next.next.next.next = new ListNode();
        head.next.next.next.next.next.val = 6;

        ListNode last = head.next.next.next.next.next.next = new ListNode();
        head.next.next.next.next.next.next.val = 7;

        System.out.println(findKthToTail(head, 7).val);
        System.out.println(findKthToTail(head, 3).val);

    }
}

第二十三题-链表中环的入口节点

image-20220423091500122

·

import java.util.List;

public class Test24_1 {
    public static ListNode meetingNode(ListNode head){
        ListNode fast = head;
        ListNode slow = head;

        while(fast != null && slow != null){
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) break;
        }
        if (fast == null || fast.next == null) return null; //没有环

        fast = head;
        while (fast != slow){
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
    }

    public static void main(String[] args) {
        // 1->2->3->4->5->6
        //       ^        |
        //       |        |
        //       +--------+
        ListNode n1 = new ListNode(1);
        ListNode n2 = new ListNode(2);
        ListNode n3 = new ListNode(3);
        ListNode n4 = new ListNode(4);
        ListNode n5 = new ListNode(5);
        ListNode n6 = new ListNode(6);

        n1.next = n2;
        n2.next = n3;
        n3.next = n4;
        n4.next = n5;
        n5.next = n6;
        n6.next = n3;

        System.out.println(meetingNode(n1).val);
    }
}

第二十四题-反转链表

image-20220413090648636

public class Test16 {
    public static ListNode reverse(ListNode cur){
        ListNode pre = null;
        while (cur != null){
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }

    public static void printList(ListNode head){
        ListNode temp = head;
        while (temp != null){
            System.out.println(temp.val);
            temp = temp.next;
        }
    }
    public static void main(String[] args) {


        ListNode head = new ListNode();
        head.val = 1;

        head.next = new ListNode();
        head.next.val = 2;

        head.next.next = new ListNode();
        head.next.next.val = 3;

        head.next.next.next = new ListNode();
        head.next.next.next.val = 4;

        ListNode middle = head.next.next.next.next = new ListNode();
        head.next.next.next.next.val = 5;

        head.next.next.next.next.next = new ListNode();
        head.next.next.next.next.next.val = 6;

        ListNode last = head.next.next.next.next.next.next = new ListNode();
        head.next.next.next.next.next.next.val = 7;
        ListNode reverse = reverse(head);
        printList(reverse);

    }
}

第二十五题-合并两个链表

image-20220413093345469

public class Test17 {
    public static ListNode merge(ListNode head1,ListNode head2){
        if(head1 == null) return head2;
        if(head2 == null) return head1;
        ListNode root = new ListNode();
        ListNode temp = root;
        while(head1 != null && head2 != null){
            if(head1.val < head2.val) {
                temp.next = head1;
                head1 = head1.next;

            }else{
                temp.next = head2;
                head2 = head2.next;
            }
            temp = temp.next;
        }
        if(head1 != null) temp.next = head1;
        if(head2 != null) temp.next = head2;

        return root.next;
    }

    public static ListNode merge2(ListNode head1,ListNode head2){
        if(head1 == null) return head2;
        if(head2 == null) return head1;
        if(head1.val < head2.val) {
            head1.next = merge2(head1.next,head2);
            return head1;
        }
        else {
            head2.next = merge2(head1,head2.next);
            return head2;
        }

    }


    public static void printList(ListNode head){
        ListNode temp = head;
        while (temp != null){
            System.out.print(temp.val);
            temp = temp.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        ListNode head = new ListNode();
        head.val = 1;

        head.next = new ListNode();
        head.next.val = 3;

        head.next.next = new ListNode();
        head.next.next.val = 5;

        head.next.next.next = new ListNode();
        head.next.next.next.val = 6;

        ListNode middle = head.next.next.next.next = new ListNode();
        head.next.next.next.next.val = 7;

        ListNode head2 = new ListNode();
        head2.val = 2;

        head2.next = new ListNode();
        head2.next.val = 4;

        head2.next.next = new ListNode();
        head2.next.next.val = 8;

        head2.next.next.next = new ListNode();
        head2.next.next.next.val = 9;

        ListNode middle2 = head.next.next.next.next = new ListNode();
        head.next.next.next.next.val = 10;

        //ListNode merge = merge(head, head2);
        ListNode merge2 = merge2(head,head2);
        //printList(merge);
        printList(merge2);

    }
}

第二十六题-树的结构

image-20220413101656182

public class Test18 {
    public static boolean hasSubtree(TreeNode root1,TreeNode root2){
        if(root1 == root2) return true; 
        if(root2 == null) return true;
        if(root1 == null) return false;
        boolean res = false;
        // 如果结点的值相等就，调用匹配方法
        if(root1.val == root2.val) res = mach(root1,root2);
        if(res) return true; //如果匹配成功 返回
        return hasSubtree(root1.left,root2) || hasSubtree(root1.right,root2); //匹配失败。找下一个相等的节点继续匹配
    }
    public static boolean mach(TreeNode root1,TreeNode root2){
        if(root1 == root2) return true;
        if(root2 == null) return true;
        if(root1 == null) return false;
		//匹配根节点下的所有左右子树
        if(root1.val == root2.val) return mach(root1.left,root2.left) && mach(root1.right,root2.right);

        return false;
    }

    public static void main(String[] args) {
        TreeNode root1 = new TreeNode();
        root1.val = 8;
        root1.right = new TreeNode();
        root1.right.val = 7;
        root1.left = new TreeNode();
        root1.left.val = 8;
        root1.left.left = new TreeNode();
        root1.left.left.val = 9;
        root1.left.right = new TreeNode();
        root1.left.right.val = 2;
        root1.left.right.left = new TreeNode();
        root1.left.right.left.left = new TreeNode();
        root1.left.right.left.left.val = 3;
        root1.left.right.left.right = new TreeNode();
        root1.left.right.left.right.val = 8;

        TreeNode root2 = new TreeNode();
        root2.val = 8;
        root2.left = new TreeNode();
        root2.left.val = 9;
        root2.right = new TreeNode();
        root2.right.val = 2;

        System.out.println(hasSubtree(root1, root2));
        System.out.println(hasSubtree(root2, root1));
        System.out.println(hasSubtree(root1, root1.left));
        System.out.println(hasSubtree(root1, null));

    }
}

第二十七题-二叉树的镜像

image-20220413103550194

public class Test19 {
    public static TreeNode mirror(TreeNode node){
        if(node == null) return null;
        mirror(node.left);
        mirror(node.right);
        swap(node);
        return node;

    }
    public static  void swap(TreeNode node){
        TreeNode temp = node.left;
        node.left = node.right;
        node.right = temp;
    }

    public static void printTreeNode(TreeNode node){
        if (node != null) {
            System.out.print(node.val + " ");
            printTreeNode(node.left);
            printTreeNode(node.right);
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode();
        root.val = 1;
        root.left = new TreeNode();
        root.left.val = 2;
        root.right = new TreeNode();
        root.right.val = 3;
        root.left.left = new TreeNode();
        root.left.left.val = 4;
        root.left.right = new TreeNode();
        root.left.right.val = 5;
        root.right.left = new TreeNode();
        root.right.left.val = 6;
        root.right.right = new TreeNode();
        root.right.right.val = 7;
        printTreeNode(root);
        System.out.println();
        TreeNode mirror = mirror(root);
        printTreeNode(mirror);

    }
}

第二十八题-对称二叉树

public class Test28_1 {
    public static boolean  isSymmetrical(TreeNode root){
        return isSymmetrical(root,root);
    }

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

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

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

    public static void main(String[] args) {
        TreeNode root = new TreeNode();
        root.val = 1;
        root.left = new TreeNode();
        root.left.val = 2;
        root.right = new TreeNode();
        root.right.val = 3;
        root.left.left = new TreeNode();
        root.left.left.val = 4;
        root.left.right = new TreeNode();
        root.left.right.val = 5;
        root.right.left = new TreeNode();
        root.right.left.val = 6;
        root.right.right = new TreeNode();
        root.right.right.val = 7;

        System.out.println(isSymmetrical(root));
    }
}

第二十九题-顺时针打印矩阵

image-20220413110933936

image-20220413111007304

public class Test20 {
    public static void printMatrixClockWisely(int[][] numbers){
        if (numbers == null) return;
        int x = 0;
        int y = 0;
        //最后一圈起始的行号列号
        //（number-1）/2
        //一共（number-1）/2
        while(x*2 < numbers.length && y*2<numbers.length){
            printMatrixCircle(numbers,x,y);
            x++;
            y++;
        }
    }
    public static void printMatrixCircle(int[][] numbers,int x,int y){
        //数组行数
        int row = numbers.length;
        //数组列数
        int col = numbers.length;
        int i= x;
        int j = y;
        //输出上面的一行
        for(;j<col-y;j++) System.out.print(numbers[i][j]+" ");
        if (row-x-1>x){
            //输出右边的一行
            for(i = x+1;i<row-x;i++) System.out.print(numbers[i][j-1]+ " ");
        }
        if (col-y-1 >y && row-x-1>x){
            //输出下面的一行
            for(j=col-y-2;j>=y;j--) System.out.print(numbers[i-1][j] + " ");
        }
        if (row-x-2>x & col-y-1 >y){
            //输出左边一行
            for (i=row-x-2;i>x;i--) System.out.print(numbers[i][j+1] + " ");
        }
    }

    public static void main(String[] args) {
        int[][] numbers = {
                {1, 2, 3, 4, 5},
                {16, 17, 18, 19, 6},
                {15, 24, 25, 20, 7},
                {14, 23, 22, 21, 8},
                {13, 12, 11, 10, 9},
        };
        printMatrixClockWisely(numbers);
        System.out.println();
    }
}

第三十题-包含min函数的栈

image-20220414090623640

import java.util.Stack;

public class Test21 {
    public static class StackWithMin<T extends Comparable<T>>{
        private Stack<T> dataStack;
        private Stack<T> minStack;

        public StackWithMin() {
            dataStack = new Stack<>();
            minStack = new Stack<>();
        }

        public T pop(){
            if (dataStack.isEmpty()){
                throw new RuntimeException("IS Empty");
            }
            // 如果有数据，最小数位置栈和数据栈必定是有相同的元素个数，
            // 两个栈同时出栈
            minStack.pop();
            return dataStack.pop();
        }

        public void push(T t){
            if (t == null) throw new RuntimeException("can not be null");
            if(dataStack.isEmpty()){
                dataStack.push(t);
                minStack.push(t);
            }else{
                dataStack.push(t);
                T temp = minStack.peek();
                if(temp.compareTo(t) > 0){
                    minStack.push(t);
                    // 插入的元素不比原来的最小元素小，复制最小栈栈顶元素，将其入栈
                }else minStack.push(minStack.peek());
            }
        }

        public T min(){
            if (minStack.isEmpty()) throw new RuntimeException("No element in stack.");
            return minStack.peek();
        }
    }
    public static void main(String[] args) {
        StackWithMin<Integer> stack = new StackWithMin<>();
        stack.push(3);
        System.out.println(stack.min());
        stack.push(4);
        System.out.println(stack.min());
        stack.push(2);
        System.out.println(stack.min());
        stack.push(3);
        System.out.println(stack.min());
        stack.pop();
        System.out.println(stack.min());
        stack.pop();
        System.out.println(stack.min());
        stack.push(0);
        System.out.println(stack.min());
    }
}

小七rrrrr
关注
专栏目录
剑指Offer —— 面试题（十四）
想要进大厂的螺丝钉的博客
07-19 604
由于Handler消息的延时发送持有Handler对象，内部类持有外部类导致内存泄漏，所以我们可以将Handler定义成静态的内部类，在内部持有Activity的弱引用，并在Acitivity的onDestroy()中调用handler.removeCallbacksAndMessages(null)及时移除所有消息。存储消息的顺序时按照时间先后顺序来存储的，它是先进先出的，只是这里的先依据的不是谁先入队，而是消息待发送的时间。.........
剑指Offer —— 面试题（一）
想要进大厂的螺丝钉的博客
07-07 173
秋招面试题
剑指offer 面试题
John的博客
05-02 3813
# 这两天通过做作业接触了《剑指offer》 这本书；觉得里面的面试题真是异常经典，当你看到那一道一道面试题时，对自我的做题笔试能力肯定会大有脾益！ # 平常可以多做练习，养成一个习惯！好了，废话不多说了，直接上题吧！  我已经感到饥渴难耐了！ # 第一道： /*剑指offer 面试题14：调整数组使奇数全部都位于偶数前面。 题目： 输入一个整数数组，实现一个函数
【一刷《剑指Offer》】面试题 33：把数组排成最小的数
Elena's Blog
07-20 338
我们将说法换一下，对于本题而言，我们要的有效序列是：序列中任何一个元素 y，和它前的任何一个元素 x 进行有序组合形成 xy，比和他后面的任何一个元素z进行有效序列组合 yz，满足条件 xy < yz（采用字典序列排序），如 {32，31}，有效组合是 3132，所以我们拍完序列之后序列变成 {31，32}。可以采用字符串来表示数字，这样就能简洁地解决大数问题。这道题的核心理解是对于排序算法的理解。通常我们所理解的排序是比较大小的，比如：升序排序的序列意思是：序列中任何一个数字都比前面的小，比后面的大。
剑指offer面试题
鲍礼彬的CSDN博客 ~_~
03-05 1058
剑指offer的java版本实现。 完整代码请看github： 地址：https://github.com/baolibin/offer 以后有时间出版c语言实现的版本。
剑指offer面试题(一)
微风
05-08 1263
剑指offer是一本讲了五十多道经典面试题的书，从今天开始一天一道，希望自己坚持下去，加油！
面试高频算法题总结-剑指Offer题解
最新发布
09-01
面试高频算法题总结-剑指Offer题解，主要包含： 数据结构 数组 字符串 链表 栈和队列 二叉树 图 堆 线段树 字典树 单调栈 算法 二分查找 排序 递归 动态规划 分治 记忆化搜索 贪心 回溯 位运算 数学 设计 其他 共66...
剑指offer面试题python题解（做题记录）.zip
11-14
python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 ...
剑指offer题目题解java版+c++版+Python版.zip
07-15
《剑指Offer》是一本备受推崇的编程面试指南，它汇集了众多知名互联网公司的面试题，旨在帮助求职者提升算法和编程能力。本压缩包包含了该书中的题目及其解法，分别以Java、C++和Python三种编程语言实现。下面我们将...
剑指offer题解(C++).docx
07-17
《剑指Offer题解》是针对面试准备的一份宝贵资源，由Sidney.Tan精心整理，结合了牛客网上的讨论、《剑指Offer》书中的解法以及个人的编程实践，提供了全面的代码和思路解析。这份文档按照牛客网上的题目顺序，覆盖了...
[剑指offer] JAVA版题解（完整版）
热门推荐
尾尾部落
08-16 6万+
本文首发于我的个人博客：尾尾部落 序号 题解 牛客 OJ 数据结构类型 03 [剑指offer] 二维数组中的查找 二维数组中的查找 数组 04 [剑指offer] 替换空格 替换空格 字符串 05 [剑指offer] 从尾到头打印链表 从尾到头打印链表 链表 06 [剑指offer] 重建二...
剑指offer面试题01
小唐同学的博客
08-07 223
简介 做一下面试的准备，开始搞一下算法题，把剑指offer的题都搞一下 题目 1.数组中重复的数字 offer.03 找出数组中重复的数字 题目描述： 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。 我的想法 我自己是这样想的，利用set中的值只能存在一个，再次添加时返回false的特性，找到重复的数字，代码如下： class Solution { pub
【Java版本】剑指offer所有面试题(题解总汇)
小七自学博客
04-24 392
所有代码下载地址：https://gitee.com/nian_xiaoqi/sword-finger-offer.git 2-10题: 【Java版本】剑指offer所有面试题(完整版题解1). 11-20题: 【Java版本】剑指offer所有面试题(完整版题解2). 21-30题: 【Java版本】剑指offer所有面试题(完整版题解3). 31-40题: 【Java版本】剑指offer所有面试题(完整版题解4). 41-50题: 【Java版本】剑指offer所有面试题(完整版题解5). 51-65
【剑指offer】面试题集锦
qq_42397330的博客
06-20 170
数据结构 数组 字符串 链表 树 栈和队列 算法
剑指Offer面试题25java版
隔海前尘
04-23 201
题目：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。 分析：此题分为递归和非递归 非递归版本：public class Solution { public ListNode Merge(ListNode list1,ListNode list2) { ListNode result = null; ListNo
剑指offer中的面试题汇总
u010505080的博客
03-29 240
剑指offer书中的面试题，目前只更新了50题，都是一个一个自己写了又对着源码敲一遍，自己写的就不贴出来了，看书本自带源码，方便以后回过头来看看： // 面试题3（一）：找出数组中重复的数字 // 题目：在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字重复了， // 也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。例如，如果...
【Java版本】剑指offer所有面试题(完整版题解4)
小七自学博客
04-24 652
文章目录第三十一题-栈的压入、弹出序列第三十二题-从上往下打印二叉树第三十三题-二叉搜索树的后序遍历序列第三十四题-二叉树中和为某一值的路径第三十五题-复杂链表的复制第三十六题-二叉搜索树与双向链表第三十七题-序列化二叉树第三十八题-字符串的排列第三十九题-数组中出现次数超过一半的数字第四十题-最小的k个数 第三十一题-栈的压入、弹出序列 import java.util.Stack; public class Test22 { public static boolean isPopOrder(
【Java版本】剑指offer所有面试题(完整版题解5)
小七自学博客
04-24 333
文章目录第四十一题-数据流中的中位数第四十二题-连续子数组的最大的和第四十三题-从1到n整数中1出现的次数第四十四题-数字序列中的某一位的数字第四十五题-把数组排成最小的数第四十六题-把数字翻译成字符串第四十七题-礼物的最大值第四十八题-最长不含重复字符的子字符串第四十九题-丑数第五十题-第一个只出现一次的字符 第四十一题-数据流中的中位数 ​ 由于数据是从一个数据流中读出来的，数据的数目随着时间的变化而增加。如果用一个数据容器来保存从流中读出来的数据，当有新的数据流中读出来时，这些数据就插入到数据容器
【Java版本】剑指offer所有面试题(完整版题解1)
小七自学博客
04-24 1106
剑指offer 文章目录剑指offer第二题-单例模式第一种第二种第三种第四种第五种第六种第七种全部代码第三题-数组中重复的数字第四题-二维数组中的查找第五题-替换空格第六题-从尾到打印链表第七题-重构二叉树第八题-二叉树的下一个节点第九题-使用两个栈实现队列第十一题-旋转数组的最小数字第十题-斐波契那数列第十二题-矩阵中的路径第十三题-机器人的运动范围第十四题-剪绳子第十五题：二进制中1的个数第十六题-数值的整数次方第十七题-打印1到最大的n位数第十八题-在O(1)时间删除链表节点第十九题-正则表达式匹配
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小七rrrrr

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值