Найти позицию элемента в Java TreeMap

после того, как вы построили карту дерева, скопируйте ее отсортированные ключи в массив и используйте Arrays.binarySearch для поиска индекса в O(logN) времени. Если вам нужно значение, выполните поиск на исходной карте тоже.

Edit: вот как вы копируете ключи в массив

String[] mapKeys = new String[treeMap.size()];
int pos = 0;
for (String key : treeMap.keySet()) {
    mapKeys[pos++] = key;
}

в самом JDK такой реализации нет. Хотя TreeMap итерации в естественном порядке ключей, его внутренние структуры данных основаны на деревьях, а не массивах (помните, что Maps Не заказывайте ключи по определению, несмотря на то, что это очень распространенный вариант использования).

тем не менее, вы должны сделать выбор, поскольку невозможно иметь время вычисления O(1) для ваших критериев сравнения как для вставки в Map и indexOf(key) расчет. Это связано с тот факт, что лексикографический порядок нестабилен в изменяемой структуре данных (в отличие от порядка вставки, например). Пример: как только вы вставляете первую пару ключ-значение (запись) в карту, ее позиция всегда будет одной. Однако в зависимости от второго вставленного ключа эта позиция может измениться, поскольку новый ключ может быть "больше" или "ниже", чем в Map. Вы можете реализовать это, поддерживая и обновляя индексированный список ключей во время операции вставки, но тогда у вас будет O(N log(n)) для ваших операций вставки (так как вам нужно будет переупорядочить массив). Это может быть желательно или нет, в зависимости от ваших шаблонов доступа к данным.

ListOrderedMap и LinkedMap в Apache Commons оба приближаются к тому, что вам нужно, но полагаются на порядок вставки. Вы можете проверить их реализацию и разработать свое собственное решение проблемы с небольшими и умеренными усилиями, я считаю (это должно быть просто вопросом замены ListOrderedMaps внутренний массив поддержки с сортированный список -TreeList в Apache Commons, например).

вы также можете вычислить индекс самостоятельно, вычитая количество элементов, которые ниже, чем заданный ключ (который должен быть быстрее, чем итерация по списку поиска вашего элемента, в наиболее частом случае - поскольку вы ничего не сравниваете).

альтернативным решением было бы использовать TreeMap ' s headMap метод. Если слово существует в TreeMap, потом size() его карта головы равна индексу слова в словаре. Это может быть немного расточительно по сравнению с моим другим ответом, через.

вот как вы кодируете его на Java:

import java.util.*;

class Test {
    public static void main(String[] args) {
        TreeMap<String,String> tm = new TreeMap<String,String>();
        tm.put("quick", "one");
        tm.put("brown", "two");
        tm.put("fox", "three");
        tm.put("jumps", "four");
        tm.put("over", "five");
        tm.put("the", "six");
        tm.put("lazy", "seven");
        tm.put("dog", "eight");
        for (String s : new String[] {
            "quick", "brown", "fox", "jumps", "over",
            "the", "lazy", "dog", "before", "way_after"}
        ) {
            if (tm.containsKey(s)) {
                // Here is the operation you are looking for.
                // It does not work for items not in the dictionary.
                int pos = tm.headMap(s).size();
                System.out.println("Key '"+s+"' is at the position "+pos);
            } else {
                System.out.println("Key '"+s+"' is not found");
            }
        }
    }
}

вот результат, полученный программой:

Key 'quick' is at the position 6
Key 'brown' is at the position 0
Key 'fox' is at the position 2
Key 'jumps' is at the position 3
Key 'over' is at the position 5
Key 'the' is at the position 7
Key 'lazy' is at the position 4
Key 'dog' is at the position 1
Key 'before' is not found
Key 'way_after' is not found

у меня была та же проблема. Поэтому я взял исходный код java.утиль.TreeMap и написал IndexedTreeMap. Он реализует мой собственный IndexedNavigableMap:

public interface IndexedNavigableMap<K, V> extends NavigableMap<K, V> {
   K exactKey(int index);
   Entry<K, V> exactEntry(int index);
   int keyIndex(K k);
}

реализация основана на обновлении Весов узлов в красно-черном дереве при его изменении. Вес-это количество дочерних узлов под данным узлом, плюс один-self. Например, когда дерево поворачивается влево:

    private void rotateLeft(Entry<K, V> p) {
    if (p != null) {
        Entry<K, V> r = p.right;

        int delta = getWeight(r.left) - getWeight(p.right);
        p.right = r.left;
        p.updateWeight(delta);

        if (r.left != null) {
            r.left.parent = p;
        }

        r.parent = p.parent;


        if (p.parent == null) {
            root = r;
        } else if (p.parent.left == p) {
            delta = getWeight(r) - getWeight(p.parent.left);
            p.parent.left = r;
            p.parent.updateWeight(delta);
        } else {
            delta = getWeight(r) - getWeight(p.parent.right);
            p.parent.right = r;
            p.parent.updateWeight(delta);
        }

        delta = getWeight(p) - getWeight(r.left);
        r.left = p;
        r.updateWeight(delta);

        p.parent = r;
    }
  }

updateWeight просто обновляет вес до корень:

   void updateWeight(int delta) {
        weight += delta;
        Entry<K, V> p = parent;
        while (p != null) {
            p.weight += delta;
            p = p.parent;
        }
    }

и когда нам нужно найти элемент по индексу вот реализация, которая использует вес:

public K exactKey(int index) {
    if (index < 0 || index > size() - 1) {
        throw new ArrayIndexOutOfBoundsException();
    }
    return getExactKey(root, index);
}

private K getExactKey(Entry<K, V> e, int index) {
    if (e.left == null && index == 0) {
        return e.key;
    }
    if (e.left == null && e.right == null) {
        return e.key;
    }
    if (e.left != null && e.left.weight > index) {
        return getExactKey(e.left, index);
    }
    if (e.left != null && e.left.weight == index) {
        return e.key;
    }
    return getExactKey(e.right, index - (e.left == null ? 0 : e.left.weight) - 1);
}

также очень удобно найти индекс ключа:

    public int keyIndex(K key) {
    if (key == null) {
        throw new NullPointerException();
    }
    Entry<K, V> e = getEntry(key);
    if (e == null) {
        throw new NullPointerException();
    }
    if (e == root) {
        return getWeight(e) - getWeight(e.right) - 1;//index to return
    }
    int index = 0;
    int cmp;
    if (e.left != null) {
        index += getWeight(e.left);
    }
    Entry<K, V> p = e.parent;
    // split comparator and comparable paths
    Comparator<? super K> cpr = comparator;
    if (cpr != null) {
        while (p != null) {
            cmp = cpr.compare(key, p.key);
            if (cmp > 0) {
                index += getWeight(p.left) + 1;
            }
            p = p.parent;
        }
    } else {
        Comparable<? super K> k = (Comparable<? super K>) key;
        while (p != null) {
            if (k.compareTo(p.key) > 0) {
                index += getWeight(p.left) + 1;
            }
            p = p.parent;
        }
    }
    return index;
}

Я скоро реализую IndexedTreeSet, а пока вы можете использовать набор ключей из IndexedTreeMap.

обновление: теперь реализован IndexedTreeSet.

вы можете найти результат этой работы в https://github.com/geniot/indexed-tree-map

Я согласен с Isolvieira. Пожалуй, лучшим подходом было бы использовать другую структуру, чем дерева.

однако, если вы все еще хотите пойти с вычислением индекса ключей, решение будет посчитать, сколько ключей ниже, чем ключ, который вы ищете.

вот фрагмент кода:

    java.util.SortedMap<String, String> treeMap = new java.util.TreeMap<String, String>();
    treeMap.put("d", "content 4");
    treeMap.put("b", "content 2");
    treeMap.put("c", "content 3");
    treeMap.put("a", "content 1");

    String key = "d"; // key to get the index for
    System.out.println( treeMap.keySet() );

    final String firstKey = treeMap.firstKey(); // assuming treeMap structure doesn't change in the mean time
    System.out.format( "Index of %s is %d %n", key, treeMap.subMap(firstKey, key).size() );

вы думали, чтобы сделать значения в вашем TreeMap содержать позицию в словаре? Я использую BitSet здесь мои данные файла.

это работает не так хорошо, как моя другая идея ниже.

Map<String,Integer> dictionary = new TreeMap<String,Integer> ();

private void test () {
  // Construct my dictionary.
  buildDictionary();
  // Make my file data.
  String [] file1 = new String[] {
    "1", "3", "5"
  };
  BitSet fileDetails = getFileDetails(file1, dictionary);
  printFileDetails("File1", fileDetails);
}

private void printFileDetails(String fileName, BitSet details) {
  System.out.println("File: "+fileName);
  for ( int i = 0; i < details.length(); i++ ) {
    System.out.print ( details.get(i) ? 1: -1 );
    if ( i < details.length() - 1 ) {
      System.out.print ( "," );
    }
  }
}

private BitSet getFileDetails(String [] file, Map<String, Integer> dictionary ) {
  BitSet details = new BitSet();
  for ( String word : file ) {
    // The value in the dictionary is the index of the word in the dictionary.
    details.set(dictionary.get(word));
  }
  return details;
}

String [] dictionaryWords = new String[] {
  "1", "2", "3", "4", "5"
};

private void buildDictionary () {
  for ( String word : dictionaryWords ) {
    // Initially make the value 0. We will change that later.
    dictionary.put(word, 0);
  }
  // Make the indexes.
  int wordNum = 0;
  for ( String word : dictionary.keySet() ) {
    dictionary.put(word, wordNum++);
  }
}

здесь построение деталей файла состоит из одного поиска в TreeMap для каждого слова в файле.

если вы планируете использовать value в словарь TreeMap для чего-то еще вы всегда может составить его с Integer.

добавил

думая об этом далее, если

Я бы предложил вам написать SkipList для хранения вашего словаря, так как это по-прежнему будет предлагать поиск, вставку и удаление O(log N), а также возможность предоставлять индекс (реализации дерева обычно не могут возвращать индекс, так как узлы его не знают, и будет стоить их обновления). К сожалению, реализация Java ConcurrentSkipListMap не предоставляет индекс, поэтому вам нужно будет реализовать свою собственную версию.

получаете индекс элемента будет O (log N), если вы хотите как индекс, так и значение, не делая 2 поиска, вам нужно будет вернуть объект-оболочку, содержащий оба.