Você está na página 1de 11

Estruturas encadeadas

1. Escrever um programa que (a) leia uma sequncia de n nmeros inteiros e monte uma lista ligada
com tais nmeros em ordem inversa da sequncia de entrada, (b) remova todas as ocorrncias de
um dado valor na lista e (c) escreva os valores na lista resultante (resoluo, cdigo: verso 1, verso
2).
2. Escrever uma aplicao que (a) leia uma sequncia de n nmeros inteiros e monte uma lista ligada
com tais nmeros na mesma ordem da sequncia de entrada, (b) remova todas as ocorrncias de um
dado valor na lista e (c) escreva os valores na lista resultante (resoluo, cdigo).
3. Escrever uma aplicao que (a) leia uma sequncia de n nmeros inteiros e monte uma lista ligada
com tais nmeros em ordem crescente, (b) remova todas as ocorrncias de um dado valor na lista e
(c) escreva os valores na lista resultante (resoluo, cdigo).
4. Escrever uma funo que inverta uma lista ligada (resoluo, cdigo).
5. Escrever uma funo que retorne a referncia para o item de uma lista que contenha um dado valor
(resoluo, cdigo).
6. Escrever uma funo que concatene duas listas ligadas (resoluo, cdigo).
7. Escrever uma funo que intercale duas listas ordenadas (resoluo, cdigo).
8. Escrever um programa que crie uma lista circular a partir de n valores lidos, percorra a lista e escreva
os valores na lista, inverta a lista e escreva novamente tais valores (resoluo, cdigo).
9. Escrever um programa que leia uma descrio de uma rvore binria e, depois, percorra a rvore e
imprima os valores inteiros nos seus ns (resoluo, cdigo).
10. Escrever um programa que leia uma expresso sufixa terminada por uma cerquilha (#) e apresente
uma expresso infixa (resoluo, cdigo: verso 1, verso 2). Exemplo: Se o programa receber a
primeira linha apresentada abaixo, ento ele precisa produzir a segunda.
11. 2 5 8 + * 11 2 / - 3 / #
(((2 * (5 + 8)) - (11 / 2)) / 3)

Referncia:
Ronaldo Fumio Hashimoto, Listas ligadas
Data Structure Halloween Costumes
Linked List Problems
Animaes
Linked List Teaching System (insero)
Linked List (insero e remoo)
Linked List (insero no incio e no fim)
Linked List Animation (busca)
Lists
Stack (abstrao)
Binary Tree Teaching System

Exemplo:
Estouro de memria: use_up_mem.c

Programa
1 /* Adaptao do cdigo de Stephen Bloch em
2
http://home.adelphi.edu/sbloch/class/archive/270/fall2003/examples/C/use_up_mem.c */
3
4 #include <stdio.h> /* for printf */
5 #include <stdlib.h> /* for malloc */
6
7 #define CHUNKSIZE 10000
8
9 int main (void)
10 {
11
char *chunk;
12
int i;
13
14
for (i = 1;; ++i)
15
{
16
printf ("Chunk %d\n", i);
17
chunk = (char *)malloc(CHUNKSIZE);
18
if (! chunk)
19
{
20
printf ("Failed to allocate!\n");
21
return 1;
22
}
23
free(chunk);
24
}
25
return 0;
26 }

Permutao com vetor e lista usados como pilha de dados: perm.zip

perm.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

/* Adaptao do cdigo de Paul Griffiths em


http://www.paulgriffiths.net/program/c/srcs/permarraysrc.html */
/*
Prints all the possible permutations of 'n' items.
'n' must be supplied as the sole command line argument.
*/
#include <stdio.h>
#include <stdlib.h>
#include
#include
#include
#include

"perm.h"
"data.h"
"stack.h"
"cmdline.h"

static void perm(unsigned n);


static int count = 0;
int main(int argc, char *argv[])
{
unsigned n = parseCmdLine(argc, argv);
initializeData(n);
printf("Permutations of %u items:\n\n", n);

28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

perm(n);
printf("\n%d permutations in all.\n", count);
freeData();
return EXIT_SUCCESS;
}
void perm(unsigned n)
{
unsigned item;
if (n == 0)
{
printStack();
++count;
return;
}
for (item = 0; item < n; ++item)
{
push(removeItem(item));
perm(n-1);
insertItem(pop(), item);
}
}

perm.h
1
2
3
4
5
6
7
8
9
10

/* Adaptao do cdigo de Paul Griffiths em


http://www.paulgriffiths.net/program/c/srcs/permarraysrc.html */
#ifndef PERM_H
#define PERM_H
#define ARRAY
//#define LIST
#endif

/* PERM_H */

data.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14

/* Adaptao do cdigo de Paul Griffiths em


http://www.paulgriffiths.net/program/c/srcs/permarraysrc.html */
#include "perm.h"
#ifndef DATA_H
#define DATA_H
void
void
char
void

initializeData(unsigned n);
freeData(void);
removeItem(unsigned pos);
insertItem(char n, unsigned pos);

#endif

/* DATA_H */

stack.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14

/* Adaptao do cdigo de Paul Griffiths em


http://www.paulgriffiths.net/program/c/srcs/permarraysrc.html */
#include "perm.h"
#ifndef STACK_H
#define STACK_H
void
void
char
void

initializeStack(void);
push(char n);
pop(void);
printStack(void);

#endif

/* STACK_H */

cmdline.h
1
2
3
4
5
6
7
8
9
10
11

/* Adaptao do cdigo de Paul Griffiths em


http://www.paulgriffiths.net/program/c/srcs/permarraysrc.html */
#include "perm.h"
#ifndef CMDLINE_H
#define CMDLINE_H
unsigned parseCmdLine(int argc, char *argv[]);
#endif /* CMDLINE_H */

data_array.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/* Adaptao do cdigo de Paul Griffiths em


http://www.paulgriffiths.net/program/c/srcs/permarraysrc.html */
#include "perm.h"
#ifdef ARRAY
#include <stdio.h>
#include <stdlib.h>
#include "data.h"
static char data[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static unsigned size;
/* Initialize memory for data */
void initializeData(unsigned n)
{
size = n;
}

21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

/* Free memory used for data


void freeData(void)
{
return;
}

*/

/* Remove data item at position 'pos'


char removeItem(unsigned pos)
{
char d = data[pos];

*/

if (pos >= size--)


{
fprintf(stderr, "Data position %u is out of bounds.\n", pos);
exit(EXIT_FAILURE);
}
while (pos < size)
{
data[pos] = data[pos+1];
++pos;
}
return d;
}
/* Insert data item 'n' at position 'pos'
void insertItem(char n, unsigned pos)
{
int i = (signed) size;

*/

if (pos > size++)


{
fprintf(stderr, "Data position %u is out of bounds.\n", pos);
exit(EXIT_FAILURE);
}
while (--i >= (signed)pos)
data[i+1] = data[i];
data[pos] = n;
}
#endif

data_list.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14

/* Adaptao do cdigo de Paul Griffiths em


http://www.paulgriffiths.net/program/c/srcs/permarraysrc.html */
#include "perm.h"
#ifdef LIST
#include <stdio.h>
#include <stdlib.h>
#include "data.h"
struct node
{

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

char n;
struct node *next;
};
static struct node *data;
/* Initialize memory for data */
void initializeData(unsigned n)
{
struct node *temp = NULL;
char set[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
unsigned i = 0;
while (i < n)
{
if (data == NULL)
{
data = malloc(sizeof *data);
temp = data;
}
else
{
temp->next = malloc(sizeof *(temp->next));
temp = temp->next;
}
if (temp == NULL)
{
fprintf(stderr, "Memory allocation failure\n");
exit(EXIT_FAILURE);
}
temp->n = set[i++];
temp->next = NULL;
}
}
/* Free memory used for data
void freeData(void)
{
struct node *temp = data;

*/

while (data)
{
temp = data->next;
free(data);
data = temp;
}
}
/* Remove data item at position 'pos'
char removeItem(unsigned pos)
{
struct node *temp = data;
struct node *last = NULL;
char d;

*/

while (temp)
{
if (0 == pos--)
{
if (last) last->next = temp->next;
else data = temp->next;
d = temp->n;

80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

free(temp);
return d;
}
last = temp;
temp = temp->next;
}
fprintf(stderr, "Position specifed out of bounds.\n");
exit(EXIT_FAILURE);
}
/* Insert data item 'n' at position 'pos'
void insertItem(char n, unsigned pos)
{
struct node *temp = data;
struct node *last = NULL;

*/

while (temp && pos--)


{
last = temp;
temp = temp->next;
}
if (temp == NULL && pos)
{
fprintf(stderr, "Position out of bounds\n");
exit(EXIT_FAILURE);
}
if (last)
{
last->next = malloc(sizeof *(last->next));
last = last->next;
}
else
{
data = malloc(sizeof *data);
last = data;
}
if (last == NULL)
{
fprintf(stderr, "Memory allocation failure\n");
exit(EXIT_FAILURE);
}
last->next = temp;
last->n = n;
}
#endif

stack_array.c
1 /* Adaptao do cdigo de Paul Griffiths em
2
http://www.paulgriffiths.net/program/c/srcs/permarraysrc.html */
3
4 #include "perm.h"
5
6 #ifdef ARRAY
7

8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
#define MAX_STACK_SIZE 26
static char stack[MAX_STACK_SIZE];
static int top = -1;
/* Push item 'n' onto the stack */
void push(char n)
{
if (++top == MAX_STACK_SIZE)
{
fprintf(stderr, "Stack full!\n");
exit(EXIT_FAILURE);
}
stack[top] = n;
}
/* Pop top item from the stack */
char pop(void)
{
if (top < 0)
{
fprintf(stderr, "Stack empty!\n");
exit(EXIT_FAILURE);
}
return stack[top--];
}
/* Output contents of stack
void printStack(void)
{
int i = 0;

*/

while (i <= top) putchar(stack[i++]);


putchar('\n');
}
#endif

stack_list.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

/* Adaptao do cdigo de Paul Griffiths em


http://www.paulgriffiths.net/program/c/srcs/permarraysrc.html */
#include "perm.h"
#ifdef LIST
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
struct node
{
char n;
struct node *next;

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

};
static struct node *stack;
/* Push item 'n' onto the stack
void push(char n)
{
struct node *temp = stack;

*/

if (stack == NULL)
{
stack = malloc(sizeof(struct node));
temp = stack;
}
else
{
while (temp->next) temp = temp->next;
temp->next = malloc(sizeof(struct node));
temp = temp->next;
}
if (temp == NULL)
{
fprintf(stderr, "Memory allocation failure\n");
exit(EXIT_FAILURE);
}
temp->n = n;
temp->next = NULL;
}
/* Pop top item from the stack
char pop(void)
{
struct node *temp = stack;
struct node *last = NULL;
char n;

*/

if (stack == NULL)
{
fprintf(stderr, "Stack empty!\n");
exit(EXIT_FAILURE);
}
while (temp->next)
{
last = temp;
temp = temp->next;
}
n = temp->n;
free(temp);
if (last)
last->next = NULL;
else
stack = NULL;
return n;
}
/* Output contents of stack */
void printStack(void)
{
struct node *temp = stack;

81
while (temp)
82
{
83
putchar(temp->n);
84
temp = temp->next;
85
}
86
87
putchar('\n');
88 }
89
90 #endif

cmdline.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

/* Adaptao do cdigo de Paul Griffiths em


http://www.paulgriffiths.net/program/c/srcs/permarraysrc.html */
#include "perm.h"
#include <stdio.h>
#include <stdlib.h>
#include "cmdline.h"
unsigned parseCmdLine(int argc, char *argv[])
{
unsigned n;
char *endptr;
if (argc < 2)
{
fprintf(stderr, "You must supply an argument\n");
exit(EXIT_FAILURE);
}
else
if (argc > 2)
{
fprintf(stderr, "You must only supply one argument\n");
exit(EXIT_FAILURE);
}
n = (unsigned) strtoul(argv[1], &endptr, 0);
if (*endptr)
{
fprintf(stderr, "You must supply a whole number as an argument\n");
exit(EXIT_FAILURE);
}
else
if (n > 26)
{
fprintf(stderr, "You must specify a number less than 27\n");
exit(EXIT_FAILURE);
}
else
if (n < 1)
{
fprintf(stderr, "You must specify a number greater than 0\n");
exit(EXIT_FAILURE);
}
return n;
}