String Reverse Preserving White Spaces in JavaString reversal is a common programming problem where a given string needs to be reversed such that the last character of the string becomes the first character, and vice versa. However, when preserving white spaces, the order of the white spaces should be maintained in the reversed string. Approach: Reverse string preserving spaces.Reverse string preserving spaces is a string manipulation problem where the goal is to reverse a given string while preserving the position of spaces within the string. The steps to find the solution is mentioned below: Step 1: Get the length of the input string "str". Step 2: Create a character array called "result" with the same length as "str". Step 3: Iterate over the string "str" and copy all nonspace characters into the "result" array at their respective positions. Step 4: Iterate over the string "str" again and copy all space characters into the "result" array at their respective positions. Step 5: Reverse the "result" array by iterating over it from both ends and swapping each character with its corresponding character on the opposite end. Step 6: Convert the "result" array to a string using the String constructor that takes a character array argument. Step 7: Return the resulting reversed string. ImplementationHere is an approach of how to reverse a string while preserving spaces.: Filename: ReverseStringPreservingSpaces1.java Output: public class ReverseStringPreservingSpaces1 { public static void main(String[] args) { String str = "Hello World!"; String reversed = reverseStringPreservingSpaces(str); System.out.println(reversed); } public static String reverseStringPreservingSpaces(String str) { int len = str.length(); char[] result = new char[len]; // Iterate over the string and copy nonspace characters into the result array for (int i = 0; i < len; i++) { if (str.charAt(i) != ' ') { result[i] = str.charAt(i); } } // Iterate over the string again, this time copying spaces into the result array for (int i = 0; i < len; i++) { if (str.charAt(i) == ' ') { result[i] = ' '; } } // Reverse the result array for (int i = 0, j = len  1; i < j; i++, j) { char temp = result[i]; result[i] = result[j]; result[j] = temp; } // Convert the result array to a string and return it return new String(result); } } Complexity analysis: Time complexity: The first two forloops iterate over the input string, each taking O(n) time, where n is the length of the input string. Therefore, the combined time complexity of the first two loops is O(n). The third forloop that reverses the result array also takes O(n) time, as it iterates over half the length of the array. Finally, converting the result array to a string takes O(n) time. Therefore, the overall time complexity of the program is O(n). Space complexity: The program creates a new character array with a length equal to the length of the input string, which takes O(n) space. Additionally, two integer variables are created for the third forloop, which takes O(1) space. Therefore, the overall space complexity of the program is O(n). Approach: Character Array with Two PointersCharacter Array with Two Pointers is an algorithmic technique used to manipulate character arrays by using two pointers that move towards each other from opposite ends of the array. The technique is particularly useful for solving problems involving string manipulation and can be used to efficiently reverse a string, check if a string is a palindrome, and remove duplicate characters from a string, among other things. The steps to find the solution is mentioned below: Step 1: Convert the input string into a character array using the toCharArray() method. Step 2: Define two pointers for swapping characters, one at the beginning of the array (left) and the other at the end of the array (right). Step 3: Iterate over the array using a while loop until the left and right pointers meet:
Step 4: Convert the character array back to a string using the String constructor that takes a character array as input. Step 5: Return the reversed string as the output. ImplementationHere is a possible implementation of the approach in Java, with comments explaining each step: Filename: StringReversePreservingSpaces2.java Output: !dlroW olleH Complexity Analysis: Time Complexity The while loop in the reverseStringPreservingSpaces method has a linear time complexity of O(n), where n is the length of the input string. The reason for this is that the loop goes through the character array until the two pointers converge in the middle, which requires a maximum of n/2 iterations. Within each iteration, the algorithm checks the characters at the two pointers and swaps them if necessary. Since each character is checked at most once and swapped at most once, the time complexity of each iteration is O(1). Therefore, the total time complexity of the while loop is O(n * 1) = O(n). Space Complexity: The space complexity of the algorithm is O(n), since the input string is converted to a character array of length n. The auxiliary space used by the algorithm for the pointers and temporary variables is O(1), which is constant.
Next TopicThe Deprecated Annotation in Java
