ich habe ein array mit lauter int-werten die mir prioritäten angeben. Jetzt laufe ich das array durch und suche mir die grösste priorität aus und bekomme dann deren index, den ich zurückgebe. Jetzt würde ich gerne wenn das nächste mal nach der grössten priorität gesucht wird gleich an dieser position beginnen und dann bis ans ende des arrays laufen und dann wieder von beginn bis zu dem index wieder. wie kann ich das effizient gestalten?

Es macht doch wenig sinn sowas zu machen:

for (int i = last_idx; i < array_size; i++)
{
      // do semething
}

for (int i = 0; i < last_idx; i++)
{
     // do something
}

std::priority_queue scheint da zweckmäßiger.

Grüße...

Heiko

nehmen wir mal an ich würde es gerne so ohne die stl realisieren - ginge das überhaupt schneller also so?

Wenn du also nicht mit std::priority_queue arbeiten willst, dann vielleicht so:

mach dir eine std::map<prio_type, index_type> (wobei beide typen ints sein koennen, bzw. index_type auch ein size_t) und lauf sie von hinten nach vorn durch. Oder gib als Comparator ein std::greater<prio_type> dazu, dann ist der Teil mit der groessten prio schon ganz vorn.

std::map ist dir noch zu viel STL? ok, dann mach dir ein C-Array von std::pair<prio_type, index_type> und lass einmal std::sort drueberlaufen mit std::greater<std::pair<prio_type, index_type> > als Comparator (sortiert nach dem ersten Element des pairs).

Immernoch zu viel STL? dann schreib dir das pair selber, einen Comparator dazu und den Sortieralgo auch noch. Dann hast du alles "handmade", hoechstwahrscheinlich weniger sicher und weniger effizient als mit STL, aber das ist der Preis den man zahlen muss.

Du willst keine eigen Datenstruktur und kein sortieren? Nun ja, das waere zwar unvernuenftig. Warum nicht die Sprachmittel von C++ bzw. C nutzen (ja, das wuerde auch in C gehn, wenn man statt Comparator einen Funktionspointer benutzt, das pair ist sowieso der Einfachheit halber ein struct), aber es geht auch noch primitiver:

int nextprioindex(int* prioarr, int arr_size, int last_prio) {
  int prio = MINIMUM_PRIO;  //irgendwo definiert oder hardcodiert, aber bitte kein makro ;)
  int index = arr_size;
  for (int i = 0; i<arr_size; ++i) {
    if (prioarr[i] > prio && prioarr[i] < last_prio) {
      prio = prioarr[i];
      index = i;
    }
  }
  return index;
}

Die Funktion gibt den Index der hoechsten Prioritaet zurueck, die kleiner ist als last_prio, oder arr_size, wenn es keinen solchen Index gibt (analog zu den std::finds die hinter das letzte element im Container/array zeigen wenn nix gefunden wird)

Anwendung:

int main() {
  int prio_array[100];
  /* prio_array fuellen */
  int prio; 
  int index = nextprioindex(prio_array, 100, MAXIMUM_PRIO);
  while (index != 100) {
    prio = prio_array[index];
    cout << "Prioritaet: << prio << "; Index: " << index << endl;
    index = nextprioindex(prio_array, 100, prio);
  }
}

Ach, sorry, cout ist natuerlich als std::ostream auch Teil der STL, aber mit printf und som Kram kenn ich mich net aus

Einfach

item = last_element.next();
while(item != last_element)
{
   //TODO
   item = item.next();
}

ich habe ein array mit lauter int-werten die mir prioritäten angeben. Jetzt laufe ich das array durch und suche mir die grösste priorität aus und bekomme dann deren index, den ich zurückgebe. Jetzt würde ich gerne wenn das nächste mal nach der grössten priorität gesucht wird gleich an dieser position beginnen und dann bis ans ende des arrays laufen und dann wieder von beginn bis zu dem index wieder. wie kann ich das effizient gestalten?

Ein interessantes Problem. Ich würde mir einen eigenen Iterator dafür schreiben, der quasi im Kreis laufen kann.

#include <iostream>
#include <algorithm>   // max_element
#include <iterator>    // std::iterator

template< typename I >
class RingIterator : public std::iterator< std::forward_iterator_tag, typename std::iterator_traits< I >::value_type >
{
public:
    RingIterator( I first, I last )
        : m_first( first ), m_last( last )
        , m_base( first )
        , m_begin( false )
    {}
    RingIterator& operator++()
    {
        if( ++m_base == m_last )
            m_base = m_first;
        m_begin = false;
        return *this;
    }
    typename std::iterator_traits< I >::reference operator*() const
    {
        return *m_base;
    }
    bool operator==( const RingIterator& b ) const
    {
        return m_base == b.m_base && m_begin == b.m_begin;
    }
    RingIterator begin() const
    {
        RingIterator beg( *this );
        beg.m_begin = true;
        return beg;
    }
    I base() const { return m_base; }
private:
    I m_first, m_last;
    I m_base;
    bool m_begin;
};
template< typename I >
bool operator!=( const RingIterator< I >& a, const RingIterator< I >& b )
{
    return !(a == b);
}

Sieht wohl für einige Leute einschließlich des Threaderstellers kryptisch aus, aber bei der Anwendung geht's dann recht einfach

int main()
{
    using namespace std;
    int arr[] = { 1, 2, 99, -2, 99, 4, 1, 1, 1, 1, 99 };
    RingIterator< int* > i( arr, arr + sizeof(arr)/sizeof(*arr) ); 
    for( int n = 0; n<4; ++n, ++i )
    {
        i = max_element( i.begin(), i );
        cout << "Maximum bei Position " << distance( arr, i.base() ) << " gefunden" << endl;
    }
    return 0;
}

Die Ausgabe ist:

Maximum bei Position 2 gefunden
Maximum bei Position 4 gefunden
Maximum bei Position 10 gefunden
Maximum bei Position 2 gefunden

Gruß
Werner