C++ Nodo类代码示例

Nodos::Nodos(vector<Nodo*> nds) {
    num_nodos = nds.size();
    num_nodos_validos = nds.size();
    nodos = nds;
    double mx = -1*numeric_limits<float>::max();
    double mix = numeric_limits<float>::max();
    double my = -1*numeric_limits<float>::max();
    double miy = numeric_limits<float>::max();
    double mz = -1*numeric_limits<float>::max();
    double miz = numeric_limits<float>::max();
    for(int i = 0; i < (int)nds.size(); ++i){
        Nodo* n = nds[i];
		if( n!= 0){
		    Punto p = n->getPunto();
		    double x = p.getX();
		    double y = p.getY();
		    double z = p.getZ();
		    if(x>mx) mx = x;
		    if(x<mix) mix = x;
		    if(y>my) my = y;
		    if(y<miy) miy = y;
		    if(z>mz) mz = z;
		    if(z<miz) miz = z;
		}
    }
    this->maxx = mx;
    this->minx = mix;
    this->maxy = my;
    this->miny = miy;
    this->maxz = mz;
    this->minz = miz;

    nodos_marcados = NULL;
}

void Programa::insertaDespuesDeX()
{
    int x;
    cout << "x: ";
    cin >> x;
    Nodo *ix = getX(x);
    if (!ix) {
        cout << "no hay x = " << x << endl;
        return;
    }
    int numero;
    cout << "numero: ";
    cin >> numero;
    Nodo *nodo = new Nodo(numero);

    if (ix == mFinal) {
        mFinal->setSiguiente(nodo);
        nodo->setAnterior(mFinal);
        mFinal = nodo;
        return;
    }

    Nodo *A = ix->getSiguiente();
    ix->setSiguiente(nodo);
    nodo->setAnterior(ix);
    nodo->setSiguiente(A);
    A->setAnterior(nodo);
}

// Método que verifica se um string está na trie, retorna 1 caso estejae -1 caso contrário
int Trie::buscaString(string word)
{
    int i = 0;
    Nodo* Aux;																									// Nodo auxiliar
    Aux = raiz;																									// que recebe a raiz da trie

    word = converteString(word);																				// Converte todas as letras para maiúsculas
    while(word[i] != '\0')																						// enquanto não é o fim da string continua procurando
    {
        Aux = Aux->getNodo(word[i]);																			// auxiliar recebe o nodo pra onde aponta o caracter da string

        if (Aux != NULL)																						// Se esse nodo não for nulo é porque até o momento existe a string então tem que seguir procurando
        {
            if ( word[i] == '$')																				// Caso chegou no caracter de fim de string é porque a string está na trie
            {
                return 1;																						// Então retorna 1
            }																									// Se nao for caracter de fim de string apenas segue pro proximo caracter
        }
        else																									// Se o nodo for nulo então é porque não tem o caracter q ta procurando logo a string toda nao da na trie
        {
            return -1;																							// retorna -1
        }
        i++;
    }
}

		void agregar(Nodo *a, int pos) {
			if(first == NULL) {
				first = a;
				size++;
			}else if(pos == 1) {
				agregarInicio(a);
			}else if(pos > size) {
				agregarFinal(a);
			}else {
				Nodo *aux;
				aux = first;
				for(int i = 0; i < pos-2; i++) {
					aux = aux->getNext();
				}
				//Nodo* siguiente;
				//Nodo* anterior;
				//anterior = aux;
				//siguiente = aux->getNext();
				//a->setNext(siguiente);
				//anterior->setNext(a);
				a->setNext(aux->getNext());
				aux->setNext(a);
				size++;
			}
		}

		void imprimir() {
			Nodo *aux = first;
			while(aux != NULL) {
				cout << aux->getNum() << endl;
				aux = aux->getNext();
			}
		}

void Programa::recorridoDeLaLista()
{
    for (Nodo *ix = mInicio; ix != NULL; ix = ix->getSiguiente()) {
        cout << ix->getNumero() << ' ';
    }
    cout << endl;
}

Nodo* Pila::buscar(string categoria) {
	Nodo* buscar = getUltimoElemento();
	while((buscar != NULL)and(buscar->getCategoria() != categoria))
	{
		buscar = buscar->getAnterior();
	}
	return buscar;
}

Nodo* Huffman::crearNodo(int a, int x) {

	Nodo* nodoNuevo = new Nodo();
	nodoNuevo->setFrecuencia(x);
	nodoNuevo->setNumero(a);
	nodoNuevo->setHijoDerecho(NULL);
	nodoNuevo->setHijoIzquierdo(NULL);
	return nodoNuevo;
}

void Solucion::Generar(){
    Nodo* n = _nSol;
    if (n != NULL){
        while (n->GetPadre() != NULL){
            _costo += _costMat->Get(n->GetPadre()->GetID() - 1, n->GetID() - 1);
            n = n->GetPadre();
        }
    }
}

void Programa::recorreReversa() const
{
    Nodo *ix = mFinal;
    while (ix != NULL) {
        cout << ix->getNumero() << ' ';
        ix = ix->getAnterior();
    }
    cout << endl;
}

Nodo *Programa::getX(int x) const
{
    for (Nodo *ix = mInicio; ix != NULL; ix = ix->getSiguiente()) {
        if (ix->getNumero() == x) {
            return ix;
        }
    }
    return NULL;
}

bool ArbolB<g>::remove(int valor){
	Nodo *aux = raiz;
	while(aux)
		if(aux->remove(valor)){
			if(aux->tieneHijos()) aux = aux->mayorDeLosMenores();
			rebalancear(aux);
			--n;
			return true;
		}else aux = aux->getSon(valor);
	return false;
}

void AlmacenaToComsol_1::aplicar(Malla *malla, string filename){
	//Lineas necesarias para que scanf lea archivo en computadores seteados en otro lenguaje.
	setlocale(LC_NUMERIC, "POSIX");

	FILE *archivo_x = fopen(filename.c_str(),"w");

	char separador1[32] = "% Coordinates\n";
    fprintf(archivo_x,"%s",separador1);

    Nodo *nodo;
	int* nuevoIndiceNodos=new int[malla->getMaxIndiceNodos()+1];
	int nlinea=0;
    for(int i=0; i<=malla->getMaxIndiceNodos(); i++) {
        nodo = malla->getNodo(i);
        if(nodo != NULL) {
            fprintf(archivo_x,"%f   %f  %f\n",nodo->getPunto().getX(),nodo->getPunto().getY(),nodo->getPunto().getZ());
        	nuevoIndiceNodos[i]=nlinea;
			nlinea++;
		}
    }

    ostringstream myStream;
    myStream << "% Elements (" << malla->getTipoMalla() << ")\n";
    string str_separador2 = myStream.str();
    const char *separador2 = str_separador2.c_str();

    fprintf(archivo_x,"%s",separador2);

    Cara *c;
    vector<int> ind_nodos;
    for(int i=0; i<=malla->getMaxIndiceCaras(); i++) {
        c = malla->getCara(i);
        if(c != 0) {
            ind_nodos = c->getNodos();
			//Nota: Se invierte el orden de insercion de los puntos, para que las normales queden seteadas correctamente.
			//ya que en el archivo cms_1 los nodos estan al reves, dejando las normales hacia adentro.
            //for(int j=c->getNumElem()-1; j>=0 ;--j) { // Por bug archivos de entrada
            for(int j=0; j<c->getNumElem(); ++j) { // así debiera ser
                char *delimitador = "  ";
                //if(j == 0) // Por bug archivos de entrada
                if(j == c->getNumElem()-1) // así debiera ser
                    delimitador = "\n";
                fprintf(archivo_x,"%d%s",nuevoIndiceNodos[ind_nodos[j]]+1,delimitador);
            }
        }
    }

	delete nuevoIndiceNodos;

    fclose(archivo_x);

	setlocale(LC_NUMERIC, "");
	}

void Stack::LenStack()
{
	cout << "Stack" << endl;
	Nodo * pila = Pila;
	cout << "|---- data: " << pila->getData() << endl;
	while (pila->getLink()!=NULL)
	{
		pila = pila->getLink();
		cout << "|---- data: " << pila->getData() << endl;
	}
	
}

// Imprimir la Listaa
void Lista::imprimir() {
    Nodo *temp = inicio;
    if (!inicio) {
        cout << "La Listaa está vacía " << endl;
    } else {
        while (temp) {
            temp->imprimir();
            if (!temp->sig) cout << "NULL";
            temp = temp->sig;
        }
    }
    cout << endl << endl;
}