20211202，今天有点特殊

发表于 | 更新于 | 分类于 |
字数统计 1,334 字

全对称日

今天是2012年12月2日，今天的日子正着读反着读都一样——20211202完全对称日。下一次要等到2030年了……
对称数在数学上称为回文数，比如101101，即从中间分两边对称的数，这是偶数位的对称。当然也存在于奇位数中的对称，即10101。
据计算，从公元纪年开始到2020年02月02日（20200202)总共有514个世界完全对称日。

判断回文数

简单介绍了一下回文数，那来说说，在计算机领域中，如何实现判断回文数呢？
刚刚介绍回文数的时候，说到正着读反着读都一样，其实也可以说正着写反着写都一样。

判断int回文数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
 * @description
 * @author Denghs
 * @version 1.0,2018年3月5日 下午4:52:12
 * @remark 判断回文数
 */
public class Symmetry {
	public static void main(String[] args) {
		System.out.println("symmetry---> int:" + symmetry(20211202));
		System.out.println("symmetry---> int:" + symmetry(2021202));
	}
	/**
	 * 判断一个数值是否是回文数。回文的特点是：正着写反着写都一样
	 * 
	 * @param number
	 */
	public static boolean symmetry(int number) {
		int i = 0;
		int sum = 0;
		int record = number;// 保存原记录数
		while (true) {
			i = number % 10;
			sum = sum * 10 + i;
			number /= 10;
			if (number == 0)
				break;
		}
		// 判断倒过来写的数，是否跟原来的数是一样的。
		return sum == record;
	}
}

可以看出，这段代码的最关键的地方就在while循环中。利用十进制取余数的方式，把原来的数重新计算成一个倒过来的数，再把原来的数与倒过来的数进行比较，相等时，则为回文数。

判断String回文数(一)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/**
 * @description
 * @author Denghs
 * @version 1.0,2018年3月5日 下午4:52:12
 * @remark 判断回文数
 */
public class Symmetry {
	public static void main(String[] args) {
		System.out.println("symmetry---> String:" + symmetry("20211202"));
		System.out.println("symmetry---> String:" + symmetry("2021202"));
	}
	/**
	 * 判断一个串是否是回文串。回文的特点是：倒着写跟原来是一样的。
	 * 使用栈的方式，进行比较。如果串的长度是一个奇数，会存在一个中间数没有对应的数进行比较。
	 * 则会返回false
	 * @param string
	 */
	public static boolean symmetry(String string) {
		// 获取串字符的长度
		char[] charArray = string.toCharArray();
		// 初始化栈
		Stack<Character> stack = new Stack<Character>(charArray.length / 2 + 1);
		for (int i = 0; i < charArray.length / 2; i++) {
			// 前一半的字符放入栈中
			stack.push(charArray[i]);
		}
		for (int j = charArray.length / 2; j < charArray.length; j++) {
			Character character = stack.pop();
			// 栈内已经没有元素了或者有字符不相同
			if (null == character || character != charArray[j]) {
				return false;
			}
		}
		return true;
	}
}

字符串判断回文数的一种方式，使用栈的方式来进行比较，把一个字符串从中间分开，把前一半的字符依次放入栈中，然后遍历后一半的字符，依次进行比较。

可以看出，这种判断方式，只适合偶数位的回文数，而奇数位的回文数，则判断不出来。

判断String回文数(二)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
 * @description
 * @author Denghs
 * @version 1.0,2018年3月5日 下午4:52:12
 * @remark 判断回文数
 */
public class Symmetry {
	public static void main(String[] args) {
		System.out.println("symmetryStr---> String:" + symmetryStr("20211202"));
		System.out.println("symmetryStr---> String:" + symmetryStr("2021202"));
	}
	/**
	 * 判断一个串是否是回文串。回文的特点是：倒着写跟原来是一样的。
	 * @param string
	 */
	public static boolean symmetryStr(String string) {
		char[] charArray = string.toCharArray();
		int start = 0;
		int end = charArray.length - 1;
		while (start <= end) {
			if (charArray[start] != charArray[end]) {
				return false;
			}
			start++;
			end--;
		}
		return true;
	}
}

直接两个指针，一个前一个后，前后指针所对应的值比较一次，相等，前指针往后挪一位，后指针往前挪一位，当两个指针彼此过界时，结束比较。

特殊符号

说了3种实现回文数判断的方式，其实都是对完全对称特别的实现。那接下来说说常见的判断左右符号对称的实现。主要的实现思路，其实是使用判断String回文数(一)的方式，使用栈这种方式来实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/**
 * @description
 * @author Denghs
 * @version 1.0,2018年4月5日 下午12:06:32
 * @remark
 */
public class TestStack {
	// 左符号集合
	public static List<Character> LEFT_MARKS = Arrays.asList(new Character[]{ '(', '（', '[', '【', '{' ,'<' , '《'});
	// 完整符号集合
	public static List<String> MARKS = Arrays.asList(new String[]{ "()", "（）", "[]", "【】", "{}" ,"<>" , "《》"});
	public static void main(String[] args) {
		System.out.println("matchByStack--->" + matchByStack("()()"));
		System.out.println("matchByLinkedList--->" + matchByLinkedList("(<>)"));
		System.out.println("matchByStack--->" + matchByStack("()[]"));
		System.out.println("matchByStack--->" + matchByStack("([])"));
		System.out.println("matchByStack--->" + matchByStack("({}[])"));
		System.out.println("matchByStack--->" + matchByStack("({[]})"));
		System.out.println("matchByStack--->" + matchByStack("({][})"));
	}
	/**
	 * 使用栈空间，对括号进行匹配比较。()()、(())、()[]、([])、({}[])
	 * 
	 * @param str
	 */
	public static boolean matchByStack(String str) {
		if (null == str || "".equals(str)) {
			return false;
		}
		Stack<Character> stack = new Stack<Character>();
		// 获取字符串中的char数组
		char[] charArray = str.toCharArray();
		for (int i = 0; i < charArray.length; i++) {
			char ch = charArray[i];
			boolean equals = LEFT_MARKS.contains(ch);
			if(equals){
				//左括号，入栈
				stack.push(ch);
			}else{
				//栈内没左括号元素
				if(stack.isEmpty()){
					return false;
				}
				//右括号，出栈并与当前元素进行比较
				Character pop = stack.pop();
				//组成一个完整括号集
				String tmep = pop.toString() + String.valueOf(ch);
				equals = MARKS.contains(tmep);
				return !equals;
			}
		}
		return stack.isEmpty();
	}
	/**
	 * 使用链表空间，对括号进行匹配比较。()()、(())、()[]、([])、({}[])
	 * 
	 * @param str
	 */
	public static boolean matchByLinkedList(String str) {
		if (null == str || "".equals(str)) {
			return false;
		}
		LinkedList<Character> linkedList = new LinkedList<Character>();
		// 获取字符串中的char数组
		char[] charArray = str.toCharArray();
		for (int i = 0; i < charArray.length; i++) {
			char ch = charArray[i];
			boolean equals = LEFT_MARKS.contains(ch);
			if(equals){
				//左括号，入栈
				linkedList.push(ch);
			}else{
				//栈内没左括号元素
				if(linkedList.isEmpty()){
					return false;
				}
				//右括号，出栈并与当前元素进行比较
				Character pop = linkedList.pop();
				//组成一个完整括号集
				String tmep = pop.toString() + String.valueOf(ch);
				equals = MARKS.contains(tmep);
				if(!equals){
					return false;
				}
			}
		}
		return linkedList.isEmpty();
	}
}

谢谢你请我吃糖果

--------- 本文结束，感谢您的审阅 ---------
0%