2

このサイトには基本的に同じ質問がありますが、質問に質問を投稿しないでください。ここにはリンクがあります。 二分木再帰関数

次のようなバイナリ ツリーを出力する必要がありますが、サイズは任意です。

--------x-------
----x-------x---
--x---x---x---x-
-x-x-x-x-x-x-x-x 
xxxxxxxxxxxxxxxx

ただし、コードを実行すると、無限の印刷とともにエラーが出力されます

:::X:::::X::X:XXXXX

この下に青い線があり、それをクリックすると、「ソースが見つかりません」というウィンドウが表示され、無限の X が表示されます

at sun.nio.cs.SingleByte.withResult(Unknown Source)
at sun.nio.cs.SingleByte.access$000(Unknown Source)
at sun.nio.cs.SingleByte$Encoder.encodeArrayLoop(Unknown Source)
at sun.nio.cs.SingleByte$Encoder.encodeLoop(Unknown Source)
at java.nio.charset.CharsetEncoder.encode(Unknown Source)
at sun.nio.cs.StreamEncoder.implWrite(Unknown Source)
at sun.nio.cs.StreamEncoder.write(Unknown Source)
at java.io.OutputStreamWriter.write(Unknown Source)
at java.io.BufferedWriter.flushBuffer(Unknown Source)
at java.io.PrintStream.write(Unknown Source)
at java.io.PrintStream.print(Unknown Source)
at BinaryBuilder.display(BinaryBuilder.java:25)
at BinaryBuilder.display(BinaryBuilder.java:31)
at BinaryBuilder.display(BinaryBuilder.java:31)

私がこれまでに持っていたコードは正しく機能していません.再帰と実行中のスタックフレームの順序を理解することに問題がありました. 行を使用して再帰から戻ると、私は正しい軌道に乗っていると思っていました。いくつかのガイダンスと正しい方向へのプッシュが必要です:)

    import java.util.Scanner;
public class BinaryBuilder {
    int levels = 0;
    int width = 0;
    int leaves = 0;
    Scanner sn = new Scanner(System.in);
    public BinaryBuilder() {
        //prt("how many leaves?");
        //leaves = sn.nextInt();
        //levels = (int)Math.sqrt((double)leaves);
    }
    public void setLevelLeaves(int l,int le){
        levels = l;
        leaves = le;
    }

    public void display(int left, int right, int row){
        int i =left;
        int mid = (left+right)/2;           //maybe a +1
        if(row>levels){
            return;
        }
        while(i <= right){
            if(i==mid){
                System.out.print("X");
            }else{
                System.out.print(":");
            }
            i++;
        }
        display(left, mid, row++);
        display(mid, right, row++);
    }

    public void prt(String n){
        System.out.println(n);
    }

}

主要

public class PartBTest {

    public PartBTest() {
    }

    public static void main(String[] args) {
        BinaryBuilder bb = new BinaryBuilder();
        //bb.prt("width will be reduced to a factor of 2");
        bb.setLevelLeaves(3, 8);
        bb.display( 0, bb.leaves-1, 0);
    }

}

ハッピーコーディング:}

4

2 に答える 2

1

うわー!

返信が遅くなり申し訳ありません。いくつかのゲームに巻き込まれましたが、ようやくこれを取得しました。

import java.util.Scanner;

public class Testing {

    public static void main(final String[] args) {

        final Scanner in = new Scanner(System.in);

        System.out.print("How many rows would you like?");

        final int rows = in.nextInt();
        int mod = (1 << (rows - 1)) - 1;

        for(int i = 0; i < rows; i++){
            for(int j = 0; j < mod; j++){
                System.out.print("-");
            }
            System.out.print("X");
            for (int j = 0; j < (1 << i) - 1; j++){
                for(int k = 0; k < 2 * mod + 1; k++){
                    System.out.print("-");
                }
                System.out.print("X");
            }
            for(int j = 0; j < mod; j++){
                System.out.print("-");
            }
            mod >>= 1;
            System.out.println();
        }

        in.close();

    }

}

これは非常に単純な論理的アプローチです。2 の累乗とバイナリの基礎を使用して、何を行う必要があるか、どのように行う必要があるかを計算します。ご覧のとおり、最初の行には0b1X があり、2 番目の行には X があり、以下同様です0b10。そこから、x の前に必要なダッシュの量も確認できます。4 行ある場合、最初の行には0b111ダッシュが必要で、2 番目の行には が必要0b11です。そこからはダッシュの数だけ反対の減衰を繰り返すだけです。1 つ目は 0 回の繰り返しが必要で、2 つ目は 1 回必要です。

これについてさらに説明が必要な場合は、喜んで対応させていただきます。

編集1:より説明

以下の説明ではrows = 4、分析に使用します。したがって、出力は次のようになります。

-------X-------
---X-------X---
-X---X---X---X-
X-X-X-X-X-X-X-X

1行に分解してみましょう。例として 2 番目を使用すると、ロジック フローは次のようになるという結論に達することができます。

  1. バッファの出力 (この場合は 3 つのダッシュ) ->---
  2. 孤独な x を出力 ->---x
  3. 繰り返しセクションを n 回印刷します。n = 1, ( -------x) ->---x-------x
  4. バッファの出力 (再び 3 つのダッシュ) ->---x-------x---

これは、すべてのケースで再現できます。

最初のケース: バッファ = 7、n = 0 -> n=0 から繰り返しセクションは生成されない
2 番目のケース: バッファ = 3、n = 1、バッファ内のダッシュ = 7
3 番目のケース: バッファ = 1、n = 3、バッファ内のダッシュ= 3
4 番目のケース: バッファー = 0、n = 7、バッファー内のダッシュ = 1

これらのすべてのケースで、変数はすべて 2 の累乗から 1 を引いたもの (メルセンヌ素数) に関連していることがわかります。

その手法を使用して、いくつかの基本的な式の結論に達します。

(1 << (rows - 1)) - 1)行数 (4) を使用して の値を にシフトし、000111000を減算0111して、最初のバッファーである 7 を残します。

(1 << i) - 1現在の行 (0 ~ 3 の範囲) を使用して、繰り返される回数を生成します。その式に 0、1、2、および 3 を差し込むと、それぞれ次のようになります: 0、1、3、7 (中央のセクションは行ごとに繰り返されます)

2 * mod - 1上記の式で使用される「中間セクション」のダッシュの量を計算するために使用されます

mod >>= 1mod を右にシフトします。これにより、最初の数式が初期値の 7 から 3、1、そして 0 に進むことができます。

于 2013-03-16T01:04:00.220 に答える
0

出力を直接表示しようとすると、再帰が煩雑になります。また、パラメータを再考することもできます。葉の数で十分だと思います。

出力をすぐに出力するのではなく、呼び出しごとに文字列のリストを返すことで、別の方法で行います。このように、{leaf count} / 2で実行し、リストをそれ自体とマージし(同じインデックス内の行を連結することにより)、ルートの新しいヘッダー行を追加することで、メインメソッドを実装できます。


以下は私の解決策です。2の累乗である引数のみを受け入れることに注意してください。

public static List<String> buildTree(int leafs) {
    if (leafs == 1)
        return Arrays.asList("x");

    // Recursive call
    List<String> subTree = buildTree(leafs/2);

    ArrayList<String> merged = new ArrayList<String>();
    // Add new header
    String blanks = String.format("%-" + (leafs/2) + "s", "").replace(' ', '-');
    String header = blanks + "x" + blanks.substring(1);
    merged.add(header);

    // Duplicate subtree
    for (String row : subTree)
        merged.add(row + row);

    return merged;
}
于 2013-03-15T23:56:59.337 に答える