├── README.md
├── solucoes
    └── anachan01h
    │   └── 02-listas_lineares
    │       ├── ex17.org
    │       ├── ex11.org
    │       ├── ex01.org
    │       └── ex06.org
└── exercicios_selecionados
    └── 02-listas_lineares.md


/README.md:
--------------------------------------------------------------------------------
 1 | # Grupo de Estudos de Estruturas de Dados
 2 | 
 3 | Repositório com informações sobre o grupo de estudos de Estruturas de Dados da UBL.
 4 | 
 5 | ### Exercícios selecionados
 6 | A cada capítulo, selecionamos alguns dos exercícios do livro para serem resolvidos pelos participantes do grupo. Para acessá-los, [clique aqui](./exercicios_selecionados/).
 7 | 
 8 | Caso deseje registrar sua solução e compartilhá-la com os outros participantes, você pode fazer um Pull Request para este repositório, colocando uma pasta com seu nome e suas soluções na pasta `solucoes`.
 9 | 
10 | ### Referências
11 | 
12 | [1] Jayme Luiz Szwarcfiter e Lilian Markenzon. *Estruturas de dados e seus algoritmos*, 3ª edição.
13 | 


--------------------------------------------------------------------------------
/solucoes/anachan01h/02-listas_lineares/ex17.org:
--------------------------------------------------------------------------------
 1 | ** Exercício 17
 2 | 
 3 | Uma palavra é um palíndromo se a sequência de letras que a forma é a mesma, quer seja lida da esquerda para a direita ou da direita para a esquerda (exemplo: raiar). Escrever um algoritmo eficiente para reconhecer se uma dada palavra é um palíndromo. Escolher a estrutura de dados conveniente para representar a palavra.
 4 | 
 5 | ** Solução
 6 | 
 7 | Seja ~String~ um tipo com os seguintes atributos:
 8 | - ~data: &char~;
 9 | - ~capacity: u32~;
10 | - ~size: u32~.
11 | 
12 | Vamos considerar que ~String~ possui um método de acesso ao elemento em uma dada posição ~get(self: &String, pos: u32) -> Option<char>~. Note que ~String~ é uma lista de caracteres (tipo ~char~).
13 | 
14 | *** Detectar palíndromos
15 | 
16 | #+BEGIN_SRC
17 | function is_palindrome(str: &String) -> bool:
18 | 	for i = 0 to floor(n/2) - 1:
19 | 		if str.get(i) != str.get(str.size - 1 - i):
20 | 			return false
21 | 	return true
22 | #+END_SRC
23 | 


--------------------------------------------------------------------------------
/exercicios_selecionados/02-listas_lineares.md:
--------------------------------------------------------------------------------
 1 | # Exercícios do Capítulo 2 - Listas Lineares
 2 | 
 3 | **Exercício 1.** *(2.1)* Apresentar os algoritmos de inserção e remoção de uma lista ordenada em alocação sequencial.
 4 | 
 5 | **Exercício 2.** *(2.6)* Apresentar algoritmos para um deque em alocação sequencial. São dados fornecidos:
 6 | - na inserção: o nó a ser inserido e a extremidade desejada (E1 ou E2),
 7 | - na remoção: a extremidade da remoção.
 8 | 
 9 | **Exercício 3.** *(2.11)* Descrever algoritmos de inserção e remoção em uma lista não ordenada, em alocação encadeada.
10 | 
11 | **Exercício 4.** *(2.17)* Uma palavra é um *palíndromo* se a sequência de letras que a forma é a mesma, quer seja lida da esquerda para a direita ou da direita para a esquerda (exemplo: raiar). Escrever um algoritmo eficiente para reconhecer se uma dada palavra é um palíndromo. Escolher a estrutura de dados conveniente para representar a palavra.
12 | 
13 | ### Referência
14 | 
15 | Jayme Luiz Szwarcfiter e Lilian Markenzon. *Estruturas de dados e seus algoritmos*, 3ª edição.
16 | 


--------------------------------------------------------------------------------
/solucoes/anachan01h/02-listas_lineares/ex11.org:
--------------------------------------------------------------------------------
 1 | ** Exercício 11
 2 | 
 3 | Descrever algoritmos de inserção e remoção em uma lista não ordenada, em alocação encadeada.
 4 | 
 5 | ** Solução
 6 | 
 7 | Seja ~T~ um tipo e considere o tipo ~Node<T>~ com os seguintes atributos:
 8 | - ~data: T~;
 9 | - ~next: &Node<T>~.
10 | 
11 | Considere também o tipo ~List<T>~ com os seguintes atributos:
12 | - ~start: &Node<T>~;
13 | - ~size: u32~.
14 | 
15 | Vamos considerar que ~List<T>~ sempre possui um nó-cabeça e um método de busca ~search(self: &List<T>, value: T) -> Option<(&Node<u32>, &Node<u32>)>~.
16 | 
17 | *** Inserir elemento
18 | 
19 | #+BEGIN_SRC
20 | function insert(self: &List<T>, value: T):
21 | 	match self.search(value):
22 | 		None =>
23 | 			new_node = mem_alloc(size_of(Node<T>))
24 | 			new_node.data = value
25 | 			new_node.next = self.start.next
26 | 			self.start.next = new_node
27 | 		Some(_) =>
28 | 	return
29 | #+END_SRC
30 | 
31 | *** Remover elemento
32 | 
33 | #+BEGIN_SRC
34 | function remove(self: &List<T>, value: T):
35 | 	match self.search(value):
36 | 		Some(prev_node, node) =>
37 | 			prev_node.next = node.next
38 | 			mem_free(node)
39 | 		None =>
40 | 	return
41 | #+END_SRC
42 | 


--------------------------------------------------------------------------------
/solucoes/anachan01h/02-listas_lineares/ex01.org:
--------------------------------------------------------------------------------
 1 | ** Exercício 1
 2 | 
 3 | Apresentar os algoritmos de inserção e remoção de uma lista ordenada em alocação sequencial.
 4 | 
 5 | ** Solução
 6 | 
 7 | Seja ~T~ um tipo e considere o tipo ~List<T>~ com os seguintes atributos:
 8 | - ~data: &T~;
 9 | - ~capacity: u32~;
10 | - ~size: u32~.
11 | 
12 | Também assuma que ~List<T>~ possui um método de busca ~search(self: &List<T>, value: T) -> Option<u32>~.
13 | 
14 | *** Inserir elemento
15 | 
16 | #+BEGIN_SRC
17 | function insert(self: &List<T>, value: T) -> Result:
18 | 	if self.size < self.capacity:
19 | 		self.data[self.size] = value
20 | 		i = 0
21 | 		while self.data[i] < value:
22 | 			i = i + 1
23 | 		if i == self.size:
24 | 			self.size = self.size + 1
25 | 		else if self.data[i] != value:
26 | 			for j = self.size - 1 to i with step -1:
27 | 				self.data[j + 1] = self.data[j]
28 | 			self.data[i] = value
29 | 			self.size = self.size + 1
30 | 		return Ok
31 | 	else:
32 | 		return Error
33 | #+END_SRC
34 | 
35 | *** Remover elemento
36 | 
37 | #+BEGIN_SRC
38 | function remove(self: &List<T>, value: T) -> Result:
39 | 	if self.size != 0:
40 | 		match self.search(value):
41 | 			Some(i) =>
42 | 				for j = i to self.size - 2:
43 | 					self.data[j] = self.data[j + 1]
44 | 				self.size = self.size - 1
45 | 			None =>
46 | 		return Ok
47 | 	else:
48 | 		return None
49 | #+END_SRC
50 | 


--------------------------------------------------------------------------------
/solucoes/anachan01h/02-listas_lineares/ex06.org:
--------------------------------------------------------------------------------
 1 | ** Exercício 6
 2 | 
 3 | Apresentar algoritmos para um deque em alocação sequencial. São dados fornecidos:
 4 | - na inserção: o nó a ser inserido e a extremidade desejada (E1 ou E2),
 5 | - na remoção: a extremidade da remoção.
 6 | 
 7 | ** Solução
 8 | 
 9 | Seja ~T~ um tipo e considere o tipo ~Deque<T>~ com os seguintes atributos:
10 | - ~data: &T~;
11 | - ~capacity: u32~;
12 | - ~size: u32~;
13 | - ~start: u32~.
14 | 
15 | *** Inserir elemento na esquerda
16 | 
17 | #+BEGIN_SRC
18 | function push_front(self: &Deque<T>, value: T) -> Result:
19 | 	if self.size < self.capacity:
20 | 		i = (self.start - 1) % self.capacity
21 | 		self.data[i] = value
22 | 		self.size = self.size + 1
23 | 		self.start = i
24 | 		return Ok
25 | 	else:
26 | 		return Error
27 | #+END_SRC
28 | 
29 | *** Inserir elemento na direita
30 | 
31 | #+BEGIN_SRC
32 | function push_back(self: &Deque<T>, value: T) -> Result:
33 | 	if self.size < self.capacity:
34 | 		i = (self.start + self.size) % self.capacity
35 | 		self.data[i] = value
36 | 		self.size = self.size + 1
37 | 		return Ok
38 | 	else:
39 | 		return Error
40 | #+END_SRC
41 | 
42 | *** Remover elemento na esquerda
43 | 
44 | #+BEGIN_SRC
45 | function pop_front(self: &Deque<T>) -> Result<T, ()>:
46 | 	if self.size != 0:
47 | 		value = self.data[self.start]
48 | 		self.size = self.size - 1
49 | 		self.start = (self.start + 1) % self.capacity
50 | 		return Ok(value)
51 | 	else:
52 | 		return Error
53 | #+END_SRC
54 | 
55 | *** Remover elemento na direita
56 | 
57 | #+BEGIN_SRC
58 | function pop_back(self: &Deque<T>) -> Result<T, ()>:
59 | 	if self.size != 0:
60 | 		i = (self.start + self.size - 1) % self.capacity
61 | 		value = self.data[i]
62 | 		self.size = self.size - 1
63 | 		return Ok(value)
64 | 	else:
65 | 		return Error
66 | #+END_SRC
67 | 


--------------------------------------------------------------------------------