题目，得到某个数组，比如【1，2，3】获得其全部的排列组合，包括1个数字的。2个数字的，和三个数字的等等。
查看复制到剪切板打印
1. import java.util.Stack;
2.
3.
8. public class TestSequenceAll {
9. public static void main(String[] args) {
10. TestSequenceAll t = new TestSequenceAll();
11. Object[] arr = { 1, 2, 3 };
12. // 循环获得每个长度的排列组合
13. for (int num = 1; num <= arr.length; num++) {
14. t.getSequence(arr, 0, num);
15. }
16. }
17.
18. // 存储结果的堆栈
19. private Stack<Object> stack = new Stack<Object>();
20.
21.
28. public void getSequence(Object[] arr, int begin, int num) {
29. if (num == 0) {
30. System.out.println(stack); // 找到一个结果
31. } else {
32. // 循环每个可用的元素
33. for (int i = begin; i < arr.length; i++) {
34. // 当前位置数据放入结果堆栈
35. stack.push(arr[i]);
36. // 将当前数据与起始位置数据交换
37. swap(arr, begin, i);
38. // 从下一个位置查找其余的组合
39. getSequence(arr, begin + 1, num - 1);
40. // 交换回来
41. swap(arr, begin, i);
42. // 去除当前数据
43. stack.pop();
44. }
45. }
46. }
47.
48.
55. public static void swap(Object[] arr, int from, int to) {
56. if (from == to) {
57. return;
58. }
59. Object tmp = arr[from];
60. arr[from] = arr[to];
61. arr[to] = tmp;
62. }
63. }
1. Vvv
归并排序算法思想:
分而治之(divide - conquer);每个递归过程涉及三个步骤
第一, 分解: 把待排序的 n 个元素的序列分解成两个子序列, 每个子序列包括 n/2 个元素.
第二, 治理: 对每个子序列分别调用归并排序MergeSort, 进行递归操作
第三, 合并: 合并两个排好序的子序列,生成排序结果.
查看复制到剪切板打印
1. import java.util.Arrays;
2.
3.
8. public class Test {
9. final static int MAXVALUE = 10000;
10.
11. static int[] L;
12.
13. static int[] R;
14.
15. public static void Merge(int[] A, int p, int q, int r) {
16. int n1 = q - p;
17. int n2 = r - q + 1;
18. L = new int[n1 + 1];
19. R = new int[n2 + 1];
20. for (int i = 0; i < n1; i++) {
21. L[i] = A[p + i];
22. }
23. for (int j = 0; j < n2; j++) {
24. R[j] = A[q + j];
25. }
26. L[n1] = MAXVALUE;
27. R[n2] = MAXVALUE;
28. int i = 0, j = 0;
29. for (int k = p; k <= r; k++) {
30. if (L[i] <= R[j]) {
31. A[k] = L[i];
32. i++;
33. } else {
34. A[k] = R[j];
35. j++;
36. }
37. }
38. }
39.
40. public static void MergeSort(int[] A, int p, int r) {
41. int q;
42. if (p < r) {
43. q = (p + r) / 2;
44. MergeSort(A, p, q);
45. MergeSort(A, q + 1, r);
46. Merge(A, p, q + 1, r);
47. }
48. }
49.
50. public static void main(String[] args) {
51. int[] inputArray = { 1, 3, 2, 6, 5, 2, 4, 7, 1, 3, 2, 6, 5, 2, 4, 7, 1, 3, 2, 6, 5, 2, 4, 7, 1,
52. 3 };
53. // 方法1
54. MergeSort(inputArray, 0, inputArray.length - 1);
55. System.out.println(Arrays.toString(inputArray));
56. Integer[] inputArray2 = { 1, 3, 2, 6, 5, 2, 4, 7, 1, 3, 2, 6, 5, 2, 4, 7, 1, 3, 2, 6, 5, 2, 4,
57. 7, 1, 3 };
58. // 方法2
59. new MergeSort().sort(inputArray2);
60. System.out.println(Arrays.toString(inputArray2));
61. }
62. }
63.
64.class MergeSort {
65. private Comparable[] bridge;
66.
67.
70. public void sort(Comparable[] obj) {
71. if (obj == null) {
72. throw new NullPointerException("The param can not be null!");
73. }
74. bridge = new Comparable[obj.length];// 初始化中间数组
75. mergeSort(obj, 0, obj.length - 1); // 归并排序
76. bridge = null;
77. }
78.
79.
86. private void mergeSort(Comparable[] obj, int left, int right) {
87. if (left < right) {
88. int center = (left + right) / 2;
89. mergeSort(obj, left, center);
90. mergeSort(obj, center + 1, right);
91. merge(obj, left, center, right);
92. }
93. }
94.
95.
103. private void merge(Comparable[] obj, int left, int center, int right) {
104. int mid = center + 1;
105. int third = left;
106. int tmp = left;
107. while (left <= center && mid <= right) { // 从两个数组中取出小的放入中间数组
108. if (obj[left].compareTo(obj[mid]) <= 0) {
109. bridge[third++] = obj[left++];
110. } else
111. bridge[third++] = obj[mid++];
112. }
113. // 剩余部分依次置入中间数组
114. while (mid <= right) {
115. bridge[third++] = obj[mid++];
116. }
117. while (left <= center) {
118. bridge[third++] = obj[left++];
119. }
120. // 将中间数组的内容拷贝回原数组
121. copy(obj, tmp, right);
122. }
123.
124.
131. private void copy(Comparable[] obj, int left, int right) {
132. while (left <= right) {
133. obj[left] = bridge[left];
134. left++;
135. }
136. }
137. }
import java.util.Arrays;
public class Test {
final static int MAXVALUE =10000;
static int[] L;
static int[] R;
public static void Merge(int[]A, int p, int q, int r) {
int n1 = q -p;
int n2 = r -q + 1;
L = newint[n1 + 1];
R = newint[n2 + 1];
for (int i =0; i < n1; i++) {
L[i] = A[p + i];
}
for (int j =0; j < n2; j++) {
R[j] = A[q + j];
}
L[n1] =MAXVALUE;
R[n2] =MAXVALUE;
int i = 0, j= 0;
for (int k =p; k <= r; k++) {
if(L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
public static voidMergeSort(int[] A, int p, int r) {
int q;
if (p< r) {
q = (p + r) / 2;
MergeSort(A, p, q);
MergeSort(A, q + 1, r);
Merge(A, p, q + 1, r);
}
}
public static voidmain(String[] args) {
int[]inputArray = { 1, 3, 2, 6, 5, 2, 4, 7, 1, 3, 2, 6, 5, 2, 4, 7, 1,3, 2, 6, 5, 2, 4, 7, 1,
3 };
// 方法1
MergeSort(inputArray, 0, inputArray.length - 1);
System.out.println(Arrays.toString(inputArray));
Integer[]inputArray2 = { 1, 3, 2, 6, 5, 2, 4, 7, 1, 3, 2, 6, 5, 2, 4, 7, 1,3, 2, 6, 5, 2, 4,
7, 1, 3 };
// 方法2
newMergeSort().sort(inputArray2);
System.out.println(Arrays.toString(inputArray2));
}
}
class MergeSort {
private Comparable[]bridge;
public void sort(Comparable[]obj) {
if (obj ==null) {
throw new NullPointerException("The param can not be null!");
}
bridge = newComparable[obj.length];// 初始化中间数组
mergeSort(obj, 0, obj.length - 1); // 归并排序
bridge =null;
}
private voidmergeSort(Comparable[] obj, int left, int right) {
if (left< right) {
int center = (left + right) / 2;
mergeSort(obj, left, center);
mergeSort(obj, center + 1, right);
merge(obj, left, center, right);
}
}
private voidmerge(Comparable[] obj, int left, int center, int right) {
int mid =center + 1;
int third =left;
int tmp =left;
while (left<= center && mid<= right) { // 从两个数组中取出小的放入中间数组
if (obj[left].compareTo(obj[mid]) <= 0) {
bridge[third++] = obj[left++];
} else
bridge[third++] = obj[mid++];
}
//剩余部分依次置入中间数组
while (mid<= right) {
bridge[third++] = obj[mid++];
}
while (left<= center) {
bridge[third++] = obj[left++];
}
//将中间数组的内容拷贝回原数组
copy(obj,tmp, right);
}
private void copy(Comparable[]obj, int left, int right) {
while (left<= right) {
obj[left] = bridge[left];
left++;
}
}
}
运行结果
[1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6,6, 7, 7, 7]
[1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6,6, 7, 7, 7]
将字符串 String oldstr="I am aprogrammer"完全反转为"programmer a am I"，
最好不用函数，自己写，当然也可以用
这样的 题目很多人写不出，真是汗啊！我是用链表实现的，但是比较繁琐，算是过关了，今天特来寻求最好的解决方案
A:
这里给出一个最简单的实现
查看复制到剪切板打印
1. public static void reverse() {
2. String s = "i am a programmer "; // 几个空格的数量分别为1，2，3，4个
3. String[] eg = s.split(" ", -1);
4. String result = "";
5. for (int i = eg.length - 1; i > 0; i--) {
6. result += eg[i] + " ";
7. }
8. result += eg[0]; // 这里要注意第一个字符的前面是不能增加空格的。否则就多了一个空格
9. System.out.println(result);
10. }
public static void reverse(){
String s ="i am a programmer ";// 几个空格的数量分别为1，2，3，4个
String[] eg= s.split(" ", -1);
Stringresult = "";
for (int i =eg.length - 1; i > 0; i--) {
result += eg[i] + " ";
}
result +=eg[0]; // 这里要注意第一个字符的前面是不能增加空格的。否则就多了一个空格
System.out.println(result);
}
原理很简单，用空格分隔，但一定要指定第二个参数为-1，否则如果在字符串的末尾出现了空格，则会引起数据丢失。
运行结果
programmer a am i
查看复制到剪切板打印
1.
6. public class Test {
7. public static void reverse(int[] a, int left, int right) {
8. if (left >= right)
9. return;
10. int temp;
11. temp = a[left];
12. a[left] = a[right];
13. a[right] = temp;
14. reverse(a, ++left, --right);
15. }
16.
17. public static void main(String args[]) {
18. int[] a = { 1, 2, 3, 4, 5 };
19. reverse(a, 0, a.length - 1);
20. for (int i = 0; i < a.length; i++)
21. System.out.println(a[i]);
22. }
23. }
public class Test {
public static voidreverse(int[] a, int left, int right) {
if (left>= right)
return;
inttemp;
temp =a[left];
a[left] =a[right];
a[right] =temp;
reverse(a,++left, --right);
}
public static void main(Stringargs[]) {
int[] a = {1, 2, 3, 4, 5 };
reverse(a,0, a.length - 1);
for (int i =0; i < a.length; i++)
System.out.println(a[i]);
}
}
从字符串的两端开始交换，然后缩短字符串的长度，从新的两端开始。
String = "20080230" 和当前时间相比较，算日期差，打印
这个题目分如下几块
1 将字符串解析为日期类型
用DatetimeFormater.parse就行了
2 日期差
我不知道很好的方法，唯一能做的，就是将日期通过getTime()转化为long,然后计算其差距
1. SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
2. long to = new Date().getTime();
3. long from = df.parse("20080230").getTime();
System.out.println((to
- from) / (1000 * 60 * 60 * 24));
