java - while(true) 循环不会中断，永远运行

Question

    import java.util.*;
import java.awt.*;

public class Lab11bst
{
   public static void main(String args[])
   {
      System.out.println("Pick A Card, Any Card");
      System.out.println();     
      Deck deck = new Deck();
      System.out.println(deck);
   }
}

class Card
{
   private String suit;
   private String rank;
   private int pointValue;

   public Card(String s, String r, int pV)
   {
      suit = s;
      rank = r;
      pointValue = pV;
   }

   public String suit()      { 
      return suit; }
   public String rank()      { 
      return rank; }
   public int pointValue()   { 
      return pointValue; }

   public boolean matches(Card otherCard) 
   {
      return otherCard.suit().equals(this.suit())
          && otherCard.rank().equals(this.rank())
          && otherCard.pointValue() == this.pointValue();
   }

   public String toString()
   {
      return rank + " of " + suit + " (Point Value = " + pointValue + ")";
   }
}

class Deck 
{
   private Card[] cards;
   private int size;
   private Card[] newcards;

   private String[] Suits = {"Clubs", "Diamonds", "Hearts", "Spades"};
   private String[] Ranks = {"Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King", "Ace"};
   private int[] pointValues = {2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10, 11};

   public Deck() 
   {
      size = 52;
      cards = new Card[size];

      int index = 0;

      for (int s = 0; s < 4; s++)
      {
         for (int r = 0; r < 13; r++)
         {
            cards[index] = new Card(Suits[s], Ranks[r], pointValues[r]);
            index +=1;
         }
      }

      //SwapShuffle();
      OneBigShuffle();
   }

   public String toString()
   {
      String temp = "";
      for (int k = 0; k <= size -1; k++)
      {
         temp += cards[k];
         temp += "\r\n";
      }
      return temp;
   }

   private void SwapShuffle()
   {
      int uno;
      int due;
      Card temp;

      for (int w = 0; w < 1000; w++)
      {
         uno =  (int)( Math.random() *52 );
         due = (int)( Math.random() *52 );

         temp = cards[uno];
         cards[uno] = cards[due];
         cards[due] = temp;
      }
   }

    public static boolean repeat (int[] array, int e) 
         {
        boolean result = false;
        for (int i : array)
        {
            if (i == e)
            {
                result = true;
                break;
            }
        }
        return result;
    }

   private void OneBigShuffle()
   {
      newcards = new Card[size];
      int spot;
      int[]  prevSpots = new int[size];
      boolean running = true;

      for (int k = 0; k < size; k++)
         {
            while(true)
            {
            spot = (int)( Math.random() *52 );
            if (repeat(prevSpots, spot) == false)
               {
              break;
               }
            }
            newcards[k]  = cards[spot];
            prevSpots[k] = spot;
         }
         cards = newcards;
   }
}

那里完全可能有一个愚蠢的错误，但我的 while 循环拒绝终止。我对 OneBigShuffle 方法的目标是让 while 循环运行，直到 Math.random 生成一个不包含在 prevSpots 数组中的数字(使用“repeat”方法检查该数组)。然而，尽管 if 语句带有中断，但程序似乎无限期地运行。我还尝试了 while(condition) 格式，其中条件设置为 false 而不是中断。这导致了一个错误，它说“ Blob 可能尚未初始化”。整个程序在上面，但这似乎是下面的问题区域:

for (int k = 0; k < size; k++)
         {
            while(true)
            {
            spot = (int)( Math.random() *52 );
            if (repeat(prevSpots, spot) == false)
               {
              break;
               }
            }
            newcards[k]  = cards[spot];
            prevSpots[k] = spot;
         }

大小为 52，因此数组有 52 个点!

Answer 1

你的问题是你每次都检查整个数组，而不仅仅是你填充的部分。

数组最初有 52 个单元格，其中包含 0。

┌───┬───┬───┬───┬─────┬───┐
│ 0 │ 0 │ 0 │ 0 │ ... │ 0 │
└───┴───┴───┴───┴─────┴───┘

您选择一个数字，例如 6。它会检查所有 52 个单元格 - 它发现它们都不包含 6。这很好，因此它将 6 放在第一位。

┌───┬───┬───┬───┬─────┬───┐
│ 6 │ 0 │ 0 │ 0 │ ... │ 0 │
└───┴───┴───┴───┴─────┴───┘

您选择另一个数字，例如 19。它会检查所有 52 个单元格。它的值是 6 和 0。好的，19 也可以，它把它放在下一个单元格中。

┌───┬────┬───┬───┬─────┬───┐
│ 6 │ 19 │ 0 │ 0 │ ... │ 0 │
└───┴────┴───┴───┴─────┴───┘

等等。问题是你将选择除 0 之外的所有数字。每次选择 0 时，它都会检查它，并且数组中已经有一个 0。一旦您填写了所有其他数字(1-51)，您就不能选择除 0 之外的任何其他数字。但是您已经有 0，因为您检查了整个数组!

您必须仅检查“重复”最多 - 并且不包括 - k。

顺便说一句，这是一种非常糟糕的数组洗牌方式。其时间复杂度可能接近无限，具体取决于随机数生成器。最高效的shuffle算法是:

• 按照卡片的自然顺序(从 0 到 51)填充数组。
• 对于 num 按从 51 到 0 降序排列:
  • 选择一个介于 0 和 num(含)之间的随机数 rand。
  • 在array[rand]和array[num]之间交换卡片

当你完成后，你的数组会被洗牌 - 因为在每一轮中，你都会选择一个尚未被选择的随机单元格。因为如果它被选中了，它就已经被换成了另一个没有被选中的号码。