Question

char_array[]是＆＃34; x，a，x，c，x，b，x，a，x，x，b，x，x，x，x＆＃34;

key_array[]是＆＃34; a，b，c＆＃34;

预期返回数组：＆＃34; 1,5,3＆＃34;

目标是打印与char_array匹配的key_array索引。例如，在这种情况下，程序必须打印＆＃34; 1,5,3＆＃34;。它只统计它匹配的第一个索引。

另一个例子是

char_array[]是＆＃34; q，h，e，h，w，e，r，t，l，y，l，l，o＆＃34;

key_array[]是＆＃34; h，e，l，l，o＆＃34;

预期回报数组：＆＃34; 1,2,8,10,12＆＃34;

到目前为止我尝试过的是

int index = 0;
for(int i = 0; i < key_array.length; i++)
{
    isFound = false;
    for(int k = index + 1; k < char_array.length && isFound == false; k++) 
    {
        if(char_array[i] == key_array[k])
        {
            index = k;
            num[j] = index;
            isFound = true;
        }
    }
}

这样，我的第二个例子涉及＆＃34;你好＆＃34;但是我的第一个例子涉及＆＃34; abc＆＃34;不起作用。

我使用k启动了index+1，但我想我必须将其从0更改为char_array.length ..

有人可以帮助我理解这个逻辑吗

Answer 1

试试这个;

for(int i=0;i<key_array.length;i++)
{
    int pos=new String(char_array).indexOf(key_array[i]);

    char_array[pos]='0'                          //considering there is no numeric character in char_array  

    collection.push(pos);                        //collection is a java Collection framework's object
}

Answer 2

我想你可以先自己做一个indexOf方法，它会返回数组中对象的索引。

private static int indexOf(char item, char[] array) {
    for (int i = 0 ; i < array.length ; i++) {
        if (array[i] == item) {
            return i;
        }
    }
    return -1;
}

然后，您只需要再增加4行代码：

int[] resultArray = new int[key_array.length];
for (int i = 0 ; i < key_array.length ; i++) {
    resultArray[i] = indexOf(key_array[i], char_array);
}

说明：

indexOf方法对数组进行线性搜索，并返回所需项的第一次出现的索引。如果找不到所需的项目，则返回-1。

我首先创建了一个与key_array长度相同的结果数组。然后我循环了key_array。在每次迭代中，我调用indexOf来获取索引，并同时修改result_array。

Answer 3

似乎要做的伎俩

static int[] foo(char[] char_array, char[] key_array) {
    // copy the original so we can modify to avoid repeats
    char[] copy = new char[char_array.length];
    System.arraycopy(char_array, 0, copy, 0, char_array.length);
    int[] result = new int[key_array.length];
    boolean found = true;
    for(int i = 0; found && i < key_array.length; i++) {
        found = false;
        for(int j = 0; j < copy.length; j++) {
            if (copy[j] == key_array[i]) {
                copy[j] = 0;
                result[i] = j;
                found = true;
                break;
            }
        }
    }
    if (found) {
        return result;
    }
    return null;
}

public static void main(String[] args) {
    System.out.println(Arrays.toString(foo("xaxcxbxaxxbxxxx".toCharArray(), "abc".toCharArray())));
    System.out.println(Arrays.toString(foo("qhehwertlyllo".toCharArray(), "hello".toCharArray())));
}

Answer 4

这仅适用于第二个示例，因为字符按顺序发生。

但是，您需要根据是否已经为此char设置字符串（在找到char之后开始）来决定开始搜索的索引。

E.g。

object_id

或者使用for (int i = 0; i < key_array.length; i++) { char c = key_array[i]; int previousIndex; // go back and find the last index with a matching char for (previousIndex = i-1; previousIndex >= 0 && key_array[previousIndex] != c; previousIndex--) {} if (previousIndex >= 0 && num[previousIndex] == -1) { // last key not found => no further matches available num[i] = -1; } else { // find occurence of char after last match num[i] = -1; for (int j = (previousIndex >= 0 ? num[previousIndex] + 1 : 0); j < char_array.length; j++) { if (char_array[j] == c) { num[i] = j; break; } } } }来存储Map的索引，并使用它来有效地检索索引：

char

Answer 5

我认为这将完成工作（O（n））：

char[] char_array = {'q', 'h', 'e', 'h', 'w', 'e', 'r', 't', 'l', 'y', 'l', 'l', 'o'};
char[] key_array = {'h', 'e', 'l', 'l', 'o'};

Map<Character, Queue<Integer>> charPossitions = new HashMap<Character, Queue<Integer>>();
for(int i = 0; i < char_array.length; i++){
    if(charPossitions.get(char_array[i]) == null){           
       Queue<Integer> possitionsQueue=new LinkedList<Integer>();
       possitionsQueue.add(i);
       charPossitions.put(char_array[i], possitionsQueue);
    }else { 
       charPossitions.get(char_array[i]).add(i);
    }                                           
}
for(char key : key_array){
    System.out.println(key + "/" + charPossitions.get(key).poll());
}

Answer 6

你好，这应该做的！

public class Main
{

  private static final char[] liste1 = {'x', 'a', 'x', 'c', 'x', 'b', 'x', 'a', 'x', 'x' ,'b' ,'x' ,'x', 'x', 'x'};
  private static final char[] liste2 = {'q', 'h', 'e', 'h', 'w', 'e', 'r', 't', 'l', 'y', 'l', 'l', 'o'};
  private static final char[] key1 = {'a', 'b', 'c'};
  private static final char[] key2 = {'h', 'e', 'l', 'l', 'o'};


  private static void lookupIndexOfChar(char c, char[] list, List<Integer> result){
    for(int i = 0; i < list.length; i++){
      if(list[i] == c){
        if(notInResult(i, result)){
          result.add(i);
          break;
        }
      }
    }
  }

  private static boolean notInResult(int i, List<Integer> result)
  {
    return !(result == null || result.contains(i));
  }

  public static void main(String[] args){
    List<Integer> result = new ArrayList<Integer>();
    for (char c : key1)
    {
      lookupIndexOfChar(c, liste1, result);
    }
    for (Integer integer : result)
    {
      System.out.print(integer);
    }
    System.out.println(" ");
    result.clear();
    for (char c : key2)
    {
      lookupIndexOfChar(c, liste2, result);
    }
    for (Integer integer : result)
    {
      System.out.print(integer);
    }
  }

}

Java字符数组打印索引

6 个答案: