C++ Lista类代码示例

void MainWindow::on_actionOpen_Disk_triggered()
{
    QString disco = QFileDialog::getOpenFileName(this, "Seleccione un disco", "", "*.disk");
    if(disco == "")
        return;
    QFileInfo file(disco);
    QString name = file.baseName();
    name.append(".disk");
    Lista<string>* canciones = disk.openDisk(name.toStdString());
    this->cant_bloques_previo = disk.super.used_blocks;

    if(canciones != NULL)
    {
        for(int i = 0; i < canciones->getCantidad(); i++)
        {
            string cancion = canciones->obtenerValor(i);
            ui->cmbSongs->addItem(cancion.c_str());
        }
    }

    enableButtons();
    ui->tableWidget->setRowCount(disk.super.cant_block / ui->tableWidget->columnCount());
    loadTable();
}

int _tmain(int argc, _TCHAR* argv[])
{


	srand(time(NULL));

	Lista l;
	cout << "Crear una lista l con los valores, 2,3,6,7" << endl;
	l.insertarFinal(new ElementoInt(2));
	l.insertarFinal(new ElementoInt(3));
	l.insertarFinal(new ElementoInt(6));
	l.insertarFinal(new ElementoInt(7));
	cout << "La lista l es: " << l << endl;
	cout << endl;
	
	cout << "Insertar el elemento 12, al inicio" << endl;
	l.insertarInicio(new ElementoInt(12));
	cout <<"La lista l es: "<< l << endl;
	cout << endl;

	cout << "Insertar el elemento 67, en la posicion 2" << endl;
	l.insertar(new ElementoInt(67), 2);
	cout << "La lista l es: " << l << endl;
	cout << endl;

	cout << "Remover el elemento del final" << endl;
	l.removerFinal();
	cout << "La lista l es: " << l << endl;
	cout << endl;

	cout << "Remover el elemento del inicio" << endl;
	l.removerInicio();
	cout << "La lista l es: " << l << endl;
	cout << endl;

	cout << "Remover el elemento de la posicion 2" << endl;
	l.remover(2);
	cout << "La lista l es: " << l << endl;
	cout << endl;

	system("pause");
	return 0;

}

/**
 * Riempie ricorsivamente un sotto-albero in base all'elemento
 * da inserire
 * [FUNZIONE_PRIVATA]
 */
void private_riempiAlbero(Lista lista, int lunghezzaLista, Albero &t, nodoBin nodoRiferimento) {
	
	tipoelem elemento;
	posizione p;
	nodoBin nuovoRiferimentoSx, nuovoRiferimentoDx;
	Lista listaSx, listaDx;
	int lSottolistaSx, lSottolistaDx;
	
	// 1: calcola il mediano e lo scrive nel nodo di riferimento
	p = mediano(lista,lista.primoLista(), lista.pos(lunghezzaLista));
	lista.leggiLista(elemento, p);
	t.scriviNodo(nodoRiferimento, elemento);
	// :1
	// 2: calcola la sottolista sinistra in base al mediano
	listaSx = creaSottoLista(lista, lista.primoLista(), p);
	lSottolistaSx = lunghezza(lista, lista.primoLista(), p);
	// 2.1: controlla che abbia senso avviare una ricorsione
	if ( lSottolistaSx > 0 ) {
		t.insFiglioSx(nodoRiferimento);
		nuovoRiferimentoSx = t.figlioSx(nodoRiferimento);
		// 2.1.1 Se la lista ha 1 solo elemento, allora è una foglia
		if ( lSottolistaSx == 1 ) {
			listaSx.leggiLista(elemento, listaSx.primoLista());
			t.scriviNodo(nuovoRiferimentoSx, elemento);
		// :2.1.1
		// 2.1.2 Se la lista ha piu di un elemento allora avvia la ricorsione
		} else {
			private_riempiAlbero(listaSx, lSottolistaSx, t, nuovoRiferimentoSx);
		}
		// :2.1.2
	}
	// :2.1
	// 3: calcola la sottolista destra analogamente a quella sinistra
	listaDx = creaSottoLista(lista, lista.succLista(p), salta(lista, lista.primoLista(), lunghezzaLista));
	lSottolistaDx = lunghezzaLista / 2;
	if ( lSottolistaDx > 0 ) {		
		t.insFiglioDx(nodoRiferimento);
		nuovoRiferimentoDx = t.figlioDx(nodoRiferimento);
		if ( lSottolistaDx == 1 ) {
			listaDx.leggiLista(elemento, listaDx.primoLista());
			t.scriviNodo(nuovoRiferimentoDx, elemento);
		} else {
			private_riempiAlbero(listaDx, lSottolistaDx, t, nuovoRiferimentoDx );
		}
	}
	// :3
	return;
}

int main()
{
    Lista l;

    l.agregar(new Perro(5,"hola"));
    l.agregar(new Perro(5,"adios"));
    l.agregar(new Perro(8,"valemadre"));
    l.insertar(new Lora(4,"blu"),9);

    cout<<l.buscar("adios")->edad<<endl;

    return 0;
}

int main()
{
    int iPuntuacion = 0, iNumCorte = 0;
    string Entrada;

    Lista Jugadores;
    while( cin >> Entrada >> iPuntuacion ) {
        if( Entrada == "corte" ) {
            iNumCorte++;
            for( Lista::iterator it = Jugadores.begin(); it != Jugadores.end(); it++ ) {
                if( it->second.first < iPuntuacion && it->second.second == 0 ) {
                    it->second.second = iNumCorte;
                }
            }
        } else {
            if( iNumCorte == 0 ) {
                Jugadores[Entrada].first += iPuntuacion;
            } else {
                if( Jugadores.find( Entrada ) == Jugadores.end() ) {
                    cout << Entrada << "?" << endl;
                } else {
                    if( Jugadores[Entrada].second != 0 ) {
                        cout << Entrada << " OUT" << endl;
                    } else {
                        Jugadores[Entrada].first += iPuntuacion;
                    }
                }
            }
        }
    }

    vector<Pareja> Ordenar;
    for( Lista::iterator it = Jugadores.begin(); it != Jugadores.end(); it++ ) {
            Ordenar.push_back( Pareja(it->second.first, it->first) );
    }
    sort( Ordenar.begin(), Ordenar.end(), Comparar );

    for( int i = 0; i < int(Ordenar.size()); i++ ) {
        if( Jugadores[Ordenar[i].second].second == 0 )
            cout << "** " << Ordenar[i].second << " " << Ordenar[i].first << endl;
        else
            cout << "C" << Jugadores[Ordenar[i].second].second << " " << Ordenar[i].second << " " << Ordenar[i].first << endl;
    }

    return 0;
}

PertCpm<Actividade*, int>
Projecto::load_pert()
{
    PertCpm<Actividade*, int> p;
    Lista<Actividade*> l = this->l_actividades;
    Actividade *a;
    Lista<Actividade*> lp = this->l_actividades;
    Actividade *b;
    int x = 1;
    int y = 1;
    while( ! l.vazia() ){
        l.remove( x, a);
        lp = a->getPrecedencias();
        while( ! lp.vazia() ){
            lp.remove(y, b);    
            p.juntar_ramo(y, b , a);
        }
    }
    return p; 
}

int main(){
	srand(time(NULL));
	int ilosc;
	//wczytywanie od uzytkownika informacji
	//o ilosci elementow dodanych do listy
	printf("Podaj ilosc elementow: ");
	scanf("%d",&ilosc);
	Lista zadanie;
 
	//dodawanie elementow do listy
	for(int i=0; i<ilosc; i++){
		if(!zadanie.AddSort(rand()%200+1)){
			printf("Klucz o podanym indexie juz istnieje!\n");
		}
	}
 
	zadanie.Wyswietl(true);
	int szuk;
	printf("Szukaj elementu: ");
	scanf("%d",&szuk);
 
	pole*sz=zadanie.Szukaj(szuk);
	//jezeli znalazlo
	if(sz){
		printf("Znalazlem klucz: %d\n",sz->klucz);
	}
	//jesli nie znalazlo
	else printf("Nie znalazlem podanego klucza!\n");
 
	int usun;
	printf("Usun element: ");
	scanf("%d",&usun);
 
	if(zadanie.Usun(usun)){
		printf("Usunalem klucz: %d\n",usun);
	}
	//jesli nie znalazlo
	else printf("Nie znalazlem podanego klucza!\n");
	zadanie.Wyswietl(false);
	return 0;
}

 void Lista::quickSort(Lista list, int left, int right)
 {
 	int i=left;
 	int j=right;
 	int mid=(left+right)/2;
 	int x=list.getName(mid);
 	while(i<=j)
 	{
 		while(list.getName(i)<x) i++;
 		while(list.getName(j)>x) j--;
 		if (i<=j)
 		{
 			swap(list.getName(i), list.getName(j));
 			swap(list.getNext(i), list.getNext(j));
 			i++;
 			j--;
 		}
 	}
 	if(left<j) quickSort(list, left, j);
 	if(right>i) quickSort(list, i, right);
 }

bool Competencia::gananLosMasCapaces() const{
    Deporte d = categoria().first;
    Lista<Atleta> rank = ranking();
    int i = 0;
    bool res;

    while (i<_ranking.longitud()){
        if (rank.longitud()<=1){
            res = true;
            i = _ranking.longitud();
        } else {
            if(rank.iesimo(0).capacidad(d) >= rank.iesimo(1).capacidad(d)){
                rank.sacar(rank.iesimo(0));
            } else {
                res = false;
                i = _ranking.longitud();
            }
        }
    }
    return res;
}

void caminos_simples(const Grafo<C> & grafo, int origen, int destino,
		     bool visitado[], Lista<Lista<int> > & caminos, Lista<int> & camino_parcial)
{
     visitado[origen] = true;
     camino_parcial.agregarFinal(origen);
     if (origen == destino) {
	  caminos.agregarFinal(camino_parcial);
	  camino_parcial.eliminarFinal();
	  visitado[origen] = false;
	  return;
     }
     
     Lista<typename Grafo<C>::Arco> adyacentes;
     grafo.devolverAdyacentes(origen, adyacentes);
     typename Lista<typename Grafo<C>::Arco>::Iterador ady = adyacentes.devolverIterador();
     while (!ady.llegoAlFinal()) {
	  int v = ady.elementoActual().devolverAdyacente();
	  if (!visitado[v]) 
	       caminos_simples(grafo, v, destino, visitado, caminos, camino_parcial);
	  ady.avanzar();
     }
     camino_parcial.eliminarFinal();
     visitado[origen] = false;
}

LinkLinkIt::ItAcceso::ItAcceso(Lista<Acceso> &ac)
{
    _itLista = ac.CrearIt();
}

void JJOO::cargar (std::istream& is) {
    char c;
    //Saco J anio jornada [
    is >> c >> _anio >> _jornadaActual >> c;
    bool loop = true;
    Lista<Atleta> nuevosAtletas;
    if(is.peek() != ']') {
        while(loop) {
            //Saco (
            is >> c;
            Atleta atle;
            atle.cargar(is);
            nuevosAtletas.agregarAtras(atle);
            //Saco )
            is >> c;
            if(is.peek() != ',') {
                loop = false;
            }
            else {
                //Saco la coma
                is >> c;
            }
        }
    }
    _atletas = nuevosAtletas;
    //Saco ] y [
    is >> c >> c;
    Lista<Lista<Competencia> > nuevasCompetenciasPorDia;
    if(is.peek() != ']') {
        loop = true;
        while(loop) {
            //Saco [
            is >> c;
            Lista<Competencia> nuevaCompetenciasEnElDia;
            if(is.peek() != ']') {
                Competencia compe;
                bool secLoop = true;
                while(secLoop) {
                    //Saco (
                    is >> c;
                    compe.cargar(is);
                    nuevaCompetenciasEnElDia.agregarAtras(compe);
                    //Saco )
                    is >> c;
                    if(is.peek() != ',') {
                        secLoop = false;
                    }
                    else {
                        //Saco la coma
                        is >> c;
                    }
                }
            }
            //Saco ]
            is >> c;
            nuevasCompetenciasPorDia.agregarAtras(nuevaCompetenciasEnElDia);
            if(is.peek() != ',') {
                loop = false;
            }
            else {
                //Saco la coma
                is >> c;
            }
        }

void JJOO::liuSong(const Atleta& a, const Pais p) {
    Atleta atletaNacionalizado(a.nombre(), a.sexo(), a.anioNacimiento(), p, a.ciaNumber());
    int i = 0;
    while(i<a.deportes().longitud()) {
        atletaNacionalizado.entrenarNuevoDeporte(a.deportes().iesimo(i), a.capacidad(a.deportes().iesimo(i)));
        i++;
    }

    //Saco el atleta y lo agrego nacionalizado en atletas;
    _atletas.sacar(a);
    _atletas.agregarAtras(atletaNacionalizado);

    i=0;
    int j = 0;
    //Lista que va a reemplazar a la vieja lista de listas competencias
    Lista<Lista<Competencia> > nuevaCompetenciasPorDia;
    while(i<_competenciasPorDia.longitud()) {
        //Lista de competencias que va a reemplazar a la anterior en ese dia
        Lista<Competencia> nuevaCompetenciasEnDia;
        j = 0;
        while(j<_competenciasPorDia.iesimo(i).longitud()) {
            Competencia viejaCompe = _competenciasPorDia.iesimo(i).iesimo(j);
            //Me fijo si esa competencia tiene al atleta, si no, la dejo como estaba
            if(viejaCompe.participantes().pertenece(a)) {
                //Creo la nueva lista de participantes
                Lista<Atleta> nuevosParticipantes = viejaCompe.participantes();
                nuevosParticipantes.sacar(a);
                nuevosParticipantes.agregarAtras(atletaNacionalizado);
                //
                //Guardo la categoria
                Deporte dep = viejaCompe.categoria().first;
                Sexo sex = viejaCompe.categoria().second;
                //
                //Creo lo que va a ser la nueva competencia con el atleta cambiado
                //
                Competencia nuevaCompe(dep, sex, nuevosParticipantes);

                //Si esta finalizada, asigno el ranking y el doping
                if(viejaCompe.finalizada()) {
                    int h = 0;
                    Lista<int> ranking;
                    Lista<pair<int, bool> > control;
                    while(h<viejaCompe.ranking().longitud()) {
                        ranking.agregarAtras(viejaCompe.ranking().iesimo(h).ciaNumber());
                        h++;
                    }
                    h = 0;
                    while(h<viejaCompe.lesTocoControlAntidoping().longitud()) {
                        bool leToco = viejaCompe.leDioPositivo(viejaCompe.lesTocoControlAntidoping().iesimo(h));
                        int suCiaNumber = viejaCompe.lesTocoControlAntidoping().iesimo(h).ciaNumber();
                        pair<int, bool> par = make_pair(suCiaNumber, leToco);
                        control.agregarAtras(par);
                        h++;
                    }
                    //Finalizo
                    nuevaCompe.finalizar(ranking, control);
                }
                //Agrego a lo que va a ser mi nueva lista de competencias en ese dia
                nuevaCompetenciasEnDia.agregarAtras(nuevaCompe);
            }
            else {
                nuevaCompetenciasEnDia.agregarAtras(viejaCompe);
            }
            j++;
        }
        i++;
        nuevaCompetenciasPorDia.agregarAtras(nuevaCompetenciasEnDia);
    }
    _competenciasPorDia = nuevaCompetenciasPorDia;
}

  void Cine::cargar (std::istream& is) {

    Nombre n;
    Pelicula p;
    Lista<pair<Pelicula,Sala> > ps ;
    Lista<pair<Sala, int> > es ;
    Lista <Ticket> tvsu;
    int s;
    int e;
    int i;
    Ticket t;
    char c;
    is >> c;
    is >> c;
    getline(is, nombre_,'|');
    is >> c;//descarta el [
    while (c!=']') {
        is >> s;
        salasSinUsar_.agregarAtras(s);
        is >> c;//vale , o ]
    }
    is >> c;//descarta [
    while (c!=']') {
        is >> c;//descarta (
        if (c==']'){
            break;
        }
        is >> s;
        is >> c;//descarta ,
        is >> e;
        es.agregarAtras(make_pair(s,e));
        is >> c;//descarta )
        is >> c;//vale , o ]
    }
    espectadores_ = es;
    is >> c;//descarta [
    while (c!=']') {
        is >> c;//descarta (
        if (c==']'){
            break;
        }
        is >> s;
        is >> c;//descarta ,
        is >> i;
        while (i !=0) {
        ticketsVendidos_.agregar(Ticket(peliculaC(s),s,false));
        i=i-1;
        }
        is >> c;//descarta )
        is >> c;//vale , o ]
    }
    is >> c;//descarta [
    while (c!=']') {
        is >> c;//descarta (
        if (c==']'){
            break;
        }
        is >> s;
        is >> c;//descarta ,
        is >> c;//descarta (
        p.cargar(is);
        ps.agregarAtras(make_pair(p,s));
        is >> c;//descarta )
        is >> c;//descarta )
        is >> c;//vale , o ]
    }
    peliculas_ =ps;
    is >> c;
  }

void Reportes::reportePorDistrito(int idDistrito, bool guardaEncriptado, string claveEncriptado)
{
	ABMConteo *abmConteo = new ABMConteo();
	ABMEleccion* abmEleccion = new ABMEleccion();
	ABMCargo* abmCargo = new ABMCargo();
	ABMDistrito* abmDistrito = new ABMDistrito();
	std::stringstream out;

	vector<Conteo> resultados =  abmConteo->GetConteoByDistrito(idDistrito);

	if(resultados.size() == 0){
		out << "No se encontraron resultados." << endl;
		return;
	}

	//Primero ordeno por fecha de eleccion
	resultados = Reportes::OrderByFecha(resultados);

	//Agrupo por fecha de eleccion
	vector< vector<Conteo> > resAgrupados;
	vector<Conteo> cs;
	cs.push_back(resultados[0]);
	resAgrupados.push_back(cs);
	int idEleccionActual = resultados[0].GetIdEleccion();

	//Tengo que agrupar por eleccion
	for(int i = 1; i < resultados.size(); i++){

	      Conteo conteo = resultados[i];
	      if(conteo.GetIdEleccion() == idEleccionActual){
	    	resAgrupados[resAgrupados.size() - 1].push_back(conteo);
	      }
	      else{	//Nuevo grupo de eleccion

		      vector<Conteo> cs;
		      cs.push_back(conteo);
		      resAgrupados.push_back(cs);
		      idEleccionActual = conteo.GetIdEleccion();

	      }

	}
	for(int i = 0; i < resAgrupados.size(); i++){

		vector<Conteo> aux = Reportes::OrderByCantidadVotos(resAgrupados[i]);
		resAgrupados[i] = aux;
	}

	out << endl << endl << endl;

	ABMLista* abmLista = new ABMLista();
	for(int i = 0; i < resAgrupados.size(); i++){

		vector<Conteo> cs = resAgrupados[i];

		if(resAgrupados.size() > 0){

			Conteo conteo = cs[0];
			Eleccion* e = abmEleccion->GetEleccion(conteo.GetIdEleccion());
			string cargo = abmCargo->GetCargo(e->GetIdCargo())->GetNombre();
			Fecha fecha = e->GetDate().getStrFecha();

			out << "Eleccion: (" << fecha.getFriendlyStr() << " - " << cargo << ")" << endl;

			for(int j = 0; j < cs.size(); j++){

				Conteo res = cs[j];
				Lista* lista = abmLista->GetLista(res.GetIdLista());
				out << "		Lista: " << lista->GetNombre() << " tiene " << res.GetCountVotos() << " votos." << endl;
			}
		}
	}

	if (guardaEncriptado)
	{
		string fileName = ConfigurationMananger::getInstance()->getReportFileDirectory().append("ReportexDistrito");
		fileName.append(Helper::IntToString(Identities::GetNextNroReporteXDistrito())).append(".ecr");

		string reporteEncriptado = Vigenere::encriptar(claveEncriptado, out.str());
		ofstream file;
		file.open(fileName.c_str(), ios::app);
		file.write(reporteEncriptado.c_str(), reporteEncriptado.size());
		file.close();

		cout << "Reporte encriptado correctamente" << endl;
	}
	else{
		cout << out.str();
	}

	delete abmConteo;
	delete abmEleccion;
	delete abmCargo;
	delete abmDistrito;
	delete abmLista;
}