Java 使用堆栈的素因子分解

我正在尝试编写一个程序，使用堆栈按降序打印正整数的素数因子

然而，我不确定我所做的是正确的

这是我到目前为止掌握的代码。目前我已经完成了素数分解，但是

堆栈
部分让我大吃一惊

import java.util.Stack; // Initialize Stacks

public class PrimeFactorization {

    public static void printPrimeNumbers(int prime) {
        Stack<Integer> stack = new Stack<Integer>(); //create stack
        int n = 0;

        for (int i = 0; i < n; i++) { //intialize for loop to check each letter
            stack.push(n);
        }

        while (!stack.isEmpty()) {
            n += stack.pop();
        }

        for (int i=0; i <= prime; i++) {
            n = 0;
            while (prime % i == 0) {
                prime /= i;
                n++;
            }

            if (n != 0) {
                for (int j = n; j > 0; j--) {
                    System.out.print(i);
                    if (prime != 1) {
                        System.out.print("*");
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        printPrimeNumbers(1)
    }
}

import java.util.Stack；//初始化堆栈
公共类素因子分解{
公共静态空打印素数（整数素数）{
堆栈=新堆栈（）；//创建堆栈
int n=0；
for（int i=0；i
首先，找到所有分割输入的2，并将它们添加到
堆栈中

其次，找到所有大于2的素数，如果它们除以输入，则将它们添加到
堆栈中

第三，作为最后一步，检查输入本身是否是大于2的素数。如果是，请打印，因为步骤2不会添加该数字

 public static void printPrimeNumbers(int n) {
    Stack<Integer> stack = new Stack<Integer>(); //create stack

    //First Step
    while (n % 2 == 0) {
        stack.add(2);
        n = n / 2;
    }

    //Second Step
    for (int i = 3; i <= Math.sqrt(n); i += 2) {
        while (n % i == 0) {
            stack.add(i);
            n = n / i;
        }
    }

    //Third Step
    if (n > 2) {
        System.out.printf("%d ", n);
    }
    while (!stack.isEmpty()) {
        System.out.printf("%d ", stack.pop());
    }
}

公共静态无效打印素数（int n）{
堆栈=新堆栈（）；//创建堆栈
//第一步
而（n%2==0）{
堆栈。添加（2）；
n=n/2；
}
//第二步
对于（int i=3；i 2）{
System.out.printf（“%d”，n）；
}
而（！stack.isEmpty（））{
System.out.printf（“%d”，stack.pop（））；
}
}
首先，找到所有分割输入的2，并将它们添加到
堆栈中

其次，找到所有大于2的素数，如果它们除以输入，则将它们添加到
堆栈中

第三，作为最后一步，检查输入本身是否是大于2的素数。如果是，请打印，因为步骤2不会添加该数字

 public static void printPrimeNumbers(int n) {
    Stack<Integer> stack = new Stack<Integer>(); //create stack

    //First Step
    while (n % 2 == 0) {
        stack.add(2);
        n = n / 2;
    }

    //Second Step
    for (int i = 3; i <= Math.sqrt(n); i += 2) {
        while (n % i == 0) {
            stack.add(i);
            n = n / i;
        }
    }

    //Third Step
    if (n > 2) {
        System.out.printf("%d ", n);
    }
    while (!stack.isEmpty()) {
        System.out.printf("%d ", stack.pop());
    }
}

公共静态无效打印素数（int n）{
堆栈=新堆栈（）；//创建堆栈
//第一步
而（n%2==0）{
堆栈。添加（2）；
n=n/2；
}
//第二步
对于（int i=3；i 2）{
System.out.printf（“%d”，n）；
}
而（！stack.isEmpty（））{
System.out.printf（“%d”，stack.pop（））；
}
}
您基本上可以找到素数并将它们添加到堆栈中，然后只需打印，直到堆栈中没有元素：

public static void main(String[] args) {
    printPrimeFactors(189); // prints 7 3 3 3
}

public static void findPrimeNumbers(int n, Stack<Integer> stack) {

    for (int i = 2; i <= n; i++) {
        if (n % i == 0) {
            stack.add(i);
            n /= i;
            i--;
        }
    }
}

public static void printPrimeFactors(int n){
    if(n > 1){
        Stack<Integer> stack = new Stack<Integer>();
        findPrimeNumbers(n, stack);
        while (!stack.isEmpty()) {
            System.out.print(stack.pop()+ " ");             
        }   
    }
}

publicstaticvoidmain（字符串[]args）{
printPrimeFactors（189）；//打印7 3
}
公共静态void findPrimeNumber（int n，堆栈）{
对于（int i=2；i 1）{
堆栈=新堆栈（）；
FindPrimeNumber（n，堆栈）；
而（！stack.isEmpty（））{
System.out.print（stack.pop（）+）；
}   
}
}
您基本上可以找到素数并将它们添加到堆栈中，然后只需打印，直到堆栈中没有元素：

public static void main(String[] args) {
    printPrimeFactors(189); // prints 7 3 3 3
}

public static void findPrimeNumbers(int n, Stack<Integer> stack) {

    for (int i = 2; i <= n; i++) {
        if (n % i == 0) {
            stack.add(i);
            n /= i;
            i--;
        }
    }
}

public static void printPrimeFactors(int n){
    if(n > 1){
        Stack<Integer> stack = new Stack<Integer>();
        findPrimeNumbers(n, stack);
        while (!stack.isEmpty()) {
            System.out.print(stack.pop()+ " ");             
        }   
    }
}

publicstaticvoidmain（字符串[]args）{
printPrimeFactors（189）；//打印7 3
}
公共静态void findPrimeNumber（int n，堆栈）{
对于（int i=2；i 1）{
堆栈=新堆栈（）；
FindPrimeNumber（n，堆栈）；
而（！stack.isEmpty（））{
System.out.print（stack.pop（）+）；
}   
}
}
@partycoder堆栈将在此处工作，因为目标是按降序打印基本因子…@partycoder堆栈将在此处工作，因为目标是按降序打印基本因子。。。。