/** Adiciona um novo elemento no final da Lista.
* Este método recebe um dado do tipo T e adiciona este elemento no final da lista, ou seja, adiciona esse dado na última posição da lista.
* @param dado O dado que será inserido dentro da lista. Precisa ser do mesmo tipo de dados que a lista armazena.
* @see listaCheia()
* @exception ExcecaoListaCheia Exceção que indica que um novo dado não pode ser adicionado, pois a lista já está cheia.
*/
void adiciona(T dado) {
if (!listaCheia()) {
dados[++ultimo] = dado;
} else {
throw ExcecaoListaCheia;
}
}
//comentário
void adiciona(T dado)
{
if(listaCheia())
throw 20;
ultimo++;
dados[ultimo] = dado;
}
/*
* @brief Metodo para adicionar um elemento na Lista
* @details Caso exista lugar na lista, incrementa a variavel 'fim' e adiciona o parametro
* 'dado' no vetor 'dados[]' na posição 'fim'
*/
void adiciona(T dado) {
if (listaCheia()) {
throw(ERROLISTACHEIA);
} else {
fim += 1;
dados[fim] = dado;
}
}
template<class T>int Lista<T>::adiciona(T dado){
if(listaCheia())
return ERROLISTACHEIA;
else{
ultimo++;
dados[ultimo] = dado;
return ultimo;
}
};
void Lista<T>::adicionaEmOrdem(T dado) {
if (listaCheia()) {
throw ExcecaoListaCheia();
}
int posicao = 0;
while((posicao <= ultimo) && (maior(dado, lista[posicao]))) {
posicao++;
}
adicionaNaPosicao(dado, posicao);
}
//comentário
void adicionaEmOrdem(T dado)
{
if(listaCheia())
throw 20;
int pos = 0;
while(pos <= ultimo && (dado > dados[pos]))
{
pos++;
adicionaNaPosicao(dado, pos);
}
}
int Lista::adicionarEmOrdem(const char* lancamento) {
if (listaCheia())
return -1;
int pos = 0;
while (pos <= ultimo && strcmp(lancamento, lista[pos]) > 0) {
pos++;
}
return adicionaNaPosicao(lancamento, pos);
}
/*
* @brief Metodo adicionar elementos em ordem no vetor
* @details Verifica se a lista não está Cheia
* Cria uma variavel auxiliar de inteiros chamada 'pos'
* Faz comparações dos parametros 'dado' e 'dados[pos]' atraves do metodo 'maior()'
* Retorna o metodo 'adicionaNaPosicao()' e passa como parametros 'dado' e a variavel 'pos'
*/
void adicionaEmOrdem(T dado) {
int pos;
if (listaCheia()) {
throw(ERROLISTACHEIA);
} else {
pos = 0;
while (pos < fim && maior(dado, dados[pos])) {
pos += 1;
}
return (adicionaNaPosicao(dado, pos));
}
}
/** Adiciona um novo elemento no início da Lista.
* Este método recebe um dado do tipo T e adiciona este elemento no início da lista, ou seja, adiciona esse dado na posição zero.
* @param dado O dado que será inserido dentro da lista. Precisa ser do mesmo tipo de dados que a lista armazena.
* @see listaCheia()
* @exception ExcecaoListaCheia Exceção que indica que um novo addo não pode ser adicionado, pois a lista já está cheia.
*/
void adicionaNoInicio(T dado) {
int posicao;
if (!listaCheia()) {
ultimo = ultimo + 1;
for(posicao = ultimo; posicao > 0; posicao--) {
dados[posicao] = dados[posicao -1];
}
dados[0] = dado;
} else {
throw ExcecaoListaCheia;
}
}
//comentário
void adicionaNoInicio(T dado)
{
if(listaCheia())
throw 20;
ultimo++;
int pos = ultimo;
while (pos > 0)
{
dados[pos] = dados[pos - 1];
pos--;
}
dados[0] = dado;
}
template<class T>int Lista<T>::adicionaNoInicio(T dado){
if(listaCheia())
return ERROLISTACHEIA;
else{
ultimo++;
for(int pos = ultimo; pos > 0; pos--){
//Empurra tudo pra trás
dados[pos] = dados[pos-1];
}
dados[0] = dado;
return 0;
}
};
/** Adiciona um novo elemento seguindo a ordem da Lista.
* Este método recebe um dado do tipo T e adiciona este elemento em determinada posição.
* @param dado O dado a ser inserido na Lista.
* @see listaCheia()
* @exception ExcecaoListaCheia Exceção que indica que um novo dado não pode ser adicionado, pois a lista já está cheia.
*/
void adicionaEmOrdem(T dado) {
if (!listaCheia()) {
int i;
for(i = 0; i <= ultimo; i++) {
if (!maior(dado, dados[i])) {
break;
}
}
adicionaNaPosicao(dado, i);
} else {
throw ExcecaoListaCheia;
}
}
void Lista<T>::adicionaNaPosicao(T dado, int posicao) {
if (listaCheia()) {
throw ExcecaoListaCheia();
}
if (posicaoInvalida(posicao)) {
throw ExcecaoPosicao();
}
ultimo++;
for (int i = ultimo; i > posicao; i--) {
lista[i] = lista[i - 1];
}
lista[posicao] = dado;
}
/*
* @brief Metodo para adicionar um elemento no inicio da Lista
* @details Cria uma variavel de inteiros auxiliar chamada 'pos' e verifica se a lista já não está cheia
* Caso ainda exista lugar na lista passa todos os elementos do vetor uma posição para frente e
* adiciona o o parametro 'dado' na posição '0' do vetor 'dados[]'
*/
void adicionaNoInicio(T dado) {
int pos;
if (listaCheia()) {
throw(ERROLISTACHEIA);
} else {
fim += 1;
pos = fim;
while (pos > 0) {
dados[pos] = dados[pos-1];
pos -= 1;
}
dados[0] = dado;
}
}
/** Adiciona um novo elemento em uma posição específica da Lista.
* Este método recebe um dado do tipo T e adiciona este elemento em determinada posição.
* @param posicao A posição na lista em que o dado será adicionado.
* @param dado O dado a ser inserido na Lista.
* @see listaCheia()
* @exception ExcecaoListaCheia Exceção que indica que um novo dado não pode ser adicionado, pois a lista já está cheia.
*/
void adicionaNaPosicao(T dado, int destino) {
int posicao;
if (listaCheia()) {
throw ExcecaoListaCheia;
} else {
if(destino < 0 || destino > ultimo + 1)
throw ExcecaoErroPosicao;
ultimo = ultimo + 1;
for(posicao = ultimo; posicao > destino; posicao--) {
dados[posicao] = dados[posicao - 1];
}
dados[destino] = dado;
}
}
template<class T>int Lista<T>::adicionaNaPosicao(T dado, int dest){
if(listaCheia())
return ERROLISTACHEIA;
else{
if(dest > (ultimo+1) || dest < 0)
return ERROPOSICAO;
ultimo++;
for(int pos = ultimo; pos <= ultimo; pos++){
//Empurra tudo para trás
dados[pos] = dados[pos-1];
}
dados[dest] = dado;
return dest;
}
};
/** Adiciona um novo elemento em uma posição específica da Lista.
* Este método recebe um dado do tipo T e adiciona este elemento em determinada posição.
* @param posicao A posição na lista em que o dado será adicionado.
* @param dado O dado a ser inserido na Lista.
* @see listaCheia()
* @exception ExcecaoListaCheia Exceção que indica que um novo dado não pode ser adicionado, pois a lista já está cheia.
*/
void adicionaNaPosicao(T dado, int destino) {
if (!listaCheia()) {
if (destino >= 0 && destino <= ultimo + 1) {
int posicao;
for(posicao = ++ultimo; posicao > destino; posicao--) {
dados[posicao] = dados[posicao - 1];
}
dados[destino] = dado;
} else {
throw ExcecaoErroPosicao;
}
} else {
throw ExcecaoListaCheia;
}
}
//comentário
void adicionaNaPosicao(T dado, int posicao)
{
if(listaCheia())
throw 20;
if(posicao > ultimo+1 || posicao < 0)
throw 20;
ultimo++;
int pos = ultimo;
while (pos > posicao)
{
dados[pos] = dados[pos - 1];
pos--;
}
dados[posicao] = dado;
}
/** Adiciona um novo elemento seguindo a ordem da Lista.
* Este método recebe um dado do tipo T e adiciona este elemento em determinada posição.
* @param dado O dado a ser inserido na Lista.
* @see listaCheia()
* @exception ExcecaoListaCheia Exceção que indica que um novo dado não pode ser adicionado, pois a lista já está cheia.
*/
void adicionaEmOrdem(T dado) {
int posicao = 0;
if (listaCheia()) {
throw ExcecaoListaCheia;
} else {
for(int i = 0; i <= ultimo; i++) {
if (maior(dado, dados[posicao])) {
posicao++;
} else {
break;
}
}
adicionaNaPosicao(dado, posicao);
}
}
/**
NOME DA FUNÇÃO: vagarPosicao
ALUNOS: Pedro Paulo e Felipe dos Santos
PROPÓSITO:
responsável por realizar uma bateria de testes para saber se é possível mover outros contatos da
lista de forma a desocupar a posição desejada, posteriormente realiza a operação propriamente dita
retornando ao final o sucesso ou não da operação.
PARÂMETROS:
nome tipo valor/referência descrição
---------------------------------------------------------------------
posicao int valor posição da lista a ser vaga
VALOR DE RETORNO:
nome tipo descrição
---------------------------------------------------------------------
-- int 0 em caso de sucesso, código de erro em caso de problema
*/
int vagarPosicao(int posicao) {
if (listaCheia() == 1)
return ERRO_LISTA_CHEIA;
if (listaVazia() == 1)
return 0;
if (posicao > aLista.ultimo + 1 || posicao < 0)
return ERRO_POSICAO_INVALIDA;
int i;
for (i = aLista.ultimo; i >= posicao; i--)
aLista.elem[i + 1] = aLista.elem[i];
return 0;
}
/*
* @brief Metodo para adicionar um dado numa determinada posição do vetor
* @details Verifica se a lista não está cheia ou se a posição passada pelo paramentro 'posicao' está dentro dos limites da Lista
* Cria uma variavel auxiliar de inteiros chamada 'pos'
* Joga todos os elementos da lista até 'posicao' uma posição a frente no vetor e apos isso
* Adicion o parametro 'dado' na posição passada pelo parametro 'posicao'
*/
void adicionaNaPosicao(T dado, int posicao) {
int pos;
if (listaCheia()) {
throw(ERROLISTACHEIA);
} else {
if (posicao > fim+1 || posicao < 0) {
throw(ERROPOSICAO);
}
fim += 1;
pos = fim;
while (pos > posicao) {
dados[pos] = dados[pos-1];
pos -= 1;
}
dados[posicao] = dado;
}
}
//Adiciona na posição do argumento dado.
int Lista::adicionaNaPosicao(const char* lancamento, int pos_destino) {
int pos;
if (listaCheia() || pos_destino > ultimo + 1 || pos_destino < 0) {
return -1;
}
//// find out the size of the string to be inserted
//// this is very dangerous as we assume the input string is '\0' terminated
//// a malicious user may pass an ill-formed and/or huge string
size_t length = strlen(lancamento);
//// we could return -1 here
assert(length < 10000);
//// Suppose we have this list:
//// [A, B, C]
//// ^ ultimo
//// And we want to insert D in pos = 1
//// so that in the end we would have
//// [A, D, B, C]
//// ^ ultimo
//// [A, D, B, C, NULL]
//// ^ ultimo
ultimo++;
pos = ultimo;
while (pos > pos_destino) {
lista[pos] = lista[pos - 1];
pos--;
}
//// When the while loop exits we have
//// [A, B, B, C]
//// ^ ultimo
//// [A, D, B, C]
//// ^ ultimo
lista[pos_destino] = new char[length + 1]; //// allocate memory to the destination buffer
strncpy(lista[pos_destino], lancamento, length); //// copy data from src to dst
lista[pos_destino][length] = '\0'; //// make sure we '\0' the dst buffer, very important!
return pos_destino;
}
