剑指offer_java_1-10

最新推荐文章于 2024-07-21 21:08:59 发布
最新推荐文章于 2024-07-21 21:08:59 发布
阅读量71 收藏
点赞数
分类专栏： 剑指offer 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42358663/article/details/104975287
版权

在这里插入图片描述

  1. 略
  2. 设计一个类，我们只能生成该类的一个实例。
/**
 * @author yangfan
 * @date 2020/3/19 14:43
 * @description 实现Singleton模式
 * 题目：设计一个类，我们只能生成该类的一个实例。
 */
public class B {
    private static class BHodler{
        private static final B INSTANCE = new B();
    }

    private static B getInstance(){
        return BHodler.INSTANCE;
    }
}
  1. 二维递增数组中的查找
/**
 * @author yangfan
 * @date 2020/3/19 15:23
 * @description 二维递增数组中的查找
 */
public class C {
    
    /**
     * @param array
     * @param target
     * @return void
     * @description 从左下或右上开始查找
     */
    private static void find(int[][] array, int target) {
        if (array == null || array.length == 0) {
            return;
        }
        int row = 0;
        int column = array[0].length - 1;
        while (row < array.length && column >= 0) {
            if (array[row][column] == target)
                System.out.println(row + " " + column);
            if (array[row][column] > target)
                column--;
            else
                row++;

        }
    }

    public static void main(String[] args) {
        int[][] array = new int[][]{
                {1, 2, 8, 9},
                {2, 4, 9, 12},
                {4, 7, 10, 13},
                {6, 8, 11, 15}
        };
        find(array,10);

    }

    private void show(int[][] array) {
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
    }
}
  1. 替换字符串中的空格
/**
 * @author yangfan
 * @date 2020/3/19 15:49
 * @description 替换字符串中的空格
 */
public class D {

    private static void replaceSpace(String str) {
        if (str == null)
            return;

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            if (String.valueOf(str.charAt(i)).equals(" ")) {
                sb.append("%20");
                continue;
            }
            sb.append(str.charAt(i));
        }
        System.out.println(sb);
    }

    public static void main(String[] args) {
        replaceSpace("Hello My World");
    }
}
  1. 从尾到头打印链表
/**
 * @author yangfan
 * @date 2020/3/19 15:59
 * @description 从尾到头打印链表
 */
public class E {
    private static class Node {
        Node(int value) {
            this.value = value;
        }

        int value;
        Node next;
    }

    private static void printListFromTail(Node head) {
        if (head == null) {
            return;
        }

        Stack<Node> stack = new Stack<>();
        Node n = head;
        while (n != null) {
            stack.push(n);
            n = n.next;
        }
        while (!stack.empty()) {
            System.out.println(stack.pop().value);
        }
    }

    private static void printListReverse(Node node) {
        if (node != null) {
            if (node.next != null) {
                printListReverse(node.next);
            }
            System.out.println(node.value);
        }
    }

    public static void main(String[] args) {
        Node head = new Node(999);
        Node tail = head;
        for (int i = 0; i < 5; i++) {
            Node node = new Node(i);
            tail.next = node;
            tail = node;
        }
        //printListFromTail(head);
        printListReverse(head);

        /*Node n = head;
        while (n != null) {
            System.out.println(n.value);
            n = n.next;
        }*/
    }
}
  1. 重建二叉树
/**
 * @author yangfan
 * @date 2020/3/19 17:45
 * @description 重建二叉树
 */
public class A {
    private static class Node {
        Node(int value) {
            this.value = value;
        }

        int value;
        Node left;
        Node right;
    }

    private static Node constructTree(int[] pre, int[] in) {
        if (pre == null || in == null || pre.length == 0 || in.length == 0)
            return null;
        if (pre.length != in.length)
            return null;

        Node root = new Node(pre[0]);
        for (int i = 0; i < pre.length; i++) {
            if (in[i] == pre[0]) {
                root.left = constructTree(Arrays.copyOfRange(pre, 1, i + 1), Arrays.copyOfRange(in, 0, i));
                root.right = constructTree(Arrays.copyOfRange(pre, i + 1, pre.length), Arrays.copyOfRange(in, i + 1, in.length));
            }
        }
        return root;
    }

    public static void main(String[] args) {
        int[] pre = {1, 2, 4, 7, 3, 5, 6, 8};
        int[] in = {4, 7, 2, 1, 5, 3, 8, 6};
        Node node = constructTree(pre, in);
        show(node);
    }

    private static void show(Node node) {
        if (node == null)
            return;
        show(node.left);
        System.out.print(node.value + " ");
        show(node.right);
    }
}
  1. 用两个栈实现队列
/**
 * @author yangfan
 * @date 2020/3/19 18:17
 * @description 用两个栈实现队列
 */
public class B {

    private static Stack<Integer> stack1 = new Stack<>();
    private static Stack<Integer> stack2 = new Stack<>();

    private static Integer pop() {
        if (stack1 == null && stack2 == null)
            return null;

        if (stack2.empty()) {
            while (!stack1.empty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }

    private static void push(Integer i) {
        stack1.push(i);
    }

    public static void main(String[] args) {
        push(1);
        push(2);
        push(3);
        push(4);
        System.out.println(pop());
        push(5);
        System.out.println(pop());
        push(6);
        push(7);
        System.out.println(pop());
        System.out.println(pop());
        System.out.println(pop());
        System.out.println(pop());
        System.out.println(pop());
    }
}
  1. 旋转数组的最小数字
/**
 * @author yangfan
 * @date 2020/3/19 18:41
 * @description 旋转数组的最小数字
 */
public class C {

    private static int printMin(int[] array) {
        if (array == null || array.length == 0) {
            return -1;
        }
        if (array[0] < array[array.length - 1]) {
            return array[0];
        }

        int left = 0;
        int right = array.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (array[mid] > array[mid + 1]) {
                return array[mid + 1];
            }
            if (array[mid] < array[mid - 1]) {
                return array[mid];
            }

            if (array[mid] > array[0]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }

    private static int printMin2(int[] array) {
        if (array == null || array.length == 0) {
            return -1;
        }
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
            int mid = (left + right) / 2;
            if (array[mid] > array[right])
                left = mid + 1;
            else
                right = mid;
        }
        return array[left];
    }

    public static void main(String[] args) {
        int[] array = {1, 0, 1, 1, 1};
        //int[] array = {3, 4, 5, 1, 2};
        System.out.println(printMin(array));
        System.out.println(printMin2(array));
    }
}
  1. 斐波那契数列
/**
 * @author yangfan
 * @date 2020/3/19 19:13
 * @description 斐波那契数列
 */
public class D {

    private static int fibonacci(int n) {
        if (n <= 1)
            return n <= 0 ? -1 : 1;

        int result = 0;
        int preone = 1;
        int pretwo = 0;

        for (int i = 2; i <= n; i++) {
            result = preone + pretwo;
            pretwo = preone;
            preone = result;
        }
        return result;
    }

    /**
     * @param n
     * @return int
     * @description 青蛙跳台阶
     */
    private static int gua(int n) {
        if (n <= 0)
            return -1;
        if (n < 2)
            return n;

        int result = 0;
        int preone = 2;
        int pretwo = 1;

        for (int i = 3; i <= n; i++) {
            result = preone + pretwo;
            pretwo = preone;
            preone = result;
        }
        return result;
    }

    /**
     * @param n
     * @return int
     * @description 2*1覆盖2*n方式
     */
    private static int cover(int n) {
        if (n <= 1)
            return n <= 0 ? -1 : 1;

        int number = 1;
        int sum = 1;
        while (n-- >= 2) {
            sum += number;
            number = sum - number;
        }
        return sum;
    }

    public static void main(String[] args) {
        System.out.println(fibonacci(3));
        System.out.println(gua(3));
        System.out.println(cover(3));
    }
}
  1. 二进制中1的个数
/**
 * @author yangfan
 * @date 2020/3/19 19:31
 * @description 二进制中1的个数
 */
public class E {

    private static int numberOf1(int num) {
        int count = 0;
        while (num != 0) {
            count++;
            num = num & (num - 1);
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(numberOf1(11));
    }
}
像欢欢一样棒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sword-pointing-to-offer_java.zip_剑指offer_剑指offer java
09-20
这本书的原始版本是用C++语言编写的，而"剑指offer_java.zip_剑指offer_剑指offer java"则提供了这些问题的Java实现版本。Java是一种广泛使用的面向对象的编程语言，以其平台无关性、丰富的类库和安全性著称。将这些...
剑指offer-Java代码_java_剑指offer_
09-30
《剑指Offer》是一本备受推崇的编程面试指南，尤其对于Java开发者来说，它提供了大量精心设计的面试题目，旨在帮助求职者提升编程技能和解决问题的能力。这本书的Java代码实现和文字说明是深入理解问题解决方案的...
剑指offer（java版）.rar_剑指offer_剑指offer java_剑指offer（java版）
09-24
《剑指Offer》是针对Java开发者的一本面试指南，它集结了47道常见的Java面试编程题目，旨在帮助求职者更好地准备技术面试，提升解决问题的能力。这本书覆盖了多个核心的编程概念和技术，包括设计模式、数据结构、...
剑指offer--java版1--10源码及解析总结.zip
07-08
《剑指Offer——Java版1-10源码及解析总结》是一份针对《剑指Offer》这本书中前10个编程题目的Java实现及解析的资料合集。《剑指Offer》是许多程序员面试必备的参考书，它涵盖了大量经典的算法和数据结构问题，旨在...
剑指offer（java版）----牛客.zip
09-20
《剑指Offer》是经典的一本面试准备书籍，主要针对计算机科学与技术领域的求职者，尤其是对Java开发者具有很高的参考价值。这本书源自牛客网，一个专注于编程技能测试和在线编程竞赛的平台，旨在帮助求职者提升编程...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 222
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 410
AtCoder Beginner Contest 363 ABCDE
算法刷题笔记 排列数字（C++实现）
hanmo22357的博客
07-17 283
一道简单的深度优先搜索（DFS）模板题，给出了DFS问题的一般思路以及C++代码实现
24暑假算法刷题 | Day15 | LeetCode 110. 平衡二叉树，257. 二叉树的所有路径，404. 左叶子之和，222. 完全二叉树的节点个数
weixin_54468359的博客
07-17 1153
day15打卡：二叉树的递归与迭代
(算法)区间调度问题
2202_75519246的博客
07-17 230
此外,参与工作的时间段不能重复(即使是开始的瞬间和结束的瞬间的重叠也是不允许的). 你的目标是参与尽王多的工作,那么最多能参与多少项工作呢?有n项工作,每项工作分别在s时间开始,在t时间结束. 对于每项工作,你都可以选择参与与否,如果选择了参与,那么自始至终都必须全程参与.
游戏中的敏感词算法初探
555.add(111)
07-17 403
在游戏中起名和聊天需要服务器判断是否含有敏感词，从而拒绝或屏蔽敏感词显示，这里枚举一些常用的算法和实际效果。
《算法笔记》总结No.8——双指针
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-17 1056
去年发表过较简单的双指针案例，建议先行阅读~C++实现双指针算法_c++ 双指针排序-CSDN博客文章浏览阅读154次。本贴介绍双指针的入门典例~_c++ 双指针排序https://jslhyh32.blog.csdn.net/article/details/129829790相比说双指针是一种算法，他更倾向是一种编程技巧，话不多说直接看一个引例：如下，给定递增序列【1,3,5,7,9】，寻找到两个相加为16的元素。如果使用暴力的思想，相当于是一个双层循环：外层下标i对应的A[i]和内层下标为j的A[j]之
算法力扣刷题记录 五十【106.从中序与后序遍历序列构造二叉树】和【105.从前序与中序遍历序列构造二叉树】
danaaaa的博客
07-17 1079
构造二叉树
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 147
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
算法力扣刷题记录 五十六【501.二叉搜索树中的众数】
最新发布
danaaaa的博客
07-21 496
求众数方法
多源字段聚合重塑算法
qq_43071699的博客
07-18 371
【代码】多源字段聚合重塑算法。
AI算法20-分位数回归算法Quantile Regression | QR
yangguangjiujiu99的专栏
07-17 739
分位数回归（Quantile Regression）是一种统计方法，最早由Roger Koenker和Gilbert Bassett于1978年提出。它通过估计条件分位数函数来分析自变量与因变量之间的关系，与传统的最小二乘回归（OLS）相比，分位数回归可以提供更全面的信息。分位数回归模型是一种非参数统计模型，它能够描述因变量和自变量之间的关系，并且可以提供关于数据分布不同方面的信息。这种模型能够估计因变量的不同分位数与自变量之间的关系，而不仅仅是最小二乘法所估计的均值。
探讨C++中巧妙的边界条件处理：以花坛种花问题为例【巧妙思想、边界条件】
qq_22841387的博客
07-17 433
通过上述代码和分析，我们可以看到，巧妙的边界条件处理不仅让代码更简洁明了，而且减少了潜在的错误。希望这篇文章能帮助我们更好地理解边界条件的处理方法，并将这种技巧应用到其他算法问题中。
leetcode力扣_二分查找
bici_1的博客
07-17 686
② 第二种是二分查找法，二分查找的下界设置为 0 ，上界设置为 x ，定义一个中间变量 mid ，然后将 mid 做如下定义，这样定义的目的是防止越界，如果直接定义为 (right + left) / 2 在计算过程中，(right + left) 的结果可能会超出 int 所能表达的最大数字。① 第一种就是暴力解法，因为 x 开方之后的值肯定是小于等于其本身的，所以定义一个变量 i 让它从 0~i 遍历并比较i*i 和 x 的大小，注意返回的值是 i 还是 i+1。如果不存在这样的字符，则返回。
《剑指Offer》Java编程题目与代码解析
"《剑指Offer》是一本针对Java编程的面试指南，涵盖了广泛的算法和数据结构问题，旨在帮助读者提升编程技能，成功通过面试，获得理想的IT工作offer。本书包含47个经典面试题，涉及单例设计模式、链表操作、二叉树...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值