62,614
社区成员
发帖
与我相关
我的任务
分享java 查找替换高手请入！！查找高级算法！
查找关键字为数组且与数组的顺序无关(变量)：示例数组 String[] s = { "aba", "bab", "z", "q" };
查找内容(变量): 示例字符 String str = "sababqczac";
替换后的内容为:s<b>ababq</b>c<b>zac
我的思路：
输出：[1,4],[7,8],[5,6],[2,5],
然后找出重叠的区间，有：组成新的区间，无：保留
比如
输入为：[1，5]，[10，15]，则输出为[1，5]，[10，15],
输入为：[1，2]，[2，3]，[2，4]，[3，5]，则输出为[1，5],
输入为：[1，7]，[2，5]，[3，4]，[8，15]，[9，17]，[20，25]，则输出为[1，7]，[8，17]，[20，25],
。。。。
查找内容(变量): 示例字符 String str = "sababqczac";
替换后的内容为:s<b>ababq</b>c<b>zac
我的思路：
for (String a : s) {
x = str.indexOf(a);
y = x + a.length();
if (x >= 0) {
sba.append("[");
sba.append(x);
sba.append(",");
sba.append(y);
sba.append("]");
sba.append(",");
}
}输出：[1,4],[7,8],[5,6],[2,5],
然后找出重叠的区间，有：组成新的区间，无：保留
比如
输入为：[1，5]，[10，15]，则输出为[1，5]，[10，15],
输入为：[1，2]，[2，3]，[2，4]，[3，5]，则输出为[1，5],
输入为：[1，7]，[2，5]，[3，4]，[8，15]，[9，17]，[20，25]，则输出为[1，7]，[8，17]，[20，25],
。。。。
...全文
请发表友善的回复…
发表回复
reyoreyoreyo 2017-12-01
- 打赏
- 举报
查找关键字为数组且与数组的顺序无关(变量)：示例数组 String[] s = { "aba", "bab", "z", "q" };
查找内容(变量): 示例字符 String str = "sababqczac";
替换后的内容为:s<b>ababq</b>c<b>z</b>ac 这样才对
自由自在_Yu 2017-12-01
- 打赏
- 举报
替换后的内容为:s<b>ababq</b>c<b>zac
结果是要s<b>ababq</b>c<b>z</b>ac 最后一个z也要分开吧？
reyoreyoreyo 2017-12-01
- 打赏
- 举报
能试着写一下吗？
huage 2017-12-01
- 打赏
- 举报
这个算法首先想到的先把数组的值作为key value的方式保存为另一个数据源 key作为数组的下标描述 value作为实际值保存 在通过对value排序 就可以得到你想要的东西了
reyoreyoreyo 2017-12-01
- 打赏
- 举报
非常感谢 ！！！！！！
自由自在_Yu 2017-12-01
- 打赏
- 举报
这下应该差不多了，多个匹配的也加上了
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test {
/**
* 思路：[1,3],[7,7],[5,5],[2,4] 把每个区间的两个数都保存在同一个数组里，然后排序
* 数组中不连续的位置就是分割点,例子中得到的数组是【1 2 3 4 5 5 7 7】
* 判断规则，如0不在数组，而1在数组中，所以0和1之间是个分割点，则在str[0]后面加上<b>
* 5在数组中，6不在数组中，则5和6之间是个分割点，str[5]后面加上</b>
* 添加count，奇数偶数统计判断是<b>还是</b>？
* @param args
*/
public static void main(String[] args) {
String result = "";
boolean flag = false; //标志第一位是否匹配到
String[] s = { "aba", "bab", "z", "q"};
String str = "sababqczazcqjhdzabas";
int[] arr = new int[str.length()*str.length()]; //保存区间内两个数值
int n = 0;//result 数组下标
System.out.println("匹配区间如下：");
for (int i = 0; i < s.length; i++) {
if(str.indexOf(s[i]) == 0){ //记录第一位是否匹配到，因为数组长度不确定，定义数组多余的项为0
flag = true;
}
int[] arrs = checkNum(s[i],str); //数组s的每一项匹配多次
for (int j = 0; j < arrs.length; j++) {
arr[n++] = arrs[j];
arr[n++] = arrs[j] + s[i].length() - 1;
for (int k = arrs[j]; k <= arrs[j] + s[i].length() - 1; k++) {
arr[n++] = k;
}
System.out.print("[" + arrs[j] + "," + (arrs[j] + s[i].length() - 1) + "] ");
}
}
System.out.println();
arr = removeRe(arr,flag);//去重复
Arrays.sort(arr); //排序
System.out.print("区间组成数组：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
int count = 1; //奇数<b>，偶数</b>
for (int i = 0; i < str.length(); i++) {
if(check(i,arr) && !check(i+1,arr)){
if(count%2 == 0){
result += str.charAt(i) + "</b>";
}else{
result += str.charAt(i) + "<b>";
}
count ++;
}else if(check(i,arr) && check(i+1,arr)){
result += str.charAt(i);
}else if(!check(i,arr) && check(i+1,arr)){
if(count%2 == 0){
result += str.charAt(i) + "</b>";
}else{
result += str.charAt(i) + "<b>";
}
count ++;
}else if(!check(i,arr) && !check(i+1,arr)){
result += str.charAt(i);
}
}
System.out.println("结果：" + result);
}
//去重复
private static int[] removeRe(int[] arr,boolean flag) {
Set<Integer> set = new HashSet<Integer>();
for (int i = 0; i < arr.length-1; i++) {
if(arr[i] !=0 ){
set.add(arr[i]);
}
}
Object[] obj = set.toArray();
int[] arrs;
if(flag){
arrs = new int[set.size()+1];
arrs[0] = 0;
for (int i = 0; i < obj.length; i++) {
arrs[i+1] = (Integer) obj[i];
}
}else{
arrs = new int[set.size()];
for (int i = 0; i < obj.length; i++) {
arrs[i] = (Integer) obj[i];
}
}
return arrs;
}
public static boolean check(int n, int[] arr){
for (int i = 0; i < arr.length; i++) {
if(arr[i] == n){
return true;
}
}
return false;
}
//正则表达式匹配多次
public static int[] checkNum(String s, String str){
int[] arr = new int[str.length()];
int n = 0;
Pattern pt = Pattern.compile(s);
Matcher mt = pt.matcher(str);
while (mt.find()) {
arr[n++] = mt.start();
}
return removeRe(arr,false);
}
}
匹配区间如下：
[16,18] [1,3] [2,4] [7,7] [9,9] [15,15] [5,5] [11,11]
区间组成数组：1 2 3 4 5 7 9 11 15 16 17 18
结果：s<b>ababq</b>c<b>z</b>a<b>z</b>c<b>q</b>jhd<b>zaba</b>s
dong_19890208 2017-12-01
- 打赏
- 举报
之前拼接那块写太复杂了，改了一下
String[] s = {"aba", "bab", "z", "q"};
String str = "sababqczac";
// 获取各子字符串在目标字符串的起始坐标位置
List<Integer[]> primaryIndex = new ArrayList<>();
for (String e : s) {
int index = str.indexOf(e);
if (-1 == index) {
continue;
}
primaryIndex.add(new Integer[]{index, index + e.length() - 1});
System.out.println(index + "," + (index + e.length() - 1));
}
// 对坐标按照开始坐标从小到大排序
Collections.sort(primaryIndex, new Comparator<Integer[]>() {
@Override
public int compare(Integer[] o1, Integer[] o2) {
return o1[0] - o2[0];
}
});
if (primaryIndex.size() <= 0) {
System.out.println("目标字符串中不包含搜索结果");
return;
}
// 合并相连坐标
List<Integer[]> resultIndex = new ArrayList<>();
Integer[] index = primaryIndex.get(0);
for (int i = 0; i < primaryIndex.size() - 1; i++) {
Integer[] index1 = primaryIndex.get(i + 1);
if (index[1] + 1 >= index1[0]) {// 有交集
//拼接index
if (index[1] < index1[1]) {
index[1] = index1[1];
}
} else {// 没有交集
resultIndex.add(index);
index = primaryIndex.get(i + 1);
}
}
resultIndex.add(index);
// 替换相应位置字符串
String result = "";
for (int i = 0; i < resultIndex.size(); i++) {
Integer[] point = resultIndex.get(i);
int start = 0 == i ? 0 : resultIndex.get(i - 1)[1]+1;
result += str.substring(start,point[0]);
result += "<b>"+str.substring(point[0],point[1]+1)+"</b>";
}
Integer[] point = resultIndex.get(resultIndex.size()-1);
if(point[1]<str.length()){
result += str.substring(point[1]+1,str.length());
}
System.out.println(result);
dong_19890208 2017-12-01
- 打赏
- 举报
运行结果为：s<b>ababq</b>c<b>z</b> 少了字符啊？再帮忙看一下，谢谢[/quote]
最后的字符串忘拼接了
最后 把System.out.println(new String(resultArray));替换成下面这几句
Integer[] point = resultIndex.get(resultIndex.size()-1);
if(point[1]<str.length()){
System.arraycopy(array, point[1]+1, resultArray, point[1]+(bPrefix.length + bSuffix.length)*resultIndex.size() +1, str.length()-point[1]-1);
}
System.out.println(new String(resultArray));
reyoreyoreyo 2017-12-01
- 打赏
- 举报
很感谢能及时回复并附上带码！！！！
能不能说说你的思路怎么处理这样的查询替换问题！！非常感谢 ！！！！！！！！！！！！[/quote]
程序还是有问题；
String[] s = { "aba", "bab", "z", "q", "uku", "kuk" };
String str = "erabatertertert";
匹配区间如下：
[2,4] [-1,1] [-1,-1] [-1,-1] [-1,1] [-1,1]
区间组成数组：-1 -1 -1 -1 -1 -1 -1 1 1 1 2 4
结果：e<b>ra</b>b<b>a</b>tertertert 正确结果应该为：er<b>aba</b>tertertert
String[] s = { "aba", "bab", "z", "q", "uku", "kuk" };
String str = "erterterterte";
匹配区间如下：
[-1,1] [-1,1] [-1,-1] [-1,-1] [-1,1] [-1,1]
区间组成数组：-1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1
结果：e<b>r</b>terterterte 正确结果应该为：erterterterte
自由自在_Yu 2017-12-01
- 打赏
- 举报
这样还是有问题，巧合了，区间处理只在数组中加入了区间的两个边界值，没有把区间内的其他数加入，比如[1,4],[2,5]这样的区间整合后就是[1,2,3,4,5],我的处理变成了[1,2,4,5],所以这一点有问题。
s a b a b q c z a c
0 1 2 3 4 5 6 7 8 9
1 2 3 4 5 7 都有匹配的顺序，所以0-1,5-6,6-7,7-8 这几个位置是分界点，然后一次填进去<b>、</b>
reyoreyoreyo 2017-12-01
- 打赏
- 举报
很感谢能及时回复并附上带码！！！！
能不能说说你的思路怎么处理这样的查询替换问题！！非常感谢 ！！！！！！！！！！！！
reyoreyoreyo 2017-12-01
- 打赏
- 举报
运行结果为：s<b>ababq</b>c<b>z</b> 少了字符啊？再帮忙看一下，谢谢
自由自在_Yu 2017-12-01
- 打赏
- 举报
import java.util.Arrays;
public class Test {
/**
* 思路：[1,3],[7,7],[5,5],[2,4] 把每个区间的两个数都保存在同一个数组里，然后排序
* 数组中不连续的位置就是分割点,例子中得到的数组是【1 2 3 4 5 5 7 7】
* 判断规则，如0不在数组，而1在数组中，所以0和1之间是个分割点，则在str[0]后面加上<b>
* 5在数组中，6不在数组中，则5和6之间是个分割点，str[5]后面加上</b>
* 添加count，奇数偶数统计判断是<b>还是</b>？
* @param args
*/
public static void main(String[] args) {
String result = "";
String[] s = { "aba", "bab", "z", "q" };
String str = "sababqczac";
int[] arr = new int[2*s.length]; //保存区间内两个数值
int n = 0;//result 数组下标
System.out.println("匹配区间如下：");
for (int i = 0; i < s.length; i++) {
int index = str.indexOf(s[i]);
arr[n++] = index;
arr[n++] = index + s[i].length() - 1;
System.out.print("[" + index + "," + (index + s[i].length() - 1) + "] ");
}
System.out.println();
Arrays.sort(arr); //排序
System.out.print("区间组成数组：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
int count = 1; //奇数<b>，偶数</b>
for (int i = 0; i < str.length(); i++) {
if(check(i,arr) && !check(i+1,arr)){
if(count%2 == 0){
result += str.charAt(i) + "</b>";
}
count ++;
}else if(check(i,arr) && check(i+1,arr)){
result += str.charAt(i);
}else if(!check(i,arr) && check(i+1,arr)){
if(count%2 != 0){
result += str.charAt(i) + "<b>";
}
count ++;
}else if(!check(i,arr) && !check(i+1,arr)){
result += str.charAt(i);
}
}
System.out.println("结果：" + result);
}
public static boolean check(int n, int[] arr){
for (int i = 0; i < arr.length; i++) {
if(arr[i] == n){
return true;
}
}
return false;
}
}
dong_19890208 2017-12-01
- 打赏
- 举报
String[] s = {"aba", "bab", "z", "q"};
String str = "sababqczac";
// 获取各子字符串在目标字符串的起始坐标位置
List<Integer[]> primaryIndex = new ArrayList<>();
for (String e : s) {
int index = str.indexOf(e);
if (-1 == index) {
continue;
}
primaryIndex.add(new Integer[]{index, index + e.length() - 1});
System.out.println(index + "," + (index + e.length() - 1));
}
// 对坐标按照开始坐标从小到大排序
Collections.sort(primaryIndex, new Comparator<Integer[]>() {
@Override
public int compare(Integer[] o1, Integer[] o2) {
return o1[0] - o2[0];
}
});
if (primaryIndex.size() <= 0) {
System.out.println("目标字符串中不包含搜索结果");
return;
}
// 合并相连坐标
List<Integer[]> resultIndex = new ArrayList<>();
Integer[] index = primaryIndex.get(0);
for (int i = 0; i < primaryIndex.size() - 1; i++) {
Integer[] index1 = primaryIndex.get(i + 1);
if (index[1] + 1 >= index1[0]) {// 有交集
//拼接index
if (index[1] < index1[1]) {
index[1] = index1[1];
}
} else {// 没有交集
resultIndex.add(index);
index = primaryIndex.get(i + 1);
}
}
resultIndex.add(index);
// 通过字符数组替换相应位置的字符
char[] array = str.toCharArray();
char[] bPrefix = "<b>".toCharArray();
char[] bSuffix = "</b>".toCharArray();
char[] resultArray = new char[array.length + (bPrefix.length + bSuffix.length) * resultIndex.size()];
for (int i = 0; i < resultIndex.size(); i++) {
//System.out.println(i[0]+","+
Integer[] point = resultIndex.get(i);
int start = 0 == i ? 0 : resultIndex.get(i - 1)[1]+1;
System.arraycopy(array, start, resultArray, start + (bPrefix.length + bSuffix.length) * i, point[0] - start);
System.arraycopy(bPrefix, 0, resultArray, (bPrefix.length + bSuffix.length) * i + point[0], bPrefix.length);
System.arraycopy(array, point[0], resultArray, (bPrefix.length + bSuffix.length) * i + point[0] + bPrefix.length, point[1] - point[0] + 1);
System.arraycopy(bSuffix, 0, resultArray, (bPrefix.length + bSuffix.length) * i + point[0] + bPrefix.length + point[1] - point[0] + 1, bSuffix.length);
}
System.out.println(new String(resultArray));
