java字符串反转

那个大神帮我用java写个字符串反转，要求时间复杂度最低

17 个解决方案

#1

/**
	 * 字符串反转
	 * @return
	 */
	public static String reverser(String str){
		char[] chars = str.toCharArray();
		int end = chars.length - 1;
		int start = 0;
		while(end > start){
			char tmp = chars[end];
			chars[end] = chars[start];
			chars[start] = tmp;
			++start;
			--end;
		}
		return new String(chars);
	}

#2

谢谢指教。。。

#3

public String getReversalStr(String str){
		char[] chs = str.toCharArray();
		char temp;
		for(int i = 0; i < chs.length >>> 1; i++){
			temp = chs[i];
			chs[i] = chs[chs.length - i -1];
			chs[chs.length - i - 1] = temp;
		}
		return new String(chs);
	}

不谢，时间复杂度为O（n）,给分吧。。。

#4

引用 1 楼 udbwcso 的回复:

/**
	 * 字符串反转
	 * @return
	 */
	public static String reverser(String str){
		char[] chars = str.toCharArray();
		int end = chars.length - 1;
		int start = 0;
		while(end > start){
			char tmp = chars[end];
			chars[end] = chars[start];
			chars[start] = tmp;
			++start;
			--end;
		}
		return new String(chars);
	}

手真快。。。，方法差不多额。。。能否让时间复杂度保持为logn？

#5

public static String stringReverse(String str){

      StringBuffer sb = new StringBuffer(str).reverse();

      return sb.toString();

}

#6

上面有些楼给出的答案中都用到了方法toCharArray,该方法的实现依赖于System.arraycopy,arraycopy虽然是一个本地方法因此有着更高效的实现,但也会消耗时间的吧...

public char[] toCharArray() {
    // Cannot use Arrays.copyOf because of class initialization order issues
    char result[] = new char[value.length];
    System.arraycopy(value, 0, result, 0, value.length);
    return result;
}

要求时间复杂度最低的话,下面是一个时间复杂度为O(1)的解决方法:

int i = inputStr.length() - 1;
while(i >= 0)
  // 正在使用反转字符串,Sysetm.out.print是一个用例
  System.out.print( inputStr.charAt(i--) );

#7

引用 6 楼 blue123ABC 的回复:

上面有些楼给出的答案中都用到了方法toCharArray,该方法的实现依赖于System.arraycopy,arraycopy虽然是一个本地方法因此有着更高效的实现,但也会消耗时间的吧...

public char[] toCharArray() {
    // Cannot use Arrays.copyOf because of class initialization order issues
    char result[] = new char[value.length];
    System.arraycopy(value, 0, result, 0, value.length);
    return result;
}

要求时间复杂度最低的话,下面是一个时间复杂度为O(1)的解决方法:

int i = inputStr.length() - 1;
while(i >= 0)
  // 正在使用反转字符串,Sysetm.out.print是一个用例
  System.out.print( inputStr.charAt(i--) );

这时间复杂度怎么是O（1）呢。还是O（n）吧。

#8

受教了，toCharArray应该要传个参数进来吧

#9

推荐7楼方法 最方便快捷

#10

引用 9 楼 magi1201 的回复:

推荐7楼方法 最方便快捷

 看差了 是5楼方法 通过StringBuffer 进行反转 

#11

5楼的方法写起来简便，但是 其实相比较而言还是挺耗资源的。

#12

static String reverse(String str) {
		char[] arr = str.toCharArray();
		int length = str.length();
		for(int i = 0;i < length / 2;++i) {
			char temp = arr[i];
			arr[i] = arr[length - i - 1];
			arr[length - i - 1] = temp;
		}
		return String.valueOf(arr);
	}

#13

这个貌似String还是StringBuffer就有自带方法

#14

    public static void main(String[] args) {
        String str = "123456ABCD中国";
        char[] dist = new char[str.length()];
        for(int x = str.length() - 1, p = 0; x >= 0; x--){
            dist[p++] = str.charAt(x);
        }
        System.out.println(new String(dist));
    }

#15

楼上 灌水的混子 写的简单明了。

#16

//反转部分字符串
public String reverseString(String s,int start, int end)
{
   char[] arr = s.toCharArray();
    reverse(arr,start,end);
    return new String(arr);
}
//反转整个字符串
public String reverseString(String s)
{
   return reverseString(s,0,s.length())
}

public void reverse(char[] arr,int x,int y)
{
  for(int start=x,end=y-1; start<=end; start++,end--)
  {     
        swap(arr,strat,end);
   }
}

public void swap(char[] arr,int x,int y)
{
     char temp=arr[x];
     arr[x]=arr[y];
     arr[y]=temp;
}

#17

引用 10 楼 magi1201 的回复:

Quote: 引用 9 楼 magi1201 的回复:

推荐7楼方法 最方便快捷

 看差了 是5楼方法 通过StringBuffer 进行反转 

没看差吧

#18

• java 用递归实现字符串反转
• 字符串反转方法总结