колода не перетасованный связанный список

Question

привет, ребята, я не знаю, почему мой тасовка не перетасовывается. я не получаю ошибку, но это не перетасовка, но когда я впечатаю свой список, он выходит из сортировки и не перетасовывается. может ли кто-нибудь сказать мне, что проблема? я должен поставить свою перетасовать в моем связанный список вместо

мой пучок/палуба:

namespace BlackJack 
{ 
    class Bundle 
    { 
    //private List<Card> deck1; 
    GameLinkedList<Card> deck = new GameLinkedList<Card>(); 

    public void Shuffle() 
    { 
     for (int index = 0; index > 52; index++) 
     { 
      Random r = new Random(); 
      int count = deck.Count(); 
      for (int i = 0; i < count; i++) 
      { 
       int rnd = (int)(r.Next(count)); 
       deck.AddLast(deck.Delete(rnd)); 
      } 
     } 
    } 

    public void view() 
    { 
     deck.Print(); 
    } 
    } 
} 

мой связанный список:

namespace BlackJack 
{ 
    class GameLinkedList<T> where T : IComparable 
    { 
    private Node<T> head; 
    private Node<T> temp; 
    private int count = 0; 

    public void Clear() 
    { 
     head = null; 
     count = 0; 
    } 

    public void Delete(T t) 
    { 
     Node<T> prev = temp; 
     temp = head; 

     while (temp != null) 
     { 
      if (t.CompareTo(temp.data) == 0) 
      { 
       prev.next = temp.next; 
       temp = null; 
      } 
      else 
      { 
       prev = temp; 
       temp = temp.next; 
      } 
     } 
     count--; 
    } 

    public T Delete(int i) 
    { 
     Node<T> prev = temp; 
     temp = head; 

     while (temp != null) 
     { 
      if (i.CompareTo(temp.id) == 0) 
      { 
       prev.next = temp.next; 
       count--; 
       return temp.data; 
      } 
      else 
      { 
       prev = temp; 
       temp = temp.next; 
      } 
     } 
     return temp.data; 
    } 

    public void AddLast(T t) 
    { 
     if (head == null) 
     { 
      head = new Node<T>(); 

      head.data = t; 
      head.next = null; 
     } 
     else 
     { 
      Node<T> n = new Node<T>(); 
      n.data = t; 

      Node<T> current = head; 
      while (current.next != null) 
      { 
       current = current.next; 
      } 

      current.next = n; 
     } 
     count++; 
    } 

    public int Count() 
    {...} 

    public void Print() 
    { 
     temp = head; 

     while (temp != null) 
     { 

      Console.WriteLine(temp.data.ToString()); 

      temp = temp.next; 
     } 
    } 
    } 
} 

Answer 1

Без a good, minimal, complete code example, которая надежно воспроизводит проблему, невозможно определить каждая последняя проблема с кодом. Тем не менее, есть ряд очевидных проблем всего метода Shuffle():

1. Ваше условие цикла продолжение является index > 52. Поскольку index начинается с 0, выражение index > 52 сразу же ошибочно, поэтому цикл не будет выполняться вообще.
2. Вы назначаете новый объект Random на каждую итерацию внешнего цикла. Это почти всегда ошибка, потому что код будет выполняться так быстро, что каждый новый объект Random начнет с того же семестра и, таким образом, вернет ту же последовательность чисел.
3. У вас есть внешний контур вообще. Внутренний цикл должен быть достаточным для целей этой реализации. То есть внутренний цикл, для количества карт в колоде, выберет случайную карту и переместит ее до конца. Это не хорошая перетасовка, но, по крайней мере, теоретически это может перепутать карты. Добавление внешнего цикла может немного увеличить энтропию (если вы исправите ошибку Random), но это просто добавит к неэффективности реализации.

Мне кажется, что вы могли бы улучшить на текущей реализации значительно с некоторыми незначительными изменениями:

public void Shuffle() 
{ 
    Random r = new Random(); 
    int count = deck.Count(); 
    for (int i = 0; i < count; i++) 
    { 
     int rnd = (int)(r.Next(count--)); 
     deck.AddLast(deck.Delete(rnd)); 
    } 
} 

Другими словами, не заморачиваться с внешним контуром, а также при выборе новой карты , не включайте какие-либо из ранее выбранных вами карт. Уменьшая count с каждой итерацией, это ограничит выбор карты, которая будет помещена в конце, на карты, которые еще не были выбраны.