剑指Offer（一）—— 单例模式，数组，字符串

一、关键点

高质量代码
边界条件、特殊输入（NULL 空字符串）、错误处理
优化时间、空间 —— 如何分析效率？
熟知各种数据结构优缺点，并能够选择合适的数据结构解决问题
熟练掌握常用算法 查找、排序
知识迁移能力、发散性思维

二、单例模式

• 1.只有一个实例
• 2.必须创建自己唯一的实例
• 3.必须给所有其他对象提供这一实例

饿汉式

package com.mys.offer.singleton;

/**
 * @author mys
 * @version 2019.9.26
 * 饿汉式
 * 1.多线程安全
 * 2.比较常用，但容易产生垃圾对象
 * 3.没有加锁，执行效率高
 * 4.类加载时就初始化，浪费内存
 */

public class SingletonEH {
    private static SingletonEH instance = new SingletonEH();
    private SingletonEH() {

    }
    public static SingletonEH getInstance() {
        System.out.println("instance:" + instance);
        System.out.println("饿汉式");
        return instance;
    }
}

懒汉式

/**
 * @author mys
 * @version 2019.9.26
 * ；懒汉式
 * 1.不是多线程安全
 * 2.不支持多线程，没有加锁synchronized
 */


package com.mys.offer.singleton;

public class SingletonLH {
    private static SingletonLH instance;
    private SingletonLH() {

    }

    public static SingletonLH getInstance() {
        if (instance == null) {
            instance = new SingletonLH();
        }
        return instance;
    }
}

饿汉式实现线程安全

/**
 * 懒汉式实现线程安全
 * 1.多线程安全
 * 2.第一次调用才初始化，避免浪费内存
 * 3.必须加锁synchronized才能保证单例，但加锁会影响效率
 */


package com.mys.offer.singleton;

public class SingletonLHsyn {
    private static SingletonLHsyn instance;
    private SingletonLHsyn() {

    }

    public static synchronized SingletonLHsyn getInstance() {
        if (instance == null) {
            instance = new SingletonLHsyn();
        }
        return instance;
    }
}

面试题2：实现Singleton模式

题目：设计一个类，只能生成该类的一个实例

/**
 * @author mys
 * @version 2019.9.26
 * 题目：设计一个类，只能生成该类的一个实例
 */


package com.mys.offer;

public class test02 {
    //饿汉式,线程安全
    public static class A {
        private final static A instance = new A();

        private A() {

        }

        public static A getInstance() {
            return instance;
        }
    }

    //懒汉式，使用静态内部类，线程安全
    public static class B {
        private static final B instance = new B();

        private B() {

        }

        public static B getInstance() {
            return B.instance;
        }
    }

    // 懒汉式线程安全写法 静态内部类，使用双重校验锁，线程安全
    public static class C {
        private volatile static C instance = null;

        private C() {

        }

        public static C getInstance() {
            if (instance == null) {
                synchronized (C.class) {
                    if (instance == null) {
                        instance = new C();
                    }
                }
            }
            return instance;
        }
    }

    public static void main(String[] args) {
        System.out.println(A.getInstance() == A.getInstance());
        System.out.println(B.getInstance() == B.getInstance());
        System.out.println(C.getInstance() == C.getInstance());
    }
}

三、数组

1. 连续内存，顺序存储
2. 创建时指定数组容量大小，分配内存
3. 根据下标，时间效率高
4. 用数组表示哈希表：下标 => Key 值 => Value
5. 动态数组，解决空间效率不高问题

面试题3：二维数组中查找

题目：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否函数该整数

package com.mys.offer;

/**
 * @author mys
 * @version 2019.9.26
 * 题目:在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，
 * 每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，
 * 判断数组中是否含有该整数
 */

public class test3 {
    public static boolean search(int[][] arr, int value) {
        //判断输入条件
        if (arr == null || arr.length < 1 || arr[0].length < 1) {
            return false;
        }

        int rows = arr.length;//数组的行数
        int cols = arr.length;//数组的列数

        int row = 0;
        int col = rows - 1;

        //确保查找的位置在数组内
        while (row >= 0 && row < rows && col >= 0 && col < cols) {
            //找到value
            if (arr[row][col] == value) {
                return true;
            } else if (arr[row][col] > value) {//当前数比value大，说明value在当前数的左边
                col --;//列数减一，向左移动
            } else {//当前数比value小，说明value在当前数下边
                row ++;//行数加一，向下移动
            }
        }
        return false;
    }

    public static void main(String[] args) {
        int[][] arr = {{1, 2, 8, 9},
                {2, 4, 9, 12},
                {4, 7, 10, 13},
                {6, 8, 11, 15}};
        System.out.println(search(arr, 7));
    }

}

四、字符串

1. '\0’作为结尾

//注意数组越界：
char str[10];
strcpy(str, "0123456789");//需要11个字节数组