剑指offer_java_11-20

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

在这里插入图片描述

  1. 数值的整数次方
/**
 * @author yangfan
 * @date 2020/3/19 20:30
 * @description 数值的整数次方
 */
public class A {

    private static double Power(double base, int ex) {
        double result;
        if (String.valueOf(base).equals("0.0")) {
            return 0;
        }
        if (ex == 0) {
            return 1.0;
        }

        if (ex > 0) {
            result = mutiply(base, ex);
        } else {
            result = mutiply(1 / base, -ex);
        }
        return result;
    }

    private static double mutiply(double base, int ex) {
        double sum = 1;
        for (int i = 0; i < ex; i++) {
            sum *= base;
        }
        return sum;
    }

    public static void main(String[] args) {
        System.out.println(Power(0, -3));
    }
}
  1. 打印1到最大的n位数
/**
 * @author yangfan
 * @date 2020/3/19 21:35
 * @description 打印1到最大的n位数
 */
public class B {

    private static void printMax(int n) {
        int[] array = new int[n];
        if (n <= 0) {
            return;
        }
        printArray(array, 0);
    }

    private static void printArray(int[] array, int n) {
        for (int i = 0; i < 10; i++) {
            if (n != array.length) {
                array[n] = i;
                printArray(array, n + 1);
            } else {
                boolean isFirst0 = false;
                for (int value : array) {
                    if (value != 0) {
                        System.out.print(value);
                        if (!isFirst0)
                            isFirst0 = true;
                    } else {
                        if (isFirst0)
                            System.out.print(value);
                    }
                }
                System.out.println();
                return;
            }
        }

    }

    public static void main(String[] args) {
        printMax(2);
    }
}
  1. 在O（1）时间删除链表结点
/**
 * @author yangfan
 * @date 2020/3/19 22:27
 * @description 在O（1）时间删除链表结点
 */
public class C {

    private static class Node {
        Node(int value) {
            this.value = value;
        }

        int value;
        Node next;
    }

    private static void deleteNode(Node head, Node del) {
        if (head == null || del == null)
            return;

        if (head == del) {
            head.value = -1;
        } else if (del.next != null) {
            del.value = del.next.value;
            del.next = del.next.next;
        } else {
            Node n = head;
            while (n.next.next != null) {
                n = n.next;
            }
            n.next = null;
        }
    }

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

        deleteNode(head, del);

        Node n = head;
        while (n != null) {
            System.out.println(n.value);
            n = n.next;
        }
    }
}
  1. 调整数组顺序使奇数位于偶数前面
/**
 * @author yangfan
 * @date 2020/3/19 22:48
 * @description 调整数组顺序使奇数位于偶数前面
 */
public class D {

    private static void reOrderArray(int[] array) {
        if (array == null || array.length == 0)
            return;

        int left = 0;
        int right = array.length - 1;
        int flag;
        while (left < right) {
            while (left<right && array[left] % 2 != 0)
                left ++;
            while (left<right && array[right] % 2 == 0)
                right --;

            if (left<right){
                flag = array[right];
                array[right] = array[left];
                array[left] = flag;
            }
        }

        System.out.println(Arrays.toString(array));
    }

    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5,6,7};
        reOrderArray(array);
    }
}
  1. 链表中倒数第k个结点
/**
 * @author yangfan
 * @date 2020/3/19 23:03
 * @description 链表中倒数第k个结点
 */
public class E {

    private static class Node {
        Node(int value) {
            this.value = value;
        }

        int value;
        Node next;
    }

    private static Node findKfromTail(Node head, int k) {
        if (head == null || k == 0)
            return null;

        Node before = head;
        Node after = head;

        while (k-- > 1) {
            if (before.next == null)
                return null;
            before = before.next;
        }

        while (before.next != null) {
            before = before.next;
            after = after.next;
        }

        return after;
    }


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

        System.out.println(findKfromTail(head, 2));

    }
}
  1. 反转链表
/**
 * @author yangfan
 * @date 2020/3/19 23:14
 * @description 反转链表
 */
public class A {

    private static class Node {
        Node(int value) {
            this.value = value;
        }

        int value;
        Node next;
    }

    private static Node reverse(Node head) {
        if (head == null)
            return null;

        Node pre = null;
        Node node = head;
        Node next;

        while (node != null) {
            next = node.next;
            node.next = pre;
            pre = node;
            node = next;
        }
        return pre;
    }

    public static void main(String[] args) {
        Node head = new Node(666);
        Node tail = head;
        for (int i = 0; i < 5; i++) {
            Node node = new Node(i);
            tail.next = node;
            tail = node;
        }
        
        Node n = reverse(head);
        while (n != null) {
            System.out.println(n.value);
            n = n.next;
        }
    }
}
  1. 合并两个排序的链表
/**
 * @author yangfan
 * @date 2020/3/20 12:03
 * @description 合并两个排序的链表
 */
public class B {

    /**
     * @param node1
     * @param node2
     * @return jzoffer.utils.Node
     * @description 递归
     */
    private static Node mergeTwoLists1(Node node1, Node node2) {
        if (node1 == null)
            return node2;
        if (node2 == null)
            return node1;

        if (node1.value < node2.value) {
            node1.next = mergeTwoLists1(node1.next, node2);
            return node1;
        } else {
            node2.next = mergeTwoLists1(node1, node2.next);
            return node2;
        }
    }

    /**
     * @param node1
     * @param node2
     * @return jzoffer.utils.Node
     * @description 迭代
     */
    private static Node mergeTwoLists2(Node node1, Node node2) {
        Node newHead = new Node();
        Node pre = newHead;

        while (node1 != null && node2 != null) {
            if (node1.value < node2.value) {
                pre.next = node1;
                node1 = node1.next;
            } else {
                pre.next = node2;
                node2 = node2.next;
            }
            pre = pre.next;
        }
        pre.next = node1 == null ? node2 : node1;
        return newHead.next;
    }

    public static void main(String[] args) {
        Node.show(mergeTwoLists1(Node.getNode1(10), Node.getNode2(10)));
        Node.show(mergeTwoLists2(Node.getNode1(10), Node.getNode2(10)));
    }
}
  1. 树的子结构
/**
 * @author yangfan
 * @date 2020/3/20 14:00
 * @description 树的子结构
 */
public class C {

    private static boolean hasSubTree(Tree source, Tree target) {
        if (target == null)
            return true;
        if (source == null)
            return false;
        if (doesRoot1HasRoot2(source, target))
            return true;
        return hasSubTree(source.left, target) || hasSubTree(source.right, target);

    }

    private static boolean doesRoot1HasRoot2(Tree source, Tree target) {
        if (source == null && target == null)
            return true;
        if (source == null || target == null)
            return false;
        if (source.value != target.value)
            return false;
        return doesRoot1HasRoot2(source.left, target.left) && doesRoot1HasRoot2(source.right, source.right);
    }


    public static void main(String[] args) {
        Tree source = Tree.creat(new Tree());
        System.out.println("------------");
        Tree target = Tree.creat(new Tree());
        System.out.println("------------");
        if (hasSubTree(source,target))
            System.out.println("yes");
        else
            System.out.println("no");
    }
}
  1. 二叉树的镜像
/**
 * @author yangfan
 * @date 2020/3/20 14:33
 * @description 二叉树的镜像
 */
public class D {

    private static void MirrorTree1(Tree root) {
        if (root == null || (root.left == null && root.right == null))
            return;
        Tree temp = root.left;
        root.left = root.right;
        root.right = temp;

        if (root.left != null)
            MirrorTree1(root.left);
        if ((root.right != null))
            MirrorTree1(root.right);
    }

    public static void main(String[] args) {
        Tree source = Tree.creat(new Tree());
        MirrorTree1(source);
        Tree.show(source);
    }
}
  1. 顺时针打印矩阵
/**
 * @author yangfan
 * @date 2020/3/20 14:51
 * @description 顺时针打印矩阵
 */
public class E {

    private static List spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        if (matrix == null || matrix[0].length == 0)
            return null;

        int r1 = 0, r2 = matrix[0].length - 1;
        int c1 = 0, c2 = matrix.length - 1;
        while (r1 <= r2 && c1 <= c2) {
            for (int i = c1; i <= c2; i++) {
                result.add(matrix[r1][i]);
            }
            for (int j = r1+1; j <= r2; j++) {
                result.add(matrix[j][c2]);
            }
            if (r1 < r2 && c1 < c2) {
                for (int i = c2-1; i > c1; i--) {
                    result.add(matrix[r2][i]);
                }
                for (int j = r2; j > r1; j--) {
                    result.add(matrix[j][c1]);
                }
            }
            c1++;
            r1++;
            c2--;
            r2--;
        }
        return result;
    }

    public static void main(String[] args) {
        int[][] array = {
                {1,2,3,4},
                {5,6,7,8},
                {9,10,11,12},
                {13,14,15,16}
        };
        System.out.println(spiralOrder(array).toString());
    }
}
像欢欢一样棒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer（java版）----牛客.zip
09-20
《剑指Offer》是经典的一本面试准备书籍，主要针对计算机科学与技术领域的求职者，尤其是对Java开发者具有很高的参考价值。这本书源自牛客网，一个专注于编程技能测试和在线编程竞赛的平台，旨在帮助求职者提升编程...
剑指offer--java版1--10源码及解析总结.zip
07-08
《剑指Offer——Java版1-10源码及解析总结》是一份针对《剑指Offer》这本书中前10个编程题目的Java实现及解析的资料合集。《剑指Offer》是许多程序员面试必备的参考书，它涵盖了大量经典的算法和数据结构问题，旨在...
List中1-10，11-20，21-30...每10条取出并重新赋值后修改到原数据
欢迎加入Android老司机学院 482266514（技术交流群）密码CSDN
07-08 2264
List中1-10，11-20，21-30…每10条取出并重新赋值后修改到原数据 需求 有1000条数据，每10条数据取出满足10条用户名一样就取出，并赋值一字段，然后合并到原始数据，必须满足1-10，11-20，21-30，这种 package com.sdbz.dbank; import java.util.ArrayList; import java.util.List; import j...
剑指Offer（java答案）
YLC_慕类的博客
04-08 1742
剑指Offer（java答案） 剑指Offerjava答案 3二维数组中的查找 4替换空格 5从尾到头打印链表 6重建二叉树 7用两个栈实现队列 8旋转数组的最小数字 9斐波那契数列 扩展1跳台阶 扩展2变态跳台阶 10二进制中1的个数 11数值的整数次方 12打印1到最大的n位数 13在O1时间删除链表结点 14调整数组顺序使奇数位于偶数前面 15链表...
JAVA：剑指_Offer_03_数组中重复的数字
家伟-冉冉的新星博客
03-10 337
JAVA：剑指_Offer_03_数组中重复的数字
剑指offer_1_整数除法(java)
一起coding，一起嗨。
11-20 1016
可以使用的符号是加法和减法，处理好边界值(除数是-2^31,除数是-1时，会产生溢出)2、使用被除数减去除数的倍数的方式，计算商；1、使用被除数减去除数的方式，计算商；
java 版剑指offer算法集锦
徐公，微信公众号同名
07-23 727
微信公众号:徐公码字（stormjun94）来源:https://github.com/gdutxiaoxu/Android_interview 前言 现如今，如果你想进入大厂，腾讯，阿里，头条，拼多多等，不管是社招还是校招，肯定都会面试到算法的。 相信很多人有这样的想法，面试的时候早火箭，工作的时候拧螺丝。确实，这种情况非常常见，我也认同。但没办法，谁叫我们想进入大厂呢，主动权掌握在人家手里。 不过，这种情况也可以理解。怎么在几轮面试中确定面试者的水平呢？ 肯定是考察算法，基础这些，原理这些。 虽然这.
剑指offer java版pdf_剑指offer(java版).pdf
weixin_29342901的博客
02-16 1254
剑指offer(java版)面试题2：实现单例模式1.饿汉式单例类public class SingletonClass{private static final SingletonClass instance=new SingletonClass();//私有构造函数private SingletonClass (){}public static SingletonClass getInstan...
《剑指offer》Java版--14.剪绳子
m0_56199449的博客
12-27 381
剑指offer原题14:剪绳子 给你一根长度为n的绳子，请把绳子剪成m段(mn都是整数n>1并且m>1)，每段绳子的长度记为O],[1],·-,[m]。请问O]xk[1]x···Xk[m]可能的最大乘积是多少?例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是 18。
剑指Offer（java实现）
热门推荐
[ 25'h ]
10-31 1万+
剑指Offer（java实现）（包含个人思考）
三天刷完《剑指OFFER编程题》--Java版本实现（第二天）
mike_jun的博客
09-11 1288
正在更新中。。。。。。。。。 剑指offer --Python版本的实现： 剑指offer（1/3）第一大部分 剑指offer（2/3）第二大部分 剑指offer（3/3）第三大部分 27.字符串的排列 输入一个字符串,按字典序打印出该字符串中字符的所有排列。 例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。 输入描述: 输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。 递归法，问题..
剑指offer--Java实现
LYZ
02-25 3673
剑指offer合辑之面试01-67 《剑指offer》面试题 Java 代码的 Github 地址 《剑指offer》面试题 Markdown 版本，包含题目、分析及代码的 Github 地址 面试题2 实现单例模式 面试题3 二维数组中的查找 面试题4 替换空格 面试题5 从尾到头打印链表 面试题6 重建二叉树 面试题7 用两个栈实现队列 面试题8 旋转数组的最小数字 面试题9 斐波那契数列...
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面试编程题目，旨在帮助求职者更好地准备技术面试，提升解决问题的能力。这本书覆盖了多个核心的编程概念和技术，包括设计模式、数据结构、...
算法日记day 45（单调栈之每日温度|接雨水）
最新发布
m0_74980681的博客
08-22 608
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 292
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
四十一、【人工智能】【机器学习】- Bayesian Logistic Regression算法模型
技术分享、程序员趣事、行业趋势等内容！
08-19 923
监督学习（Supervised Learning）是机器学习中的一种主要方法，其核心思想是通过已知的输入-输出对（即带有标签的数据集）来训练模型，从而使模型能够泛化到未见的新数据上，做出正确的预测或分类。在监督学习过程中，算法“学习”的依据是这些已标记的例子，目标是找到输入特征与预期输出之间的映射关系。Bayesian Logistic Regression是一种统计建模方法，它结合了Logistic回归的原理和贝叶斯统计的框架。
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 686
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
《剑指Offer》Java编程题目与代码解析
"《剑指Offer》是一本针对Java编程的面试指南，涵盖了广泛的算法和数据结构问题，旨在帮助读者提升编程技能，成功通过面试，获得理想的IT工作offer。本书包含47个经典面试题，涉及单例设计模式、链表操作、二叉树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值