剑指offer之字符串的全排列

题目

 

思路及代码

import java.util.ArrayList;
import java.util.Collections;
import java.util.Arrays;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList <String> result = new ArrayList<>();
       if(str.length() <= 1) {
           result.add(str);
           return result;
       }
        //字典序排列，先找到最小的排列
        char[] prim= str.toCharArray();
        Arrays.sort(prim);
        result.add(String.valueOf(prim));
     //char [] chars = prim.toCharArray();
    //
  //1 从后往前找第一对相邻的升序对记为s[i] > s[i+1];
  //2 从后往前找第一个大于s[i]的字符，记为s[j],交换s[i] s[j];
  //3 将s[i]后的元素进行反转
  //当1成立时，重复执行1 2 3
   /*
   循环的判断:
   1、break跳出一层循环；
   2、通过i==0(判断是否完成了对全部数组对的判断），每次不满足除while以外的第二层循环
   的条件判断时，对i进行判断，决定是否跳出while循环。
   */
     boolean flag = true;
     while(flag){
         for(int i = prim.length-2; i>=0;i--){
            if(prim[i] < prim[i+1]){
                 for(int j = prim.length -1;j > i;j--){
                     if(prim[j] > prim[i]){
                         swap(prim,i,j);
                         reverse(prim,i+1,prim.length-1);
                         result.add(String.valueOf(prim));
                         break;
                     }
                 }
                break;
            }
             else{
                 if(i == 0)
                    flag = false;
                 }
             }
         }
     
        return result;
    }
    //定义交换方法
    public void swap(char[] s,int i,int j){
        char tem = s[i];
         s[i] = s[j];
         s[j]= tem;
        }
    //定义反转方法
    public void reverse (char [] s,int i,int j){
        //char[] tem= new char[j-i+1];
        char tem;
        while(i<j){
            tem = s[i];
            s[i]= s[j];
            s[j]= tem;
            i++;
            j--;
        }
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Arrays;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList <String> result = new ArrayList<>();
       if(str.length() <= 1) {
           result.add(str);
           return result;
       }
        //字典序排列，先找到最小的排列
        char[] prim= str.toCharArray();
        Arrays.sort(prim);
        result.add(String.valueOf(prim));
     //char [] chars = prim.toCharArray();
    //
  //1 从后往前找第一对相邻的升序对记为s[i] > s[i+1];
  //2 从后往前找第一个大于s[i]的字符，记为s[j],交换s[i] s[j];
  //3 将s[i]后的元素进行反转
  //当1成立时，重复执行1 2 3
        boolean flag = true;
     while(flag){
         //int f= 0;
        // sign:
         for(int i = prim.length-2; i>=0;i--){
             //f = i;
              if(i == 0)
               flag = false;
             if(prim[i] < prim[i+1]){
                 for(int j = prim.length -1;j > i;j--){
                     if(prim[j] > prim[i]){
                         swap(prim,i,j);
                         reverse(prim,i+1,j);
                         result.add(String.valueOf(prim));
                        // break sign;
                         i = prim.length-2;
                         break;
                     }
                 }
             }
             break;
         }
     }
        return result;
    }
    //定义交换方法
    public void swap(char[] s,int i,int j){
        char tem = s[i];
         s[i] = s[j];
         s[j]= tem;
        }
    //定义反转方法
    public void reverse (char [] s,int i,int j){
        //char[] tem= new char[j-i+1];
        char tem;
        while(i<j){
            tem = s[i];
            s[i]= s[j];
            s[j]= tem;
            i++;
            j--;
        }
    }
}

 

import java.util.ArrayList;
import java.util.Collections;
import java.util.Arrays;
public class Solution {
    public ArrayList<String> Permutation(String str){
        ArrayList <String> result = new ArrayList<>();
        boolean flag = true;
       if(str.length() <= 1) {
           result.add(str);
           return result;
       }
        //字典序排列，先找到最小的排列
        char[] prim= str.toCharArray();
        Arrays.sort(prim);
        result.add(String.valueOf(prim));
        while(flag){
            result.add(news(prim,flag));
        }
        return result;
    }
    
    public String news (char [] prim,boolean flag){
        sign:
        for(int i = prim.length-2; i>=0;i--){
             //f = i;
              if(i == 0)
               flag = false;
             if(prim[i] < prim[i+1]){
                 for(int j = prim.length -1;j > i;j--){
                     if(prim[j] > prim[i]){
                         swap(prim,i,j);
                         reverse(prim,i+1,j);
                         break sign;
                     }
                 }
             }
            //break;
        }
        return String.valueOf(prim);
    }
        //定义交换方法
    public void swap(char[] s,int i,int j){
        char tem = s[i];
         s[i] = s[j];
         s[j]= tem;
        }
    //定义反转方法
    public void reverse (char [] s,int i,int j){
        //char[] tem= new char[j-i+1];
        char tem;
        while(i<j){
            tem = s[i];
            s[i]= s[j];
            s[j]= tem;
            i++;
            j--;
        }
    }
}