0

さて、私はここで本当に初心者の間違いを犯していますが、私は何をする必要があるのか​​考えることができません。可能な順列で再帰的に埋めている配列permArrayがあります。パラメータを準備するパブリックメソッドがあります。次に、プライベートメソッドで配列を操作します。このメソッドは、それ自体を呼び出して、ますます小さなパーツを処理します。

私が抱えている問題は、完成した配列をパブリックメソッドに戻す方法です。再帰が終了するたびに（セクションサイズが1である各セクションに最後の要素を配置した後）、配列を返しますか？

ああ、そしてまた、これは宿題ではなく練習です。

//todo:
//need to determine what is wrong with my array of linked lists
package wordchains;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.StringTokenizer;
import javax.xml.soap.Node;

/**
 *
 * @author Samuel French
 */
public class WordChains {

public static void main(String[] args) {
    //variables
    int numWords = -1; //This will hold the number of words the user is inputting
    String userInput; //holds the user input to be broken up into a string array

    //Get the user's input, 0 is the quit value
    Scanner sc = new Scanner(System.in);
    System.out.print("Enter number of words: ");
    numWords = sc.nextInt();
    System.out.println(">");
    sc.nextLine();
    userInput = sc.nextLine();
    String[] inputWords = userInput.split("\\s+");
    int numElements = inputWords.length;
    int numOfPerms = numOfPerms(numElements);

    //We will start by checking the last letter of the first word
    char cTest;
    int wordChecking = 0;

    int[][] permArray = genPerms(numElements, numOfPerms);

    for (int col = 0; col < numOfPerms; col++) {
        System.out.println();
        for (int row = 0; row < numElements; row++) {
            System.out.print(permArray[col][row] + " ");
        }

    }

}

public static int numOfPerms(int numElements) {
    int numOfPerms = numElements;
    numElements--;
    while (numElements > 0) {
        numOfPerms = numOfPerms * numElements;
        System.out.println(numOfPerms);
        numElements--;
    }
    return numOfPerms;
}

public static int[][] genPerms(int numElements, int totPerms) {
    int permArray[][] = new int[totPerms][numElements];
    //either do it like this or create an array of head nodes
    List<LinkedList<Integer>> elementsLeftList = new ArrayList<LinkedList<Integer>>();
    LinkedList tempList = new LinkedList();
    for (int x = 0; x < numElements; x++) {
        tempList.addLast(x);
    }

    for (int x = 0; x < totPerms; x++) {
        elementsLeftList.add((LinkedList<Integer>) tempList.clone());
    }

    return privateGenPerms(permArray,elementsLeftList,totPerms,0,0,totPerms);
}

private static void privateGenPerms(int[][] permArray, List<LinkedList<Integer>> elementsLeftList, int totalPermutations, int elementPlacing, int sectionBegin, int sectionSize) {
    //variables-

//totalPermutations - the total number of permutations in the whole problem

//elementPlacing - the element currently being placed's position, corresponds to the rows of permArray
//elementPlacingIndex - the number of times the element currently being placed has been placed
//sectionSize - the size of the total working section. First time this is the # of permutations

//permCounter - this counter counts the permutation working with within the section
//sectionBegin - counts the beginning of the section working with


//2 Data structures:

//permArray - 2d the array of permutations
//elementsLeftList - list of lists of elements left, corresponds to each permutation


    int totalNumberOfElements = permArray[0].length;
    //
    int numberOfElementsLeftToPlace = totalNumberOfElements - elementPlacing;
    //

    int permCounter = sectionBegin;
    //Base case
    if (numberOfElementsLeftToPlace == 1) {
        for (int x = 0; x < totalPermutations; x++) {
            permArray[x][totalNumberOfElements - 1] = (int) elementsLeftList.get(permCounter).remove(0); //may need to be a remove 1, not sure
        }
        return; //need to decide what I am going to do here
    }

    //
    int elementPlacingIndex = 0;
    int elementCurrentlyPlacing = 0; //could be a 1, don't remember
    //
    int numberOfTimesToPlaceWithinCol = (sectionSize / numberOfElementsLeftToPlace);
    //
    //
    for (; permCounter < (sectionBegin + sectionSize); permCounter++) {
        //when we need to switch to a different partition of the section
        if (elementPlacingIndex == numberOfTimesToPlaceWithinCol) {
            elementPlacingIndex = 0;
            elementCurrentlyPlacing++;
        }
        permArray[permCounter][elementPlacing] = (int) elementsLeftList.get(permCounter).remove(elementCurrentlyPlacing);
        elementPlacingIndex++;
    }
    for (int newSectionBegin = sectionBegin; newSectionBegin < (sectionBegin + sectionSize); newSectionBegin = newSectionBegin + numberOfTimesToPlaceWithinCol) {
        privateGenPerms(permArray, elementsLeftList, totalPermutations, (elementPlacing + 1), newSectionBegin, (sectionSize / numberOfElementsLeftToPlace));
    }
}
}
4

1 に答える 1

2

配列は参照によって渡されるため、private関数で行った変更は永続的であり、変更した配列を再度返す必要はありません。

ただし、これがあなたの場合に正しい方法であるかどうかを確認するために、あなたのロジックを調べていません。

于 2013-02-12T23:39:21.987 に答える