从一组数据中找出最长的连续子串（以一副扑克牌手牌为例）

来源：互联网发布：web软件开发方式编辑：程序博客网时间：2024/05/22 14:03

前几天听同学说到面试时的一道算法题，就是找出一幅手牌中最长的连续子串，怎么实现，想来最近在找工作，所以写出来当练练手，好久没有写代码了，有些手硬了。

我做这个问题的思路：1，使手上产生17张手牌，当然手牌数可以随机，可以在getDatas（）中抽取；2，在产生手牌时要做一些扑克牌限制（如最多相同牌只有四张）；3，查找过程中，为了提高速度，所以需要过滤相同的手牌，4在过滤后的手牌中遍历比较，以冒泡算法为基础遍历查找，每当有一组子串数据时，就存储在一个集合中，然后集合去存储这些子串集合，便于后面的长度查找。

package com.searchinpoke.xuganwen;

import java.awt.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;

public class TestMain {

   public static void main(String[] args) {

       // 生成17张牌
       int[] pokes = new int[17];
       pokes = getDatas(pokes, 17);

       // 打印17张牌
       System.out.print("原卡牌：\t");
       for (int i = 0; i < pokes.length; i++) {
           System.out.print(pokes[i] + "   ");
       }
       System.out.println();

       // 存储非重复数据
       HashSet<Integer> set = new HashSet<Integer>();
       for (int i = 0; i < pokes.length; i++) {
           set.add(pokes[i]);
       }

       // 将数据转存到集合中，方便查找，为后面双层for做方便铺垫
       ArrayList<Integer> list = new ArrayList<Integer>();
       Iterator<Integer> iterator = set.iterator();
       while (iterator.hasNext()) {
           list.add(iterator.next());
       }

       // 存储子链时排除1 2 大小王
       ArrayList<Integer> deleteDatas = new ArrayList<Integer>();
       deleteDatas.add(1);
       deleteDatas.add(2);
       deleteDatas.add(14);
       deleteDatas.add(15);
       list.removeAll(deleteDatas);

       // 排序后的数据
       System.out.print("去除多余的卡牌后的卡牌：\t");
       for (int i = 0; i < list.size(); i++) {
           System.out.print(list.get(i) + "\t");
       }

       System.out.println();

       ArrayList<ArrayList<Integer>> parent = new ArrayList<ArrayList<Integer>>();
       for (int i = 0; i < list.size(); i++) {
           int a = list.get(i);
           ArrayList<Integer> child = new ArrayList<Integer>();
           for (int j = 0; j < list.size(); j++) {
               if (Math.abs(list.get(j) - a) == 1) {
                   a = list.get(j);
                   // System.out.print(a+"\t");
                   child.add(a);
                   continue;
               }
           }
           parent.add(child);
           // System.out.println();
       }

       ArrayList<Integer> listSizes = new ArrayList<Integer>();
       for (ArrayList<Integer> child : parent) {
           listSizes.add(child.size());
       }
       // 子链长度排序
       Collections.sort(listSizes);
       // 最长子链
       System.out.print("最长子链：\t");
       for (ArrayList<Integer> child : parent) {
           if (child.size() == listSizes.get(listSizes.size() - 1)) {
               System.out.println(child);
           }
       }

   }

   private static int[] getDatas(int pokes[], int maxPokes) {

       HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
       for (int i = 0; i < 15; i++) {
           map.put(i + 1, 0);
       }
       for (int i = 0; i < pokes.length; i++) {

           // 如果相同的卡牌已经有四张，那么删除第四张，重新生成
           pokes[i] = judgeSameNumber(map);
       }
       return pokes;
   }

   private static int judgeSameNumber(HashMap<Integer, Integer> map) {
       float radom = (float) Math.random() * 15;
       int number = Math.round(radom);
       // 排除0
       if (0 == number) {
           number = 1;
       }

       // 排除四張以上相同的牌
       int countnumber = map.get(number);
       if (4 == countnumber) {
           return judgeSameNumber(map);
       } else {

           map.put(number, countnumber + 1);
           return number;
       }
   }

}

运行结果如图片中显示：

阅读全文

1 0