剑指offer第二版题解系列（三）

最新推荐文章于 2021-02-04 23:26:58 发布
最新推荐文章于 2021-02-04 23:26:58 发布
阅读量138 收藏
点赞数
分类专栏： Java 剑指offer题解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sfiayui123/article/details/81940715
版权

写在开头：正值毕业生求职期间，翻一翻剑指offer的书籍，将其中的题目进行分析和代码编写，并将代码整理到csdn博客上，如果有错误，敬请指出！（此系列不提供题目原文，请参考书籍《剑指offer第二版》即可。）

Test20 - Test29系列

1. Test20.java
public class Test20{
    public static boolean isnum(String str)
    {
        if(str==null||str.length()<1)
            return false;
        int index =0;
        if(str.charAt(index)=='+'||str.charAt(index)=='-')
            index++;
        if(index>=str.length())
            return false;
        while(index<str.length()&&isshuzi(str,index))
            index++;
        if(index>=str.length())
            return true;
        if(str.charAt(index)=='.') {
            index++;
            if (index >= str.length())
                return false;
            while (index < str.length() && isshuzi(str, index))
                index++;
            if (index >= str.length())
                return true;
        }
        else{
            if(str.charAt(index)=='e'|| str.charAt(index)=='E')
                index++;
            if(index>=str.length())
                return false;
            else{
                if(str.charAt(index)=='+'||str.charAt(index)=='-')
                {   index++;
                    if(index>=str.length())
                        return false;
                     else {
                         while(index<str.length()&&isshuzi(str,index))
                         index++;
                         if(index>=str.length())
                            return true;
                    }

                }
            }
        }
        return false;
    }
    public static boolean isshuzi(String str,int index) {
        if (str.charAt(index) >= '0' && str.charAt(index) <= '9')
            return true;
        else
            return false;
    }
    public static void main(String[] args)
    {
        String  str = "+100e+5";
        System.out.println(isnum(str));
    }

}
2. Test21.java
public class Test21{
    public static int[] joSwap(int[] arr)
    {
        if(arr==null||arr.length<1)
            return null;
        int i = 0;
        int j = arr.length-1;
        while(i<=j)
        {
            if((arr[i]&0x1)==1)
                i++;
            else if((arr[i]&0x1)==0)
            {
                swap(arr,i,j);
                j--;
            }
        }
        return arr;
    }
    public static void swap(int[] arr,int i,int j){
        if(arr==null||arr.length<1)
            return;

        int temp;
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    public static void print(int[] arr)
    {
        if(arr==null||arr.length<1)
            return;
        for(int i : arr)
            System.out.print(i);
    }
    public static void main(String[] args)
    {
        int[] arr = {1,2,3,4,5};
        print(joSwap(arr));
    }

}
3. Test22.java
public class Test22{
    public static class LNode{
        int data;
        LNode next;
        public LNode(int data){
            this.data = data;
        }
    }
    public static LNode thKNode(LNode head,int k){
        if(head==null||k<=0)
            return null;
        LNode quick = head;
        LNode slow = head;
        int i = 1; //如果 k=1就直接返回头结点

            while (i < k && quick != null) {
                    ++i;
                    quick = quick.next;

            }
            if(i<=k&&quick==null)
                return null;//如果经过以上循环之后，i<k说明k已经超出链表的长度了，如果i=k且quick为空，说明给出的k比链表的长度大1；


            else {
                while (quick != null && quick.next != null) {
                    quick = quick.next;
                    slow = slow.next;
                }
            }

        return slow;
    }
    public static void main(String[] args)
    {
        LNode n1 = new LNode(1);
        LNode n2 = new LNode(2);
        LNode n3 = new LNode(3);
        LNode n4 = new LNode(4);
        n1.next = n2;
        n2.next = n3;
        n3.next = n4;
        n4.next = null;
        LNode head = n1;
        LNode node = thKNode(head,5);
        System.out.println(node.data);
    }
}
4. Test23.java
public class Test23{
    public static class LNode{
        int data;
        LNode next;
        public LNode(int data){
            this.data = data;
        }
    }
    public static LNode meetingNode(LNode head)
    {
        if(head==null)
            return null;
        LNode quick = head;
        LNode slow = head;
        if(quick==null||quick.next==null||quick.next.next==null)
            return null;
        while(quick!=null&&quick.next!=null&quick.next.next!=null){
            quick = quick.next.next;
            slow = slow.next;
            if(quick==slow)
                break;
        }
        return quick;
    }
    public static int crlnum(LNode head,LNode meetingNode)
    {
        if(head==null)
            return 0;
        LNode p = meetingNode.next;
        int num = 1;
        while(p!=meetingNode) {
            p = p.next;
            ++num;
        }
        return num;
    }
    public static LNode rkNode(LNode head,int num)
    {
        if(head==null)
            return null;
        LNode quick = head;
        LNode slow = head;
        int i = 1;
        while (i<=num)
        {
            quick = quick.next;
            ++i;
        }
        while(quick != slow)
        {
            quick = quick.next;
            slow = slow.next;
        }
        return slow;
    }
    public static void main(String[] args)
    {
        LNode n1 = new LNode(1);
        LNode n2 = new LNode(2);
        LNode n3 = new LNode(3);
        LNode n4 = new LNode(4);
        LNode n5 = new LNode(5);
        LNode n6 = new LNode(6);
        n1.next = n2;
        n2.next = n3;
        n3.next = n4;
        n4.next = n5;
        n5.next = n6;
        n6.next = n3;
        LNode head = n1;
        int num = crlnum(head,meetingNode(head));
        System.out.println(num);
        LNode Node = rkNode(head,num);
        System.out.println(Node.data);
    }
}
5. Test24.java
public class Test24{
    public static class LNode{
        int data;
        LNode next;
        public LNode(int data){
            this.data = data;
        }
    }
    public static LNode reverseLink(LNode head)
    {
        if(head==null)
            return null;
        LNode pre = null;
        LNode cur = head;
        LNode net = head.next;
        if(head.next==null)
            return head;
        while(net!=null)
        {
            cur.next = pre;
            pre = cur;
            cur = net;
            net = net.next;
        }
        return cur;
    }
    public static void main(String[] args)
    {
        LNode n1 = new LNode(1);
//        LNode n2 = new LNode(2);
//        LNode n3 = new LNode(3);
//        LNode n4 = new LNode(4);
        n1.next = null;
//        n1.next = n2;
//        n2.next = n3;
//        n3.next = n4;
//        n4.next = null;
        LNode head = n1;
        LNode node  = reverseLink(head);
        System.out.println(node.data);
    }
}
6. Test25.java
public class Test25{
    public static class LNode{
        int data;
        LNode next;
        public LNode(int data){
            this.data = data;
        }
    }
    public static LNode sumsort(LNode head1,LNode head2)
    {
        if(head1==null&&head2==null)
            return null;
        if(head1==null)
            return head2;
        if(head2==null)
            return head1;
        LNode cur1 = head1;
        //LNode net1 = head1.next;
        LNode cur2 = head2;
        //LNode net2 = head2.next;
        LNode head = null;
        if(cur1!=null&&cur2!=null&&cur1.data<=cur2.data) {
            head = cur1;
            cur1 = cur1.next;
            head.next = sumsort(cur1,cur2);
        }
        else if(cur1!=null&&cur2!=null&&cur2.data<cur1.data){
            head = cur2;
            cur2 = cur2.next;
            head.next = sumsort(cur1,cur2);
        }
       return head;
    }
    public static void printLink(LNode head)
    {
        if(head==null)
         return;
        LNode p = head;
        while(p!=null) {
            System.out.print(p.data);
            p = p.next;
        }

    }
    public static void main(String[] args)
    {
        LNode n1 = new LNode(1);
        LNode n2 = new LNode(3);
        LNode n3 = new LNode(4);
        LNode n4 = new LNode(2);
        LNode n5 = new LNode(5);
        LNode n6 = new LNode(6);
        n1.next = n2;
        n2.next = n3;
        n3.next = null;
        n4.next = n5;
        n5.next = n6;
        n6.next = null;
        LNode head1 = n1;
        LNode head2 = n4;
        printLink(sumsort(head1,head2));

    }
}
7. Test26.java
public class Test26{
    public static class BinaryTree{
        double data;
        BinaryTree left;
        BinaryTree right;
        public BinaryTree(double data)
        {
            this.data = data;
        }
    }
    public static boolean samesubTree(BinaryTree root1,BinaryTree root2)
    {
        if(root1==null||root2==null)
            return false;
        boolean result = false;
        if(equal(root1.data,root2.data)) {
            result = samesubTree2(root1.left, root2.left);
             if (!result)
                result = samesubTree(root1.left, root2);
            else  if (!result)
                result = samesubTree(root1.right, root2);
        }
        return result;
    }
    public static boolean samesubTree2(BinaryTree root1,BinaryTree root2)
    {
        if(root2==null)
            return true;
        if(root1==null)
            return false;
        boolean result = false;
        if(!equal(root1.data,root2.data))
            return false;
        else
            return samesubTree2(root1.left,root2.left)&&samesubTree2(root1.right, root2.right);
    }
    public static boolean equal(double d1,double d2)
    {
        if((d1-d2>-0.0000001)&&(d1-d2)<0.0000001)
            return true;
        else
            return false;
    }
    public static void main(String[] args)
    {
        BinaryTree t1 = new BinaryTree(8);
        BinaryTree t2 = new BinaryTree(8);
        BinaryTree t3= new BinaryTree(7);
        BinaryTree t4 = new BinaryTree(9);
        BinaryTree t5 = new BinaryTree(2);
        BinaryTree t6 = new BinaryTree(4);
        BinaryTree t7 = new BinaryTree(7);
        BinaryTree t8 = new BinaryTree(8);
        BinaryTree t9 = new BinaryTree(9);
        BinaryTree t10 = new BinaryTree(2);
        t1.left = t2;
        t1.right = t3;
        t2.left = t4;
        t2.right = t5;
        t5.left = t6;
        t6.right = t7;
        t4.left = null;
        t4.right = null;
        t6.right = null;
        t6.left = null;
        t7.left = null;
        t7.right = null;
        t8.left = t9;
        t8.right = t10;
        t9.left = null;
        t9.right = null;
        t10.left = null;
        t10.right = null;
        System.out.println(samesubTree(t1,t8));

    }
}
8. Test27.java
public class Test27{
    public static class BinaryTree{
        int data;
        BinaryTree left;
        BinaryTree right;
        public BinaryTree(int data)
        {
            this.data = data;

        }
    }
    public static void reverse(BinaryTree root)
    {
        if(root==null)
            return ;
        if(root.left==null&&root.right==null)
            return ;
        if(root.left!=null&&root.right!=null) {
            BinaryTree node = root.left;
            root.left = root.right;
            root.right = node;
            reverse(root.left);
            reverse(root.right);
        }
        else if(root.left==null) {
            root.left = root.right;
            root.right = null;
            reverse(root.left);
        }
        else if(root.right == null)
        {
            root.right = root.left;
            root.left = null;
            reverse(root.right);
        }
    }
    public static void print(BinaryTree root)
    {
        if(root==null)
            return;
        System.out.println(root.data);
        print(root.left);
        print(root.right);
    }
   public static void main(String[] args)
   {
       BinaryTree t1 = new BinaryTree(8);
       BinaryTree t2 = new BinaryTree(8);
       BinaryTree t3 = new BinaryTree(7);
       BinaryTree t4 = new BinaryTree(9);
       BinaryTree t5 = new BinaryTree(2);
       BinaryTree t6 = new BinaryTree(4);
       BinaryTree t7 = new BinaryTree(7);
       t1.left = t2;
       t1.right = t3;
       t2.left = t4;
       t2.right = t5;
       t5.left = t6;
       t5.right = t7;
       t4.left = null;
       t4.right = null;
       t6.right = null;
       t6.left = null;
       t7.left = null;
       t7.right = null;
//         t1.left = null;
//         t1.right = null;
       reverse(t1);
       print(t1);

   }
}
9. Test28.java
public class Test28{
    public static class BinaryTree{
        int data;
        BinaryTree left;
        BinaryTree right;
        public BinaryTree(int data)
        {
            this.data = data;

        }
    }
    public static boolean isSymmerial(BinaryTree root)
    {
        if(root==null)
            return true;
        else
            return isSymmerial(root,root);
    }
    public static boolean isSymmerial(BinaryTree root1,BinaryTree root2)
    {
        if(root1==null&&root2==null)
            return true;
        if(root1==null||root2==null)
            return false;
        if(root1.data!=root2.data)
            return false;
        else
            return isSymmerial(root1.left,root2.right)&&isSymmerial(root1.right,root2.left);
    }
    public static void main(String[] args)
    {
        BinaryTree t1 = new BinaryTree(8);
        BinaryTree t2 = new BinaryTree(8);
        BinaryTree t3 = new BinaryTree(7);
        BinaryTree t4 = new BinaryTree(9);
        BinaryTree t5 = new BinaryTree(2);
        BinaryTree t6 = new BinaryTree(4);
        BinaryTree t7 = new BinaryTree(7);
        t1.left = t2;
        t1.right = t3;
        t2.left = t4;
        t2.right = t5;
        t5.left = t6;
        t5.right = t7;
        t4.left = null;
        t4.right = null;
        t6.right = null;
        t6.left = null;
        t7.left = null;
        t7.right = null;
        System.out.println(isSymmerial(t1));
    }
}
10. Test29.java
public class Test29{
    public static void printMatrix(int[][] numbers,int rows,int cols)
    {
        if(numbers==null||rows<1||cols<1)
            return;
        int start = 0;
        while(rows>start*2&&cols>start*2) {
            printMatrix1(numbers, rows, cols, start);
            start++;
        }
        return;
    }
    public static void printMatrix1(int[][] numbers,int rows,int cols,int start){
        int endX = cols-1-start;
        int endY = rows-1-start;
        for(int i = start;i<=endX;i++)
        {
            print(numbers[start][i]);
        }
        if(start<endY) {
            for (int i = start + 1; i <= endY; i++) {
                print(numbers[i][endX]);
            }
        }
        if(start<endX)
        {
            for(int i=endX-1;i>=start;i--)
            {
                print(numbers[endY][i]);
            }
        }
        if(start<endY-1&&start<endX)
        {
            for(int i=endY-1;i>start;i--)
                print(numbers[i][start]);
        }
        return;
    }
    public static void print(int num)
    {
        System.out.print(num);
    }

    public static void main(String[] args)
    {
        int[][] numbers = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
        printMatrix(numbers,4,4);

    }
}
sfiayui123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcodeoj调试-LeetCode-Exercise:LeetCode刷题&剑指offer第二版题解(67题已完成)&部分数据结构的实
07-01
leetcode oj 调试 LeetCode练习 ...CaptureOffer：剑指offer第二版68题题解和部分面试模拟题题解，OJ平台为牛客网 Interview，AlibabaInterview：面试题题解 java/utils:几种算法的实现 java/inteview:
《剑指offer第二版》三
weixin_43928720的博客
03-23 79
1. 旋转数组的最小数字 （1）题目描述 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。 示例 1： 输入：[3,4,5,1,2] 输出：1 （2）题目分析 遇到排序数组的查找问题，最优解一般都是二分法，这个题要分三种情况考虑...
数据结构：链表大解析(java实现)
一个人漫步走
08-09 5956
￥本文内容主要总结链表的的相关知识与常见题目一、链表的定义链表是线性表的链式存储的实现（物理顺序可以是任意的，不一定要与逻辑顺序一致）。线性表是指存储相同类型的一组数据，除了第一个和最后一个元素外，每一个元素都有它的一个直接前驱和直接后继，第一个元素有一个直接后继，最后一个元素有一个直接前驱。链表基本元素是结点，它里面包含数据域与指针域，结点之间用指针连接起来，形成一个简单的链。它有以下几种类型：二
面试算法经典书籍--剑指offer
后台开发
02-04 448
剑指Offer第二版面试题3（java实现）
Coder_kiwi的博客
03-12 247
题目描述 在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。 解题思路 最简单的就是用一个数组或者哈希表来存储已经遍历过的数字，但是这样需要开辟...
《剑指offer》python答案整理（1）
riario的博客
08-28 2258
1. 二维数组查找 在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 # -*- coding:utf-8 -*- class Solution: # array 二维列表 def Find(self, target, array): # wri
完整学习笔记：《剑指offer》Java版代码实现
10-31
第二题 单例设计模式 测试2 第三题 二维码中找到目标值 测试3 第四题 替换字符串中的空格 测试4 第五题 从尾到头打印链表 测试5 第六题 由前序和中序重建重建二叉树 测试6 第七题 使用两个栈实现队列 测试7 第八题 ...
leetcode走方格起点到终点-Coding-Interviews:剑指offer
06-30
所用图书：剑指offer第二版 括号内是考察的知识点 题目前加 * 代表该题需要着重去理解（*的数目代表着重理解程度） 标红（下划线）的地方是需要着重理解 添加与LeetCode对应的题号（虽然目前LeetCode有剑指offer专题...
jian-zhi-offer:此资源是剑指OFFER的题解（C ++），由本人在刷剑指OFFER题的期间整理，其中有整理牛客网讨论区的代码+剑指OFFER书中的代码+自己编写的代码，方法很全，且附有解析和思路，很方便大家在刷题时参考。资源中过渡顺序参照牛客网上的顺序。作者：Sidney.Tan
03-23
剑指OFFER题解（C ++）（很全） 此由本人在刷剑指OFFER题的期间整理，其中有整理牛客网讨论区的代码+剑指OFFER书中的代码+自己编写的代码，方法很全，且附有解析和思路，很方便大家在刷题时参考。 作者：Sidney.Tan
sword-for-offer:使用Python3用优雅的方式实现《剑指Offer》中的题目
04-23
使用Python3用pythonic的方式实现《剑指Offer 第二版》中的题目。拒绝直接“翻译”java等实现。代码有些并非原创，搬运了一些LeetCode中大神的优秀解法，比如：如何用一行代码实现顺时针打印矩阵。 基本所有题都包含...
剑指offer第二版第三题：数组中重复的数字
qq_1306238492的博客
11-21 221
题目一：找出数组中重复的数字 法一： import java.util.HashMap; public class Solution { // Parameters: // numbers: an array of integers // length: the length of array numbers // dupl...
《剑指offer》第三_二题（不修改数组找出重复的数字）
weixin_30319097的博客
03-02 66
// 面试题3（二）：不修改数组找出重复的数字 // 题目：在一个长度为n+1的数组里的所有数字都在1到n的范围内，所以数组中至 // 少有一个数字是重复的。请找出数组中任意一个重复的数字，但不能修改输入的 // 数组。例如，如果输入长度为8的数组{2, 3, 5, 4, 3, 2, 6, 7}，那么对应的 // 输出是重复的数字2或者3。 #include <iostre...
剑指Offer学习总结-第3章 高质量的代码
那远远的云端
01-17 1221
剑指Offer学习总结-第3章 高质量的代码 本系列为剑指Offer学习总结，主要是代码案例的分析和实现： 书籍链接：http://product.dangdang.com/24242724.html 原作者博客：http://zhedahht.blog.163.com/blog/static/254111742011101624433132/ 原作者博客链接有完整的项目代码下载。
剑指offer（纪念版）读书笔记【实时更新】
weixin_30748995的博客
09-03 128
C++ 1.STL的vector每次扩充容量，新容量是前一次的两倍。 2.32位机指针大小为4个字节，64位机指针大小为8个字节。 3.当数组作为函数参数传递时，数组会自动退化成同类型指针。 4. "0123456789"占11个字节，因为有'\0'。 如果定义char a[10]; strcpy(str,"0123456789");// 将会导致字符串越界。 5. ...
剑指offer-找工作必看的书
xp215774576的专栏
05-28 3979
书的由来：作者海涛2011年9月，发了60篇关于面试的博客，当时点击量超过了70万，网址http://zhedahht.blog.163.com/，后来整理成书，剑指offer,马上要找工作高潮了，准备准备以防不测。1 共享桌面远程面试 是指应聘者把桌面远程传给面试官看。 这时要注意几个问题：(1)思考清楚再写代码。这样就可以少再代码完成以后，修改。要考虑好时间复杂度，空间复制度，有些什么特殊情
剑指offer（三）C++版
葵的博客
08-27 298
1.二进制中1的个数 2.数值的整数次方 3.调整数组顺序使奇数位于偶数前面 4.链表中倒数第k个结点 5.反转链表
剑指offer3
spec_yue
03-16 190
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。 方法1 先顺序存入vector,再反向读取vector.back() /** * struct ListNode { * int val; * struct ListNode *next; * ListNode(int x) : * val(x), next(N...
【剑指offer】
weixin_41643439的博客
11-21 135
题目描述 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 class Solution: # array 二维列表 def Find(self, target, array): # write code here ...
数字信号处理题解及电子课件第二版pdf
最新发布
12-20
数字信号处理题解及电子课件第二版pdf是一本非常有价值的学习资料。它包含了大量数字信号处理的题目和详细的解答，对于学习者来说是一个很好的练习资源。通过这本电子课件，我们可以更好地理解数字信号处理的基本...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值