杨辉三角（java中ArrayList实际应用）

1.杨辉三角（简单）

给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

题目来源：力口（LeetCode）

示例 1:

输入: numRows = 5
输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
示例 2:

输入: numRows = 1
输出: [[1]]

代码实现：

class Solution {               //使用leetcode题目框架
    public List<List<Integer>> generate(int numRows) {
  List sanjiao=new ArrayList<>();//三角形
        List<Integer> row1=new ArrayList<>();//行
        row1.add(1);                //第一行特例只有一个1
        sanjiao.add(row1);            //将第一行添加到三角形中
        for (int i = 1; i <numRows; i++) {            //2-n行具有相同特征
            List<Integer> row=new ArrayList<Integer>();
            row.add(1);                            //每一行的第一个元素都是1

for(int j=1;j<=(i-1);j++){
    List<Integer> rooww= (List<Integer>) sanjiao.get(i-1);
    int left=rooww.get(j-1);                       //获取三角形中的上一行数据
int right=rooww.get(j);
int sum=left+right;
row.add(sum);

}
row.add(1);                                        //每一行的最后一个元素都是1
            sanjiao.add(row);
        }
        return sanjiao;
    }
}

2.扑克牌

ArrayList实际应用——创建一副扑克牌，并实现洗牌发牌等功能

public class Poker {
public String suit;//花色
public int rank;//数值
    @Override
    public String toString() {
        return String.format("[%s %d]", suit, rank);
    }

}

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

public class CardDemo {
    public static   final String[] suits={"♦","♣","♥","♠"};
    //买一副新牌(初始化)
    //deck是一副牌，poker是一张牌
    private static List<Poker>buyDeck(){
        List<Poker> deck=new ArrayList<>(52);
        for (int i = 0; i <4; i++) {
            for (int j = 0; j <14; j++) {
                String suit=suits[i];
                int rank=j;
                Poker poker=new Poker();        //初始化一张牌
                poker.rank=rank;
                poker.suit=suit;

                deck.add(poker);        //将一张牌添加到一副牌中
            }
        }
        return deck;
    }

//牌进行交换
    private static  void swap(List<Poker> deck,int i ,int j){
        Poker t= deck.get(i);       //设置临时变量保存目标下标
        deck.set(i,deck.get(j));
        deck.set(j,t);
    }
    //以随机交换的形式进行洗牌
    private static void xipai(List<Poker> deck){
        Random random=new Random(52);
        for (int i = 1; i <=52; i++) {
            int z= random.nextInt(i);
            swap(deck,i,z);
        }
    }

    public static void main(String[] args) {
        List<Poker> deck=buyDeck(); //初始化
        System.out.println("买一副新扑克牌");
        System.out.println(deck);
        //洗牌
        xipai(deck);
        System.out.println("洗牌后:"+deck);
        //假设三个人玩
        List<List<Poker>> hands=new ArrayList<>();
        hands.add(new ArrayList<>());
        hands.add(new ArrayList<>());
        hands.add(new ArrayList<>());
//发牌
        for (int i = 0; i <14; i++) {
            for (int j = 0; j < 3; j++) {
                hands.get(j).add(deck.remove(0));
            }
        }
        System.out.println("第一个人的牌："+hands.get(0));
        System.out.println("第二个人的牌："+hands.get(1));
        System.out.println("第三个人的牌："+hands.get(2));
    }
}

运行结果：

3.移除元素

题目描述：

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

来源：力口（LeetCode）

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

class Solution {
    public int removeElement(int[] nums, int val) {
        int j=0;
for(int i=0;i<nums.length;i++){
if(nums[i]!=val){
    nums[j]=nums[i];
    j++;
}

}
return j;
    }
}

4.删除排序数组中的重复项

题目描述：

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

来源：力口（LeetCode）

示例 1：输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
示例 2：输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

class Solution {
    public int removeDuplicates(int[] nums) {
int j=1;
for(int i=1;i<nums.length;i++){
    if(nums[i]!=nums[i-1]){
nums[j]=nums[i];                             
j++;
    }
}
return j;
    }
}