剑指offer 练习六（Java版）

最新推荐文章于 2023-06-24 19:25:05 发布
最新推荐文章于 2023-06-24 19:25:05 发布
阅读量249 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37676632/article/details/77280078
版权

题五十一  请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。

public class Solution {
    public boolean isNumeric(char[] str) {
        String res = String.valueOf(str);
        boolean result = res.matches("[\\+-]?[0-9]*(\\.[0-9]+)?([eE][\\+-]?[0-9]+)?");
        
        return result;
    }
}


题五十二  请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。如果当前字符流没有存在出现一次的字符，返回#字符。 

import java.util.*;

public class Solution {
    HashMap<Character,Integer> map = new HashMap<>();
    ArrayList<Character> list = new ArrayList<>();
    //Insert one char from stringstream
    public void Insert(char ch)
    {
        if(map.containsKey(ch)) map.put(ch,map.get(ch)+1);
        
        else map.put(ch,1);
        
        list.add(ch);
    }
  //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {  char res = '#';
     
     for(char ch:list){
         if(map.get(ch) == 1){
             res = ch;
             break;
         }
     }
      return res;
    }
}

题五十三  一个链表中包含环，请找出该链表的环的入口结点。 

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
     public ListNode meetingNode(ListNode head){
         if(head == null || head.next == null) return null;
         
         ListNode slow = head.next;
         ListNode fast = slow.next;
         
         while(slow != null && fast != null){
             if(slow == fast)  return fast;
             slow = slow.next;
             fast = fast.next;
             if(fast != null)  fast = fast.next;
         }
         return null;
     }
    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        ListNode meet = meetingNode(pHead);
        if(meet == null) return null;
        
        int cnt =1;
        ListNode p1 = meet;
        while(p1.next != meet){
            p1 = p1.next;
            cnt++;
        }
        
        p1 = pHead;
        for(int i=0; i< cnt; i++){
            p1 = p1.next;
        }
        
        ListNode p2 = pHead;
        while(p1 != p2){
            p1 = p1.next;
            p2 = p2.next;
        }
             
        return p2;     
    }
}

题五十四  在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5 

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
       if(pHead == null || pHead.next == null) return pHead;
        
        ListNode tmp = new ListNode(-1);
        tmp.next = pHead;
        ListNode curr = pHead;
        ListNode pre = tmp;
        
        while(curr != null && curr.next != null){
            ListNode nxt = curr.next;
            
            if(curr.val == nxt.val){
                while(nxt != null && curr.val == nxt.val)  nxt = nxt.next;  
                pre.next = nxt;
                curr = nxt;
            }
                
             else {
                 pre = curr;
                 curr = curr.next;
        }
       }
        return tmp.next;
    }
}


题五十五  给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

/*
public class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;

    TreeLinkNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public TreeLinkNode GetNext(TreeLinkNode pNode)
    {
         if(pNode == null )  return null;
         if(pNode.right != null){
            pNode = pNode.right;
             while(pNode.left != null) pNode = pNode.left;
             return pNode;
         }
        while(pNode.next != null){
            if(pNode == pNode.next.left )  return pNode.next;
            pNode = pNode.next;
            
        }
        
        return null;    
    }
}

题五十六  请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。 

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    boolean isSymmetrical(TreeNode pRoot)
    {
         if(pRoot == null) return true;
        
        return help(pRoot.left,pRoot.right);
    }
    boolean help(TreeNode left,TreeNode right){    
        
        if(left == null && right == null) return true;
        
        if(left != null && right != null){
        
        return(left.val == right.val && help(left.left,right.right)&&help(left.right,right.left));
         }
        return false;
    }
}

题五十七  请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。 

import java.util.ArrayList;
import java.util.*;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
 ArrayList<ArrayList<Integer> >  result = new ArrayList<ArrayList<Integer> > ();
        
         if(pRoot == null) return result;
        
       Deque<TreeNode> q = new LinkedList<TreeNode>();
        q.offer(pRoot);
        int layer = 0;
        
        while(!q.isEmpty()){
            layer++;
            ArrayList<Integer> res = new ArrayList<Integer>();
            int curr = 0, size = q.size();
            if((layer &1 ) == 0){
                Iterator<TreeNode> it = q.descendingIterator();
                while(it.hasNext()){
                    res.add(it.next().val);
                }
            }else{
                Iterator<TreeNode> it = q.iterator();
                while(it.hasNext()){
                    res.add(it.next().val);
                 }
            }
            
            while(curr <size){
                TreeNode node = q.poll();
                if(node.left != null)  q.offer(node.left);
                if(node.right != null) q.offer(node.right);
           
                curr++;
            }
            result.add(res);
            
        }
         
    return result;
    }

}

题五十八  从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

import java.util.ArrayList;
import java.util.*;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
     ArrayList<ArrayList<Integer> >  result = new ArrayList<ArrayList<Integer> > ();
        
         if(pRoot == null) return result;
        
       Deque<TreeNode> q = new LinkedList<TreeNode>();
        q.offer(pRoot);
        int layer = 0;
        
        while(!q.isEmpty()){
            layer++;
            ArrayList<Integer> res = new ArrayList<Integer>();
            int curr = 0, size = q.size();
           
            Iterator<TreeNode> it = q.iterator();
            while(it.hasNext()){
                    res.add(it.next().val);
                 }
            
            while(curr <size){
                TreeNode node = q.poll();
                if(node.left != null)  q.offer(node.left);
                if(node.right != null) q.offer(node.right);
           
                curr++;
            }
            result.add(res);
            
          }
         
        return result;
    }
    
}

  题五十九     请实现两个函数，分别用来序列化和反序列化二叉树 

import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
     String Serialize(TreeNode root) {
       if(root == null ) return "#,";
        
        String res = root.val +",";
        res += Serialize(root.left);
        res += Serialize(root.right);
        
        return res;
  }
    
    TreeNode Deserialize(String str) {
       String[] values = str.split(",");
        
        Queue<String> q = new LinkedList<>();
        for(int i =0; i!= values.length;i++){
            q.offer(values[i]);
        }
          return preOrder(q);
  }
    TreeNode preOrder(Queue<String> q){
        String s = q.poll();
        if(s.equals("#"))  return null;
        
        TreeNode node = new TreeNode(Integer.valueOf(s));
        node.left = preOrder(q);
        node.right = preOrder(q);
        return node;
        
    }
}

题六十   给定一颗二叉搜索树，请找出其中的第k大的结点。例如， 5 / \ 3 7 /\ /\ 2 4 6 8 中，按结点数值大小顺序第三个结点的值为4。 

import java.util.*;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    TreeNode KthNode(TreeNode pRoot, int k)
    {
        if(pRoot == null || k <= 0) return null;
        
        TreeNode p = pRoot;
        Stack<TreeNode> stack = new Stack<>();
        int cnt = 1;
        
        while(p!= null || !stack.isEmpty()){
            while(p!= null){
                stack.push(p);
                p = p.left;
            }
            TreeNode tmp = stack.pop();
            if(cnt++ == k)  return tmp;
            
            p = tmp.right;
        }
        
        return null;
    }


}

题六十一   如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。 

import java.util.*;

public class Solution {
    int cnt;
    PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>();
    PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(11,new Comparator<Integer>(){
          public int compare(Integer t1,Integer t2){
              return t2.compareTo(t1);
          }   
    });
    
    public void Insert(Integer num) {
    
        cnt++;
        if((cnt & 1) == 0){
            if(!maxHeap.isEmpty() && num < maxHeap.peek()){
                maxHeap.offer(num);
                num = maxHeap.poll();
            }
            minHeap.offer(num);
        }else{
            if(!minHeap.isEmpty() && num > minHeap.peek()){
                minHeap.offer(num);
                num = minHeap.poll();
            }
            maxHeap.offer(num);
        }
    }

    public Double GetMedian() {
        if(cnt == 0)
            throw new RuntimeException("no available number");
        double res;
        
        if((cnt & 1)== 1)  res = maxHeap.peek();
        else res = (minHeap.peek() + maxHeap.peek())/2.0;
        return res;
    }

}

题六十二  给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。 

import java.util.*;

public class Solution {
    public ArrayList<Integer> maxInWindows(int [] num, int size)
    { 
        ArrayList<Integer> res = new ArrayList<Integer>();
        if(size == 0) return res;
        
        Deque<Integer> deq = new LinkedList<Integer>();
        
        for(int i=0; i<num.length; i++){
            int begin = i-size +1;
            if(deq.isEmpty()) deq.offerLast(i);
            else if(begin > deq.peekFirst()) deq.pollFirst();
            
            while((!deq.isEmpty())&& num[deq.peekLast()]<=num[i]){
                deq.pollLast();
            }
            
            deq.offerLast(i);
            
            if( begin>= 0) res.add(num[deq.peekFirst()]);
        }
        
     return res;
    }
   
}

题六十三  请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如 a b c e s f c s a d e e 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。   

public class Solution {
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
    {
         boolean[] visited = new boolean[matrix.length];
        for(int i=0; i<rows; i++){
            for(int j=0; j<cols; j++){
                if(searchFromHere(matrix,rows,cols,i,j,0,str,visited))
                    return true;
            }
        }
        return false;
    }
    public boolean searchFromHere(char[] matrix, int rows, int cols, int r, int c, int index,char[] str,boolean[] visited){
        if(r<0 || r>=rows || c<0 || c>=cols || matrix[r*cols+c]!=str[index] || visited[r*cols+c]) return false;
        
        if(index == str.length -1) return true;
        
        visited[r*cols+c] = true;
        if(searchFromHere(matrix,rows,cols,r-1,c,index+1,str,visited)||
           searchFromHere(matrix,rows,cols,r,c-1,index+1,str,visited)||
           searchFromHere(matrix,rows,cols,r+1,c,index+1,str,visited)||
           searchFromHere(matrix,rows,cols,r,c+1,index+1,str,visited))
            return true;
        
        visited[r*cols+c] = false;
        return false;
       }
}

题六十四  地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

public class Solution {
    public int movingCount(int threshold, int rows, int cols)
    {   if(threshold <0) return 0;
     
        boolean [][]dp = new boolean[rows+1][cols+1];
        dp[0][0] = true;
        
        for(int i=1; i<=rows; i++){
            if(dp[i-1][0] && reach(threshold,i,0)) dp[i][0] = true;
            else dp[i][0] = false;
        }
      
        for(int i=1; i<= cols; i++){
            if(dp[0][i-1] && reach(threshold,0,i)) dp[0][i] = true;
            else dp[0][i] = false;
        }
     
        for(int i=1; i<= rows; i++){
            for(int j=1; j<= cols; j++){
              if((dp[i-1][j] && reach(threshold,i,j))||(dp[i][j-1] && reach(threshold,i,j))) dp[i][j] = true;
              else dp[i][j] = false;  
            } 
        }
     
        int cnt=0;
        for(int i=0; i< rows; i++){
            for(int j=0; j< cols; j++){
                if(dp[i][j]) cnt++;       
            }
        }
        return cnt;
    }
    public boolean reach(int thr, int x, int y){
        int sum = 0;
        while(x>0){
            sum += x%10;
            x /= 10;
        }
        while(y>0){
            sum += y%10;
            y /= 10;
        }
        return sum <= thr;
        
    }
}


      

Edith077
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
剑指offer之JAVA版---史上最全
Amber8080的博客
11-21 1440
1.单例模式 Ⅰ 懒汉式-线程不安全 以下实现中，私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。 这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 if (uniqueInstance == null) ，并且此时 uniqueInstance 为 null，那么会有多个线程执行 uniqueInstance = new Singleton(); 语句，这将导致实例化多次 uniqueIns
《剑指offer》Java版全系列题解（2021版，持续更新！）
热门推荐
Viper的程序员修炼手册
03-12 2万+
《剑指offer》Java版全系列题解（2021版，持续更新！） 本系列记录了最新版 《剑指Offer》 的题解过程与代码，因为原书是c语言。这里用Java代码复现并优化，并包含解题分析。 希望各位能够点赞，收藏！关注我！ 每日更新！ 如果在准备java面试，可以看看我的另外一篇文章！ Java面试复习体系总结（2021版,持续更新） csdn题解（包含详细分析过程，代码） 力扣链接 剑指Offer系列（java版，详细解析） 03. 数组中重复的数字 剑指 Offer 03. 数组中重复
《剑指offer》66道算法题合集（java实现）
weixin_43774841的博客
01-20 1万+
1
《剑指offer第2版》Java题解总结（中）
qq_41227539的博客
06-04 209
剑指offer第二版Java版题解
牛客网剑指offer -树（java实现）
语桥的博客
02-23 280
牛客网剑指offer -树（java实现），共19题
【剑指offer第2版-第8题-JAVA】
weixin_42648243的博客
06-22 102
剑指offer第2版- JAVA，重建二叉树，前序遍历，中序遍历
剑指Offer（java答案）
YLC_慕类的博客
04-08 1221
剑指Offer（java答案） 剑指Offerjava答案 3二维数组中的查找 4替换空格 5从尾到头打印链表 6重建二叉树 7用两个栈实现队列 8旋转数组的最小数字 9斐波那契数列 扩展1跳台阶 扩展2变态跳台阶 10二进制中1的个数 11数值的整数次方 12打印1到最大的n位数 13在O1时间删除链表结点 14调整数组顺序使奇数位于偶数前面 15链表...
剑指offer牛客练习java
07-12
剑指offer牛客练习java
offersword:剑指offer的Java代码练习
06-09
剑指offer的Java代码练习
剑指Offer题目集栈与队列算法练习
最新发布
01-23
剑指Offer题目集栈与队列算法练习
九度-剑指Offer习题全套答案
12-19
使用vs2010编写，直接用vs2010打开加压后的.sln文件即可看到...九度OJ上面的剑指Offer习题全套答案，全部AC，且具有较好的时间复杂度。部分参考网络上的idea，但代码已经尽量要求简洁，是OJ练习不可多得的参考代码。
leetcode答案-OfferCodingPractice:剑指OFFER刷题记录
06-30
剑指Offer leetcode刷题代码 为本人练习记录学习所作 com.hackhu 原本 包下为2014版 剑指Offer 刷题代码 ： 数据结构篇 数据结构系列包括：数组、字符串、链表、栈&队列、Hash、树、堆以及位运算。 数据结构篇的主要...
【 剑指offer第2版-第19题-JAVA】
weixin_42648243的博客
06-24 152
剑指offer第2版- JA VA
剑指Offer题解（java与go）
qq_35515283的博客
12-13 594
剑指 Offer经典题解
面试必刷的算法题 - 剑指offer题集Java实现
clonechen
04-12 2289
本文的题目均来自LeetCode的剑指offer题库 文章目录基础知识数据结构面试题03.数组中重复的数字面试题04.二维数组中的查找面试题05.替换空格面试题06.从尾到头打印链表面试题07.重建二叉树面试题09.用两个栈实现队列算法与数据操作面试题10-I.斐波那契数列面试题11.旋转数组的最小数字面试题12.矩阵中的路径面试题13.机器人的运动范围[面试题14-I. 剪绳子](https:/...
三天刷完《剑指OFFER编程题》--Java版本实现（第二天）
mike_jun的博客
09-11 1131
正在更新中。。。。。。。。。 剑指offer --Python版本的实现： 剑指offer（1/3）第一大部分 剑指offer（2/3）第二大部分 剑指offer（3/3）第三大部分 27.字符串的排列 输入一个字符串,按字典序打印出该字符串中字符的所有排列。 例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。 输入描述: 输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。 递归法，问题..
三个月接触java的愣头青，刷题了这份剑指offer 指南，竟然拿到腾讯offer ! ! !
Java_may的博客
06-18 168
前言 首先来个自我介绍吧，我是一个拥有大厂梦的程序猿，在传统的外包公司干了几年，实在是干不下去了，然后本来就一直想去大厂，趁着辞职，想去大厂闯一下，于是我花了整整3个月的的时间整理出了大厂的面试题，结果皇天不负苦心人，靠着这些面试题，终于拿到了腾讯的offer，成功入职腾讯，然后就来写一篇文章，和大家分享一下我的面试经历，和我整理的大厂的面试题，希望大家都能圆了去大厂的梦！加油，奥利给！ 腾讯一面： 1.自我介绍 2.擅长哪方面的技术? 3. Java有哪些锁种类? (乐观锁&悲观锁.
剑指offer题目实现41~50（java实现）
weixin_44730746的博客
03-21 132
剑指offer题目实现41~50（java实现）
剑指offer [1- 50 ]-- java题解
Alex抱着爆米花的博客
02-14 730
剑指offer Java题解
剑指offerjava版pdf
07-16
《剑指offer Java版PDF》是一本广受欢迎的面试算法题解答指南。这本书主要针对求职者准备技术面试，特别是Java语言相关的职位。这本书不仅仅提供了问题解析，还包含了详细的答案和清晰的思路。这使得读者能够更好地...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值