字符数组反转_字符数组的初始化

大家好，又见面了，我是你们的朋友全栈君。

关于字符串的反转，倒是很简单，但是编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

开辟新的字符数组空间倒是简单的很，如下

class sad{
    public char [] yoyo (char [] a ){
        int q=a.length;
        char [] k=new char [q];
        for(int i=0;i<a.length;i++){
            k[q-i-1]=a[i];
        }
        for(int j=0;j<q;j++){
            System.out.print(k[j]);

        }
        return k;
    }


}


public class charobease {
    public static void main(String args[]){

        sad s=new sad();
        char [] l={'h','e','l','l','o'};
        s.yoyo(l);


    }
}

直接遍历原数组放在新的数组里，但是如何才能不开辟新的数组呢

class sad{
    public char [] yoyo (char [] a ){
        int q=a.length;

        for(int i=0;i<a.length/2;i++){
          char temp=a[i];
          a[i]=a[q-1-i];
          a[q-1-i]=temp;
        }
        for(int j=0;j<q;j++){
            System.out.print(a[j]);

        }
        return a;
    }


}


public class charobease {
    public static void main(String args[]){

        sad s=new sad();
        char [] l={'h','e','l','l','o'};
        s.yoyo(l);


    }
}

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

示例 1:

输入: “Let’s take LeetCode contest”
输出: “s’teL ekat edoCteeL tsetnoc”

class Solution {
    public String reverseWords(String s) {
        String [] aa= s.split(" ");
     StringBuilder sb = new StringBuilder();
	     int size =0;//不能在循环里面初始化，不然它会反复初始化
	    for(int i=0;i<aa.length;i++) {
	    	char [] ch=aa[i].toCharArray();
	    	for(int j=0;j<ch.length/2;j++) {
	    		int p=aa[i].length();
	    		char temp=ch[j];	  	
	    		ch[j]=ch[p-j-1];
	    		ch[p-j-1]=temp;
	    		
	    		
	    	}
            sb.append(ch);
	    	
	    	 size++;
	    	
	    	 if(size != aa.length){
	              sb.append(" "); 
	            }
	    }
     return sb.toString();
    }
}

class happy{
    public String shishi (String s, int k){
   char [] c=s.toCharArray();
for(int i=0;i<s.length();i=i+2*k)  {
    int size=i+k-1;
    for(int j=i,b=size;j<=(i+size)/2;j++,b--)
    {
        char temp=c[j];
        c[j]=c[b];
        c[b]=temp;


    }
}
        for(int e=0;e<s.length();e++){
            System.out.print(c[e]);

        }
return  new String(c);
    }


}




public class test {
    public static void main(String args[]){
        happy h=new happy();
        String sb="hhssfiadsofgdiogf";
        int p=3;
        h.shishi(sb,3);


    }
}

给定只含 “I”（增大）或 “D”（减小）的字符串 S ，令 N = S.length。

返回 [0, 1, …, N] 的任意排列 A 使得对于所有 i = 0, …, N-1，都有：

如果 S[i] == “I”，那么 A[i] < A[i+1]
如果 S[i] == “D”，那么 A[i] > A[i+1]

示例 1：

输出：“IDID”
输出：[0,4,1,3,2]

class boring {
    public int[] training(String a) {
        int N = a.length();
        int pos = 1;
        int neg = -1;
        int[] clk = new int[N + 1];
        char[] ch = a.toCharArray();
        for (int i = 0; i < N; i++) {
            if (ch[i] == 'I') {
                clk[i] = clk[i] + pos;
                pos++;
            } else {
                clk[i] = clk[i] + neg;
                neg--;

            }

        }
        int p = -neg - 1;
        int[] ar = new int[N + 1];
        for (int j = 0; j <= N; j++) {
            ar[j] = clk[j] + p;

        }
        for (int k=0;k<=N;k++) {
            System.out.print(ar[k]);


        }
        return ar;
    }

}


public class leetcode0404 {

    public static void main(String[] args) {
        String sb = "IDID";
        boring b = new boring();
        b.training(sb);

    }
}