Computer-Science on Adam Hacks

CS Review: Merge Sort

Sun, 28 Feb 2021 00:00:00 +0000

Merge sort is among the divide and conquer algorithms. That is to say, it divides the input array into half, calls itself on both halves. This process is done recursively over the entire array. When we’re done, all the individually sorted pieces are merged back together to form the fully sorted array.

CS Review: Quicksort

Sun, 28 Feb 2021 00:00:00 +0000

Quicksort is another one of the divide and conquer sorting algorithms. It works by partitioning the array around some chosen pivot point, which there are a few different ways to choose.

Quicksort is generally preferred over merge sort for sorting arrays due to the fact that the general form of the algorithm sorts in-place.

CS Review: Bubble Sort

Sat, 27 Feb 2021 00:00:00 +0000

Bubble sort is the easiest possible sorting algorithm you could imagine. It works by simply iterating over an array of data and comparing adjacent items. If those items are in the wrong order, then they are swapped. In doing this, the largest items “bubble up” to the correct position in the array (assuming ascending order, anyway).

While this is great from a simplicity standpoint, it’s a pretty awful solution in terms of efficiency. The worst-case performance of bubble sort is O(n2). The best-case turns out to be O(n).

As you can see, this algorithm is not suitable for any sufficiently large datasets.

CS Review: Selection Sort

Sat, 27 Feb 2021 00:00:00 +0000

The previous sorting algorithm we took a look at was bubble sort. This time around we will be taking a look at selection sort, which is slightly more complex than bubble sort, but only by a tiny bit.

The idea behind selection sort is that you keep iterating over your array of data, finding the minimum element each time and placing it at the start of the list. In this way, you can think of selection sort as managing two subarrays: the portion of the array that is sorted and the portion that still needs to be sorted.

Like bubble sort, selection sort has a worst-case time complexity of O(n2), but it does have a tendency to outperform bubble sort. Selection sort also has a nice side-effect where it will never do more than O(n) swaps, which is nice if you’re operating in an environment in which memory writes are costly.

A Review of Binary Search Trees

Fri, 26 Feb 2021 00:00:00 +0000

My previous computer science review post took a look at the tree data structure. This time around we will be exploring a specific kind of binary tree: The Binary Search Tree.

Let’s not waste any more time and just jump right in!

A Review of Graphs

Fri, 26 Feb 2021 00:00:00 +0000

You may have noticed that I’ve been putting a lot more work into writing posts for my Computer Science Review series lately. The last installment of this series took a look at binary search trees. This time around we will be taking some time to review one of my favorite data structures: Graphs.

A Review of Binary Trees

Thu, 25 Feb 2021 00:00:00 +0000

In my previous review series, I wrote a brief review of set theory. This time around we’ll take a look at the binary tree data structure. The tree structure is very common, incredibly useful data structure in the field of computer science and it’s essential that any engineer understand how they work.

A Brief Review of Set Theory

Mon, 11 Jan 2021 00:00:00 +0000

Set theory is the branch of mathematics that, unsurprisingly, deals with sets. It’s an area of great importance in a number of fields, including computer science.

In this post, I’ll go over a brief review of basic set theory as it pertains to those pursuing an interest in computer science. Let’s just jump right in!

The Dining Philosophers Problem

Fri, 21 Aug 2020 00:00:00 +0000

The dining philosophers problem is a classic problem in the realm of computer science. If you’ve had any formal CS education you’ve more than likely seen the problem when learning about concurrent programming.

Today we will take a look at the problem and look at an example of how we can solve it.

Boolean Algebra Cheat Sheet

Mon, 20 Apr 2020 00:00:00 +0000

I previously posted a logic rules cheat sheet and figured it was about time that I do the same for boolean algebra.

Logic Rules Cheat Sheet

Sun, 02 Feb 2020 00:00:00 +0000

When working with logic in discrete math appliations there are a plethora of rules you can use for working with the well formed formulas. Remembering them all can be a daunting task, which is why I like to have a cheat sheet available. As such, here’s a simple one that I like to use when working with these problems.

CS Review - Binary Numbers

Tue, 19 Sep 2017 00:00:00 +0000

Welcome to what will be the first in an ongoing series aimed at reviewing computer science topics. Today we will be diving into binary number representation. Understanding binary is an important step in gaining a better understanding of how the computer works on a lower level.

Recall that a computer is made up a whole bunch of integrated circuits, which are in turn made up of a bunch of transistors. These transistors can have one of two states: on or off. We represent these states as a 1 or a 0, respectively. This means that a computer can only work with two different values, 1s and 0s. This is where binary comes in.