算法2-字符串编辑距离问题

字符数据类型

数据类型	所占字节
byte	字节型 1字节(8bit)
char	字符型 2字节(16bit)
short	短整型 2字节(16bit)
int	整型 4字节(32bit) 初始值：0
long	长整型 8字节(64Bit) 初始值：0L
float	单精度浮点型 4字节(32bit) 初始值：0.0f
double	双精度浮点型 8字节(64bit) 初始值：0.0d
boolean	java未明确指出的大小(可能1bit、1byte、4byte

ASCII码表

字符串查找

查找字符串中第一个只出现一次的字符

/************************/
//通过创建一个数组存放每个字符出现次数，这样只需要O(N)复杂度
 public int FirstNotRepeatingChar(String str) {
 	if(str.length()==0)
 		return -1;
 	int [] ss = new int[128];
 	for(i=0;i<str.length();i++){
 		ss[str.charAt(i)]++;
 	}
 	for(i=0;i<str.length();i++){
 		if(ss[str.charAt(i)]==1)
 			return i;
 	}
 	return -1;
 }

字符串数字转换

//通过手工设计规则来判断是否合法
public bool isNumeric(String str) {
	boolean hase= false,decimal = false;
	for(int i=0;i<str.length();i++){
		//判断指数
		if(str.charAt(i)=='e'||str.charAt(i)=='E'){
			if(i==str.length()-1) return false;
			if(hase) return false;
			hase=true;
		}else if(str.charAt(i)=='+'||str.charAt(i)=='-'){//判断正负号
			if(i!=0&&str.charAt(i-1)!='e'&&str.charAt(i-1)!='E')
				return false;
		}else if(str.charAt(i)=='.'){//判断小数点
			if(hase||decimal) return false;
			decimal = true;
		}else if(str[i]<'0'||str[i]>'9')
                return false;
}

//转换数字重点看是否越界
public int StrToInt(String str) {
	const int len = str.length();
    if (len == 0) return 0;
    int i = 0;
    while (i < len && str[i] == ' ') { ++i; } // 排除开头的空格
    if (i == len) return 0;
    if (!isdigit(str[i]) && str[i] != '+' && str[i] != '-') return 0;
    bool neg = str[i]=='-' ? true : false;
    i = isdigit(str[i]) ? i : i+1;
    long long ans = 0L;
    
	//主要代码
	while(i<len&&isdigit(str[i])){
		ans = ans*10+(str[i++]-'0');
		if(!neg&&ans>INT_MAX){
			ans=INT_MAX;
			break;
		}
		if(neg&&ans>1L+INT_MAX){
			ans=1L+INT_MAX;
			break;
		}
	}
	if (i != len) return 0; // 不要此处，就是atoi()库函数的实现
	return !neg?static_cast<int>(ans):static_cast<int>(-ans);
}

字符串全排列

目前感觉这个部分是最难的
题目描述

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

输入描述:

输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

思路1
1.把字符串分为两部分：第一部分为第一个字符，第二部分为第一个字符以后的字符串。
2.然后接下来求后面那部分的全排列。
3.再将第一个字符与后面的那部分字符逐个交换

function Permutation(str)
{
    let res=[];
    if(str.length<=0) return res;
    arr=str.split("");//将字符串转化为字符数组
    res=permutate(arr,0,res);
    res=[...new Set(res)];//删除重复和排序
    res.sort();
    return res;
}
function permutate(arr,index,res){
    if(arr.length==index){
        let s="";
        for(let i=0;i<arr.length;i++){
            s+=arr[i];
        }
        return res.push(s);
    }else{
        for(var i=index;i<arr.length;i++){
            [arr[index],arr[i]]=[arr[i],arr[index]];
            permutate(arr,index+1,res);
            [arr[index],arr[i]]=[arr[i],arr[index]];
        }
    }
    return res;
}

思路2

链接：https://www.nowcoder.com/questionTerminal/fe6b651b66ae47d7acce78ffdd9a96c7?f=discussion
来源：牛客网

/**
     * 2、字典序排列算法
     *
     * 可参考解析： http://www.cnblogs.com/pmars/archive/2013/12/04/3458289.html  （感谢作者）
     *
     * 一个全排列可看做一个字符串，字符串可有前缀、后缀。
     * 生成给定全排列的下一个排列.所谓一个的下一个就是这一个与下一个之间没有其他的。
     * 这就要求这一个与下一个有尽可能长的共同前缀，也即变化限制在尽可能短的后缀上。
     *
     * [例]839647521是1--9的排列。1—9的排列最前面的是123456789，最后面的987654321，
     * 从右向左扫描若都是增的，就到了987654321，也就没有下一个了。否则找出第一次出现下降的位置。
     *
     * 【例】 如何得到346987521的下一个
     * 1，从尾部往前找第一个P(i-1) < P(i)的位置
     * 3 4 6 <- 9 <- 8 <- 7 <- 5 <- 2 <- 1
     * 最终找到6是第一个变小的数字，记录下6的位置i-1
     *
     * 2，从i位置往后找到最后一个大于6的数
     * 3 4 6 -> 9 -> 8 -> 7 5 2 1
     * 最终找到7的位置，记录位置为m
     *
     * 3，交换位置i-1和m的值
     * 3 4 7 9 8 6 5 2 1
     * 4，倒序i位置后的所有数据
     * 3 4 7 1 2 5 6 8 9
     * 则347125689为346987521的下一个排列
     *
     * @param str
     * @return
     */
 
public ArrayList<String> Permutation2(String str){
        ArrayList<String> list = new ArrayList<String>();
        if(str==null || str.length()==0){
            return list;
        }
        char[] chars = str.toCharArray();
        Arrays.sort(chars);
        list.add(String.valueOf(chars));
        int len = chars.length;
        while(true){
            int lIndex = len-1;
            int rIndex;
            while(lIndex>=1 && chars[lIndex-1]>=chars[lIndex]){
                lIndex--;
            }
            if(lIndex == 0)
                break;
            rIndex = lIndex;
            while(rIndex<len && chars[rIndex]>chars[lIndex-1]){
                rIndex++;
            }
            swap(chars,lIndex-1,rIndex-1);
            reverse(chars,lIndex);
 
            list.add(String.valueOf(chars));
        }
 
        return list;
    }
 
    private void reverse(char[] chars,int k){
        if(chars==null || chars.length<=k)
            return;
        int len = chars.length;
        for(int i=0;i<(len-k)/2;i++){
            int m = k+i;
            int n = len-1-i;
            if(m<=n){
                swap(chars,m,n);
            }
        }
 
    }

有关两个字符串的问题通常会想到编辑距离问题