数据开发工程师-面试题

1、数据仓库的结构？

数据仓库是一个用于存储、管理和分析大规模数据的集中式数据存储系统。它的结构通常包括以下主要组件和层次。

• 数据源：数据仓库的数据源包括各种不同的数据系统，如关系数据库、日志文件、外部API、云存储等。数据从这些源头采集、抽取、转换和加载到数据仓库种。
• 数据抽取：在这个阶段，数据从各个数据源中提取出来，以备后续处理。抽取的数据可能包括原始数据、历史数据、事务数据等。
• 数据转换：在数据仓库中，数据通常需要经过清洗、转换和整合，以满足分析和报告需求。数据转换的任务包括数据清洗、字段映射、数据合并、计算指标等。
• 数据加载：转换后的数据被加载到数据仓库中的不同层次，通常包括原始数据存储、中间数据存储和数据仓库数据存储。数据加载过程可以是批处理或实时流处理。
• 数据存储层次：数据仓库包括多个存储层次，其中包括①原始数据存储，保留未经处理的原始数据，以备不同的分析需求；②数据仓库存储，包含已经经过清洗、转换和整合的数据，用于执行高级分析和报告。③数据汇总存储：包含已经汇总和预计算的数据，用于提高查询性能和执行复杂的分析任务。
• 元数据管理：数据仓库需要维护元数据，以描述存储在其中的数据的结构、来源、定义、变换规则等信息。元数据对于数据仓库的管理和查询优化非常重要。
• 数据访问层：数据仓库提供不同的方式供用户和应用程序访问数据，包括SQL查询、OLAP（在线分析处理）工具、报告工具和API等。
• 查询和分析工具：数据仓库通常于各种查询和分析工具集成，以支持用户进行数据探索、查询和报告。
• 安全性和权限控制：数据仓库需要实施严格的安全行和权限控制，以确保只有经过授权的用户可以访问和操作数据。
• 监控和性能优化：数据仓库需要实时监控，以确保性能和可用性。性能优化是一个持续的过程，包括索引、分区、缓存等技术。

2、python-逆序对取模

逆序对取模通常需要使用归并排序算法。逆序对在一个数组中，如果一个数比其后面的数大，则称这两个数构成一个逆序对。

def merge_sort(arr, mod):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = arr[:mid]
        right_half = arr[mid:]
 
        left_half, left_inv_count = merge_sort(left_half, mod)
        right_half, right_inv_count = merge_sort(right_half, mod)
 
        merged_arr, split_inv_count = merge(left_half, right_half, mod)
 
        inv_count = left_inv_count + right_inv_count + split_inv_count
        return merged_arr, inv_count
    else:
        return arr, 0
 
def merge(left, right, mod):
    merged_arr = []
    inv_count = 0
    i = j = 0
 
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            merged_arr.append(left[i])
            i += 1
        else:
            merged_arr.append(right[j])
            j += 1
            inv_count += len(left) - i
 
    merged_arr.extend(left[i:])
    merged_arr.extend(right[j:])
 
    return merged_arr, inv_count
 
def count_inverse_pairs(arr, mod):
    _, inv_count = merge_sort(arr, mod)
    return inv_count % mod
 
# 示例用法
arr = [2, 4, 1, 3, 5]
mod = 1000000007
result = count_inverse_pairs(arr, mod)
print("逆序对数取模结果:", result)

3、Python-合并两个已排序的数组

方法：使用双指针的方法，遍历两个输入数组，逐个比较元素，将较小的元素添加到新数组中。

def merge_sorted_arrays(arr1, arr2):
    merged_arr = []
    i = j = 0
 
    while i < len(arr1) and j < len(arr2):
        if arr1[i] < arr2[j]:
            merged_arr.append(arr1[i])
            i += 1
        else:
            merged_arr.append(arr2[j])
            j += 1
 
    # 将剩余的元素添加到新数组中
    while i < len(arr1):
        merged_arr.append(arr1[i])
        i += 1
 
    while j < len(arr2):
        merged_arr.append(arr2[j])
        j += 1
 
    return merged_arr
 
# 示例用法
arr1 = [1, 3, 5, 7]
arr2 = [2, 4, 6, 8]
result = merge_sorted_arrays(arr1, arr2)
print("合并后的已排序数组:", result)

4、Spark和Hadoop是大数据处理领域的两个重要框架，它们有一些异同点。

相同点：

• 都为开源框架，可以免费使用和修改。
• 两者都旨在处理大规模数据，采用分布式计算模型，能够在多台计算节点上并行执行任务。
• 容错性：两者都具备容错性，能够处理节点故障，并保证任务的完成。
• 支持多种数据源：两者都可以处理不同的数据源，包括结构化数据（如关系型数据）、半结构化数据（XML，JSON）和非结构化数据（文本、日志等）
• 支持多种编程语言：包括Java、Python、Scala等，使开发者可以使用他们熟悉的语言进行大数据处理。

不同点：

• 数据处理模型：①Hadoop使用MapReduce模型，这是一种批处理模型，适用于离线的数据处理。MapReduce任务通常需要将数据写入磁盘中间存储，因此对于迭代算法或实时处理来说效率较低。②spark使用基于内存的计算模型，可以更高效地进行迭代处理和实时处理，因为它可以将中间数据存储在内存中。
• 性能：①Spark通常比Hadoop的Mapreduce更快，尤其在迭代算法（如机器学习）和实时数据处理方面。这是因为spark充分利用了内存计算，减少了磁盘IO。②Hadoop的MapReduce更适合一次性、批处理式的任务。
• API和生态系统：①Spark提供了更多的高级API，包括支持SQL查询的Spark SQL、机器学习库MLib、图处理库GraphX等，使得开发更加方便。②Hadoop生态系统包括Hive(支持SQL查询、pig(数据流脚本语言）、HBase(NoSQL数据库）等，但需要更多的工具和库来实现类似的功能。
• 复杂度：①Spark通常更容易使用，因为它提供了高级API和更友好的编程模型。②Hadoop的MapReduce需要更多的手工编码和配置。
• 资源管理器：①Hadoop使用YARN（Yet Another Resource Negotiator）作为资源管理器，负责分配集群资源给不同的任务。②Spark自带了一个资源管理器，称为Cluster Manager，也可以与YARN和Mesos等外部资源管理器集成。

5、Java-二分查找

public int search(int[] nums, int left, int right, int target) {
        while (left <= right){
            int mid = left + (right - left) / 2;
            if (nums[mid] == target){
                return mid;
            }else if (nums[mid]< target){
                return search(num, mid + 1, right, target);
            }else{
                return search(num, left, mid - 1, target);
            }
        }
        return -1;
 }

6、Java-双指针

递增数组，判断数组中是否存在两个数之和为target，思路为双指针，一个begin,一个end,每次移动一个指针

public int[] twoSum(int[] numbers, int target) {
        int p1 = 0;
        int p2 = numbers.length - 1;
        while (p1 < p2){
            int sum = numbers[p1] + numbers[p2];
            if (sum == target){
                return new int[]{p1 + 1, p2 + 1};
            } else if (sum < target){
                p1++;
            } else {
                p2--;
            }
        }
        //无解
        return new int[]{-1, -1};
}

7、Java-最长递增子序列LIS（动态规划）

 给一个整数数组nums，找到其中最长严格递增子序列的长度。最优时间复杂度为O（nlogn)

public int lengthOfLIS(int[] nums) {
        int dp[] = new int[nums.length];
        dp[0] = 1;
        int maxSeqLen = 1;
        for (int i=1; i
            //初始化为1
            dp[i] = 1;
            for (int j = 0; j <= i; j++) {
                //对dp[i]进行更新，严格递增
                if (nums[i] > nums[j]){
                    dp[i] = Math.max(dp[i], dp[j]+1);
                }
            }
            maxSeqLen = Math.max(maxSeqLen, dp[i]);
        }
        return maxSeqLen;
}

8、逆序链表两数求和

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode pre = new ListNode(0);
        ListNode cur = pre;
        int carry = 0;
        while(l1 != null || l2 != null) {
            int x = l1 == null ? 0 : l1.val;
            int y = l2 == null ? 0 : l2.val;
            int sum = x + y + carry;
            
            carry = sum / 10;
            sum = sum % 10;
            cur.next = new ListNode(sum);
 
            cur = cur.next;
            if(l1 != null)
                l1 = l1.next;
            if(l2 != null)
                l2 = l2.next;
        }
        if(carry == 1) {
            cur.next = new ListNode(carry);
        }
        return pre.next;
    }
}

9、Mysql的三范式

• 第一范式（1NF）：数据表中的每一列都包含不可再分的原子数据，也就是每个单元格中只能存储一个值。所有的数据必须是原子的，不能包含集合、数组、嵌套表格等非原子数据。

• 第二范式（2NF）：数据表必须符合第一范式（1NF）。所有非主键列（非关键字列）都必须完全依赖于候选键（主键）。 这意味着没有部分依赖，即表中的每一列都应该与主键有关系，而不是只与主键的一部分有关。

• 第三范式（3NF）：数据表必须符合第二范式（2NF）。所有非主键列都不应该传递依赖于主键。换句话说，非主键列之间不应该存在传递依赖关系。如果一个非主键列依赖于另一个非主键列，而后者又依赖于主键，那么就存在传递依赖，这需要通过分解表来消除。非主键都和主键直接相关，不存在间接相关。

10、Mysql的InnoDB和MyIsam的区别

• InnoDB支持事务，MyISAM不支持事务。
• InnoDB支持外键
• InnoDB是聚集索引，MyISAM是非聚集索引
• InnoDB不支持具体的行数；InnoDB的最小锁的粒度是行锁，MyISAM的最小粒度是表锁。

11、MySQL的隔离级别

• 未提交读：即未提交也读，事务中间也可以读，容易产生脏读、幻读、不可重复读。
• 已提交读：只有在事务提交后才可以读，避免了脏读，但是无法避免不可重复读、幻读。
• 可重复读：在事务提交的时候，不可以读和修改数据，避免了脏读和不可重复读。
• 串行读：隔离级别最高，所有的事务都是串行化执行，避免了脏读、幻读和不可重复读。