package 编程之法;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
/**
* 三步翻转法
* @author Administrator
*
*/
public class 字符串旋转 {
/**
* 将字符串反转,传入的是字符数组,则void,传入的是字符串,则要返回字符串
* @param ch
* @param begin
* @param end
*/
public static void reverseStr0(char[] ch,int begin,int end)
{
while(begin <end)
{
char temp = ch[begin];
ch[begin++] = ch[end];
ch[end--] = temp;
}
}
/**
* 将字符串按照指定个数反转
* @param str
* @param n
* @return
*/
public static char[] reverseStrN(String str,int n)
{
char[] ch = str.toCharArray();
//编程考虑三层测试,功能测试,边界测试,非法输入测试
//如果移动的字符个数超过了字符串的长度呢
int len = ch.length;
if(n > len)
n = n%len;
//若只有一个字符,就不让进入函数,提高效率
if(len == 1)
return ch;
reverseStr0(ch,0,n-1);
reverseStr0(ch,n,len-1);
reverseStr0(ch,0,len-1);
return ch;
}
/**
* 7种字符串反转
*/
//1. 递归反转字符串
public static String reverseStr1(String str)
{
int len = str.length();
//递归必须有结束条件,不然会栈溢出错误
if(len <= 1)
return str;
String left = str.substring(0,len/2);
String right = str.substring(len/2,len);
return reverseStr1(right)+reverseStr1(left);
}
//2. 字符串String拼接,不推荐
public static String reverseStr2(String s) {
int length = s.length();
String reverse = "";
for (int i = 0; i < length; i++)
reverse = s.charAt(i) + reverse;//及其不推荐,每一次+的时候都会申请新的内存空间,差评
return reverse;
}
//3. 跟2差不多,不推荐,用StringBuilder改进
public static String reverseStr3(String str)
{
// String res = "";//跟String有关的拼接操作都不推荐
StringBuilder sb = new StringBuilder();
char[] ch = str.toCharArray();
for(int i = ch.length-1;i>=0;i--)
{
// res = res+ch[i];
sb.append(ch[i]);
}
// return res;
return sb.toString();
}
//4. 用jdk封装的接口
public static String reverseStr4(String str)
{
return new StringBuilder(str).reverse().toString();
}
//5. 一想到字符串反转,就想到堆栈stack
public static String reverseStr5(String str)
{
char[] ch = str.toCharArray();
Stack<Character> stack = new Stack<Character>();
StringBuilder sb = new StringBuilder();
for(int i = 0;i<ch.length;i++)
{
stack.push(ch[i]);
}
while(!stack.isEmpty())
{
sb.append(stack.pop());
}
return sb.toString();
}
//6. 这里练习一下队列,突然想到先进先出
public static String reverseStr6(String str)
{
char[] ch = str.toCharArray();
Queue<Character> queue = new LinkedList<Character>();
StringBuilder sb = new StringBuilder();
for(int i = 0;i<ch.length;i++)
{
queue.offer(ch[i]);
}
while(!queue.isEmpty())
{
sb.append(queue.poll());
}
return sb.toString();
}
//7. 新型栈
public static String reverseStr7(String str)
{
char[] ch = str.toCharArray();
// Deque<Character> deque = new ArrayDeque<Character>();
// Deque<Character> deque = new LinkedList<Character>();
LinkedList<Character> list = new LinkedList<Character>();
StringBuilder sb = new StringBuilder();
for(int i = 0;i<ch.length;i++)
{
// deque.addFirst(ch[i]);
// deque.push(ch[i]);
list.push(ch[i]);
}
while(!list.isEmpty())
{
// sb.append(deque.removeFirst());
// sb.append(deque.pop());
sb.append(list.pop());
}
return sb.toString();
}
//8. 推荐,效率源码
public static String reverseStr8(String orig) {
char[] s = orig.toCharArray();
int n = s.length - 1;
int halfLength = n / 2;
for (int i = 0; i <= halfLength; i++) {//n/2
char temp = s[i];
s[i] = s[n - i];
s[n - i] = temp;
}
return new String(s);
}
//9.更快,异或操作
public static String reverseStr9(String s) {
char[] str = s.toCharArray();
int begin = 0;
int end = s.length() - 1;
while (begin < end) {
str[begin] = (char) (str[begin] ^ str[end]);
str[end] = (char) (str[begin] ^ str[end]);
str[begin] = (char) (str[end] ^ str[begin]);
begin++;
end--;
}
return new String(str);
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
char[] ch = reverseStrN(str,3);
int i = 0;
while(i < ch.length)
{
System.out.print(ch[i]+" ");
i++;
}
System.out.print(reverseStr9(str));//字符串反转测试
}
}
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
/**
* 三步翻转法
* @author Administrator
*
*/
public class 字符串旋转 {
/**
* 将字符串反转,传入的是字符数组,则void,传入的是字符串,则要返回字符串
* @param ch
* @param begin
* @param end
*/
public static void reverseStr0(char[] ch,int begin,int end)
{
while(begin <end)
{
char temp = ch[begin];
ch[begin++] = ch[end];
ch[end--] = temp;
}
}
/**
* 将字符串按照指定个数反转
* @param str
* @param n
* @return
*/
public static char[] reverseStrN(String str,int n)
{
char[] ch = str.toCharArray();
//编程考虑三层测试,功能测试,边界测试,非法输入测试
//如果移动的字符个数超过了字符串的长度呢
int len = ch.length;
if(n > len)
n = n%len;
//若只有一个字符,就不让进入函数,提高效率
if(len == 1)
return ch;
reverseStr0(ch,0,n-1);
reverseStr0(ch,n,len-1);
reverseStr0(ch,0,len-1);
return ch;
}
/**
* 7种字符串反转
*/
//1. 递归反转字符串
public static String reverseStr1(String str)
{
int len = str.length();
//递归必须有结束条件,不然会栈溢出错误
if(len <= 1)
return str;
String left = str.substring(0,len/2);
String right = str.substring(len/2,len);
return reverseStr1(right)+reverseStr1(left);
}
//2. 字符串String拼接,不推荐
public static String reverseStr2(String s) {
int length = s.length();
String reverse = "";
for (int i = 0; i < length; i++)
reverse = s.charAt(i) + reverse;//及其不推荐,每一次+的时候都会申请新的内存空间,差评
return reverse;
}
//3. 跟2差不多,不推荐,用StringBuilder改进
public static String reverseStr3(String str)
{
// String res = "";//跟String有关的拼接操作都不推荐
StringBuilder sb = new StringBuilder();
char[] ch = str.toCharArray();
for(int i = ch.length-1;i>=0;i--)
{
// res = res+ch[i];
sb.append(ch[i]);
}
// return res;
return sb.toString();
}
//4. 用jdk封装的接口
public static String reverseStr4(String str)
{
return new StringBuilder(str).reverse().toString();
}
//5. 一想到字符串反转,就想到堆栈stack
public static String reverseStr5(String str)
{
char[] ch = str.toCharArray();
Stack<Character> stack = new Stack<Character>();
StringBuilder sb = new StringBuilder();
for(int i = 0;i<ch.length;i++)
{
stack.push(ch[i]);
}
while(!stack.isEmpty())
{
sb.append(stack.pop());
}
return sb.toString();
}
//6. 这里练习一下队列,突然想到先进先出
public static String reverseStr6(String str)
{
char[] ch = str.toCharArray();
Queue<Character> queue = new LinkedList<Character>();
StringBuilder sb = new StringBuilder();
for(int i = 0;i<ch.length;i++)
{
queue.offer(ch[i]);
}
while(!queue.isEmpty())
{
sb.append(queue.poll());
}
return sb.toString();
}
//7. 新型栈
public static String reverseStr7(String str)
{
char[] ch = str.toCharArray();
// Deque<Character> deque = new ArrayDeque<Character>();
// Deque<Character> deque = new LinkedList<Character>();
LinkedList<Character> list = new LinkedList<Character>();
StringBuilder sb = new StringBuilder();
for(int i = 0;i<ch.length;i++)
{
// deque.addFirst(ch[i]);
// deque.push(ch[i]);
list.push(ch[i]);
}
while(!list.isEmpty())
{
// sb.append(deque.removeFirst());
// sb.append(deque.pop());
sb.append(list.pop());
}
return sb.toString();
}
//8. 推荐,效率源码
public static String reverseStr8(String orig) {
char[] s = orig.toCharArray();
int n = s.length - 1;
int halfLength = n / 2;
for (int i = 0; i <= halfLength; i++) {//n/2
char temp = s[i];
s[i] = s[n - i];
s[n - i] = temp;
}
return new String(s);
}
//9.更快,异或操作
public static String reverseStr9(String s) {
char[] str = s.toCharArray();
int begin = 0;
int end = s.length() - 1;
while (begin < end) {
str[begin] = (char) (str[begin] ^ str[end]);
str[end] = (char) (str[begin] ^ str[end]);
str[begin] = (char) (str[end] ^ str[begin]);
begin++;
end--;
}
return new String(str);
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
char[] ch = reverseStrN(str,3);
int i = 0;
while(i < ch.length)
{
System.out.print(ch[i]+" ");
i++;
}
System.out.print(reverseStr9(str));//字符串反转测试
}
}