почему мой вывод повторяется?

Question

У меня это работает, однако последний метод Array, Sorted C Method выводит это:

SORTED C METHOD: 179, 181, 238, 190, 105, 144, 26, 63, 90, 14, SORTED C METHOD: 190, 238, 181, 179, 105, 144, 26, 63, 90, 14, SORTED C METHOD: 238, 190, 181, 179, 105, 144, 26, 63, 90, 14,

Почему повторяется так много раз, когда метод Sorted A и метод B отсортированы только один раз?
Ниже приведен код:

Основной класс:

import java.util.ArrayList;
import java.util.Random;

public class main {
    public static void main(String[] args) {
        ThreeSorts.SortA(randArray(0));
        System.out.println("\n");
        ThreeSorts.SortB(randArray(0));
        System.out.println("\n");
        ThreeSorts.SortC(randArray(0));
        System.out.println("\n");
    }
    public static ArrayList<Integer> randArray(int n) {
        ArrayList<Integer> a = new ArrayList<Integer>(n);
        Random rand = new Random();
        rand.setSeed(System.currentTimeMillis());

        int[] x = new int[10];
        for (int i = 0; i < x.length; i++) {
            Integer r = Math.abs(rand.nextInt() % 256);
            a.add(r);
        }
        showArray(a);
        return a;
    }

    public static void showArray(ArrayList<Integer> a) {
        int n = a.size();
        System.out.println("RANDOM NUMBERS GENERATED 0 TO 255:");
        for (int i = 0; i < n; i++) {
            int r = a.get(i);
            System.out.print("|" + r + "| ");
        }
        System.out.println("\n");
    }

    public static void showA(ArrayList<Integer> array) {
        int n = array.size();
        System.out.print("SORTED A METHOD: ");
        for (int i = 0; i < n; i++) {
            int r = array.get(i);
            System.out.print(r + ", ");
        }
    }

    public static void showB(ArrayList<Integer> array) {
        int n = array.size();
        System.out.print("SORTED B METHOD: ");
        for (int i = 0; i < n; i++) {
            int r = array.get(i);
            System.out.print(r + ", ");
        }
    }

    public static void showC(ArrayList<Integer> array) {
        int n = array.size();

        System.out.print("SORTED C METHOD: ");
        for (int i = 0; i < n; i++) {
            int r = array.get(i);
            System.out.print(r + ", ");
        }
    }
}

Класс отсортированных массивов:

import java.util.*;

pubic class ThreeSorts {
    private static ArrayList<Integer> CopyArray(ArrayList<Integer> a) {
        ArrayList<Integer> resa = new ArrayList<Integer>(a.size());
        for (int i = 0; i < a.size(); ++i) {
            resa.add(a.get(i));
        }
        return (resa);
    }

    public static ArrayList<Integer> SortA(ArrayList<Integer> a) {
        ArrayList<Integer> array = CopyArray(a);
        int n = a.size(), i;
        boolean noswaps = false;

        while (noswaps == false) {
            noswaps = true;
            for (i = 0; i < n - 1; ++i) {
                if (array.get(i) < array.get(i + 1)) {
                    Integer temp = array.get(i);
                    array.set(i, array.get(i + 1));
                    array.set(i + 1, temp);
                    noswaps = false;
                }
            }
        }
        main.showA(array);
        return (array);

    }

    public static ArrayList<Integer> SortB(ArrayList<Integer> a) {
        ArrayList<Integer> array = CopyArray(a);
        Integer[] zero = new Integer[a.size()];
        Integer[] one = new Integer[a.size()];
        int i, b;
        Integer x, p;
        // Change from 8 to 32 for whole integers - will run 4 times slower
        for (b = 0; b < 8; ++b) {
            int zc = 0;
            int oc = 0;
            for (i = 0; i < array.size(); ++i) {
                x = array.get(i);
                p = 1 << b;
                if ((x & p) == 0) {
                    zero[zc++] = array.get(i);
                } else {
                    one[oc++] = array.get(i);
                }
            }
            for (i = 0; i < oc; ++i)
                array.set(i, one[i]);
            for (i = 0; i < zc; ++i)
                array.set(i + oc, zero[i]);
        }
        main.showB(array);
        return (array);
    }

    public static ArrayList<Integer> SortC(ArrayList<Integer> a) {
        ArrayList<Integer> array = CopyArray(a);
        SortC(array, 0, array.size() - 1);
        return (array);
    }

    public static void SortC(ArrayList<Integer> array, int first, int last) {
        if (first < last) {
            int pivot = PivotList(array, first, last);
            SortC(array, first, pivot - 1);
            SortC(array, pivot + 1, last);
        }

    }

    private static void Swap(ArrayList<Integer> array, int a, int b) {
        Integer temp = array.get(a);
        array.set(a, array.get(b));
        array.set(b, temp);
    }

    private static int PivotList(ArrayList<Integer> array, int first, int last) {
        Integer PivotValue = array.get(first);
        int PivotPoint = first;
        for (int index = first + 1; index <= last; ++index) {
            if (array.get(index) > PivotValue) {
                PivotPoint = PivotPoint + 1;
                Swap(array, PivotPoint, index);
            }
        }
        main.showC(array);
        Swap(array, first, PivotPoint);
        return (PivotPoint);
    }
}

P.S. Я использую Eclipse Java

Answer 1

Это все о вашем public static void SortC(ArrayList<Integer> array,int first,int last) методе.Он вызывается несколько раз из-за Recursion.

Но если вы хотите получить правильную формулировку неправильно, то вам помогут следующие строки кода.Внутри class ThreeSorts определите переменную, такую ​​как

public static boolean isPrinted;

и обновите ваш метод PivotList (), как указано ниже, или просто скопируйте его в любую вставку, в которой он будет работать.

private static int PivotList(ArrayList<Integer> array, int first, int last) {
        Integer PivotValue = array.get(first);
        int PivotPoint = first;
        for (int index = first + 1; index <= last; ++index) {
            if (array.get(index) > PivotValue) {
                PivotPoint = PivotPoint + 1;
                Swap(array, PivotPoint, index);
            }
        }
        if (!isPrinted) {
            Main.showC(array);
            isPrinted = true;
        }
        //Main.showC(array);
        Swap(array, first, PivotPoint);
        return (PivotPoint);
    }

Answer 2

Ваш вызов метода showC является проблемой. Попробуйте это:

    public static void SortC(ArrayList<Integer> array, int first, int last) {
    if (first < last) {
        int pivot = PivotList(array, first, last);
        SortC(array, first, pivot - 1);
        SortC(array, pivot + 1, last);
    }
    main.showC(array)//this method has to be called only when your array has been sorted
    }

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

Answer 3

Как я сказал, связка 11 дала правильный ответ, это действительно потому, что вы используете ShowC в своем алгоритме, он вызывается несколько раз.

Но это только симптом, а не основная проблема.Ваша проблема здесь в том, что вы создаете ненужную связь между вашими алгоритмическими функциями (класс SortedArray) и вашими служебными функциями (основной класс).

Другими словами, ваш класс SortedArrays ни в коем случае не должен зависеть от основного классаничто в классе SortedArrays не должно вызывать что-либо в главном.

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

примерно так:

public static void main(String[] args) {
        showA(ThreeSorts.SortA(randArray(0)));
        System.out.println("\n");
        showB(ThreeSorts.SortB(randArray(0)));
        System.out.println("\n");
        showC(ThreeSorts.SortC(randArray(0)));
        System.out.println("\n");
    }

Затем удалите все main.showXXX из вашего другого класса.Предполагается, что каждая функция сортировки возвращает массив.

Таким образом, каждый класс имеет одну цель и делает все намного проще для понимания и понимания.Смешивание целей (сортировка и отображение) в одной и той же функции (или в одном и том же классе в объектно-ориентированном) часто приводит к побочным эффектам, таким как этот.

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

Answer 4

Может ли быть так, что SortC вызывается 3 раза?

public static void SortC(ArrayList<Integer> array,int first,int last){
    if (first < last) {
        int pivot = PivotList(array,first,last);
        SortC(array,first,pivot-1);
        SortC(array,pivot+1,last);
     } 
}

• SortC() звонки PivotList()
• PivotList() звонки showC()
• showC() печатает в SystemOut

Я бы обновил ваш основной SortC метод для печати вместо рекурсивного:

public static ArrayList<Integer> SortC(ArrayList<Integer> a) {
    ArrayList<Integer> array = CopyArray(a);
    SortC(array, 0, array.size() - 1);
    main.showC(array) // print only when finished sorting!
    return (array);
}