We want a benchmark that proves that it is a better solution.

i want to work on this.

I was just wondering how "Union-Find Approach using rank or path-compression" could be a better approach in finding the number of connected components. It'll take O(n log n) while the dfs approach works in O(n).
Union-Find Structure (DSU) is rather generally used for the case where we are given several elements, each of which is a separate set. A DSU will have an operation to combine any two sets, and it will be able to tell in which set a specific element is and can create a set from a new element.
An implementation describing this use of DSU would be more helpful.

Why write all this theoretical text?? Write up both algorithms and a benchmark instead.

I have added Pull Request #773 regarding this issue.

@coderanant DFS will take O(E) and O(E) = [O(V), O(V2)].

@deadshotsb Sorry for not making it clear.
DFS will take O(E) = [O(V), O(V²)]
DSU will take O(E) = [O(V log(V)), O(V² log(V))]
I have however added approach with both Union by size of tree and Path Compression which might work very closer to DFS approach in most cases.

Where is the benchmark?

How am I supposed to write a benchmark?
Please pardon if this is very intuitive as I am kinda new to Open Source.

@coderanant The best method to write a benchmark according to test the algorithms based on some randomly generated Graphs and showing a relation between time and the size of graph for the algorithms under consideration.

what is the current status of this issue, as far as i know i had merged the PR related to this issue, what the status of benchmark @coderanant ?

I was just wondering how "Union-Find Approach using rank or path-compression" could be a better approach in finding the number of connected components. It'll take O(n log n) while the dfs approach works in O(n).
Union-Find Structure (DSU) is rather generally used for the case where we are given several elements, each of which is a separate set. A DSU will have an operation to combine any two sets, and it will be able to tell in which set a specific element is and can create a set from a new element.
An implementation describing this use of DSU would be more helpful.

Let's say you are given Q queries. Each query is to add an edge into a graph. After each query you are to return the amount of connected components in this graph.

DFS is O(NQ), while DSU is (Q a(N)).

I was just wondering how "Union-Find Approach using rank or path-compression" could be a better approach in finding the number of connected components. It'll take O(n log n) while the dfs approach works in O(n).
Union-Find Structure (DSU) is rather generally used for the case where we are given several elements, each of which is a separate set. A DSU will have an operation to combine any two sets, and it will be able to tell in which set a specific element is and can create a set from a new element.
An implementation describing this use of DSU would be more helpful.

Let's say you are given Q queries. Each query is to add an edge into a graph. After each query you are to return the amount of connected components in this graph.

DFS is O(NQ), while DSU is (Q a(N)).

Since this repository is presenting multiple algorithms from an educational perspective, older inefficient algorithm implementations would also be welcome along with faster and more efficient implementations.

In that case I am confused as for why cclauss is obsessed with speed benchmarks.

We want to be able to see the theoretical performance DFS is O(NQ), while DSU is (Q a(N)) as well as the actual performance 32 sec. vs. 97 sec.

As your username says, let's test the item. ;-)

I was just wondering how "Union-Find Approach using rank or path-compression" could be a better approach in finding the number of connected components. It'll take O(n log n) while the dfs approach works in O(n).
Union-Find Structure (DSU) is rather generally used for the case where we are given several elements, each of which is a separate set. A DSU will have an operation to combine any two sets, and it will be able to tell in which set a specific element is and can create a set from a new element.
An implementation describing this use of DSU would be more helpful.

Let's say you are given Q queries. Each query is to add an edge into a graph. After each query you are to return the amount of connected components in this graph.

DFS is O(NQ), while DSU is (Q a(N)).

Thanks for the clarification.
I didn't consider this use-case.

If the "point" of this repo is to present algorithms from an "educational" perspective, what use are benchmarks?

On a similar note, if the goal is to present algorithms from an "educational" perspective, the repo should do a better job of documenting/explaining each algorithm.

If the "point" of this repo is to present algorithms from an "educational" perspective, what use are benchmarks?

On a similar note, if the goal is to present algorithms from an "educational" perspective, the repo should do a better job of documenting/explaining each algorithm.

Documentation is being updated. A major re-work in these regards can be found here https://kvedala.github.io/C-Plus-Plus. However, for this documentation to automatically stay up-to-date with latest commits, the code submitted must be properly structured and documented.

If the "point" of this repo is to present algorithms from an "educational" perspective, what use are benchmarks?
On a similar note, if the goal is to present algorithms from an "educational" perspective, the repo should do a better job of documenting/explaining each algorithm.

Documentation is being updated. A major re-work in these regards can be found here https://kvedala.github.io/C-Plus-Plus. However, for this documentation to automatically stay up-to-date with latest commits, the code submitted must be properly structured and documented.

Also, any help towards this herculean effort would be greatly appreciated 😅