Bubble sort с использованием рекурсии в C #

2

Я написал этот простой кусок кода. И у меня есть небольшая проблема.

int [] x = [50,70,10,12,129];
sort(x, 0,1);
sort(x, 1,2);
sort(x, 2,3);
sort(x, 3,4);

for(int i = 0; i < 5; i++) 
 Console.WriteLine(x[i]);

static int [] sort(int [] x, int i, int j)
{
   if(j ==x.length) 
      return x;
   else if(x[i]>x[j])
   {
      int temp = x[i];
      x[i] = x[j];
      x[j] = temp;
      return sort(x, i, j+1);
    }
    else 
       return sort(x, i, j+1);
}

Я чувствую, что вызов сортировки 4 времени - не лучшая душа. Мне нужен способ справиться с этим, используя sort(). Я также прошу вас советом, предложением или советом. Благодаря

  • 0
    Есть ли причина, по которой вы используете собственный метод sort () вместо использования Array.Sort () или List.Sort ()?
  • 2
    Да, я хочу сделать это сам!
Теги:
recursion

4 ответа

3
Лучший ответ

Во-первых, ваш тип ограничен ints, однако вы можете использовать интерфейс IComparable<T>, чтобы распространить его на любой сопоставимый тип. В качестве альтернативы вы можете иметь еще один параметр для Comparer<T>, чтобы пользователь мог определить, как сравнивать элементы во входном файле.

Рекурсивная сортировка пузырьков, вероятно, будет выглядеть примерно так: (ПРИМЕЧАНИЕ: не проверено...)

public static T[] BubbleSort(T[] input) where T : IComparable<T>
{
    return BubbleSort(input, 0, 0);
}

public static T[] BubbleSort(T[] input, int passStartIndex, int currentIndex) where T : IComparable<T>
{
    if(passStartIndex == input.Length - 1) return input;
    if(currentIndex == input.Length - 1) return BubbleSort(input, passStartIndex+1, passStartIndex+1);

    //compare items at current index and current index + 1 and swap if required
    int nextIndex = currentIndex + 1;
    if(input[currentIndex].CompareTo(input[nextIndex]) > 0)
    {
        T temp = input[nextIndex];
        input[nextIndex] = input[currentIndex];
        input[currentIndex] = temp;
    }

    return BubbleSort(input, passStartIndex, currentIndex + 1);
}

Однако, итерационное решение, вероятно, было бы более эффективным и понятным...

Поделиться
3

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

public int[] Sort(int[] sortArray)
    {
        for (int i = 0; i < sortArray.Length - 1; i++)
        {
            for (int j = sortArray.Length - 1; j > i; j--)
            {
                if (sortArray[j] < sortArray[j - 1])
                {
                    int x = sortArray[j];
                    sortArray[j] = sortArray[j - 1];
                    sortArray[j - 1] = x;

                }
            }
        }
        return sortArray;
    }
Поделиться
  • 3
    Хм, «потребность» применительно к рекурсивным алгоритмам всегда интересна, и если это упражнение в самообразовании, то желание использовать рекурсию не является необоснованным.
  • 1
    Возможно, Роббан должен был сказать, что пузырьковая сортировка не поддается рекурсии. Возможно, было бы более полезно кодировать рекурсивную сортировку с помощью алгоритма, предназначенного для рекурсии. Конечно, это зависит от того, что ОП хочет изучить.
Показать ещё 1 комментарий
2

Ничего плохого в желании учиться - пара очевидных вещей.

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

Во-вторых, вам может понадобиться подумать о том, как работает сортировка - как насчет этого: вы пытаетесь выпустить значение до своего правильного места в списке (или вниз, если вы предпочитаете!) - так что для списка n элементов, удалите первый, отсортируйте оставшиеся n - 1 элементы (то есть рекурсивный бит), затем пузырьковый первый элемент на место.

Прошло несколько десятилетий с тех пор, как я подумал об этом, весело!

Поделиться
0

другой с двумя параметрами: p yeah:

static void Sort(IList<int> data)
{
    Sort(data, 0);
}

static void Sort(IList<int> data, int startIndex)
{
    if (startIndex >= data.Count) return;

    //find the index of the min value
    int minIndex = startIndex;
    for (int i = startIndex; i < data.Count; i++)
        if (data[i] < data[minIndex])
            minIndex = i;

    //exchange the values
    if (minIndex != startIndex)
    {
        var temp = data[startIndex];
        data[startIndex] = data[minIndex];
        data[minIndex] = temp;
    }

    //recurring to the next
    Sort(data, startIndex + 1);
}

Примечание. Это абсолютно бесполезно в реальной жизни, потому что  - его чрезвычайно медленный  - его повторная итерация линейки означает, что когда у вас есть более 1 тыс. элементов, это будет stackoverflow

Поделиться

Ещё вопросы

Сообщество Overcoder
Наверх
Меню