【数据结构】顺序表（杨辉三角、简单的洗牌算法）

🎇🎉🎉🎉点进来你就是我的人了
博主主页：🙈🙈🙈戳一戳，欢迎大佬指点！
欢迎志同道合的朋友一起加油喔 💪💪💪
谢谢你这么帅气美丽还给我点赞！比个心**

文章目录

一、面试题（CVTE）
- 1. 题目描述
- 2. 要求及解析
- 3. 代码展示
- 4. 注意点
二、杨辉三角
- 1. 题目
- 2. 画图解析
- 3. 知识点
- 4. 代码展示
三、简单的洗牌算法
- 1. 理解怎么玩扑克牌
- 2. 抽象出一张扑克牌
- 3. 买牌
- 4. 洗牌
- 5. 发牌
- 6. 测试类
- 7. 对牌进行操作方法的完整代码
四、移除元素
- 1. 示例 1：
- 2. 示例 2：
- 3. 求解代码

一、面试题（CVTE）

1. 题目描述

有两个字符串
         字符串1: welcome to cvte  
         字符串2: come
         结果：   wl t vt

2. 要求及解析

要求删除字符串1中所包含的字符串2中的字符
即删除字符串1中所有的c o  m e 这四个字符

在这里插入图片描述

3. 代码展示

package test;
import java.util.ArrayList;
import java.util.List;
public class Test {
    public static void main(String[] args) {
        List<Character> arrayList = new ArrayList<>();
        String str1 = "welcome to cvte";
        String str2 = "come";
        List<Character> ret = func(str1, str2);
        //利用 for - each 循环
        for (char ch : ret){
            System.out.print(ch);
        }
        System.out.println();
    }

    private static List<Character> func(String str1, String str2) {
        List<Character> list = new ArrayList<>();
        //首先遍历 str1
        for (int i = 0; i < str1.length(); i++) {
            //取出来str1中的每个字符
            char ch = str1.charAt(i);
            //在 str2 中进行判断是否存在
            if (!str2.contains(ch + "")){
                list.add(ch);
            }
        }
        return list;
    }
}

4. 注意点

以下两行代码有什么区别在使用上？

List<Character> arrayList = new ArrayList<>();
//只能调用接口当中的方法

ArrayList<Character> arrayList1 = new ArrayList<>();
//可以调用当前类自己的方法和接口当中的方法

在这里插入图片描述

二、杨辉三角

杨辉三角

1. 题目

在这里插入图片描述

2. 画图解析

在这里插入图片描述

3. 知识点

 List<List<Integer>> ret = new ArrayList<>();
 //定义了一个二维数组

在这里插入图片描述

4. 代码展示

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> ret = new ArrayList<>();

        //第一行 数组
        //在二维数组里面 第一行数组的下标为 0
        List<Integer> list = new ArrayList<>();
        list.add(1);
        //把第一行一维数组放到 二位数组的 0 下标
        ret.add(list);

        //处理其他行
        for (int i = 1; i < numRows; i++) {
            //每循环一次 就是 一行
            //创建一个一维数组
            List<Integer> curRow = new ArrayList<>();
            curRow.add(1);//每一行的第一个元素
            //处理中间的数字
            //要获取上一行一维数组
            List<Integer> prevRow = ret.get(i - 1);

            //从第二列开始
            for (int j = 1; j < i; j++) {
                int x = prevRow.get(j) + prevRow.get(j - 1);
                curRow.add(x);
            }
            //处理最后一个数字
            curRow.add(1);
            ret.add(curRow);
        }
        return ret;
    }
}

三、简单的洗牌算法

1. 理解怎么玩扑克牌

买牌、洗牌，发牌（根据人数）

在这里插入图片描述

2. 抽象出一张扑克牌

package demo;

//抽象出来一张牌

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 "Card{" +
//                "suit='" + suit + '\'' +
//                ", num=" + num +
//                '}';

        return suit + "" + num;
    }
}

3. 买牌

//定义扑克牌的4种花色  红桃，梅花，方块，黑桃
    public static String[] suits = {"♥","♣","♦","♠"};

    //首先需要买牌，没有牌这怎么玩
    //买的牌放到哪里呢

    /**
     * 生成一副扑克牌
     * 52张 不包含大小王
     * 4种花色 每种花色 13 张
     * @return
     */
    public List<Card> buyCard(){
        List<Card> cardList = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            for (int j = 1; j <= 13; j++) {
//                String suit = suits[i];
//                //实例化一张扑克牌
//                Card card = new Card(suit,j);
//                cardList.add(card);

                cardList.add(new Card(suits[i],j));
            }
        }
         return cardList;
    }

4. 洗牌

在这里插入图片描述

//洗牌 ---》》传一副扑克牌
    //洗牌需要什么呢？ ---》》 扑克牌
    //扑克牌在哪放着呢？ ----》》数组里面
    public void shuffle(List<Card> cardList){
        //首先需要有随机数
        Random rand = new Random();
        for (int i = cardList.size() - 1; i > 0 ; i--) {
            int index = rand.nextInt(i);
            //在这里用 swap 方法进行交换
            swap(cardList,i,index);
        }
    }

    private static void swap(List<Card> cardList,int i,int j) {
        //首次从数组里面获取i下标的牌
        //利用面向对象的方式去做
        Card tmp = cardList.get(i);
        cardList.set(i,cardList.get(j));
        cardList.set(j,tmp);
    }

5. 发牌

/**
     * 发牌
     * 3个人，每个人轮流抓 5 张牌
     * 1.每个人拿到的牌放到哪里？
     * 2.什么叫做 每个人轮流抓 5 张牌？
     * @param cardList
     */
    public List<List<Card>> getCard(List<Card> cardList){
        List<List<Card>> hand = new ArrayList<>();
        //应该有 三个 一维数组，三位玩家放各自的扑克牌

        List<Card> hand1 = new ArrayList<>();
        List<Card> hand2 = new ArrayList<>();
        List<Card> hand3 = new ArrayList<>();

        hand.add(hand1);
        hand.add(hand2);
        hand.add(hand3);

        //每个人抓5次
        //利用for循环
        for (int i = 0; i < 5; i++) {
            //每一次有三个人
            for (int j = 0; j < 3; j++) {
                //怎么揭牌???
                //相当于每次 拿 0下标的牌（删除0下标的牌就行）
                Card card = cardList.remove(0);
                //放到对应人的手里
                hand.get(j).add(card);
            }
        }
        return hand;
    }

6. 测试类

package demo;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        CardGame cardGame = new CardGame();
        List<Card> ret = cardGame.buyCard();
        System.out.println("买牌：");
        System.out.println(ret);

        System.out.println("洗牌：");
        cardGame.shuffle(ret);
        System.out.println(ret);

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

        System.out.println("剩下的牌：");
        System.out.println(ret);
    }
}

7. 对牌进行操作方法的完整代码

package demo;

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

import static java.util.Collections.swap;

public class CardGame {
    //定义扑克牌的4种花色  红桃，梅花，方块，黑桃
    public static String[] suits = {"♥","♣","♦","♠"};

    //首先需要买牌，没有牌这怎么玩
    //买的牌放到哪里呢

    /**
     * 生成一副扑克牌
     * 52张 不包含大小王
     * 4种花色 每种花色 13 张
     * @return
     */
    public List<Card> buyCard(){
        List<Card> cardList = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            for (int j = 1; j <= 13; j++) {
//                String suit = suits[i];
//                //实例化一张扑克牌
//                Card card = new Card(suit,j);
//                cardList.add(card);

                cardList.add(new Card(suits[i],j));
            }
        }
         return cardList;
    }

    //洗牌 ---》》传一副扑克牌
    //洗牌需要什么呢？ ---》》 扑克牌
    //扑克牌在哪放着呢？ ----》》数组里面
    public void shuffle(List<Card> cardList){
        //首先需要有随机数
        Random rand = new Random();
        for (int i = cardList.size() - 1; i > 0 ; i--) {
            int index = rand.nextInt(i);
            //在这里用 swap 方法进行交换
            swap(cardList,i,index);
        }
    }

    private static void swap(List<Card> cardList,int i,int j) {
        //首次从数组里面获取i下标的牌
        //利用面向对象的方式去做
        Card tmp = cardList.get(i);
        cardList.set(i,cardList.get(j));
        cardList.set(j,tmp);
    }

    /**
     * 发牌
     * 3个人，每个人轮流抓 5 张牌
     * 1.每个人拿到的牌放到哪里？
     * 2.什么叫做 每个人轮流抓 5 张牌？
     * @param cardList
     */
    public List<List<Card>> getCard(List<Card> cardList){
        List<List<Card>> hand = new ArrayList<>();
        //应该有 三个 一维数组，三位玩家放各自的扑克牌

        List<Card> hand1 = new ArrayList<>();
        List<Card> hand2 = new ArrayList<>();
        List<Card> hand3 = new ArrayList<>();

        hand.add(hand1);
        hand.add(hand2);
        hand.add(hand3);

        //每个人抓5次
        //利用for循环
        for (int i = 0; i < 5; i++) {
            //每一次有三个人
            for (int j = 0; j < 3; j++) {
                //怎么揭牌???
                //相当于每次 拿 0下标的牌（删除0下标的牌就行）
                Card card = cardList.remove(0);
                //放到对应人的手里
                hand.get(j).add(card);
            }
        }
        return hand;
    }
}

四、移除元素

给你一个数组nums和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与val不同的元素的数量。
假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：
更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
返回k。
用户评测：

评测机将使用以下代码测试您的解决方案：
int[] nums = […]; // 输入数组
int val = …; // 要移除的值
int[] expectedNums = […]; // 长度正确的预期答案。
// 它以不等于 val 的值排序。
int k = removeElement(nums, val); // 调用你的实现
assert k == expectedNums.length;
sort(nums, 0, k); // 排序 nums 的前 k 个元素
for (int i = 0; i < actualLength; i++) {
assert nums[i] == expectedNums[i];
}
如果所有的断言都通过，你的解决方案将会通过。

1. 示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2, _ , _ ]
解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

2. 示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3, _ , _ , _ ]
解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

提示：
0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100

3. 求解代码

class Solution {
    public int removeElement(int[] nums, int val) {
        //利用双指针
        int n = nums.length;
        int left = 0;
        for (int right = 0; right < n; right++) {
            if (nums[right] != val){
                nums[left] = nums[right];
                left++;
            }
        }
        return left;
    }
}