【Java数据结构】ArrayList相关的算法

下面是一些关于ArrayList（次序表）相关的题目：
第一题：算法题

1.     public static List<Character> fun(String str1, String str2) {
2.         List<Character> list = new ArrayList<>();
3.         for (int i = 0; i < str1.length(); i++){
4.             char ch = str1.charAt(i);
5.             if (!str2.contains(ch+""))
6.             list.add(ch);
7.         }
8.         return list;
9.     }

复制代码

        这个算法是如许实现的，起首先将str1中的首字符取出来，然后将首字符在str2中寻找，如果没有就将这个字符添加到新创建的list中；然后一个一个取出来举行比力，找出str2中不存在的存进去即可。
        如果不用ArrayList，那么这个算法的复杂度就会增加，我们如今是奇妙地运用了contains这个方法就可以不用两层循环办理。
第二题：杨辉三角

1.     public static List<List<Integer>> fun(int n){
2.         List<List<Integer>> list =  new ArrayList<>();
3.         List<Integer> ret = new ArrayList<>();
4.         ret.add(1);
5.         list.add(ret);
6.         for (int i = 1; i < n; i++){
7.             List<Integer> cur = new ArrayList<>();
8.             cur.add(1);
9.             List<Integer> pre = list.get(i-1);
10.             for (int j = 1; j < i; j++){
11.                 cur.add(pre.get(j)+pre.get(j-1));
12.             }
13.             cur.add(1);
14.             list.add(cur);
15.         }
16.         return list;
17.     }

复制代码

        这个原理就是把这个"二维数组"看作一个二维的链表（List<List<Integer>>），起首先把第一层的添加进去，然后通过for循环将其他的n-1层添加进去就构成了这个图中的杨辉三角。其重点还是在for循环里，起首某一层的的第一个都是1，在for内里创建一个变量，把1加进去，然后再通过循环将对应上一层的一个和前一个相加（得到j位置的数和j-1位置的数相加），这一层末了一个数也是1，所以都放在第一个循环里，末了返回这个链表就可以结束了。
第三题 ：简单的洗牌算法

   大致流程就是：牌、一副牌、打乱、发牌
          起首需要有牌，一张牌中有数组和花色；

1. public class Card {
2.     public String degin;//花色
3.     public int digit;//数字
5.     public String toString(){
6.         return "["+degin+","+digit+"]";
7.     }
8. }

复制代码

         然后再创建一副牌，包罗四种花色，每种花色分别有13张牌（除去巨细王）；这里为什么用静态方法，就是这副牌是实现就创造好的，往后再利用这副牌就不需要再创造一副。

1. public class CardPile {
2.     private static String[] suit = {"♠","♥","♣","♦"};
3.     //创造一副牌
4.     private static List<Card> buyCard(){
5.         List<Card> list = new ArrayList<>();
6.         for(int i = 0; i < suit.length; i++){
7.             for (int j =1; j <= 13; j++){
8.                 String degin = suit[i];
9.                 int digit = j;
10.                 Card card = new Card();
11.                 card.degin = degin;
12.                 card.digit = digit;
13.                 list.add(card);
14.             }
15.         }
16.         return list;
17.     }

复制代码

 其次就是将这副牌打乱，如何打乱？将第一张牌与随机一张牌交换，就可以打乱其所有牌；

1.     public List<Card> disturbCard(List<Card> list){
2.         Random r = new Random();
3.         for (int i = 0; i < list.size() - 1; i++){
4.             int ret = r.nextInt(list.size());
5.             swap(list, i, ret);
6.         }
7.         return list;
8.     }

复制代码

 末了就是发牌，每次一张三个人一个回合直至牌发完（没人平均17张，剩一张）；重点就是这三个玩家又构成一个链表，然后通过两层循环外层每个玩家的牌数，内层玩家个数。

1.     public static void main(String[] args) {
2.         List<Card> card = buyCard();
3.         System.out.println(card);
4.         disturbCard(card);
5.         System.out.println(card);
6.         //将这堆牌发给三个人
7. //        List<Card> hand1 = new ArrayList<>();
8. //        List<Card> hand2 = new ArrayList<>();
9. //        List<Card> hand3 = new ArrayList<>();
10.         //不能以上的方法创建三个人，不然不好发牌
11.         List<List<Card>> hands = new ArrayList<>();
12.         hands.add(new ArrayList<>());
13.         hands.add(new ArrayList<>());
14.         hands.add(new ArrayList<>());
16.         for (int i = 0; i < 17; i++){
17.             for (int j = 0; j <3; j++){
18.                 //统一将第一张牌安顺序发给三位玩家，相当于删除这堆牌的第一张
19.                 hands.get(j).add(card.remove(0));
20.             }
21.         }
22.         System.out.println("剩下的一张牌");
23.         System.out.println(card);
24.         System.out.println("第一位玩家的牌");
25.         System.out.println(hands.get(0));
26.         System.out.println("第二位玩家的牌");
27.         System.out.println(hands.get(1));
28.         System.out.println("第三位玩家的牌");
29.         System.out.println(hands.get(2));
30.     }
31. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。