ArrayList集合的两个实例应用,有趣的洗牌算法与杨辉三角

本节课的内容,就让我们来学习一下ArrayList集合的应用,ArrayList的本质就是一个顺序表,那下面一起来学习吧

目录

一、杨辉三角

1.题目详情及链接

2.剖析题目  

3.思路及代码

二、洗牌算法

1.创造牌对象

2.创造一副牌

3.洗牌操作

4.发牌操作


一、杨辉三角

这不是普通的杨辉三角,这是力扣里面的杨辉三角

1.题目详情及链接

力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台

 

有同学说,这里的题目也看不出跟ArrayList集合有鸡毛关系呀?我说,你别急,继续往下看

看到这里,你急了没有,题目给的类型是什么狗屎?这不就与ArrayList扯上关系了嘛,这到底是什么意思呢?接着往下看

2.剖析题目  

(1)题目的要求是根据参数,生成杨辉三角的前numRows行,并返回存放杨辉三角的空间

比如:numRows=3,就生成杨辉三角的前面3行;如果你用普通的二维数组存储,那就返回该二维数组的地址。

(2)剖析返回值

我们也应该可以猜到,List<List<Integer>>也是表示二维数组的意思

此时还不算完整的二维数组,List只是一个接口,需要实例化对象

(3)我们需要将这些数字放入该二维数组中

3.思路及代码

(1)思路解析

通过面向对象的思想来完成

第一步:分析杨辉三角的规律

题目要求生成杨辉三角的前numRows行,也就是可以一行一行生成

规律是显而易见的,除了第一行,其他每行的第一个元素和最后一个元素的值都是1;从第3行开始,中间的值与前一行的值紧密相连

第二步:创建二维数组并单独完成杨辉三角的第一行

不用担心测试用例一行都没有,1<=numRows<=30

List<List<Integer>> list = new ArrayList<>();
List<Integer> first = new ArrayList<>();
//先设置第一行的元素
first.add(1);
list.add(first);

核心思想:先单独建立一个一维的顺序表,存放好一行的元素,然后再将这个一维的顺序表当成一个元素放入二维的顺序表中,后面也是一样的思想

第三步:存放第二行及后面的元素

for (int i = 1; i < numRows; i++) {//每层循环代表一行
     List<Integer> ret = new ArrayList<>();//定义一个一维数组    
}

我们将在这个循环里面存放完成后续的行,如果只有一行,就不会进入这个循环内

第四步:分析如何将每一行存入

由前面分析知道,第二行开始,第一个和最后一个元素都是1,我们可以在前面和最后面存入1

    for (int i = 1; i < numRows; i++) {//每层循环代表一行
            List<Integer> ret = new ArrayList<>();//定义一个一维数组
            //1.添加第一个元素
            ret.add(1);
            //2.设置中间元素,从第二列开始
           
            //3.添加最后元素
            ret.add(1);
            list.add(ret);//将每一行放入二维数组中
    }

然后中间的元素如何添加?第二行是没有中间元素的,而且中间的元素都是与前一行的元素有着紧密的关系,所以我们也需要考虑好。首先,我们需要从第二个位置开始存放;然后,第几行就说明那一行有多少个元素,就与行号绑定了关系

        for (int i = 1; i < numRows; i++) {//每层循环代表一行
            List<Integer> ret = new ArrayList<>();//定义一个一维数组
            //1.添加第一个元素
            ret.add(1);
            //2.设置中间元素,从第二列开始
            for (int j = 1; j < i; j++) {
                //利用面向对象的思想,拿到元素
                int tmp = list.get(i-1).get(j)+list.get(i-1).get(j-1);
                ret.add(tmp);
            }
            //3.添加最后元素
            ret.add(1);
            list.add(ret);
        }

(2)完整代码

 public List<List<Integer>> generate(int numRows) {
         List<List<Integer>> list = new ArrayList<>();
        List<Integer> first = new ArrayList<>();
        //先设置第一行的元素
        first.add(1);
        list.add(first);
        //从第二行开始
        for (int i = 1; i < numRows; i++) {//每层循环代表一行
            List<Integer> ret = new ArrayList<>();//定义一个一维数组
            //1.添加第一个元素
            ret.add(1);
            //2.设置中间元素,从第二列开始
            for (int j = 1; j < i; j++) {
                int tmp = list.get(i-1).get(j)+list.get(i-1).get(j-1);
                ret.add(tmp);
            }
            //3.添加最后元素
            ret.add(1);
            list.add(ret);
        }

        return list;
}

(3)总结一下思路

第一:将杨辉三角分成两个部分存储(第一行和第一行后面的

第二:存储第一行后面的时候,又分成三部分存储(第一个元素、中间部分元素、最后一个元素)

第三:存储中间部分元素时,通过与前一行的元素的关系进行存储(利用面向对象的思想获得前一行的元素)

二、洗牌算法

其实,洗牌算法就是ArrayList的一种应用,或者运用,没有那么的高大尚,下面简单介绍洗牌算法的一些基本功能和流程

下面是程序运行起来的结果: 

什么是洗牌算法?

(1)使用类和对象的知识定义一个牌对象

(2)创造出一副排序好的牌,存储在ArrayList中(有牌)

(3)然后将这些牌的顺序打乱(洗牌)

(4)将洗乱的牌随机分发给三个人(发牌)

下面开始讲解洗牌算法

1.创造牌对象

 牌这个对象的属性有两个:第一是花色,第二就是号码;然后我们提供一下构造方法,在创建每一张牌的时候就赋值;最后,重写一下toString方法,用来打印牌。

public class Card {
    //用来定义一张牌
    public String suit;//牌的花色
    public int num;//号码

    public Card(String suit, int num) {
        this.suit = suit;
        this.num = num;
    }

    @Override
    public String toString() {
       return suit+num;
    }
}
2.创造一副牌

main函数,用来实例化对象,和调用对象中的方法(创造牌的方法)

public static void main(String[] args) {
        PlayCard game = new PlayCard();

        System.out.println("设置牌:");
        List<Card> cards = game.setCard();
        System.out.println(cards);

}

 创建一个类,用来表示玩牌的游戏,里面存放创建牌、洗牌和发牌的操作

public class PlayCard {
    
    public static final String[] suits = {"♠","♥","♣","♦"};//定义花色的数组

    //1.设置牌操作
    public List<Card> setCard() {
        List<Card> cards = new ArrayList<>();//定义一个数组,用来存放所有牌
        for (int i = 0; i < 4; i++) {//每次循环代表一个花色
            for (int j = 1; j <=13 ; j++) {//13个号码
                String suit = suits[i];//获得一个花色

                Card card = new Card(suit,j);//定义一个牌对象并赋值

                cards.add(card);//将牌放入一个牌数组中
            }
        }
        return cards;//返回一副牌
    }
}

(1)这是一个带返回值的函数。

(2)第一层循环,代表花色;第二层循环代码号码;每循环一次:拿到一个花色和号码,然后将这两个赋值给牌对象,并将牌放入ArrayList集合中(cards)

(3)最后将这个集合返回(接收返回值就拿到了返回值)

3.洗牌操作

这里先把上一阶段创造牌的操作隐藏,独将洗牌操作

这里洗牌的思想是:(1)从后面遍历这副牌,每张牌都随机与前面某一张牌交换

(2)获得前面随机牌使用产生随机数种子

(3)交换则单独包装成一个方法

public class PlayCard {
    //在这里类里面操作牌:设置牌,洗牌和发牌
    public static final String[] suits = {"♠","♥","♣","♦"};//定义花色的数组

    //1.设置牌操作
   //这里介绍洗牌操作,所以设置牌的操作就省略了

    //2.洗牌操作
    public void shuffle(List<Card> cards) {
        Random random = new Random();
        for (int i = 51; i > 0; i--) {
            int index  = random.nextInt(i);//随机获取一个牌下标与i下标的牌交换
            swap(cards,i,index);
        }
        //return cards;
    }
    private static void swap(List<Card> cards,int i,int j) {
        //交换两张牌
        Card tmp = cards.get(i);
        cards.set(i,cards.get(j));
        cards.set(j,tmp);
    }

}

4.发牌操作

同样的,我们把前面创造牌和洗牌的操作隐藏起来,单独介绍发牌操作

我们发牌的思路是:(1)有三个人轮流接牌,每次接一张,一共接五轮(2)每个人随机接牌,每拿到一张牌,就从这副牌中删除(3)每个人拿到五张牌,每个人看作一个一维数组;要保存三个人的牌,就需要一个二维数组。

public class PlayCard {
    //在这里类里面操作牌:设置牌,洗牌和发牌
    public static final String[] suits = {"♠","♥","♣","♦"};//定义花色的数组

    //1.设置牌操作
  
    //2.洗牌操作
  
    //3.发牌操作
    public List<List<Card>> getCard(List<Card> cards) {
        //定义三个对象,存取牌
        List<Card> hand1 =new ArrayList<>();
        List<Card> hand2 =new ArrayList<>();
        List<Card> hand3 =new ArrayList<>();
        //定义一个二维数组,存取三个对象
        List<List<Card>> hand = new ArrayList<>();
        hand.add(hand1);
        hand.add(hand2);
        hand.add(hand3);

        //每个人只能拿五张牌
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
              Card card = cards.remove(0);//每次拿到第一张牌,并从数组中删掉
              //放入每个人手中
              hand.get(j).add(card);
            }
        }
        return hand;
    }
}

(1)用三个一维的集合代表三个一维数组 (2)再定义一个集合,存放三个一维集合 (3)第一层循环,每循环一次就是一张牌;第二层循环就是每个人轮流拿牌 (4) hand.get(j)代表第几个人,add(card)代表把这张牌给某个人

完整代码:

public static void main(String[] args) {
        PlayCard game = new PlayCard();

        System.out.println("设置牌:");
        List<Card> cards = game.setCard();
        System.out.println(cards);

        System.out.println("洗牌后:");
        game.shuffle(cards);
        System.out.println(cards);

        System.out.println("发牌:");
        List<List<Card>> hand = game.getCard(cards);
        for (int i = 0; i < 3 ; i++) {
            System.out.println("第"+(i+1)+"个人的牌为:"+hand.get(i));
        }

        System.out.println("剩余的牌为:");
        System.out.println(cards);
    }
public class Card {
    //用来定义一张牌
    public String suit;//牌的花色
    public int num;//号码

    public Card(String suit, int num) {
        this.suit = suit;
        this.num = num;
    }

    @Override
    public String toString() {
       return suit+num;
    }
}
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;

public class PlayCard {
    //在这里类里面操作牌:设置牌,洗牌和发牌
    public static final String[] suits = {"♠","♥","♣","♦"};//定义花色的数组

    //1.设置牌操作
    public List<Card> setCard() {
        List<Card> cards = new ArrayList<>();//定义一个数组,用来存放所有牌
        for (int i = 0; i < 4; i++) {//四种花色
            for (int j = 1; j <=13 ; j++) {//13个号码
                String suit = suits[i];//获得一个花色

                Card card = new Card(suit,j);//定义一个牌对象并赋值

                cards.add(card);//将牌放入一个牌数组中
            }
        }
        return cards;//返回一副牌
    }

    //2.洗牌操作
    public void shuffle(List<Card> cards) {
        Random random = new Random();
        for (int i = 51; i > 0; i--) {
            int index  = random.nextInt(i);//随机获取一个牌下标与i下标的牌交换
            swap(cards,i,index);
        }
        //return cards;
    }
    private static void swap(List<Card> cards,int i,int j) {
        //交换两张牌
        Card tmp = cards.get(i);
        cards.set(i,cards.get(j));
        cards.set(j,tmp);
    }

    //3.发牌操作
    public List<List<Card>> getCard(List<Card> cards) {
        //定义三个对象,存取牌
        List<Card> hand1 =new ArrayList<>();
        List<Card> hand2 =new ArrayList<>();
        List<Card> hand3 =new ArrayList<>();
        //定义一个二维数组,存取三个对象
        List<List<Card>> hand = new ArrayList<>();
        hand.add(hand1);
        hand.add(hand2);
        hand.add(hand3);

        //每个人只能拿五张牌
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
              Card card = cards.remove(0);//每次拿到第一张牌,并从数组中删掉
              //放入每个人手中
              hand.get(j).add(card);
            }
        }
        return hand;
    }
}

本节的内容就是介绍ArrayList集合的用法,可以当成一维数组,也可以当成二维数组。看到这里本机就结束了,快趁着这个感觉去刷题吧!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/245168.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Alibaba分布式事务组件Seata AT实战

1. 分布式事务简介 1.1 本地事务 大多数场景下&#xff0c;我们的应用都只需要操作单一的数据库&#xff0c;这种情况下的事务称之为本地事务(Local Transaction)。本地事务的ACID特性是数据库直接提供支持。本地事务应用架构如下所示&#xff1a; 在JDBC编程中&#xff0c;我…

力扣24 两两交换链表中的节点 Java版本

文章目录 题目解题方法Code 题目 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 示例 1&#xff1a; 输入&#xff1a;hea…

事务隔离级别:保障数据库并发事务的一致性与性能

目录 引言 1. 事务隔离级别概述 2. 读未提交隔离级别 3. 读已提交隔离级别 4. 可重复读隔离级别 5. 串行化隔离级别 6. 保障事务隔离级别的机制 7. 如何选择合适的隔离级别 8. 结语 引言 在数据库管理系统&#xff08;DBMS&#xff09;中&#xff0c;事务隔离级别是一…

12.14_黑马数据结构与算法笔记Java

目录 120 二叉搜索树 min max 121 二叉搜索树 put 122 二叉搜索树 前任后任1 123 二叉搜索树 前任后任2 124 二叉搜索树 删除1 125 二叉搜索树 删除2 126 二叉搜索树 删除3 127 二叉搜索树 删除 递归1 128 二叉搜索树 删除 递归2 129 二叉搜索树 范围查询 130 二叉搜…

ADC学习总结

ADC的架构分类&#xff1a; 1、Delta-Sigma 采样率一般是在1M以内&#xff0c;位数一般可以做的很高&#xff0c;比如24位&#xff0c;Delta-Sigma ADC采用了过采样技术&#xff0c;不需要在模拟输入端加抗混叠滤波&#xff0c;由后端数字滤波器进行处理&#xff0c;通过信噪…

网工内推 | IT经理,50k*14薪,NP以上即可,七险一金

01 海天瑞声 招聘岗位&#xff1a;IT经理 职责描述&#xff1a; 1、IT基础架构的方案制定、实施和日常维护&#xff0c;包括机房建设运维、服务器配置及运维、网络规划及运维、上网行为管理、电话、电话、监控、门禁等各类弱电系统搭建及运维 2、负责公司环境及网络安全防御体…

WEB服务器介绍

Web服务器是指驻留于因特网上某种类型计算机的程序。当Web浏览器连到服务器上并请求文件时&#xff0c;服务器将处理该请求并将文件发送到该浏览器上&#xff0c;附带的信息会告诉浏览器如何查看该文件&#xff0c;即文WEB服务器件类型。服务器使用HTTP进行信息交流&#xff0c…

ASF-YOLO开源 | SSFF融合+TPE编码+CPAM注意力,精度提升!

目录 摘要 1 Introduction 2 Related work 2.1 Cell instance segmentation 2.2 Improved YOLO for instance segmentation 3 The proposed ASF-YOLO model 3.1 Overall architecture 3.2 Scale sequence feature fusion module 3.3 Triple feature encoding module …

Kvaser Leaf v3 重磅上新!报文速率高达20000条/秒!支持CAN FD!EAN: 73-30130-01424-4

作为CAN总线领域的专家&#xff0c;Kvaser深耕行业40年&#xff0c;至今已经累计推出100多款CAN产品。其中稳定小巧、便携易用的Kvaser经典Leaf系列是将计算机与CAN网络连接并获取CAN/CAN FD数据的最简单、性价比最高的方法之一。Kvaser秉持着将用户放在重要位置的原则&#xf…

6.5.编解码器信息的收集

那在上节课中呢&#xff1f;我向你介绍了add track相关的内容&#xff0c;那今天呢&#xff1f;我们来看看编解码器信息的收集。那在这里呢&#xff0c;我们需要问几个重要的问题&#xff0c;那首先呢&#xff0c;就是我们上节课通过&#xff0c;可以让web rtc知道我们都要传输…

智能优化算法应用:基于旗鱼算法3D无线传感器网络(WSN)覆盖优化 - 附代码

智能优化算法应用&#xff1a;基于旗鱼算法3D无线传感器网络(WSN)覆盖优化 - 附代码 文章目录 智能优化算法应用&#xff1a;基于旗鱼算法3D无线传感器网络(WSN)覆盖优化 - 附代码1.无线传感网络节点模型2.覆盖数学模型及分析3.旗鱼算法4.实验参数设定5.算法结果6.参考文献7.MA…

优先考虑静态成员类

在Java中&#xff0c;静态成员类&#xff08;static nested class&#xff09;是一种嵌套在另一个类中的类&#xff0c;且被声明为静态。静态成员类不依赖于外部类的实例&#xff0c;可以直接通过外部类的类名来访问。 优先考虑使用静态成员类的情况通常是当这个类与外部类的实…

一文带你了解UI自动化测试框架

PythonSeleniumUnittestDdtHTMLReport分布式数据驱动自动化测试框架结构 1、Business&#xff1a;公共业务模块&#xff0c;如登录模块&#xff0c;可以把登录模块进行封装供调用 ------login_business.py from Page_Object.Common_Page.login_page import Login_Page from H…

探秘闭包:隐藏在函数背后的小秘密(上)

&#x1f90d; 前端开发工程师&#xff08;主业&#xff09;、技术博主&#xff08;副业&#xff09;、已过CET6 &#x1f368; 阿珊和她的猫_CSDN个人主页 &#x1f560; 牛客高级专题作者、在牛客打造高质量专栏《前端面试必备》 &#x1f35a; 蓝桥云课签约作者、已在蓝桥云…

C# 图解教程 第5版 —— 第17章 转换

文章目录 17.1 什么是转换17.2 隐式转换17.3 显示转换和强制转换17.4 转换的类型17.5 数字的转换17.5.1 隐式数字转换17.5.2 溢出检测上下文17.5.3 显示数字转换 17.6 引用转换17.6.1 隐式引用转换17.6.2 显式引用转换17.6.3 有效显式引用转换 17.7 装箱转换17.7.1 装箱是创建副…

小程序 -网络请求post/get

1.1网络请求的概念(post和get) 1.2步骤 1.3 应用函数 js里面写&#xff0c;用bindtap绑在控件上&#xff0c;就不讲了 实例代码&#xff1a; //发起get数据请求get_info(){wx.request({url:https://www.escook.cn/api/get,//请求的接口地址,必须基于https协议//请求的方式met…

SpringBoot的Starter自动化配置,自己编写配置maven依赖且使用及短信发送案例

目录 一、Starter机制 1. 是什么 2. 有什么用 3. 应用场景 二、短信发送案例 1. 创建 2. 配置 3. 编写 4. 形成依赖 6. 其他项目的使用 每篇一获 一、Starter机制 1. 是什么 SpringBoot中的starter是一种非常重要的机制(自动化配置)&#xff0c;能够抛弃以前繁杂…

【五】Python 代理模式

文章目录 5.1 代理模式概述5.1.1 代理介绍5.1.2 代理模式的作用 5.2 代理模式的UML类图5.3 了解不同类型的代理5.3.1虚拟代理5.3.2 远程代理5.3.3 保护代理5.3.4 智能代理 5.4 现实世界中的代理模式5.5 代理模式的优点5.6 门面模式和代理模式之间的比较 5.1 代理模式概述 5.1.…

卷积神经网络(含案例代码)

概述 卷积神经网络&#xff08;Convolutional Neural Network&#xff0c;CNN&#xff09;是一类专门用于处理具有网格结构数据的神经网络。它主要被设计用来识别和提取图像中的特征&#xff0c;但在许多其他领域也取得了成功&#xff0c;例如自然语言处理中的文本分类任务。 C…

Paper Reading: (CCVC) 基于冲突的半监督语义分割跨视图一致性

目录 简介目标/动机工作重点方法CVC: 跨视图一致性CPL: 基于冲突的伪标记 实验设置comparison with SOTAAblation 总结 简介 题目&#xff1a;《Conflict-Based Cross-View Consistency for Semi-Supervised Semantic Segmentation》&#xff0c; CVPR’23, 基于冲突的半监督语…