本文深入探讨了算法与数据结构的关键概念和技术，包括二叉树的遍历、字符串处理、动态规划等核心主题，提供了丰富的示例和实战经验。
文章目录
二刷
JZ48最长不含重复字符的子字符串
JZ31 栈的压入弹出序列
JZ36 二叉搜索树与双向链表
（注意dfs的使用）
Math用法
Math.round()//函数是取最接近整数，如果遇到一样近，则取最大值
Math.abs()//取绝对值
Math.max()//取较大值
iterator迭代器遍历
TreeSet<Integer> set=new TreeSet<>();
//正序遍历
Iterator<Integer> it=set.iterator();
//逆序遍历
Iterator<Integer> it1=set.descendingIterator();
Random用法
Random random=new Random();
//生成[0,100)之间的随机数
int i = random.nextInt(100);
1.Scanner用法
//以上是scanner的常用用法
Scanner sc=new Scanner(System.in);
while (sc.hasNextInt()){
int i = sc.nextInt();
System.out.println(i);
}
sc.close();
/***************************/
//判断是否还有输入
sc.hasNext()
//以字符串的方式接收
String str=sc.next();
//判断是否还有下一行输入
sc.hasNextLine();
//以每一行的整体作为一个字符串
String str=sc.nextLine();
2.Integer用法
//此方法可以将一个int类型整数转为二进制数并用String类型输出，其中正数用原码形式，负数用补码
String s = Integer.toBinaryString(i);
//此方法求整数n二进制数中1的个数
int count = Integer.bitCount(n);
//此方法将字符串转为整数i
int i=Integer.parseInt(str)
//该方法可以解析十六进制数的字符串，转换为integer
Integer decode = Integer.decode("0x11");
3.String用法
//String的用法：
//java中String是只读的，没有办法进行变换，因此需要使用StringBuilder。
String.length() //获取字符串的长度
String.charAt(i) //获取第i个字符的内容
String.subString(start) //获取[start,）的字符串
String.subString(start,end) //获取[start,end）中的字符串
String[] str=String.split(" ") //用空格进行分割，返回分割后的String数组
char[] c = iniString.toCharArray() //将字符串转为char数组来进行改变字符内容
String.equal() //判断两个字符串是否相等
String.trim()//可以去掉字符串前面和后面的空格
String.startsWith("abc")//判断字符串String是否为"abc"开头
//StringBuilder的用法：
除了String中支持的方法外，StringBuilder支持字符的增、删、改。
stringBuilder.append("we"); //添加we在词尾
stringBuilder.insert(0,"we");//在0的位置加入后面的内容
stringBuilder.delete(0,1); //删除[0,1)的数据
stringBuilder.deleteCharAt(0);
stringBuilder.setCharAt(0,'p'); //在某一个独特位置设置字符
char c = stringBuilder.charAt(i);//查询某个位置上的字符
System.out.println(stringBuilder);
new String(stringBuilder);//用stringBuilder来初始化String
stringBuilder.reverse();//将sb中的字符串反转，可以用来判断回文字符串
3.类型转换的方法
//int转string
String str=123+"";
//char转int
char c='2';
int i=c-'0';
4.Collections&Arrays
//直接整数转化为数组
List<Integer> list = Arrays.asList(1, 2, 3);
//对数组a进行升序排序
Arrays.sort(int[]a)
//复制int[]arr中的元素，包括from处元素，不包括to
Arrays.copyOfRange(arr,from,to)
//默认自然升序排序
Collections.sort(list)
//通过匿名内部类实现降序排序
Collections.sort(list, new Comparator<>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1-o2;//升序
return o2-o1;//降序
}
});
5.queue相关
//queue的实现方式
//LinkedList为正常的先进先出，线程不安全
Queue<TreeNode> queue=new LinkedList<>();
//优先队列，会将里面元素按照升序排列
Queue<Integer> queue=new PriorityQueue<>();
//按照降序排列
Queue<Integer> queue=new PriorityQueue<>((o1, o2) -> o2-o1);
JZ4
题目：
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
思路：
根据中序遍历和先序遍历可以确定二叉树，具体过程为：
1.根据先序序列第一个结点确定根结点
2.根据根结点在中序序列中的位置分割出左右两个子序列
3.对左子树和右子树分别递归使用同样的方法继续分解
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
import java.util.Arrays;
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
if(pre.length==0||in.length==0){
return null;
}
TreeNode root=new TreeNode(pre[0]);
for(int i=0;i<in.length;i++){
if(pre[0]==in[i]){
root.left=reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(in,0,i));
root.right=reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length),Arrays.copyOfRange(in,i+1,in.length));
}
}
return root;
}
}
JZ23
题目：
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则返回true,否则返回false。假设输入的数组的任意两个数字都互不相同。
思路：
首先对二叉搜索树后序遍历要了解清楚，根节点在最后一位，通过判断节点的大小可以划分出左右子树，然后递归判断即可
public class Solution {
public boolean VerifySquenceOfBST(int [] sequence) {
if(sequence==null||sequence.length==0)
return false;
return HelpVerify(sequence,0,sequence.length-1);
}
public boolean HelpVerify(int[] sequence,int start,int root){
if(start>=root)return true;
//找到左右子树的分界点i
int i;
for(i=start;i<root;i++){
if(sequence[i]>sequence[root])
break;
}
//判断右子树的所有节点是否小于根节点,r如果有则返回false
for(int j=i;j<root;j++){
if(sequence[j]<sequence[root])
return false;
}
return HelpVerify(sequence,start,i-1)&&HelpVerify(sequence,i,root-1);
}
}
JZ26
题目：
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
思路：
根据二叉搜索树的特性，用中序遍历可得出排序的节点，将这些排好序的节点存储起来，再构建双向链表即可
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 TreeNode Convert(TreeNode pRootOfTree) {
if(pRootOfTree==null)
return null;
ArrayList<TreeNode> list=new ArrayList<>();
inOrder(pRootOfTree,list);
//构建双向链表
for(int i=0;i<list.size()-1;i++){
list.get(i).right=list.get(i+1);
list.get(i+1).left=list.get(i);
}
return list.get(0);
}
public void inOrder(TreeNode node,ArrayList<TreeNode> list){
if(node!=null){
inOrder(node.left,list);
list.add(node);
inOrder(node.right,list);
}
}
}
总结：
掌握二叉树的先中后序遍历代码
JZ27
题目：
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则按字典序打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
思路：
import java.util.*;
public class Solution {
public ArrayList<String> Permutation(String str) {
ArrayList<String> result=new ArrayList<>();
if(str==null||str.length()==0)
return result;
else{
Help(0,str.toCharArray(),result);
/*按照字典序排序
*此处也可以利用TreeSet来排序
*TreeSet可以自动降重和字典序排序
*/
Collections.sort(result);
}
return result;
}
public void Help(int i,char[] chr,ArrayList<String> result){
if(i==chr.length-1){
String value=String.valueOf(chr);
if(!result.contains(value)){
result.add(value);
}
}else{
for(int j=i;j<chr.length;j++){
Swap(i,j,chr);//依次选一个数固定住
Help(i+1,chr,result);//让后面的数进行全排列
Swap(j,i,chr);//恢复原来的模样
}
}
}
public void Swap(int i,int j,char[] chr){
char temp=chr[i];
chr[i]=chr[j];
chr[j]=temp;
}
}
JZ30
题目：
输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为 O(n).
思路：
动态规划。dp[n]代表以当前元素为截止点的连续子序列的最大和，如果dp[n-1]>0，dp[n]=array[n]+dp[n-1]，因为当前数字加上一个正数一定会变大；如果dp[n-1]<0，dp[n]=array[n]，因为当前数字加上一个负数一定会变小。使用一个变量max记录最大的dp值返回即可
public class Solution {
public int FindGreatestSumOfSubArray(int[] array) {
if(array==null|array.length==0)
return 0;
int[] dp=new int[array.length];
dp[0]=array[0];
int max=dp[0];
for(int i=1;i<array.length;i++){
dp[i]=array[i]+(dp[i-1]>0?dp[i-1]:0);
max=max>dp[i]?max:dp[i];
}
return max;
}
}
总结：
这道题用到了动态规划，第一次接触动态规划不是很理解，后面要多练习
JZ32
题目：
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
思路：
比较两个字符串s1,
s2大小的时候，先将它们拼接起来，比较s1+s2,和s2+s1那个大，如果s1+s2大，那说明s2应该放前面，所以按这个规则，s2就应该排在s1前面
import java.util.ArrayList;
public class Solution {
public String PrintMinNumber(int [] numbers) {
if(numbers==null||numbers.length==0)
return "";
int temp;
int i,j;
for(i=0;i<numbers.length;i++){
for(j=0;j<numbers.length-1-i;j++){
if(judge(numbers[j],numbers[j+1])){
temp=numbers[j];
numbers[j]=numbers[j+1];
numbers[j+1]=temp;
}
}
}
String str=new String("");
for(i=0;i<numbers.length;i++){
str+=numbers[i];
}
return str;
}
public boolean judge(int a,int b){
String sum1=a+""+b;
String sum2=b+""+a;
if(sum1.compareTo(sum2)>0)
return true;
else
return false;
}
}
总结：
1.可以用int+""+int 的方式将int拼接为string
2.str1.compareTo(str2）方法可以比较字符串的大小。相等返回0，str1>str2返回大于0，str1<str2返回小于0。
JZ33
题目：
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
思路：
一个丑数成以2/3/5，得到的还是一个丑数；有3个对列p2/p3/p5，每次都取最小的数，放到数组中。
public class Solution {
public int GetUglyNumber_Solution(int index) {
if(index<=0)return 0;
int p2=0,p3=0,p5=0;
int[]result=new int[index];
result[0]=1;
for(int i=1;i<index;i++){
result[i]=Math.min(result[p2]*2,Math.min(result[p3]*3,result[p5]*5));
if(result[i] == result[p2]*2)p2++;//为了防止跳过丑数需要三个if都能够走到
if(result[i] == result[p3]*3)p3++;
if(result[i] == result[p5]*5)p5++;
}
return result[index-1];
}
}
JZ34
题目：
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）
思路：
用一个数组按照字符出现的顺序存储每一个字符出现的次数，然后再遍历这个数组，输出一个出现次数为1字符的索引
public class Solution {
public int FirstNotRepeatingChar(String str) {
if(str==null || str.length() == 0)return -1;
int[] count = new int['z'+1];
//用一个类似hash的东西来存储字符出现的次数，很方便
for(int i=0; i < str.length();i++)
count[str.charAt(i)]++;
//其实这个第二步应该也是ka我的地方，没有在第一时间想到只要在遍历一遍数组并访问hash记录就可以了
for(int i=0; i < str.length();i++)
if(count[str.charAt(i)]==1)
return i;
return -1;
}
}
总结：
count[‘a’]等价于count[97]。count[str.charAt(i)]++;可以非常巧妙的按照顺序统计每个字符出现的次数。
JZ38
题目：
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
思路1：
这里用层序遍历的思想，遍历了一层让high++；
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 int TreeDepth(TreeNode root) {
if(root==null)
return 0;
Queue<TreeNode> queue=new LinkedList<>();
queue.add(root);
int high=0;
int size;
while(!queue.isEmpty()){
size=queue.size();
while(size!=0){
TreeNode node=queue.poll();
if(node.left!=null)
queue.add(node.left);
if(node.right!=null)
queue.add(node.right);
size--;
}
high++;
}
return high;
}
}
思路2：
还可以采用递归的思想
public int TreeDepth(TreeNode node) {
if (node == null)
return 0;
if (node.left == null && node.right == null)
return 1;
return 1 + Math.max(TreeDepth(node.left), TreeDepth(node.right));
}
JZ39
题目：
输入一棵二叉树，判断该二叉树是否是平衡二叉树。在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树平衡二叉树（Balanced Binary Tree），具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
思路：
上题求出二叉树的深度，此题目只需判断左右子树的高度差
public class Solution {
public boolean IsBalanced_Solution(TreeNode root) {
if(root==null)
return true;
int left=depth(root.left);
int right=depth(root.right);
if(left-right>1||right-left>1)
return false;
return IsBalanced_Solution(root.left)&&IsBalanced_Solution(root.right);
}
public int depth(TreeNode node){
if(node==null)
return 0;
int left=depth(node.left);
int right=depth(node.right);
return 1+(left>right?left:right);
}
}
JZ46
题目：
首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到礼物。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)
思路：
使用ArrayList存储编号，ArrayList的增删元素的方法较为方便，定义一个指针，每当循环够m次后清零从头开始
import java.util.*;
public class Solution {
public int LastRemaining_Solution(int n, int m) {
if(n<=0||m<=0)
return -1;
ArrayList<Integer> result=new ArrayList<>();
for(int i=0;i<n;i++){
result.add(i);
}
int cur=-1;
while(result.size()>1){
for(int j=0;j<m;j++){
cur++;
if(cur==result.size())
cur=0;
}
result.remove(cur);
cur--;
}
return result.get(0);
}
}
总结：
理解cur- -的用意
JZ47
题目：
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
思路：
题目要求不能使用关键字判断语句，原本想使用递归，但递归需要if判断递归边界，故使用&&短路与达到判断递归边界的作用
public class Solution {
public int Sum_Solution(int n) {
boolean x=(n>1)&&((n+=Sum_Solution(n-1))>0);
return n;
}
}
JZ48
题目：
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
思路：
通过位运算实现。通过简单的验证，可以得到以下规律：执行加法 x ^ y，进位操作 ( x & y ) << 1。概括为：两个二进制的相加结果是用一个异或门实现的；两个二进制的进位结果是用一个与门和向左进位来实现的。
public class Solution {
public int Add(int num1, int num2) {
int result, ans;
do {
result = num1 ^ num2; // 每一位相加
ans = (num1 & num2) << 1; // 进位
num1 = result;
num2 = ans;
} while (ans != 0);
return result;
}
}
JZ49
题目：
将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0
思路：
使用ASCII码值来进行字符串到整数的转换
public class Solution {
public int StrToInt(String str) {
if(str.length()==0||str==null)
return 0;
int flag=1;
int sum=0;
for(int i=0;i<str.length();i++){
if(i==0&&str.charAt(i)=='+')flag=1;
else if(i==0&&str.charAt(i)=='-')flag=-1;
else{
//字符不是0-9的数字
if(str.charAt(i)-'9'>0||str.charAt(i)-'0'<0)
return 0;
//超出int范围
if(sum>Integer.MAX_VALUE||sum<Integer.MIN_VALUE)
return 0;
sum=sum*10+(str.charAt(i)-'0');
}
}
return sum*flag;
}
}
JZ54
题目：
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
思路：
使用linkedhashmap，linkedhashmap相比于hashmap可以保存数据的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的数据就是先插入的数据，这样解题就比较容易
import java.util.*;
public class Solution {
LinkedHashMap<Character,Integer> map=new LinkedHashMap<>();
//Insert one char from stringstream
public void Insert(char ch)
{
if(map.containsKey(ch))
map.put(ch,-1);
else
map.put(ch,1);
}
//return the first appearence once char in current stringstream
public char FirstAppearingOnce()
{
Iterator<Character> iterator=map.keySet().iterator();
while(iterator.hasNext()){
char cur=iterator.next();
if(map.get(cur)==1)
return cur;
}
return '#';
}
}
JZ56
题目：
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
思路：
用LinkedHashMap存储节点并删除重复节点，然后通过遍历map将节点取出，并连接起来
import java.util.*;
/*
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)
return null;
LinkedHashMap<Integer,ListNode> map=new LinkedHashMap<>();
ListNode p=pHead;
ArrayList<Integer> arr1=new ArrayList<>();
while(p!=null){
//记录重复的节点
if(map.containsKey(p.val))
arr1.add(p.val);
map.put(p.val,p);
p=p.next;
}
//删除重复的节点
for(int i=0;i<arr1.size();i++){
map.remove(arr1.get(i));
}
Iterator<Integer> it=map.keySet().iterator();
ArrayList<ListNode> arr=new ArrayList<>();
//将map中的value按顺序存储在list中
while(it.hasNext()){
arr.add(map.get(it.next()));
}
if(arr.size()==0)
return null;
//将节点建立连接
for(int i=0;i<arr.size()-1;i++){
arr.get(i).next=arr.get(i+1);
}
//最后一个节点指向null
arr.get(arr.size()-1).next=null;
return arr.get(0);
}
}
JZ58
题目：
请实现一个函数，用来判断一棵二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
思路：
首先要理解对称二叉树的含义，其次用递归就可以算出来
public class Solution {
boolean isSymmetrical(TreeNode pRoot)
{
if(pRoot==null)
return true;
else
return Judge(pRoot.left,pRoot.right);
}
//利用镜像二叉树的性质来判断是否为二叉树
public boolean Judge(TreeNode left,TreeNode right){
if(left==null&&right==null)
return true;
if(left==null||right==null)
return false;
if(left.val==right.val)
return Judge(left.left,right.right)&&Judge(left.right,right.left);
else
return false;
}
}
JZ60
题目：
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
思路：
首先想到用BFS，在后序分层时，思路跑偏了，用了比较复杂的方法。比较高效的方法是用queue.size(),可以得到一层的元素的数量，然后通过while循环进行操作。对于有关二叉树的层序遍历的问题，可优先考虑
import java.util.ArrayList;
import java.util.Queue;
import java.util.LinkedList;
/*
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<>();
if(pRoot==null)
return result;
Queue<TreeNode> queue=new LinkedList<>();
queue.offer(pRoot);
ArrayList<Integer> newLine;
int size;
while(!queue.isEmpty()){
size=queue.size();
newLine=new ArrayList<>();
while(size>0){
TreeNode node=queue.poll();
newLine.add(node.val);
if(node.left!=null)
queue.offer(node.left);
if(node.right!=null)
queue.offer(node.right);
size--;
}
result.add(newLine);
}
return result;
}
}
JZ61
题目：
二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
思路：
这里采用BFS的思路，用BFS遍历二叉树，也用BFS建立二叉树
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 {
private String str;
String Serialize(TreeNode root) {
StringBuilder sb=new StringBuilder();
if(root==null)
return "";
Queue<TreeNode> queue=new LinkedList<>();
queue.offer(root);
sb.append(root.val+",");
while(!queue.isEmpty()){
TreeNode node=queue.poll();
if(node.left!=null||node.right!=null){
if(node.left!=null){
queue.offer(node.left);
sb.append(node.left.val+",");
}
else
sb.append("#,");
if(node.right!=null){
queue.offer(node.right);
sb.append(node.right.val+",");
}
else
sb.append("#,");
}
}
return sb.toString();
}
TreeNode Deserialize(String str) {
TreeNode root = null;
if(!str.equals("")){
String[] list = str.split(",");
//先建立根节点
root = new TreeNode(Integer.parseInt(list[0]));
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);//把需要插入左右节点的元素放在队列中管理，一旦左右子树建立之后就从队列中移除
int index = 1;
while(!queue.isEmpty() && index < list.length){
TreeNode temp = queue.poll();
if(!list[index].equals("#")){
TreeNode newLeft = new TreeNode(Integer.parseInt(list[index]));
temp.left = newLeft;
index ++;
queue.offer(newLeft);
}else
index ++;//所有的if都应该配备else，不然真的很容易出错误
if(index < list.length && !list[index].equals("#")){
TreeNode newRight = new TreeNode(Integer.parseInt(list[index]));
temp.right = newRight;
index ++;
queue.offer(newRight);
}else
index++;//所有的if都应该配备else，不然真的很容易出错误
}
}
return root;
}
}
JZ63
题目：
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
思路：
用ArrayList存储数据，然后用冒泡排序即可
import java.util.*;
public class Solution {
ArrayList<Integer> arr=new ArrayList<>();
public void Insert(Integer num) {
arr.add(num);
}
public Double GetMedian() {
if(arr.size()==0)
return null;
int i,j,temp;
for(i=0;i<arr.size()-1;i++){
for(j=0;j<arr.size()-1-i;j++){
if(arr.get(j)>arr.get(j+1)){
temp=arr.get(j);
arr.set(j,arr.get(j+1));
arr.set(j+1,temp);
}
}
}
int index=arr.size()/2;
if(arr.size()%2==0){
double result=((double)arr.get(index)+(double)arr.get(index-1))/2;
return result;
}else{
return (double)arr.get(index);
}
}
}
总结：
double result=((double)arr.get(index)+(double)arr.get(index-1))/2; 在int和double类型转换时，需要注意将每个int转换为double再进行乘除法。
JZ65
题目：
思路：
采用递归的方法，注意判断好边界问题
public class Solution {
public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
{
if(matrix==null||matrix.length==0)
return false;
int[] flag=new int[rows*cols];
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
if(help(i,j,0,matrix,str,rows,cols,flag))
return true;
}
}
return false;
}
public boolean help(int i,int j,int cur,char[] matrix,char[] str,int rows,int cols,int[] flag){
//cur为数组str的索引，flag记录该位置是否被访问
int index=i*cols+j;//matrix的索引
if(i>=0&&i<rows&&j>=0&&j<cols&&flag[index]==0){
if(matrix[index]==str[cur]){
cur++;
//str遍历完毕，可以找到该路径
if(cur>=str.length)
return true;
//该节点被访问过
flag[index]=1;
if(help(i-1,j,cur,matrix,str,rows,cols,flag)||
help(i+1,j,cur,matrix,str,rows,cols,flag)||
help(i,j-1,cur,matrix,str,rows,cols,flag)||
help(i,j+1,cur,matrix,str,rows,cols,flag)){
return true;
}
//该节点不符合条件，重新设置为未访问
flag[index]=0;
return false;
}
return false;
}
return false;
}
}
JZ66
题目：
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
思路：
首先在某个节点处，要调用递归来决定某个位置的下一步去哪，此时有4个选择，每个选择都会进入下一个递归调用。当进入某个位置时，应当标记这个位置已访问过，避免之后又来到这里。在递归方法中，首先判断边界条件以及题目中所提的要求是否满足，都没问题，说明该位置可以访问，然后改变对应位置的标记。然后就是以该节点为中心，考虑下一步怎么走，本题就是4种走法，可以分开写，也可以一起写，由于本题是计数，所以就直接加在一起。然后return这些求和结果再+1，求和结果是下一步走的结果，而+1是本次访问此时的节点的次数。
public class Solution {
private int count=0;
public void helper(int i,int j,int rows,int cols,int[][] flag,int threshold){
//不符合条件就直接返回
if(i<0||i>=rows||j<0||j>=cols||flag[i][j]==1)return;
if(sum(i)+sum(j)>threshold){
flag[i][j]=1;
return;
}
flag[i][j]=1;
count++;
helper(i-1,j,rows,cols,flag,threshold);
helper(i+1,j,rows,cols,flag,threshold);
helper(i,j-1,rows,cols,flag,threshold);
helper(i,j+1,rows,cols,flag,threshold);
}
public int sum(int i){
int res=0;
while(i!=0){
res+=i%10;
i=i/10;
}
return res;
}
public int movingCount(int threshold, int rows, int cols)
{
int[][] flag=new int[rows][cols];
helper(0,0,rows,cols,flag,threshold);
return count;
}
}
JZ67
题目：
给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1，m<=n），每段绳子的长度记为k[1],…,k[m]。请问k[1]x…xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
思路：
这题目用动态规划。首先题目要求至少切一次。当target<=3时可以明确得出最大乘积，当target>3后，dp[n]=max(dp[n-i]*dp[i])。假设n为10，第一刀之后分为了4-6，而6也可能再分成2-4（6的最大是3-3，但过程中还是要比较2-4这种情况的），而上一步4-6中也需要求长度为4的问题的最大值，可见，各个子问题之间是有重叠的，所以可以先计算小问题，存储下每个小问题的结果，逐步往上，求得大问题的最优解
public class Solution {
public int cutRope(int target) {
if(target<2)
return 0;
if(target==2)
return 1;
if(target==3)
return 2;
int[]dp=new int[target+1];
dp[1]=1;
dp[2]=2;
dp[3]=3;
int max=0;
for(int i=4;i<=target;i++){
for(int j=1;j<=i/2;j++){
max=max>(dp[j]*dp[i-j])?max:(dp[j]*dp[i-j]);
}
dp[i]=max;
}
return dp[target];
}
}
总结：
后续对动态规划需要总结和练习
扫一扫
1191
到【灌水乐园】发言
