java学习笔记(七)

java学习笔记(七)

java部分:

继承:

关键词为extends,java中无法多重继承,一个子类只有一个父类,父类可以有多个子类,但是子类和子类没有关系,只是继承了同一个父类.java可以连环继承,子类继承了父类的父类(所有类都继承了 Object类,实现了13个方法).

加载子类之前会优先加载父类,new 子类对象之前会先new 父类对象.父类只有有参构造器没有无参构造器时(无参构造器在有有参构造器时不会默认生成),子类调用默认构造方法会报错(子类调用构造方法默认调用父类的无参构造方法).简而言之,要么自己用super(参数)调用有参构造方法,要么就给父类写无参构造方法(建议无论何种情况都先写一个无参构造方法).

抽象:

关键词 abstract.分成抽象方法和抽象类.

1. 抽象方法只能在抽象类中实现,抽象方法并没有方法体,只是为了统一子类中都实现该抽象方法.

2. 实体类如果继承了抽象类,必须重写抽象类中所有的抽象方法.

3. 抽象类不能new对象,但是有构造方法,用于给子类的对象构造时使用.

4. 抽象类可以有非抽象的方法,可以有成员变量(不存在抽象成员变量)

   访问修饰符:

   最大访问权限范围:public(不同包下其他类中就能直接使用)>protected(其他包中的有父子类关系,import导入就能使用)>(default,默认不写)(同一个包下面,没有关系的类中)>private(只能在本类中)

   private和protected是不能用来修饰类的,只能默认或者public.

   javaBean规范:

   类名符合驼峰命名法,有一个无参构造器,属性私有化并且提供public的get/set方法.

算法部分:

平衡二叉树:

​ 输入一棵二叉树，判断该二叉树是否是平衡二叉树。 在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树.平衡二叉树(Balanced Binary Tree），具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

题目已经给了提示,不用考虑是不是排序二叉树,那么可以直接改造二叉树,用深度优先搜索算法,二叉树的value就是它的深度,如果左右两个节点的差值大于1那就说明已经不平衡了.

public class Solution {
    static Boolean balance;
    public boolean IsBalanced_Solution(TreeNode root) {
        balance =true;
        if (root == null){
            return true;
        }
         if (root.left == null && root.right == null){
            return true;
        }
        if (root.left == null || root.right == null){
            return false;
        }
        FindRoot(root);
        return balance;
    }

    public static void FindRoot(TreeNode root) {
        if (root.left == null && root.right == null) {
            root.val = 1;
            return;
        } else {
            if (root.left == null) {
                FindRoot(root.right);
                root.val = root.right.val+1;
                return;
            } else if (root.right == null) {
                FindRoot(root.left);
                root.val = root.left.val+1;
                return;
            } else {
                FindRoot(root.left);
                FindRoot(root.right);
                if (Math.abs(root.left.val-root.right.val)>=2) {balance=false;}
                root.val = Math.max(root.left.val, root.right.val)+1;
            }
        }
    }
}

最长回文子串:

对于一个字符串，请设计一个高效算法，计算其中最长回文子串的长度。 给定字符串A以及它的长度n，请返回最长回文子串的长度。

我的想法是去找那个回文点,然后向两边扩散,到两边的字符不同时就是该字符串的长度,然后和max里面原来的长度比较之后再保存起来,最后输出的就是max.

public  int getLongestPalindrome(String A, int n) {
        char[] ch = A.toCharArray();
        int temp = 2, max = 0;
        int i, j, flag = 0;
        if (ch[0] == ch[1]) {
            max = 2;
        }
        while (temp < n) {
            if (ch[temp] == ch[temp - 1]) {
                i = temp + 1;
                j = temp - 2;
                flag = 2;
                while (j >= 0 && i < n) {
                    if (ch[i] != ch[j]) {
                        flag = flag - 2;
                        j = -1;
                    }
                    i++;
                    j--;
                    flag = flag + 2;
                }
                max = Math.max(max, flag);
            }
            if (ch[temp] == ch[temp - 2]) {
                i = temp + 1;
                j = temp - 3;
                flag = 3;
                while (j >= 0 && i < n) {
                    if (ch[i] != ch[j]) {
                        flag = flag - 2;
                        j = -1;
                    }
                    i++;
                    j--;
                    flag = flag + 2;
                }
                max = Math.max(max, flag);
            }
            temp++;
        }
        return max;
    }

或者可以采用暴力搜索,指针一个个字符遍历,每个字符去找所有的相同字符,然后中间的片段做回文判断,如果这个片段的总长度已经比保存的子串短那就直接不比较来稍微优化一下算法,免得超时,最后输出的也是max.