重建二叉樹
就是一个递归
注意退出递归的条件,length=0的时候就返回同样类型的,这里因为是树节点所以返回null,之前面试的时候就说返回null了面试官还说返回treenode= =惹
另外java里面不像python那样直接找.index,所以还是写一个循环来找root节点的下标Index,然后根据这个下标分成前后两半
注意Arrars.copyofrange的时候,是左闭右开的
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
import java.util.*;
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
if (pre.length==0 || in.length==0){
return null;
}
TreeNode node=new TreeNode(pre[0]);
for(int i=0;i<in.length;i++){
if(pre[0]==in[i]){
// 可以看出Arrays.copyogrange里面的区间是左閉右開的
node.left=reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(in,0,i));
node.right=reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length),Arrays.copyOfRange(in,i+1,in.length));
}
}
return node;
}
}
数字字符串转换成IP地址
基本的思想就是写一个用递归实现的dfs(s,seg_id,start_index)
那么还是递归一般的两个部分
1.退出递归的部分:完成了ip的四个部分,并且也用完了整个string,然后建一个stringbuilder来放得到的ip,再把它加入到result的列表里
2.里面具体的操作,需要对每段组成的数m进行一个判断,如果是0的话直接dfs递归了,如果<0或者>255那么就不符合ip的条件了,直接break
可以看出这个dfs就是一个递归,主要的功能就是对result和seg_list做出改变,所以result和seg_list需要写在最外面
import java.util.*;
public class Solution {
/**
*
* @param s string字符串
* @return string字符串ArrayList
*/
int[] seg_list=new int[4];
ArrayList<String> result=new ArrayList<>();
static final int n=4;
public ArrayList<String> restoreIpAddresses (String s) {
// write code here
dfs(s,0,0);
return result;
}
public void dfs(String s,int seg_id,int start_index){
//退出
if(seg_id==n){
if(start_index==s.length()){
StringBuilder temp=new StringBuilder();
for(int i=0;i<n;i++){
temp.append(seg_list[i]);
if(i!=n-1){
temp.append('.');
}
}
result.add(temp.toString());
}
return;
}
if(start_index==s.length()){
return;
}
if(s.charAt(start_index)=='0'){
seg_list[seg_id]=0;
dfs(s,seg_id+1,start_index+1);
}
int m=0;
for(int i=start_index;i<s.length();i++){
m=m*10+(s.charAt(i)-'0');
if (m>0 && m<=255){
seg_list[seg_id]=m;
dfs(s,seg_id+1,i+1);
}else{
break;
}
}
}
}
static
static表示只在类当中保存一份,那么所有本类对象共享同一份
一旦用了static关键字,那么这样的内容不再属于对象自己,而是属于对象所在的类了
举个例子,下面的room变量是static的,那么A对象规定了room=101以后,这个room就属于类了,所以可以看到打印的结果,即使没有规定B的room也可以得到B.room=101,它们就是同一个room变量
import java.util.Arrays;
public class Copytest {
private String name;
private int age;
static int room;
public Copytest(){
}
public Copytest(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String[] args){
Copytest copytest1=new Copytest("A",1);
copytest1.room=101;
Copytest copytest2=new Copytest("B",2);
System.out.println(copytest1.room);
System.out.println(copytest2.room);
}
}
另外,一旦使用static修饰成员方法,那么这就成为了静态方法,与变量同样的,静态方法不属于对象,而是属于类的.对于静态方法来说,可以通过对象名来调用,也可以直接通过类名称来调用
值得注意的是
1.静态方法可以访问静态变量
2.静态方法不能访问非静态变量
这是为什么呢?这是因为在java的内存当中,是先有的静态内容,后有的非静态内容
3.静态方法当中不能用this
这是因为this代表当前对象的,通过谁调用的方法,谁就是当前对象,也就是说this指向的是对象里面的,而不是类里面的啦
两种静态方法的调用方式如下:
public class Copytest {
public Copytest(){
}
public static void methodstatic(){
System.out.println("methodstatic");
}
public static void main(String[] args){
//1
Copytest obj=new Copytest();
obj.methodstatic();
//2,并且用这个方式来调用静态方法更加清晰,一般使用这个
Copytest.methodstatic();
//对于本类的方法,不写类名也可以
methodstatic();
}
}
static在内存中是什么样的呢?
首先我们知道内存分为堆栈和方法区,方法区里面又存在一个静态区,这个区专门用于存储静态的变量
比如说一个student类,我们实例化了两个对象studentA和studentB,那么
- 栈里面存储了studentA的地址0x多少多少,studentB的地址0x多少多少,studen.静态变量的地址.需要区分的是,studentA的地址指向的是studentA在堆里边的地址,student.静态变量指向的地址是静态变量在方法区里面的地址,再指向静态区里面的地址,可以看出这个过程已经和对象没关系了
- 堆里面存储了对象studenA的临时变量,对象studentB的临时变量
- 方法区里面存储了Student这个类通用的变量和方法,以及静态区里面存储了静态变量
什么是静态代码块?
它的特点是,当第一次用到本类时,静态代码块执行唯一的一次,那么之后再用到这个类,不管创建多少个对象,都不会再执行这个静态代码块了,而构造方法是对对象而言的,所以每创建一个对象都会执行一次构造方法
由于静态内容总是优先于非静态,所以静态代码块比构造方法先执行
所以静态代码块一般用于一次性的对静态成员进行赋值
//静态代码块
static{
}
//构造方法
public Person(){
}
设计模式之策略模式
今天先看一下策略模式,明天再看单例
比如游戏,多英雄,每个英雄有自己的技能.那么就先找出每个英雄的共同点建立一个共同的类hero,具体到某一个英雄的时候继承hero;把技能作为接口抽取出来,再通过实现接口来实现某种特殊的技能
策略模式用的就是接口的抽取和实现,把对象和接口进行一个组合的关系,从而提高了程序的扩展性
- 首先我们写一个技能接口
/**
* 技能接口
*/
public interface ISkill {
public abstract void useSkill();
}
- 然后对这个接口进行实现,从而实现两个技能,一个疾跑一个狂暴
/**
* 召唤师技能
*/
public class JiPao implements ISkill{
@Override
public void useSkill(){
System.out.println("使用疾跑技能");
}
}
public class KuangBao implements ISkill{
@Override
public void useSkill(){
System.out.println("使用狂暴");
}
}
- 然后我们写一个抽象类hero
/**
* 抽象类
*/
public abstract class Hero {
// 名称
private String heroname;
// 技能的接口(组合关系,需要使用时,传入一个具体的技能对象)
private ISkill iSkill;
// 自我介绍的方法,抽象的
public abstract void display();
// 普通攻击的方法
public abstract void normalAttack();
// 技能的使用方法
public void skill(){
iSkill.useSkill();
}
//set/get
public String getHeroname() {
return heroname;
}
public void setHeroname(String heroname) {
this.heroname = heroname;
}
public ISkill getiSkill() {
return iSkill;
}
public void setiSkill(ISkill iSkill) {
this.iSkill = iSkill;
}
public Hero(){
}
public Hero(ISkill iSkill) {
this.iSkill = iSkill;
}
}
- 通过继承hero类,得到一个后裔的类
/**
* 一个具体的英雄
*/
public class Houyi extends Hero{
//构造方法
public Houyi() {
super.setHeroname("后裔");
}
@Override
public void display(){
System.out.println("后裔展示");
}
@Override
public void normalAttack() {
}
}
- 做完了以上的一切,我们就可以实例化一个后裔类的对象,然后对这个对象传入一个具体的技能接口对象,从而使这个后裔使用不同的技能
public class HeroTest {
public static void main(String[] args){
Hero hero=new Houyi();
System.out.println("英雄:"+hero.getHeroname());
hero.display();
//面向接口的实现就是用到下面这行
hero.setiSkill(new JiPao());
System.out.println("游戏开始");
hero.normalAttack();
hero.skill();
hero.setiSkill(new KuangBao());
hero.normalAttack();
hero.skill();
}
}
下周
下周搞个crud实际项目传git去
扫一扫
689
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
