void quicksort(int *v, int f, int l) {
if (f >= l)
return;
int p = rand() % (l - f + 1) + f;
/*
localiza posicao aleatoria para inicio da ordenacao
*/
troca(v, p, f);
p = f;
int i = f, j = l;
while (i < j) {
while (v[i] <= v[p] && i <= l)
i++;
while (v[j] > v[p])
j--;
if (j > i)
troca(v, i, j);
}
troca(v, j, p);
quicksort(v, f, j - 1);
/*
chamada recursiva para ordenar posicoes anteriores
*/
quicksort(v, j + 1, l);
/*
chamada recursiva para ordenar posicoes posteriores
*/
return;
}
main() {
int x = 10, y = 20;
troca(x, y);
// Chamada da mesma macro não redefine tmp, pois
//esta é definida dentro do bloco expandido
troca(x, y);
printf("Valor de x e y: #d e #d\n", x, y);
}
void rotacao(int m[MAXLINHA][MAXCOLUNA], int* linhas, int* colunas) {
int maior = *linhas > *colunas ? *linhas : *colunas;
for (int i = 0; i < maior; i++) {
for (int j = i; j < maior; j++) {
troca(&m[i][j], &m[j][i]);
}
}
troca(linhas, colunas);
rebatimentoVertical(m, *linhas, *colunas);
}
int particiona(int *V, int inicio, int fim) {
int i = inicio, j;
for ( j=inicio+1; j<=fim; ++j )
if ( V[j] < V[inicio] ) {
i++;
troca(&V[i], &V[j]);
}
troca(&V[inicio], &V[i]);
return i;
}
int permuta_buscando_isomorfismo(int *P, int inicio, int n, grafo *G, grafo *H) {
if ( inicio == n - 1 )
return testa_isomorfismo(G, H, P);
// gera as permutacoes recursivamente em ordem nao-lexicografica
int i;
for ( i=inicio; i<=n; i++ ) {
troca(&P[i], &P[inicio]);
if ( permuta_buscando_isomorfismo(P, inicio + 1, n, G, H) ) return 1;
troca(&P[i], &P[inicio]);
}
return 0;
}
/* qsort: ordena v[esq]... v[dir] em ordem crescente */
void qsort(int v[], int esq, int dir) {
int i, ultimo;
void troca(int v[], int i, int j);
if (esq >= dir)
return;
troca(v, esq, (esq+dir)/2);
ultimo = esq;
if (v[i] < v[esq])
troca(v, ++ultimo, i);
troca(v, esq, ultimo);
qsort(v, esq, ultimo-1);
qsort(v, ultimo+1, dir);
}
main(){
int x = 1, y = 2, z[10];
int *ip; /* ip é um apontador */
int *ip2;
printf("int *ip:%d\n", *ip);
ip = &x; /* ip agora aponta para int x */
ip2 = &y;
printf("ip = &x:%d\n", *ip);
printf("ip2 = &x:%d\n", *ip2);
y = *ip; /* y agora eh 1 */
printf("y = *ip:%d\n", y);
*ip = 0; /* y agora eh 0 */
printf("y = *ip:%d\n", y);
ip = &z[0]; /* ip agora aponta para z[0] */
troca(&x, &y);
ip = &x; /* ip agora aponta para int x */
ip2 = &y;
printf("ip = &x:%d\n", *ip);
printf("ip2 = &x:%d\n", *ip2);
return 0;
}
int main(){
char text[1000], encript[1000];
ler(text);
troca(text, encript);
exibe_str(encript);
return 1;
}
void bolha(int vetor[], int tamanho){
int i, j;
for(i=0; i<tamanho; i++)
for(j=0;j<tamanho-1;j++)
if (vetor[j]>vetor[j+1])
troca(&vetor[j], &vetor[j+1]);
}
void bolha_gen (int n, void* v, int tam, int(*cmp)(void*,void*)) {
puts("Bolha");
//Circulo* c;
int i, j;
void* p1;
void* p2;
for (i=n-1; i>0; i--) {
int fez_troca = 0;
for (j=0; j<i; j++) {
p1 = acessa(v,j,tam);
p2 = acessa(v,j+1,tam);
if (cmp(p1,p2)) {
troca(p1,p2,tam);
fez_troca = 1;
}
}
/*if (tam == sizeof(Circulo)){
c = (Circulo*) p1;
printf("Centro do circulo%-2i = \t(%.2f,%.2f)\tRaio = %.2f\tCor : R = %3i, G = %3i, B = %3i\n",n-i,c[n-i].centro.x,c[i].centro.y,c[i].raio,c[i].cor.r,c[i].cor.g,c[i].cor.b);
}*/
if (fez_troca == 0) /* nao houve troca */
return;
}
}
int main(){
int a,b;
scanf("%d %d", &a,&b);
troca(&a,&b);
printf("%d %d\n\a",a,b);
return 0;
}
void rebatimentoHorizontal(int m[MAXLINHA][MAXCOLUNA], int linhas, int colunas) {
for (int i = 0; i < linhas/2; i++) {
for (int j = 0; j < colunas; j++) {
troca(&m[i][j], &m[linhas - i - 1][j]);
}
}
}
void quick(int* vet,int esq,int dir,long long int *comparacoes, long long int *trocas){
int pivo = vet[(esq + dir) / 2];
int i = esq;
int j = dir;
(*comparacoes)++;
while(i <= j){
(*comparacoes)++;
while(vet[i] < pivo && i < dir){
(*comparacoes)++;
i++;
}
(*comparacoes)++;
while(vet[j] > pivo && j > esq){
(*comparacoes)++;
j--;
}
if(i <= j){
troca(&vet[i],&vet[j]);
(*trocas)++;
i++;
j--;
}
}
if(esq < j){
quick(vet,esq,j,comparacoes,trocas);
}
if(dir > i){
quick(vet,i,dir,comparacoes,trocas);
}
}
void rebatimentoVertical(int m[MAXLINHA][MAXCOLUNA], int linhas, int colunas) {
for (int i = 0; i < linhas; i++) {
for (int j = 0; j < colunas/2; j++) {
troca(&m[i][j], &m[i][colunas - j - 1]);
}
}
}
/*
int main (void)
{
int l, i;
scanf( "%d", &l);
int *p;
p = malloc(sizeof(int) * l);
if (p == NULL) {
printf("Erro");
}
for (i=0; i<l; i++){
scanf ("%d", &p[i]);
}
imprime (p, l);
insertion (p, 0, l);
imprime (p, l);
return 0;
}*/
void insertion(int *g, int ini, int fim){
int j, i;
for (i=ini+1; i<fim; i++){
for (j=i; j>ini && g[j]<g[j-1] ; j--){
troca(g, j, j-1);
}
}
}
Var::Var(int li, int ls)
{
if (ls < li)
troca(li,ls);
for (int v=li; v<=ls; v++)
_dom.push_back(v);
}
int main () {
char texto[100], codificado[100];
char *str;
gets (str);
troca (texto, codificado);
imprime (codificado);
return 0;
}
void quicksort (int *inteiros, int esq, int dir) // esta função ordena um vetor de inteiros em ordem crescente
{
if(esq<dir){ //esta parte checa se as posição recebidas como argumento fazem sentido
int pos = rand() % (dir - esq + 1) + esq;
troca(inteiros, pos, esq);
int pos_pivo = dividir(inteiros,esq,dir);
quicksort(inteiros,esq,pos_pivo -1); // recursão da função quicksort
quicksort(inteiros,pos_pivo +1,dir);}
}
int main()
{
int A, B;
troca(&A, &B);
printf("Soma: %d\nValor de B: %d\n",A,B);
system("pause");
return 0;
}
void ordena(int ordenar[JANELA_MAX*JANELA_MAX], int tam) {
for (int k = 0; k < tam; k++) {
for (int l = 1; l < tam - k; l++) {
if (ordenar[k] > ordenar[k + l]) {
troca(&ordenar[k], &ordenar[k + l]);
}
}
}
}
/*
Algoritmo Backtracking.
1.
2. Candidatos <- {1, 2, ..., n}
3. for i in Candidatos
4. Candidatos <- Candidatos \ {i}
5. backtrack(Candidatos)
6. Candidatos <- Candidatos U {i}
*/
int backtracking(unsigned int inicio)
{
if (!objetivo(inicio))
return 0;
unsigned int i;
for (i = inicio; i < VERTICES->tamanho; i++)
{
troca(&VERTICES->C[i], &VERTICES->C[inicio]);
if (!backtracking(inicio + 1))
return 0;
troca(&VERTICES->C[i], &VERTICES->C[inicio]);
}
return 1;
}
void selectionI(int* vet,int tam, long long int*comparacoes, long long int *trocas){
int i,pos_maior;
for(i = tam-1; i > 0; i--){
pos_maior = maior(vet,i,comparacoes);
(*trocas)++;
troca(&vet[i],&vet[pos_maior]);
}
}
void heap_sort(int* vetor,int tam,long long int *comparacoes,long long int *trocas){
buildmax(vetor,tam,comparacoes,trocas);
int i;
for(i = tam - 1; i > 0; i--){
(*trocas)++;
troca(&vetor[0],&vetor[i]);
heap_fy(vetor,i,0,comparacoes,trocas);
}
}
void bubble(int * v, int n) {
int i, j;
for (i=1;i<n;i++) {
for (j=0;j < n-i; j ++) {
if (v[j] > v[j + 1]) {
troca(v, j);
}
}
}
}
void main()
{
int n1=0,n2=0;
printf("Digite 2 numeros inteiros:\n");
printf("Digite 1o. numero inteiro:\n");
scanf("%d",&n1);
printf("Digite 2o. numero inteiro:\n");
scanf("%d",&n2);
troca(&n1,&n2);
}
int main() {
float a = 1, b = 2;
troca(&a, &b);
printf("a: %.1f\n", a);
printf("b: %.1f", b);
return 0;
}
int selectionR(int* vet, int tam, long long int *comparacoes, long long int *trocas){
if(tam == 1){
return 1; // vetor esta ordenado
}else{
int m = maior(vet,tam,comparacoes);
troca(&vet[tam-1],&vet[m]);
(*trocas)++;
return selectionR(vet,tam-1,comparacoes,trocas);
}
}
void main(){
int a,b;
printf("Entre com um valor inteiro:\n");
scanf("%d",&a);
printf("Entre com outro valor inteiro:\n");
scanf("%d",&b);
printf("a = %d e b = %d\n",a,b);
troca(&a,&b);
printf("a = %d e b = %d\n",a,b);
}
int separa(int p, int r, int vetor[2][MAX]) {
int x, i, j;
x = vetor[1][p];
i = p - 1;
j = r + 1;
while (1) {
do {
j--;
} while (vetor[1][j] > x);
do {
i++;
} while (vetor[1][i] < x);
if (i < j) {
troca(&vetor[0][i], &vetor[0][j]);
troca(&vetor[1][i], &vetor[1][j]);
} else {
return j;
}
}
}
int dividir (int *inteiros, int esq, int dir) // esta função coloca o pivô do vetor em sua posição correta
{
int i = esq + 1, j = dir; // esq é o elemento tomado com pivô e dir é o último elemento do vetor
while(i <= j) // este ciclo percorre todo o vetor até encontrar a posição correta do pivô
{
if(*(inteiros + i) < *(inteiros + esq) || *(inteiros + i) == *(inteiros + esq))
i++;
if(*(inteiros + j) > *(inteiros + esq) || *(inteiros + j) == *(inteiros + esq))
j--;
if(j<i)
break;
troca(inteiros, i, j);
}
if (j >= 0) // esta parte coloca o pivô em sua posição correta e retorna a posição
{
troca(inteiros, j, esq);
return j;
}
}
