Question

我正在尝试检查一个字符串是否是回文，但它似乎不起作用，因为当我发送一个我知道不是回文的字符串时，它会返回它是一个回文，任何人都可以帮忙吗？它也不会添加到变量 counter 。

package UnaryStack.RubCol1183;

public class CheckPalindrome {

static int counter = 0;

/** Decides whether the parentheses, brackets, and braces
in a string occur in left/right pairs.
@param expression a string to be checked
@return true if the delimiters are paired correctly */
public static boolean checkBalance(String expression)
{
    StackInterface<Character> temporaryStack = new LinkedStack<Character>();
    StackInterface<Character> reverseStack = new LinkedStack<Character>();
    StackInterface<Character> originalStack = new LinkedStack<Character>();


    int characterCount = expression.length();
    boolean isBalanced = true;
    int index = 0;
    char nextCharacter = ' ';


    for (;(index < characterCount); index++)
    {
        nextCharacter = expression.charAt(index);
        switch (nextCharacter)
        {
        case '.': case '?': case '!': case '\'': case ' ': case ',':
            break;
        default: 
        {
            {
                reverseStack.push(nextCharacter);
                temporaryStack.push(nextCharacter);
                originalStack.push(temporaryStack.pop());
            }

            {
                char letter1 = Character.toLowerCase(originalStack.pop());
                char letter2 = Character.toLowerCase(reverseStack.pop());
                isBalanced = isPaired(letter1, letter2);
                if(isBalanced == false){
                    counter++;
                }
            }

            break;
        }
        } // end switch
    } // end for
    return isBalanced;
} // end checkBalance

// Returns true if the given characters, open and close, form a pair
// of parentheses, brackets, or braces.
private static boolean isPaired(char open, char close)
{
    return (open == close);
} // end isPaired

public static int counter(){
    return counter;
}


}//end class

Answer 1

您的实施似乎比它需要的更复杂。

//Check for invalid characters first if needed.
StackInterface<Character> stack = new LinkedStack<Character>();

for (char ch: expression.toCharArray()) {
    Character curr = new Character(ch);
    Character peek = (Character)(stack.peek());
    if(!stack.isEmpty() && peek.equals(curr)) {
        stack.pop();
    } else {
        stack.push(curr)
    }
}
return stack.isEmpty();

老实说使用堆栈在这里过度杀戮。我会使用以下方法。

int i = 0;
int j = expression.length() - 1;
while(j > i) {
    if(expression.charAt(i++) != expression.charAt(j--)) return false;
}
return true;

Answer 2

你在reverseStack和originalStack中放置了相同的元素，因为你推入temporaryStack的所有东西都会被立即推送到originalStack中。这没有意义。

reverseStack.push(nextCharacter);
temporaryStack.push(nextCharacter);
originalStack.push(temporaryStack.pop());

因此表达式

isBalanced = isPaired(letter1, letter2);

将始终返回true。

Answer 3

我在方法checkBalace（）中找到了逻辑中的错误，并将代码完成了一个完整的工作。以下是我完成的代码：

public class CheckPalindrome {

static int counter;

/** Decides whether the parentheses, brackets, and braces
in a string occur in left/right pairs.
@param expression a string to be checked
@return true if the delimiters are paired correctly */
public static boolean checkBalance(String expression)
{
    counter = 0;
     StackInterface<Character> temporaryStack = new LinkedStack<Character>();
     StackInterface<Character> reverseStack = new LinkedStack<Character>();
     StackInterface<Character> originalStack = new LinkedStack<Character>();

     boolean isBalanced = true;

    int characterCount = expression.length();

    int index = 0;
    char nextCharacter = ' ';


    for (;(index < characterCount); index++)
    {
        nextCharacter = expression.charAt(index);
        switch (nextCharacter)
        {
        case '.': case '?': case '!': case '\'': case ' ': case ',':
            break;
        default: 
        {
            {
                reverseStack.push(nextCharacter);
                temporaryStack.push(nextCharacter);

            }

            break;
        }
        } // end switch


} // end for

while(!temporaryStack.isEmpty()){
    originalStack.push(temporaryStack.pop());
}

while(!originalStack.isEmpty()){
    char letter1 = Character.toLowerCase(originalStack.pop());
    char letter2 = Character.toLowerCase(reverseStack.pop());
    isBalanced = isPaired(letter1, letter2);
    if(isBalanced == false){
        counter++;
    }
}


    return isBalanced;
} // end checkBalance

// Returns true if the given characters, open and close, form a pair
// of parentheses, brackets, or braces.
private static boolean isPaired(char open, char close)
{
    return (open == close);
} // end isPaired

public static int counter(){
    return counter;
}


}

我使用2而之外的方法因此修复了指出的逻辑错误。我还在方法中将值0分配给计数器以修复我遇到的小问题。如果我仍然有错误，请随意修改代码，但我认为我没有犯错，然后再说，我是初学者。

代码无法正常工作（回文检查）

3 个答案: