【数据结构刷题】顺序表与ArrayList

[1. 杨辉三角](#1. 杨辉三角)
[2. 合并两个有序数组](#2. 合并两个有序数组)

1. 杨辉三角

java 复制代码

//杨辉三角

import java.util.ArrayList;
import java.util.List;

public class Demo1 {
    public List<List<Integer>> generate(int numRows) {
            List<List<Integer>> result = new ArrayList<>();
        for (int i = 0; i < numRows; i++) {//构造 numRows 行
            List<Integer> row = new ArrayList<Integer>();//向上转型：ArrayList是具体实现的子类，List是更上层的父类（接口）
            for (int j = 0; j < i + 1; j++) {
                if(j == 0 || j == i){//杨辉三角的第一列和最后一列，都是1
                    row.add(1);
                }else {
                    //一般的列，值为：result[i-1][j-1] + result[i-1][j]
                    int current = result.get(i-1).get(j-1) + result.get(i-1).get(j);
                    row.add(current);
                }
            }
            //此处，已经把一行构造好了，只需要把这一行整体 添加到 result 中
            result.add(row);
        }
        return result;
    }
    public static void main(String[] args) {
        Demo1 demo = new Demo1();
        List<List<Integer>> result= demo.generate(5);
        System.out.println(result);
    }
}

输出结果：

2. 合并两个有序数组

牛客链接：合并两个有序数组

java 复制代码

import java.util.Arrays;

//合并两个有序数组
public class Demo2 {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        // end1、end2：分别标记nums1 和 nums2最后一个有效元素位置
        // end标记nums1的末尾，因为nums1和nums2中的元素从后往前往nums1中存放，否则会存在数据覆盖
        int end1 = m-1;
        int end2 = n-1;
        int end = nums1.length-1;

        // 从后往前遍历，将num1或者nums2中较大的元素往num1中end位置搬移
        // 直到将num1或者num2中有效元素全部搬移完
        while(end1 >= 0 && end2 >= 0){
            if(nums1[end1] > nums2[end2]){
                nums1[end--] = nums1[end1--];
            }else{
                nums1[end--] = nums2[end2--];
            }
        }

        // 如果nums2中的数据没有搬移完，搬移剩余nums中的元素
        while(end2 >= 0){
            nums1[end--] = nums2[end2--];
        }

        // num1中可能有数据没有搬移完，不用管，因为这些元素已经在nums1中了
    }

    public static void main(String[] args) {
        Demo2 merger = new Demo2();

        // 测试用例1: 正常情况
        int[] nums1 = {1, 2, 3, 0, 0, 0};
        int[] nums2 = {2, 5, 6};
        merger.merge(nums1, 3, nums2, 3);
        System.out.println("测试1 - 正常合并: " + arrayToString(nums1));
        // 预期: [1, 2, 2, 3, 5, 6]

        // 测试用例2: nums2为空
        nums1 = new int[]{1, 2, 3};
        nums2 = new int[]{};
        merger.merge(nums1, 3, nums2, 0);
        System.out.println("测试2 - nums2为空: " + arrayToString(nums1));
        // 预期: [1, 2, 3]

        // 测试用例3: nums1初始为空
        nums1 = new int[]{0, 0, 0};
        nums2 = new int[]{1, 2, 3};
        merger.merge(nums1, 0, nums2, 3);
        System.out.println("测试3 - nums1初始为空: " + arrayToString(nums1));
        // 预期: [1, 2, 3]

        // 测试用例4: 有重复元素
        nums1 = new int[]{1, 2, 2, 0, 0};
        nums2 = new int[]{2, 3};
        merger.merge(nums1, 3, nums2, 2);
        System.out.println("测试4 - 有重复元素: " + arrayToString(nums1));
        // 预期: [1, 2, 2, 2, 3]

        // 测试用例5: nums1所有元素小于nums2
        nums1 = new int[]{1, 2, 3, 0, 0};
        nums2 = new int[]{4, 5};
        merger.merge(nums1, 3, nums2, 2);
        System.out.println("测试5 - nums1全部小于nums2: " + arrayToString(nums1));
        // 预期: [1, 2, 3, 4, 5]

        // 测试用例6: nums2所有元素小于nums1
        nums1 = new int[]{4, 5, 6, 0, 0};
        nums2 = new int[]{1, 2};
        merger.merge(nums1, 3, nums2, 2);
        System.out.println("测试6 - nums2全部小于nums1: " + arrayToString(nums1));
        // 预期: [1, 2, 4, 5, 6]
    }

    // 辅助方法，用于美化数组输出
    private static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            sb.append(arr[i]);
            if (i < arr.length - 1) {
                sb.append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

输出结果：