数据结构与算法-数组练习题

工作的时候，一个bug改一天，一个需求看一周。刷题的时候，三个问题解一天，还是简单的那种，急躁的时候不要继续当前的事情，急躁的时候不要继续当前的事情，急躁的时候不要继续当前的事情（手动敲三遍，希望能牢记）。下面是解了一天的三个leetcode简单小问题：

package com.freshbin.basics.array;

import java.util.HashMap;

/**
 * 面试题 01.01. 判定字符是否唯一
 *
 * 实现一个算法，确定一个字符串 s 的所有字符是否全都不同。
 *
 * 示例 1：
 * 输入: s = "leetcode"
 * 输出: false
 *
 * 示例 2：
 * 输入: s = "abc"
 * 输出: true
 *
 * 限制：
 * 0 <= len(s) <= 100
 * 如果你不使用额外的数据结构，会很加分。
 *
 * @author freshbin
 * @date 2020/5/1 11:18
 */
public class Solution1442 {

    /**
     * 思路：遍历字符串，使用hashMap保存每一个字符，如果该字符已经存在，直接false
     *
     * @param astr
     * @return
     */
    public boolean isUnique(String astr) {
        HashMap keyMap = new HashMap<>();
        for(int i = 0; i < astr.length(); i++) {
            if(keyMap.containsKey(astr.charAt(i))) {
                return false;
            }
            keyMap.put(astr.charAt(i), 1);
        }

        return true;
    }

    public static void main(String[] arg) {
        String test = "abca";
        Solution1442 solution1442 = new Solution1442();
        System.out.println(solution1442.isUnique(test));
    }
}

package com.freshbin.basics.array;

/**
 * 面试题 10.01. 合并排序的数组
 * 给定两个排序后的数组 A 和 B，其中 A 的末端有足够的缓冲空间容纳 B。 编写一个方法，将 B 合并入 A 并排序。
 *
 * 初始化 A 和 B 的元素数量分别为 m 和 n。
 *
 * 示例:
 * 输入:
 * A = [1,2,3,0,0,0], m = 3
 * B = [2,5,6],       n = 3
 * 输出: [1,2,2,3,5,6]
 *
 * @author freshbin
 * @date 2020/5/1 17:47
 */
public class Solution1496 {
    /**
     * 思路：遍历B数组，与A数组从下标为0的值开始往后比较
     * 如果B数组的值比A数组当前下标的值大，那么A数组下标继续往后走
     * 否则，将A数组当前下标以及后面的值都往后推一个索引，
     * 将A数组当前下标的值设为B数组当前值
     * 最后如果B数组还没有全部放入A数组，那么将剩下的数据全部放入A数组后面
     *
     * @param A
     * @param m
     * @param B
     * @param n
     */
    public void merge(int[] A, int m, int[] B, int n) {
        int aIndex = 0;
        int addNum = 0;
        for(int i = 0; i < n; i++) {
            for(; aIndex < m+addNum; aIndex++) {
                if(B[i] <= A[aIndex]) {
                    for(int nextIndex = m+addNum; nextIndex > aIndex; nextIndex--) {
                        A[nextIndex] = A[nextIndex-1];
                    }
                    A[aIndex] = B[i];
                    aIndex++;
                    addNum++;
                    break;
                }
            }
        }
        for(; addNum < n; addNum++) {
            A[m+addNum] = B[addNum];
        }
    }

    public static void main(String[] arg) {
        int[] A = {4,0,0,0,0,0};
        int m = 1;
        int[] B = {1,2,3,5,6};
        int n = 5;
        Solution1496 solution1496 = new Solution1496();
        solution1496.merge(A, m, B, n);

        for(int i : A) {
            System.out.print(i + " ");
        }
    }
}

package com.freshbin.basics.array;

/**
 * 面试题29. 顺时针打印矩阵
 *
 * 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
 * -
 * 示例 1：
 * 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
 * 输出：[1,2,3,6,9,8,7,4,5]
 *
 * 示例 2：
 * 输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
 * 输出：[1,2,3,4,8,12,11,10,9,5,6,7]
 *
 * @author freshbin
 * @date 2020/5/1 14:05
 */
public class Solution1577 {
    /**
     * 思路：顺时针打印，所以流程一直都是从左到右，从上到下，从右到左，从下到上
     *  ps:一开始想到了这样处理，可是在处理边界值的时候，写得乱七八糟，结果写了一两个小时
     *  而且一运行还是错的，当时就崩溃了，于是以为这种想法不太行，
     *  想去看看有没有更巧妙的解法，看了大佬的题解，发现也是这个思路，
     *  再一看边界处理，惊呼，还能这么简单，代码还这么简洁
     *
     * @param matrix
     * @return
     */
    public int[] spiralOrder(int[][] matrix) {
        if(matrix == null || matrix.length == 0) {
            return new int[0];
        }

        int left = 0;
        int right = matrix[0].length - 1;
        int top = 0;
        int down = matrix.length - 1;
        int[] passArray = new int[matrix.length*matrix[0].length];
        int index = 0;

        while(true) {
            for(int i = left; i <= right; i++) {
                passArray[index++] = matrix[top][i];
            }
            if(++top > down) {
                break;
            }
            for(int i = top; i <= down; i++) {
                passArray[index++] = matrix[i][right];
            }
            if(--right < left) {
                break;
            }
            for(int i = right; i >= left; i--) {
                passArray[index++] = matrix[down][i];
            }
            if(--down < top) {
                break;
            }
            for(int i = down; i >= top; i--) {
                passArray[index++] = matrix[i][left];
            }
            if(++left > right) {
                break;
            }
        }
        return passArray;
    }

    public static void main(String[] arg) {
        int[][] material = {{1,2,3},{4,5,6},{7,8,9}};
        Solution1577 solution1577 = new Solution1577();
        int[] array = solution1577.spiralOrder(material);
        for(int i : array) {
            System.out.print(i + " ");
        }
    }
}

看了三个类的创建时间，很好，三个问题的创建时间间隔大概都是3，4个小时，休息，睡觉，明天继续链表的简单题。