字符串（上）

1.实现字符串反转

问题描述：把一个句子中的单词进行反转，eg：“how are you”，进行反转后为“you are how”
方法：先对整个字符串中的字符进行反转“uoy era woh”，然后对每个单词进行反转“you are how”

public static void swap(char[] carr,int front,int end){
        while(front<end){
            char temp=carr[end];
            carr[end]=carr[front];
            carr[front]=temp;
            front++;
            end--;
        }
    }

    public static String swapWords(String s){
        char[] carr=s.toCharArray();
        swap(carr,0,carr.length-1);
        int begin=0;
        for(int i=1;i<carr.length;i++){
            if(carr[i]==' '){
                swap(carr,begin,i-1);
                begin=i+1;
            }
        }
        swap(carr,begin,carr.length-1);
        return new String(carr);
    }

2.判断两个字符串是否由相同的字符组成

问题描述：两个字符串的字母及各个字母的个数是一样的
方法一：排序，对两个字符串中字符进行排序，比较两个排序后的字符串是否相等

public static void compare(String s1,String s2){
        byte[] b1=s1.getBytes();
        byte[] b2=s2.getBytes();
        Arrays.sort(b1);
        Arrays.sort(b2);
        s1=new String(b1);
        s2=new String(b2);
        if(s1.equals(s2)){
            System.out.println("equal");
        }
        else{
            System.out.println("not equal");
        }
    }

方法二：空间换时间。假设字符串只使用ASCII，ASCII共有256（0~255），实现时可以通过申请大小为266数组来记录各个字符出现的个数并初始化为0.遍历第一个字符串，将字符串中字符对应的ASCII作为数组下标并加1，遍历第二个字符串，对应元素减1。时间复杂度为O(n)

public static void compare2(String s1,String s2){
        byte[] b1=s1.getBytes();
        byte[] b2=s2.getBytes();
        int [] count=new int[256];
        for(int i=0;i<256;i++){
            count[i]=0;
        }
        for(int i=0;i<b1.length;i++){
            count[b1[i]-'0']++;
        }
        for(int i=0;i<b2.length;i++){
            count[b2[i]-'0']--;
        }
        for(int i=0;i<256;i++){
            if(count[i]!=0){
                System.out.println("not equal");
                return;
            }
        }
        System.out.println("equal");

    }

3.删除字符串中重复的字符

问题描述：“good”去掉重复的字符后变为“god”
方法一：把字符串看做一个字符数组，对数组使用双重循环遍历，如果发现有重复的字符，就把该字符置为’\0’，最后把这个字符数组中所有’\0’去掉

public static String removeDuplicate(String str){
        char[] c=str.toCharArray();
        for(int i=0;i<c.length;i++){
            if(c[i]=='\0'){
                continue;
            }
            for(int j=i+1;j<c.length;j++){
                if(c[j]=='\0'){
                    continue;
                }
                if(c[i]==c[j]){
                    c[j]='\0';
                }
            }
        }
        int m=0;
        for(int i=0;i<c.length;i++){
            if(c[i]!='\0'){
                c[m++]=c[i];
            }
        }
        return new String(c,0,m);

    }

方法二：空间换时间。常见的字符有256个，申请一个大小为256的int类型数组记录每个字符出现的次数，初始化为0，字符编码作为数组下标，遍历字符数组时，如果这个字符出现次数为0就把它置为1，如果这个字符出现次数为1说明在前面已经出现过，置为’\0’，最后去掉所有’\0’。

public static String removeDuplicate2(String str){
        char[]c=str.toCharArray();
        int []flags=new int[8];//8个int类型，32个字节，256b
        for(int i=0;i<8;i++){
            flags[i]=0;
        }
        for(int i=0;i<c.length;i++){
            int index=(int)c[i]/32;
            int shift=(int)c[i]%32;
            if((flags[index]&(1<<shift))!=0){
                c[i]='\0';
            }
            flags[index]=flags[index] | (1<<shift);
        }
        int m=0;
        for(int i=0;i<c.length;i++){
            if(c[i]!='\0'){
                c[m++]=c[i];
            }
        }
        return new String(c,0,m);
    }

4.统计一个字符中有多少个单词
分析：单词数可由空格出现次数决定。若某一个字符为非空格，它前面的字符是空格，表示新单词开始，count加1；若当前字符为非空格，前面字符也是非空格，则是原单词的继续，count不累加；前面一个字符是否是空格可以从Word是否为0看出来，若word=0，表示前面一个字符是空格，若word=1意味着前一个字符为非空格

public static int wordcount(String s){
        int word=0;
        int count=0;
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)==' '){
                word=0;
            }
            else if(word==0){
                word=1;
                count++;
            }
        }
        return count;
    }