重构字符串

题目简述

给定一个字符串S，检查是否能重新排布其中的字母，使得两相邻的字符不同。

若可行，输出任意可行的结果。若不可行，返回空字符串。

示例 1:

输入: S = “aab”
输出: “aba”

示例 2:

输入: S = “aaab”
输出: “”

注意:

S 只包含小写字母并且长度在[1, 500]区间内。

Related Topics 堆 贪心算法 排序 字符串

解题思路

1.将字符串放入到stringbuilder（变量sb）中。
2.从字符串的第二个数（下标为1）的时候开始往后遍历—构成第一层循环
3.（第一层遍历中）当遇到与之前不同的元素的时候则直接跳过，遇到相同的元素则开始更新sb，具体更新sb是判断下列三种情况。
3.1
在sb的首部插入。当前sb中的头元素与第一层循环中的数字不同，插入头部，删除这个元素，返回第一层循环的位置
3.2
在sb的中间插入。区别sb的头元素，与最后一个元素。第一层循环中的数字与当前不同且与当前后一个元素不同，插入之间，删除这个元素，更新sb
3.3
在sb的尾部插入，删除元素。判断与前一个元素是否相同，相同的返回“”。不相同返回第一层循环。

代码：

class Solution {
    public  String reorganizeString(String S) {
        if(S.length()==1)
            return S;
        StringBuilder sb=new StringBuilder(S);
        int len=S.length();
        for(int i=1;i<len;i++)
        {
            if(sb.charAt(i)!=sb.charAt(i-1))
            {
                continue;
            }
            for(int j=0;j<len;j++)
            {
                if(j==0&&sb.charAt(0)!=sb.charAt(i))
                {
                    sb.insert(0,sb.charAt(i));
                    sb.deleteCharAt(i);
                    i--;
                    break;
                }
                if(j<len-1&&sb.charAt(j)!=sb.charAt(i)&&sb.charAt(j+1)!=sb.charAt(i))
                {
                    sb.insert(j+1,sb.charAt(i));
                    sb.deleteCharAt(i);
                    i--;
                    break;
                }
                if(j==len-1)
                {
                    sb.append(sb.charAt(i));
                    sb.deleteCharAt(i);
                    if(sb.charAt(j)==sb.charAt(j-1))
                        return "";
                    i--;
                }

            }


        }
        return sb.toString();
    }
}

效果

info
解答成功:
执行耗时:9 ms,击败了9.54% 的Java用户
内存消耗:36.5 MB,击败了86.95% 的Java用户

LeetCode答案解析

PriorityQueue参考

public String reorganizeString(String S) {
        if (S.length() < 2) {
            return S;
        }
        int[] counts = new int[26];//用来存放26个字母
        int maxCount = 0;
        int length = S.length();
        for (int i = 0; i < length; i++) {
            char c = S.charAt(i);
            counts[c - 'a']++;
            maxCount = Math.max(maxCount, counts[c - 'a']);
        }//找出最大数的一系列数
        if (maxCount > (length + 1) / 2) {
            return "";
        }//判断条件，数学可证得大于 (length + 1) / 2，无法保证两两不相同。
        PriorityQueue<Character> queue = new PriorityQueue<Character>(new Comparator<Character>() {
            public int compare(Character letter1, Character letter2) {
                return counts[letter2 - 'a'] - counts[letter1 - 'a'];
            }
        });//定义一个排序方法。按照字母个数的多少排序
        for (char c = 'a'; c <= 'z'; c++) {
            if (counts[c - 'a'] > 0) {
                queue.offer(c);
            }
        }//有值的字母加入到优先级队列中
        StringBuffer sb = new StringBuffer();
        while (queue.size() > 1) {//当队列中字母大于1的情况，两两进行输出
            char letter1 = queue.poll();
            char letter2 = queue.poll();
            sb.append(letter1);
            sb.append(letter2);
            int index1 = letter1 - 'a', index2 = letter2 - 'a';
            counts[index1]--;
            counts[index2]--;
            if (counts[index1] > 0) {
                queue.offer(letter1);
            }
            if (counts[index2] > 0) {
                queue.offer(letter2);
            }
        }
        if (queue.size() > 0) {//队列只有一个的情况，输出
            sb.append(queue.poll());
        }
        return sb.toString();//输出结果
    }