java如何用程序判断回文数

Java程序判断回文数的方法有几种，常用的包括：字符串反转比较法、数学反转法、递归法。在这几种方法中，数学反转法是较为高效的，因为它不涉及到额外的空间开销。下面将详细描述数学反转法，并逐步介绍其他方法。

一、数学反转法

数学反转法通过反转数字然后进行比较来判断回文数。这种方法的优势在于不需要额外的字符串操作，效率较高。

1.1、步骤解析

判断负数：负数不是回文数。
初始化变量：初始化一个变量 reversed 用于存储反转后的数字。
反转数字：通过循环将原数字的每一位取出并加到 reversed 上。
比较：最后比较原数字和 reversed 是否相等。

1.2、代码实现

public class PalindromeNumber {
    public boolean isPalindrome(int x) {
        if (x < 0) {
            return false;
        }
        int original = x;
        int reversed = 0;
        while (x != 0) {
            int digit = x % 10;
            reversed = reversed * 10 + digit;
            x /= 10;
        }
        return original == reversed;
    }
    public static void main(String[] args) {
        PalindromeNumber pn = new PalindromeNumber();
        System.out.println(pn.isPalindrome(121)); // true
        System.out.println(pn.isPalindrome(-121)); // false
        System.out.println(pn.isPalindrome(10)); // false
    }
}

二、字符串反转比较法

字符串反转比较法通过将数字转为字符串，然后反转字符串并进行比较。这种方法比较直观，但涉及到字符串操作，效率略低。

2.1、步骤解析

转换字符串：将数字转换为字符串。
反转字符串：利用 StringBuilder 反转字符串。
比较：比较原字符串和反转后的字符串是否相等。

2.2、代码实现

public class PalindromeNumber {
    public boolean isPalindrome(int x) {
        String original = String.valueOf(x);
        String reversed = new StringBuilder(original).reverse().toString();
        return original.equals(reversed);
    }
    public static void main(String[] args) {
        PalindromeNumber pn = new PalindromeNumber();
        System.out.println(pn.isPalindrome(121)); // true
        System.out.println(pn.isPalindrome(-121)); // false
        System.out.println(pn.isPalindrome(10)); // false
    }
}

三、递归法

递归法通过递归函数将数字一位一位地取出并进行比较。这种方法的代码简洁，但可能涉及到栈空间的消耗。

3.1、步骤解析

递归基准：判断数字是否小于10，若是，则返回true。
比较首尾：比较数字的首尾两位是否相同。
递归调用：去掉首尾两位后，继续递归判断剩余部分。

3.2、代码实现

public class PalindromeNumber {
    public boolean isPalindrome(int x) {
        if (x < 0) {
            return false;
        }
        int div = 1;
        while (x / div >= 10) {
            div *= 10;
        }
        return isPalindromeHelper(x, div);
    }
    private boolean isPalindromeHelper(int x, int div) {
        if (x < 10) {
            return true;
        }
        int left = x / div;
        int right = x % 10;
        if (left != right) {
            return false;
        }
        x = (x % div) / 10;
        div /= 100;
        return isPalindromeHelper(x, div);
    }
    public static void main(String[] args) {
        PalindromeNumber pn = new PalindromeNumber();
        System.out.println(pn.isPalindrome(121)); // true
        System.out.println(pn.isPalindrome(-121)); // false
        System.out.println(pn.isPalindrome(10)); // false
    }
}

四、总结与性能比较

4.1、方法比较

数学反转法：时间复杂度 O(log n)，空间复杂度 O(1)。
字符串反转比较法：时间复杂度 O(n)，空间复杂度 O(n)。
递归法：时间复杂度 O(log n)，空间复杂度 O(log n)。

4.2、使用场景

数学反转法：适用于需要高效判断回文数的场景。
字符串反转比较法：适用于代码可读性较高的场景，但不适用于大数字的场景。
递归法：适用于递归思想较强的场景，但可能存在栈溢出的风险。

五、扩展与应用

5.1、判断回文字符串

除了回文数，还可以通过相似的方法判断回文字符串。以下是一个简单的示例代码：

public class PalindromeString {
    public boolean isPalindrome(String s) {
        int left = 0;
        int right = s.length() - 1;
        while (left < right) {
            if (s.charAt(left) != s.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
    public static void main(String[] args) {
        PalindromeString ps = new PalindromeString();
        System.out.println(ps.isPalindrome("racecar")); // true
        System.out.println(ps.isPalindrome("hello")); // false
    }
}

5.2、判断回文链表

在链表中判断回文可以通过快慢指针法找到链表的中点，然后反转后半部分进行比较。

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}
public class PalindromeLinkedList {
    public boolean isPalindrome(ListNode head) {
        if (head == null || head.next == null) {
            return true;
        }
        ListNode slow = head, fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        slow = reverse(slow);
        ListNode start = head;
        while (slow != null) {
            if (start.val != slow.val) {
                return false;
            }
            start = start.next;
            slow = slow.next;
        }
        return true;
    }
    private ListNode reverse(ListNode head) {
        ListNode prev = null;
        while (head != null) {
            ListNode next = head.next;
            head.next = prev;
            prev = head;
            head = next;
        }
        return prev;
    }
    public static void main(String[] args) {
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(2);
        ListNode node4 = new ListNode(1);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        PalindromeLinkedList pll = new PalindromeLinkedList();
        System.out.println(pll.isPalindrome(node1)); // true
    }
}

六、总结

在Java中判断回文数有多种方法，包括数学反转法、字符串反转比较法、递归法。其中，数学反转法因为其高效性和低空间复杂度，通常是首选。其他方法则在特定场景下有其独特的优势。理解和掌握这些方法，不仅有助于解决回文数的问题，还能帮助我们更好地理解和应用Java编程技巧。