1. StringBuilder/StringBuffer
ืืืจื ืื ืคืืฆื ืืืคืฉืืื ืืืืชืจ ืืื ืืืฉืชืืฉ ื-StringBuilder/StringBuffer :public static String reverseString(String str) {
return new StringBuilder(str).reverse().toString();
}
ืืคืชืจืื ืืืื ืืืืชืจ = ืืคืฉืื ืืืืชืจ. ืืฉืฉืืืืื ืืืชื ืืื ืืืคืื ืืืจืืืช ื-Java, ืื ืืืืจ ืืจืืฉืื ืฉืฆืจืื ืืขืืืช ืขื ืืืขืช. ืืื ืืืืจื ื ืขื ืืืืืจืืชืืื ืงืืื ืืื, ืื? ืืืื ื ืกืชืื ืขื ืคืชืจืื ืืช ืฉืืื ื ืืืืฅ ืืงืืคืกื.
2. ืคืชืจืื ืืขืจื
public static String reverseString(String str) {
char[] array = str.toCharArray();
String result = "";
for (int i = array.length - 1; i >= 0; i--) {
result = result + array[i];
}
return result;
}
ืื ื ืืืืจืื ืืช ืืืืจืืืช ืฉืื ื ืืืขืจื ืืฉืืืช toCharArray . ืืืื ื ืจืืฅ ืืืืืช for ืืจื ืืืขืจื ืืื ืืืงืฆื ืฉืื, ืื ืืกืืฃ ืชืืืื ืืืืจืืืช ืฉืืชืงืืื ืืืืจื ืืืจื.
3. ืคืชืจืื ืขื charAt
public static String reverseString(String str) {
String result = "";
for (int i = 0; i < str.length(); i++) {
result = str.charAt(i) + result;
}
return result;
}
ืืืงืจื ืื, ืื ืื ื ืืคืืื ืื ืฆืจืืืื ืืคืฆื ืืช ืืืืจืืืช ืืืขืจื, ืืืืืื ืฉืื ื ืืืืฆืื ืื ืชื ืืฉืืืช String class - charAt (ืืืืืช for, ืฉืื, ืืคืืื, ืื ืฉืืืคืฉืจ ืื ื ืืงืืช ืชืืืื ืืจืฆืฃ ืืืืืจ).
4. ืคืชืจืื ืขื Stack
ืืฃ ืืื ืื ืืฉืชืืฉ ืืืืืงื Stack ืืืฉื ืืื ืจื, ืืืื ื ืืฉืืช ืืืืืฉื ืช, ืื ืขื ืืืช, ืืขืืื, ืืืื ืฉืืืืฉื ืืืกืชืื ืขื ืคืชืจืื ืืืืฆืขืืชื:public static String reverseString(String str) {
Stack<Character> stack = new Stack<>();
String result = "";
for (Character character : str.toCharArray()) {
stack.add(character);
}
while (!stack.isEmpty()) {
result = result + stack.pop();
}
return result;
}
ืืื ืฉืื ืื ื ืืฉืชืืฉืื ื-toCharArray ืืื ืืคืฆื ืืช ืืืืจืืืช ืืืขืจื ืืืฉืื ืืช ืืื ื- Stack ืฉืื ื ืขื Character ืืกืื ืื ืจื . ืืืืจ ืืื, ืื ื ืืชืืืืื ืืงืืช ืืืื ืืื ืืืืืง ืืขืืืื ืฉื ืืขืจืืื. ืืฉื ืืืคื ืืืืกื ืืช ืืืื ื LIFO - L ast I n F irst O ut (ืจืืฉืื ื ืื ืก, ืืืฆื ืืืจืื), ืืืื ืืื ืืืืงืื ืืืืืจ ืืืชืืฆืื ืชืืฉืืจ ืืฉืืจื ืืืชืงืืืช.
5. ืคืชืจืื ืขื ืืื ืจืงืืจืกืื
ืืืขื ืื ืืขืืืช ืืืืืจืืชื ื ืืชื ืช ืืคืชืจืื ืืืืฆืขืืช ืจืงืืจืกืื. ืืืื ืื ืื ืื ื ืื ืืืืืื ืืืขืืื. ืื ืืคืืื ืืืขืืืื. ืืืจื ืืื, ืืืื ื ืฉืงืื ืื ืจืง ืฉืืื ืืืช ืืคืชืจืื ืจืงืืจืกืื, ืืื ืืื.-
ืฉืืื ืืืช
public static String reverseString(String str) { String rightStr; String leftStr; int length = str.length(); if (length <= 1) { return str; } leftStr = str.substring(0, length / 2); rightStr = str.substring(length / 2, length); return reverseString(rightStr) + reverseString(leftStr); }
ืื ื ืืฉืชืืฉืื ืืืฉืชื ืื rightStr ื- leftStr ืืื ืืคืฆื ืืช ืืืืจืืืช ืื ืื ืกืช ืืฉื ื ืืืงืื ืฉืืืื. ืืืืจ ืืื, ืืืืฆืขืืช ืืคืืฆืื ืืื, ืื ื ืืคืฆืืื ืืช ืืืืจืืืช ืืืืงืื ืืงืื ืื ืืืืชืจ ืืืชืืืงืื (ืชื ืืื). ืืืืจ ืืื, ืืจืงืืจืกืื ืืชืืืื ืืืชืืืื, ืืืืืืจื ืืช ืืชืืืื ืืกืืจ ืืคืื (ืืื ืฉืืื ืืืืื ืืืฆืื ืืฉืืื; ืืื ืฉืืื ืืฉืืื ืืื ืื ืืืืื)
ืืกืืจ ืืฉืืื ืฉืื ืจืงืืจืกืื ืืื ืงืจืืื ืืจืืื ืืฉืืื, ืืืชืืฆืื ืืื ืืืฆืื ืื ืืืืืืช ืฉื ืืฉืืืื. ืืืื, ืื ืื ืื ื ืืืืจืื ืขื ืจืงืืจืกืื ืขื ืชื ืื ืืฆืืื ืืืชื ื ืืชื ืื ืืืฉืื, ืื ืื ืื ืชืื ืื ืืืื ืกืืฃ ืืื StackOverflowError.
-
ืฉืืื ืฉื ืื
ืืื ืฆืจืื ืืจืืืื ื ื ืืกืฃ ืืฉืืื - ืืื ืืงืก.
ืืืฉืจ ืฉืืื ืื ืืืคืขืืช, ื ืืชื ืื ืืืจื ืืืจืืืช ืฉื -1:
String str = "JavaRush forever"; System.out.println(reverseString(str, str.length()-1));
ืืืฉืืื ืขืฆืื:
public static String reverseString(String str, int index) { if(index == 0){ return str.charAt(0) + ""; } char letter = str.charAt(index); return letter + reverseString(str, index-1); }
ืืืื ืืงืก ืฉืื ื ืืฉืืฉ ืืืื ืืืงืืืจ ืืืืื ืืืื ื ืฉืืจื ื ืฉืชืืฉ ืืขืช (ืื ืฉืชืืฉ ืืืืื ืืื ืืืกืืฃ).
ืืื, ืื ื ืืืืืจืื ืชื ืื ืืฆืืื ืืืฉืจ ืืืื ืืงืก ืืืืข ืืืืื ื ืืจืืฉืื.
- ืฉืืื ืฉืืืฉ
public static String reverseString(String str) { if (str.length() <= 1) { return str; } return reverseString(str.substring(1)) + str.charAt(0); }
ืฉืืื ืื ืืื ืืขืฆื ืืคืฉืืื ืืืื ืืฉืืื ืืจืงืืจืกืืืืช. ืืืืืืจ, ืคืฉืื = ืืื ืืื.
ืืืืื ืื ืจืืฆื, ืื ื ืืฆืืื ืื ืืช ืืืชื ืืืจืืืช, ืื ืืื ืืืืื ื ืืจืืฉืื. ืืืฉืจ ืืืืขืื ืืชื ืื ืืืฆืืื (ืืืฉืจ ื ืฉืืจ ืื ื ืชื ืืื), ืืจืงืืจืกืื ืืชืืืื ืืืชืืืื, ืืืชื ืืงืืื ืฉืื ืืื ืืฉืืืืฉ ืืชืืืกืฃ ืืื ืชืืฆืื ืฉืืืืจ ืืื.
ืื ื ืืืกืืคืื ืืช ืืขืจืืื ืฉืืืฉืื ืืืืฆืขืืช ืืื ืืงืก ืืืืชืืืช ืขื ืืชืืฆืื ืฉื ืืืืฆืืข ืืงืืื ืฉื ืืฉืืื ืืืืืืจืื ืืช ืืชืืฆืื.
6. ืฉืืืืฉ ื-XOR
XOR ืืื ืคืขืืื ืืืืืช ืืฉืืืช ืกืืืืืช. ืืืงืจื ืฉื ืฉื ื ืืฉืชื ืื, ืืชืืฆืื ืฉื ืคืขืืื ื ืืื ื ืื ืืจืง ืื ืืื ืืืืขืื ืื ื ืืื ืืืฉื ื ืืื ืฉืงืจ.ื | ื | ื |
---|---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 0 |
(A XOR B) XOR B = A
(A XOR B) XOR A = B
ืืื ืชืืจืื ืืฉืืื:
public static String reverseString(String str) {
char[] arr = str.toCharArray();
int low = 0;
int high = arr.length - 1;
String result = "";
while (low < high) {
arr[low] = (char) (arr[low] ^ arr[high]);
arr[high] = (char) (arr[low] ^ arr[high]);
arr[low] = (char) (arr[low] ^ arr[high]);
low++;
high--;
}
for (int i = 0; i < arr.length; i++) {
result = result + arr[i];
}
return result;
}
ืืืื ื ืืื ืื ืงืืจื ืืื. ืื ื ืืืฆืจืื ืืขืจื ืืืืืจืืืช ืื ืื ืกืช. ืื ื ืืืฆืจืื ืฉื ื ืืฉืชื ืื, ื ืืื ืืืืื , ืืืืืกื ืื ืืื ืืงืกืื ืืืขืืจ ืืืขืจื. ืืืชืื ืืื, ืืื ืืขืืืจ ืืืืชืืื ืืกืืฃ - ืงืืขื ื ืื ืืช ืืขืจื 0, ืืฉื ื - ืืืกืืฃ ืืืชืืื, ืงืืขื ื ืืืชื arr.length - 1 . ืื ืื ื ื ืื ืกืื ืืืืืื ืฉืชืชื ืื ืื ืขืื ืืืื ืืืืื ืืืื ืื ืืื . ืืื ืืชืืืืื ืืงืจืืช ืืืืจืื ืืืื ืื - ืืฉืืืืฉ ื-OR ืืืขืื. ืืืื ื ืกืชืื ืขื x ื- y ืืืืืื . ื ื ืื arr[high] = 'x'; ืืงืื ืืืื ืืจื ืฉืื ืืืื 1 1 1 1 0 0 0 ืืฉืื ืื arr[high] = 'n'; ืงืื ืืื ืืจื - 1 1 0 1 1 1 0 ืื ืืืื ืื ื ืืคืขืืืืช XOR ืืืืืื:
-
arr[low] = (char) (arr[low] ^ arr[high]);
arr[low] = 1 1 0 1 1 1 0 arr[high] =1 1 1 1 0 0 0 arr[low] = 0 0 1 0 1 1 0
-
arr[high] = (char) (arr[low] ^ arr[high]);
arr[low] = 0 0 1 0 1 1 0 arr[high] = 1 1 1 1 0 0 0 arr[high] = 1 1 0 1 1 1 0
-
arr[low] = (char) (arr[low] ^ arr[high]);
arr[low] = 0 0 1 0 1 1 0 arr[high] = 1 1 0 1 1 1 0 arr[low] = 1 1 1 1 0 0 0
GO TO FULL VERSION