How am I supposed to memorize the million different sorting algorithms for my data structures class? Help...

How am I supposed to memorize the million different sorting algorithms for my data structures class? Help, how do you memorize this shit?

an algorithm to sort sorting algorithms

you fucking retard, i gotta wipe your ass for you too

there's like three what are you talking about

is that what they are teaching in your data structures class, memorization of sorting algorithms?

no, I'm talking about remembering how each sorting algorithm works. I just use merge and insertion since they make the most intuitive sense for me so far. Heapsorting is also fine, but I always forget how something like selection sort works.

just write a simple program using one every day rotate between them in a couple of weeks you'll have them down. Especially use the ones you find hard to remember

>memorizing algos
I know 100% nobody in the business memorizes the algos. They may know a couple by heart, but I can assure you everybody looks them up when the situation calls for it. On that subject, It is more important to know when to use the different structures/alogs rather than the actual implementation of them.

Nobody cares about the dozens of similar quadratic sorts. The basic principle between all of them is pretty much the same, and you just need to understand the general class, not the difference between selection sort and insertion sort and bubble sort and all of the other crap. If you know mergesort, heapsort, quicksort, and (the overall class of quadratic sorts as exemplified by one particular such algorithm such as insertion sort), you should be golden.

>itt mathcucks try to give CS advice

bubble sort aka sweeping swap sort
cocktail sort aka bidirectional sweeping swap sort
selection sort aka select the smallest/biggest and remove into sorted list
insertion sort aka insert into the sorted list in the beginning
heap sort aka put it into a min/max heap and pop the min/max
merge sort aka divide and conquer sort
quick sort aka pivot sort aka divide the array by a pivot
bucket sort aka divide into ranges
radix sort aka stably sort radix from least significant radix to most significant radix
random sort aka check if sorted else shuffle
factorial sort aka systematically check all the arangments
Veeky Forums sort aka fork() -> sleep(n) -> writeback()
comb sort aka black magic bubble sort with Θ(n^2) but within a factor of 2~3 of quick/merge/heap sort
shell sort aka black magic insertion sort with actually better theoretical run times
qsort/sort aka run quick sort to a depth of ~2log2(n) and switch to merge/heap sort

The Veeky Forums bullying is getting to me desu.
I'm dropping out of CS next semester at this point.

>listening to Veeky Forums for advice

If you find CS anything other than a joke, you're not going to survive long in other stem fields.

Just stick to CS and make a decent living user. Fuck what everyone else says, especially on sci.

>implying you need a cs degree to get a programming job
>not knowing half of programmers don't have cs degrees and they are the preferred ones

>implying it's not easier to get a soul burning web dev. job with a cs degree

take notes mother fucker. I don't know a damn thing, but I know where to find what I need to know.

>instead of learning how to do my job
>I can just get a cs degree and bounce from job to job

>CS Brainlets

>Only 3 out of all algorithms are actually useful
>Can't memorize 3 thing
The absolute state of cs students. When you'll need to memorize the trillion proofs in your calculus course what are you going to do, cry?

>3

It's closer to 6/7

>bubble/cocktail
>insertion
>merge
>quick
>heap
>radix

You just do. Implement them over and over until you can do it without thinking. Then when the class is over forget about them (besides the high-level details) and look them up when you need them, or just use an out of the box solution.

>it is more important to know when to use rather than the actual implementation.

This. Remembering the different affects of each algorithm is more important than remembering how to write it in any given language. Copy/pasting a program from stack exchange or calling a function from a library is easy, knowing which one to copy/call is the important part.

>memorizing proofs
lmao

I'm in EE you faggot, programming is my worst subject.

You don't memorize them user, you LEARN them conceptually so that you can reimplement them yourself

Do this:
>Get the list of ones you need to know for class
>First, memorize their names, basic ideas, and algorithmic complexities (both time and space)
>Next, implement them in code, even just copying the pseudocode from your textbook identically
>Next, refactor them (rearrange the code) in a way that makes more sense to you
>You should be able to visualize the algorithm in your mind now and should be capable of implementing it from memory in your own pseudocode
>You should also now be able to explain why they have those algorithmic complexities (both space and time)

Have to work OP nothing comes free. Do this list

well don't worry some faggots will still ask you this in job interviews even after you have 10 years exp and be mad that you haven't looked at this bullshit in years and when needed you just look it up on the web and are able to implement the algo

not to mention all the fucking optimized sorts are in any real language with a real API
no, no, js doesn't count

there are going to be a shitload more programmers in the future, there are already too many
and don't believe the hype that you'll be one of those "rockstar" devs that floats ontop of the rest of the turd sauce that is the IT industry

who the fuck would want to work with the type of people that are on the internet all the time. everyone is a hateful selfish dickhead

listen to me young padawan
pick another fuckin way to put money in the bank this shit sucks fuckin dicks and ass

>thinks being a code monkey making $40k is anywhere close to being an engineer
That’s like saying the draftsman is an architect.

...

>>First, memorize their names, basic ideas, and algorithmic complexities (both time and space)
You should be able to derive the complexities yourself brainlet.