{"id":24358752,"url":"https://github.com/eduardob-programador/dsa-learning","last_synced_at":"2025-03-12T08:18:08.699Z","repository":{"id":272065136,"uuid":"915420617","full_name":"EduardoB-Programador/DSA-Learning","owner":"EduardoB-Programador","description":"A project where I build data structures and algorithms, and test them","archived":false,"fork":false,"pushed_at":"2025-03-05T04:41:57.000Z","size":14,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-03-05T05:29:21.290Z","etag":null,"topics":["algorithms","algorithms-datastructures","data-structures","dsa","java","junit-jupiter","junit5","searching-algorithms","sorting-algorithms"],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/EduardoB-Programador.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2025-01-11T19:56:20.000Z","updated_at":"2025-03-05T04:42:01.000Z","dependencies_parsed_at":"2025-01-11T20:42:36.179Z","dependency_job_id":null,"html_url":"https://github.com/EduardoB-Programador/DSA-Learning","commit_stats":null,"previous_names":["eduardob-programador/dsa-learning"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/EduardoB-Programador%2FDSA-Learning","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/EduardoB-Programador%2FDSA-Learning/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/EduardoB-Programador%2FDSA-Learning/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/EduardoB-Programador%2FDSA-Learning/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/EduardoB-Programador","download_url":"https://codeload.github.com/EduardoB-Programador/DSA-Learning/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":243179889,"owners_count":20249187,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["algorithms","algorithms-datastructures","data-structures","dsa","java","junit-jupiter","junit5","searching-algorithms","sorting-algorithms"],"created_at":"2025-01-18T20:22:14.715Z","updated_at":"2025-03-12T08:18:08.678Z","avatar_url":"https://github.com/EduardoB-Programador.png","language":"Java","readme":"# Navegação/Navigation\n\n|[Português](#português)|[English](#english)|[Português](#português)|[English](#english)|\n|:-|:-|:-|:-|\n|[Visão Geral](#visão-geral)|[Overview](#overview)|[InsertionSort](#insertionsort-pt)||\n|[Algoritmos](#algoritmos)|[Algorithms](#algorithms)|[QuickSort](#quicksort-pt)||\n|[Procura](#procura)||[MergeSort](#mergesort-pt)||\n|[Linear Search](#linearsearch-pt)||||\n|[Binary Search](#binarysearch-pt)||||\n|[Organização](#organizacao)||||\n|[BubbleSort](#bubblesort-pt)||||\n|[SelectionSort](#selectionsort-pt)||||\n\n\n# Português\n\n## Visão Geral\n\nO objetivo desse projeto foi entender e praticar o uso de **estruturas de dados** e **algoritmos**, aqui eu utilizo diferentes estruturas de dados e **algoritmos de organização e procura**.\n\nPor mais que a organização dos diretórios não seja a melhor, eu pelo menos tentei deixar o mais intuitivo possível.\n\nOs algoritmos se encontram em:\n- [Searching](./src/main/java/com/eduardo/Searching.java)\n- [Sorting](./src/main/java/com/eduardo/Sorting.java)\n\nEnquanto as estruturas de dados se encontram em:\n- [Estruturas de dados](./src/main/java/com/eduardo/dataStructures/)\n  - [Stack](./src/main/java/com/eduardo/dataStructures/Stack.java)\n  - [Static Stack](./src/main/java/com/eduardo/dataStructures/StaticStack.java)\n  - [Dynamic Stack](./src/main/java/com/eduardo/dataStructures/DynamicStack.java)\n  - [Linked List](./src/main/java/com/eduardo/dataStructures/LinkedList.java)\n  - [Queue](./src/main/java/com/eduardo/dataStructures/Queue.java)\n  - [Binary Tree](./src/main/java/com/eduardo/dataStructures/BinaryTree.java)\n\n## Algoritmos\n\n\u003ca id=\"procura\"\u003e\u003c/a\u003e\n### Procura/Search\n\nNo arquivo [Searching.java](./src/main/java/com/eduardo/Searching.java) temos 3 métodos referentes a algorimos de procura, onde 2 são referentes a **Binary Search** enquanto o outro faz referência à **Linear Search**. Abaixo estão as características dos métodos:\n\n```.java\npublic static int linearSearch(int[] nums, int target)\npublic static int binarySort(int[] nums, int target)\npublic static int binarySortRecursive(int[] nums, int target, int left, int right)\n//Acabei de perceber que esse último método está como \"sort\", não como search que é o que deveria estar escrito, mas pelo motivo de no arquivo original estar da mesma forma eu deixarei assim\n```\n\n### LinearSearch pt\n\n```.java\npublic static int linearSearch(int[] nums, int target)\n```\n\nO algoritmo **Linear Search** passa por cada um dos itens de uma array com o objetivo de encontrar o valor *target*, o que estamos procurando. Ele retornará o index desse valor na array caso o valor estiver presente na array, e retornará -1 caso o valor que estamos procurando não esteja presente dentro da array.\n\nImportante dizer que no código existe uma variável **step**, onde ela conta a quantidade de iterações para encontrar o *target*.\n\nA complexidade temporal desse método é O(n)\n\n### BinarySearch pt\n\n```.java\npublic static int binarySort(int[] nums, int target)\npublic static int binarySortRecursive(int[] nums, int target, int left, int right)\n```\n\nO algoritmo **Binary Search** procura um valor *target* em uma **lista já organizada**, esse algoritmo funciona da seguinte forma, ele utiliza de ponteiros para delimitar a região de procura, tornando ela cada vez menor até encontrá-la. A princípio ele encontra o índice do meio, que estamos chamando de **mid**, com base nos ponteiros que atualmente estão no começo e no final da array, e verifica se o valor que estamos procurando é maior ou menor que o valor do índice **mid**, caso seja maior, o ponteiro da esquerda move **mid + 1**. Caso o valor seja menor que o valor de **mid** o ponteiro da direita move **mid - 1**. Depois da primeira alteração dos ponteiros, é encontrado novamente o meio e o processo se repete até encontrar o valor. Quando o valor é encontrado é retornado o índice dele na array, caso não seja encontrado, retorna -1.\n\nNovamente, temos a variável step marcando a quantidade de iterações até que seja encontrado o *target*.\n\nExiste também o método BinarySearchRecursive, onde, ao invés de iterações temos recurções, mas na sua base os métodos funcionam da mesma forma.\n\nA complexidade temporal desse método é O(log2 n)\n\n\u003ca id=\"organizacao\"\u003e\u003c/a\u003e\n### Organização/Sort\n\nNo arquivo [Sorting.java](./src/main/java/com/eduardo/Sorting.java) estão reunidos 5 métodos de organização diferentes, dentre eles: **BubbleSort**, **SelectionSort**, **InsertSort**, **QuickSort** e **MergeSort**. Abaixo estão as características de cada método.\n\n```.java\npublic static void bubbleSort(int[] nums)\npublic static void selectionSort(int[] nums)\npublic static void insertionSort(int[] nums)\n\npublic static void quickSort(int[] nums, int low, int high)\nprivate static int partition(int[] nums, int low, int high)\n\npublic static void mergeSort(int[] nums, int left, int right)\nprivate static void merge(int[] nums, int left, int mid, int right)\n```\n\n### BubbleSort pt\n\n```.java\npublic static void bubbleSort(int[] nums)\n```\n\nO algoritmo **Bubble Sort** é um dos mais simples de se executar, a forma que ele funciona consiste em 2 loops, o primeiro tem o objetivo de passar pela array pela mesma quantidade de valores que ela possui, conferindo assim, que ela não esteja organizada pela metade. Já o segundo loop é onde é realizada as comparações que vão organizar a array. A princípio esse algoritmo compara os valores **índice** e **índice+1**, caso o valor de **índice** seja maior que seu sucessor, os valores trocam, caso não seja nada acontece. Isso ocorre até a última iteração do segundo loop, onde é comparado os valores do penúltimo e último índices, e ao fim da primeira iteração do primeiro loop, o último item será sempre o maior. Esse processo de colocar o maior número da parte não organizada da lista ao final se repete até a lista estar completamente organizada.\n\nA complexidade temporal desse método é O(n²)\n\n### SelectionSort pt\n\n```.java\npublic static void selectionSort(int[] nums)\n```\n\nO algoritmo **Selection Sort** também consiste em 2 loops, onde o primeiro tem o mesmo objetivo do **Bubble Sort**, que é de percorrer a array pela mesma quantidade de itens que ela possui, enquanto o segundo é onde são feitas as comparações para organizar. Fundamentalmente, esse algoritmo tem a função de identificar o maior número na array referente a parte não organizada, e colocar esse número na última posição não organizada, a forma que é feita é *selecionando* um index referente ao maior valor e comparando com cada valor da lista, caso algum valor seja maior, o index *selecionado* é trocado pelo index do valor maior, e depois de passar por toda a parte não organizada insere o valor do índice selecionado ao final.\n\nA complexidade temporal desse método é O(n²)\n\n### InsertionSort pt\n\n```.java\npublic static void insertionSort(int[] nums)\n```\n\nO algoritmo **Insertion Sort** também consiste em 2 loops como os anteriores, o primeiro loop serve para percorrer a array e também para *selecionar* o valor a ser *inserido*. E então, no segundo loop, ele percorre a array de trás pra frente desde o índice do valor selecionado até encontrar um valor menor que o valor selecionado e inseri-lo 1 índice a mais que o valor menor que ele. Uma coisa interessante sobre esse algoritmo é que ele não precisa percorrer toda a array de novo para conseguir organizar caso um novo valor entre no final, ele seleciona o valor final (que não faz parte da parcela da array que está já organizada) e *insere* ele 1 posição após o número que seja menor que ele.\n\nA complexidade temporal desse método é O(n²), mas no melhor dos casos (caso a lista aleatoriamente seja criada em ordem crescente) pode chegar à O(n).\n\n### QuickSort pt\n\n```.java\npublic static void quickSort(int[] nums, int low, int high)\nprivate static int partition(int[] nums, int low, int high)\n```\n\nO algoritmo **Quick Sort** é o primeiro que utiliza de 2 métodos para realizá-lo, esse algoritmo recebe uma array (como todos os outros) e nesse caso, também recebe o intervalo representado por `int low` e `int high`, que são respectivamente o primeiro índice e o último índice. Fundamentalmente, esse algoritmo funciona selecionando um valor dessa array como pivô e então separando todos os valores menores que este pivô e colocando para a esquerda e os valores maiores à direita, tudo isso sem organizar a array de nenhuma forma, o algoritmo faz isso para encontrar a posição final desse pivô e depois de colocar todos os valores para o lado correto ele coloca o pivô na posição final dele. Depois disso, ele particiona a array em 2 e faz o mesmo processo de selecionar um pivô e separar valores maiores e menores que ele para encontrar o valor final dele, e depois particiona a array em 2 novamente. Importante pontuar é que a array não é realmente particionada, mas os ponteiros se movem de acordo com o intervalo **low** e **high** passados.\n\nA complexidade temporal desse método é O(n • log2 n) na maioria dos casos, e O(n²) no pior dos casos (onde a array ocasionalmente já esteja organizada).\n\n### MergeSort pt\n\n# English\n\n## Overview\n\nMy goal with this project was to understand and practice using **data structures** and **algorithms**, here I utilize different data structures, **searching and sorting algorithms**.\n\nAlthough the project's directory organization isn't the best, I at least tried to make it the most intuitive as possible.\n\nHere you can find the algorithms:\n- [Searching](./src/main/java/com/eduardo/Searching.java)\n- [Sorting](./src/main/java/com/eduardo/Sorting.java)\n\nHere you can find the data structures:\n- [Estruturas de dados](./src/main/java/com/eduardo/dataStructures/)\n  - [Stack](./src/main/java/com/eduardo/dataStructures/Stack.java)\n  - [Static Stack](./src/main/java/com/eduardo/dataStructures/StaticStack.java)\n  - [Dynamic Stack](./src/main/java/com/eduardo/dataStructures/DynamicStack.java)\n  - [Linked List](./src/main/java/com/eduardo/dataStructures/LinkedList.java)\n  - [Queue](./src/main/java/com/eduardo/dataStructures/Queue.java)\n  - [Binary Tree](./src/main/java/com/eduardo/dataStructures/BinaryTree.java)\n\n## Algorithms\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Feduardob-programador%2Fdsa-learning","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Feduardob-programador%2Fdsa-learning","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Feduardob-programador%2Fdsa-learning/lists"}