https://github.com/pedrovgs/Algorithms/blob/7729e8135393710083184ce6ab6a8a1faebd447b/src/main/java/com/github/pedrovgs/problem46/BinaryTreeSerialization.java#L54

This variable could be defined as: private int index; and placed above the methods

Refactored code of two binary number summations. Less code replication.

& Elaborated on complexity of square root. Not same as binary search, though binary search is used to find closest number.

I'm a university student just doing an assignment :) This algorithm returns the count of the number of times an element is present in the collection.

I guess package names should not contain anything as meaningless as "problem65". The greatest virtue of today's world is a code reuse. I would like to import code from something with a descriptive name so as not to confuse my followers.

Why isn't it called package com.github.pedrovgs.algorithms.IsTreeBalanced?

Fixes #51

Actually, I think there are some flaws in the test for sorting. At least you should have lots of random cases to find out the lurking issues.

The updated quicksort pass through the following scale of tests:

    private static final int TEST_COUNT = 100_000;
    private static final int TEST_ARRAY_MIN_SIZE = 1;
    private static final int TEST_ARRAY_MAX_SIZE = 100_000;
    private static final int TEST_ARRAY_RANGE = 100_000;

it should check the length of the w2 string, or it will throws a StringIndexOutOfBoundsException Test Case like this: String word1 = "drso"; String word2 = "Pedro";

Hi Pedro, Hope you are doing fine. You are a wonderful programmer. I follow you. During the follow up about your recent update on 'SplitArray', I have brushed up few sentences a little bit. Please have a look and if you feel it is worth modification, please merge it.

It would be greatly appreciated if you allow me to work with you in your open source projects. Have a wonderful time.

Best regards, Azizur

I read your code and I don't think the bubble sort is like what I read from the algorithm books. I don't get it. The comment says 'compares each pair of adjacent items and swaps them if they are in the wrong order'，but it is not. The code is compare the elment to the others every step(not adjacent ones). It works but it is not as the comment says.

Disclaimer: noob

When I type javac Trie.java I get this output

Trie.java:5: error: package com.jwetherell.algorithms.data_structures.interfaces does not exist import com.jwetherell.algorithms.data_structures.interfaces.ITree

Please have a try with the following test using JUnit, it will fail with timeout.

Please hold a sec, I am starting a PR for this along with tests later (today).

public class QuickSortGitTest {
    private static final int[] unorderedIntegerArrayThree = {12, -37, -5, 43, 62, 45, -95, -70, -55, -62, -24, -14,
            -75, 43, 9, 58, -62, -22, -55};

    private static void quickSort(int[] numbers, int left, int right) {
        if (left < right) {
            int pivotIndex = partition(numbers, left, right);
            quickSort(numbers, left, pivotIndex - 1);  //sort left of pivot
            quickSort(numbers, pivotIndex, right);  //sort right of pivot
        }
    }

//    private static int partition(int[] array, int low, int high) {
//        int pivot = array[high];
//        int i = low - 1;
//        for (int j = low; j <= high - 1; j++)
//            if (array[j] <= pivot)
//                swap(array, ++i, j);
//
//        swap(array, i + 1, high);
//        return i + 1;
//    }
//
//    private static void swap(int[] array, int i, int j) {
//        int temp;
//        temp = array[i];
//        array[i] = array[j];
//        array[j] = temp;
//    }

    private static int partition(int[] numbers, int left, int right) {
        int pivot = numbers[right];
        while (left < right) {
            while (numbers[left] < pivot) {
                left++;
            }
            while (numbers[right] > pivot) {
                right--;
            }
            if (left <= right) {
                int temp = numbers[left];
                numbers[left] = numbers[right];
                numbers[right] = temp;
            }
        }
        return left; //pivot index
    }

    @Test(timeout = 5 * 1000)
    public void testRecursionZero() {
        quickSort(unorderedIntegerArrayThree, 0, unorderedIntegerArrayThree.length - 1);
    }
}

fixing issue https://github.com/pedrovgs/Algorithms/issues/49 for definition and initialization of variables on : BinaryTreeSerialization PathCalculator

Bumps junit from 4.11 to 4.13.1.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.