Remove manual mem allocation for heap sort.

    const std::vector<std::pair<uint64_t, uint64_t>> &minimizers,

    uint32_t &repetitive_seed_length, std::vector<uint64_t> &positive_hits,

    std::vector<uint64_t> &negative_hits, bool use_heap) const {

  uint32_t num_minimizers = minimizers.size();

  int repetitive_seed_count = 0;

  std::vector<uint64_t> *mm_positive_hits = NULL, *mm_negative_hits = NULL;

  bool heap_resort = false;  // need to sort the elements of heap first

  const uint32_t num_minimizers = minimizers.size();

  std::vector<std::vector<uint64_t>> mm_positive_hits;

  std::vector<std::vector<uint64_t>> mm_negative_hits;

  if (use_heap) {

    mm_positive_hits = new std::vector<uint64_t>[num_minimizers];

    mm_negative_hits = new std::vector<uint64_t>[num_minimizers];

    for (uint32_t i = 0; i < num_minimizers; ++i) {

      mm_positive_hits.emplace_back(std::vector<uint64_t>());

      mm_negative_hits.emplace_back(std::vector<uint64_t>());

    }

  }

  bool heap_resort = false;  // need to sort the elements of heap first

  positive_hits.reserve(max_seed_frequency * 2);

  negative_hits.reserve(max_seed_frequency * 2);

  uint32_t previous_repetitive_seed_position =

      std::numeric_limits<uint32_t>::max();

  int repetitive_seed_count = 0;

  for (uint32_t mi = 0; mi < num_minimizers; ++mi) {

    khiter_t khash_iterator =

        kh_get(k64, lookup_table_, minimizers[mi].first << 1);

  if (use_heap) {

    std::priority_queue<struct mmHit> heap;

    unsigned int *mm_pos = new unsigned int[num_minimizers];

    std::vector<uint32_t> mm_pos(num_minimizers);

    positive_hits.clear();

    for (uint32_t mi = 0; mi < num_minimizers; ++mi) {

      if (mm_positive_hits[mi].size() == 0) continue;

        heap.push(nh);

      }

    }

    delete[] mm_positive_hits;

    delete[] mm_negative_hits;

    delete[] mm_pos;

  } else {

    std::sort(positive_hits.begin(), positive_hits.end());

    std::sort(negative_hits.begin(), negative_hits.end());