每天一道算法题——字符串的排列

前言：

这几天有点忙，这一个月没两天更新一次吧

题目描述

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

测试用例:

abc

对应输出应该为:

[“abc”,”acb”,”bac”,”bca”,”cab”,”cba”]

错误的输出

[“bac”,”abc”,”acb”,”bca”,”cba”,”cab”]

没有进行排序，调用一下sort就好Collections.sort(list)，不必要重新写一个函数吧，那就本末倒置了。

分析：

第一种使用递归的方法来解决此题。详情见代码。比较容易懂。

第二种方法是使用一个ArrayList将各个排列结果存放其中。首先将字符串分解为字符数组，然后从大到小进行排列后再对数组元素的值进行替换。直到形成最后的“最小的排列”，此时所有排列已经存储在了ArrayList之中了。返回ArrayList即可。称这种排列方式为字典排列。形如其名，就是按照词典排列的方式，将所有“词”无重复地录入到ArrayList这个“词典”当中。

源码：

递归的方法：

import java.util.ArrayList;
import java.util.Collections;

public class Test1 {
public class Solution {
public ArrayList<String> Permutation(String str) {
ArrayList<String> list = new ArrayList<>();
if (list!=null&&str.length()!=0) {
Permutation(str.toCharArray(),0,list);
Collections.sort(list);
}
return (ArrayList<String>) list;
}

private void Permutation(char[] charArray, int i, ArrayList<String> list) {
if (i==charArray.length-1) {
String  val = String.valueOf(charArray);
if (!list.contains(val)) {
list.add(val);
}
}else {
for (int j = 0; j < charArray.length; j++) {
swap(charArray,i,j);
Permutation(charArray, i+1, list);
swap(charArray,i,j);
}
}
}

private void swap(char[] charArray, int i, int j) {
char temp = charArray[i];
charArray[i] = charArray[j];
charArray[j] = temp;
}
}
}

字典排列：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Test1 {
public class Solution {
public ArrayList<String> Permutation(String str) {
ArrayList<String> res = new ArrayList<>();
if (str != null && str.length() > 0) {
char[] seq = str.toCharArray();
Arrays.sort(seq); // 排列
res.add(String.valueOf(seq)); // 先输出一个解
int len = seq.length;
while (true) {
int p = len - 1, q;// 从后向前找一个seq[p - 1] < seq[p]
while (p >= 1 && seq[p - 1] >= seq[p])
--p;
if (p == 0)
break; // 已经是“最小”的排列，退出
// 从p向后找最后一个比seq[p]大的数
q = p;
--p;
while (q < len && seq[q] > seq[p])
q++;
--q;// 交换这两个位置上的值
swap(seq, q, p);
// 将p之后的序列倒序排列
reverse(seq, p + 1);
res.add(String.valueOf(seq));
}
}
return res;
}
public void reverse(char[] seq, int start) {
int len;
if(seq == null || (len = seq.length) <= start)
return;
for (int i = 0; i < ((len - start) >> 1); i++) {
int p = start + i, q = len - 1 - i;
if (p != q)
swap(seq, p, q);
}
}
public void swap(char[] cs, int i, int j) {
char temp = cs[i];
cs[i] = cs[j];
cs[j] = temp;
}
}
}

运行测试：

递归：运行时间：126ms 占用内存：13412k

字典排列：运行时间：96ms 占用内存：11864k

总结：

可以看到使用递归解决时还是占用相当多的资源的。所以如果需要做优化的话，可以将递归替换掉，虽然递归的条理更加清楚一点。