There's nothing wrong with including code for a data structure or algorithm (which doesn't do anything all by itself), although I suggest you include some code to test it as well, even if it's somewhat arbitrary. I can't imagine that any experienced programmer would see implementing a data structure or algorithm yourself as wasting your time - any experienced programmer should appreciate the learning experience involved with doing that.
Beyond that, you could include pretty much any code / program.
I'd err more on the side of (1) what a technical user might find impressive, (2) a game that's genuinely fun or (3) some program that's actually useful as opposed to something a non-technical user might find impressive (and also focus any explanations, which there should absolutely be, on the technical side, even if you just mention that there this is just some fun game and there isn't much technical complexity behind it). I think a technical user finding his/her way to your site during the recruiting process is way more likely than a non-technical user doing so, although you shouldn't discount that possibility completely.
With regard to (2) and (3) (and even (1)), you should strongly consider having 'releases' as well as the code - one should be able to either use / play the application / game online, or download an executable. It's all the better if you allow for bug reports and you actively support it, with continuous releases - these things mean a lot, perhaps more in some industries than others.
People may certainly:
Run a tool which would go looking for similar code on the internet (I'm sure such tools exist) (although this option seems unlikely)
Visually be able to notice different styles in your code, making them think you copied code from somewhere else (but coding styles may change over time, or using different development environments, so they might not put too much weight on this one, although it could lead to running the above-mentioned tool)
Where is the line drawn? Look at it like this:
If you copied the code for your entire project and tweaked it a bit, or combined code from various sources, that's probably too much.
However, if you explain what you did (attributing the sources), and it makes sense to do, that's probably okay though.
By "makes sense", consider combining code from various sources. If each is just an implementation of the same thing with little-to-no tweaks, and all you did was put different parts of each together, that doesn't make too much sense - the code surely isn't very useful, and most likely didn't teach you much (surely not nearly as much as implementing it from scratch). If each uses different tweaks and your code was an experiment into combining them to make something more efficient than all of them (at least under certain conditions), that might make sense, even if it failed.
In terms of posting the code from a completed tutorial - on the one hand, there's some value in showing that you completed the tutorial (this will vary from person to person - some may view you showing this negatively), on the other hand, you could pretty easily get the code from most tutorials without doing a whole lot (but I'm not saying they're not useful if done right). What would be way better is to use the knowledge you gained through this tutorial to make something else, and post that instead.
The same goes for implementing well-known data structures or algorithms - sure, it is a learning experience, but posting it may not have a whole lot of value by itself for many people. Putting it in a bigger project that actually does something useful means a whole lot more.
A bit more on attribution:
As an example:
- Copying a quick-sort function from some site (to use with the rest of your project)
- Deriving it from code / an explanation on some site
- Using a quick-sort function from a library
- Writing a quick-sort function from scratch (from memory, i.e. somewhere you can't remember, or many sources) (either as its own project, or part of a bigger project)
- Rediscovering quick-sort all by yourself (and just calling it "some partition-based sort") (either as its own project, or part of a bigger project)
Are all fine, as long as you don't pretend it's something it's not - don't try to pass others' work off as your own.
You should include attribution (e.g. "I derived this from the pseudo-code provided on {some site}") for the first two along with the explanation in the comments / outside the code (for the second one is optional in some cases, but probably still good practice).
