Java vs. Python Programming Language Comparison

/

Java and Python are two popular programming languages that represent two very different approaches to structure and syntax. Java has a more formal, strict syntax. Python syntax is more forgiving and provides many shortcuts and abbreviations. Java is compiled and Python is interpreted.

The table below shows a sampling of Java and Python programming language elements that highlight these differences.

JavaPython
Block {
   . . .
}		 def my_block( ):
      . . .
      CR
Class
Definition		 public class Hello {
   . . .
} 		class Hello:
      . . .
      CR
Class
Constructor		 public Hello(Strng msg) {
    defaultMsg=msg;
} 		def __init__(self, param1, param2, ...)
      self.p1=param1
      self.p2=param2
      CR
Class
Instantiation		 Hello mHello=new Hello();
mHello=Hello( )
Class
Variable		 static String myVariable; class MyClass:
      my_class_variable = 0
Comment // Comment text. # Comment text.
Constant final static MY_CONSTANT; MY_CONSTANT
Conditional if (a>b) {
   . . .
}  else {
   . . .
} 		if (a>b):
      . . .
else:
      . . .
Exception
Handling		 try { . . . }
catch { . . . } 		try:
      . . .
except Error, e:
      . . .
Global
Variable		 public class MyGlobals {
   public static String mG1
} 		global my_global_variable
Importing import java.sql.*; import apackage as ap
from apackage import amodule
Inheritance class Child extends Parent{...} class Child(Parent):
Instance
Variable		 // Declared outside methods
String mVariable; 		class Hello:
      def __init__(self, param1)
            self.param1=param1
Iteration for (i=0; i<5; i++) {
    . . .
}

for (myElement : myCollection){
    . . .
}
 for x in range(0, 5):
      . . .

for my_element in my_collection:
       . . .

for key, value in my_dictionary:
       . . .
Local
Variable		 String myVariable; my_variable
Method
Definition		 public void myIdea(String param) {
   . . .
} 		def my_idea(my_parameter):
      . . .
      CR
Method
Use		 myIdea(mParameter); my_idea(my_parameter)
Namespace
Reference		 packageName;
my_namespace={'a':a_object, ...}
Null Value null
None
Statement
Separator		 ;
new line
Variable String mString="Hello Java";
my_string="Hello Python"

Software Components Overview

/

Below is a list of links to and brief descriptions of common software components. It's useful to keep these in mind and reference them during software design as a shorthand for code that will be written to implement the design. Implementing a component could involve just a few or many lines of code.

A suggested way to use these components in solving/coding a computing problem is to include them using a Separation of Concerns design pattern folded into what I call Layered Logic Problem Solving that includes these steps:

  1. Describe in words the problem to be solved. This might include references to software components listed below. You might also include solution acceptance criteria, possibly in the form of formal acceptance tests.
  2. Draw a block diagram of the main problem solution pieces. For more complex problems, other types of diagrams can be used.
  3. Annotate the block diagram with references to components such as those below.
  4. Code the solution in your chosen programming language.

Communications

  • Client-Server Architecture: components include:
  • HTTP Request: indicates the desired action to be performed on an identified resource - actions include: 
    • GET: retrieve data
    • HEAD: retrieve without response body
    • POST: create new subordinate data
    • OPTIONS: retrieve supported actions
    • PUT: create/replace data
    • DELETE: delete the resource
    • CONNECT: convert connection to TCP/IP tunnel, usually to facilitate HTTPS SSL
  • Internet Protocol Suite:
    • Layers: Application/Transport/Internet/Link
    • Levels: Send/Receive, Controls/Routing, Values/Translations
  • Firewall: monitor/control of incoming/outgoing traffic
  • JSON: JavaScript Object Notation, Human Readable, Attribute-Value Pairs, Java JsonObject
  • Load Balancer: distributes workload across computing resources
  • Message: data sent across processes
  • Network: allows computers to exchange data
  • Protocol: Data Formats, Address Formats, Address Mapping, Routing, Error Detection, Acknowledgements, Sequence Control, Flow Control
  • REST: Representational State Transfer, Stateless, Client-Server, JSON data
  • Socket: endpoint of a connection across a computer network

Data

Algorithms & Processes

Objects

  • Class: object template
  • Container: collection of other objects
  • Design Patterns: reusable solutions to common software problems  
  • Object Oriented Design Patterns: reusable solutions to common object oriented software problems
  • Generics: specify type or method to operate on objects
  • Cloud Computing: internet based computing that provides shared processing resources
  • Interface : all abstract methods
  • Mutability: mutable, immutable, strong vs. weak
  • Objects: variables, data structure or function referenced by an identifier
  • OOD: uses inheritance, abstraction, polymorphism, encapsulation, other design patterns

Views

  • Ajax: groups of technologies for client-side asynchronous web applications
  • Android Fragments: UI segmenting, own lifecycle, FragmentManager
  • HTML5 Canvas:  bitmap, javascript
  • CSS:  describes the presentation of information
  • HTML:  head, body, div, script
  • Widget: simple, easy to use applicator
  • XML: markup language that defines a set of rules for encoding documents

Type System

/

A type system is a collection of rules that assign a property called type to constructs such as variables, functions, expressions and modules. Here are the two main dimensions of typing and some programming language examples:

Static vs. Dynamic

  • static:  type is set during compile
  • dynamic: type is set during execution

Strong vs. Weak

  • strong: type cannot change during execution
  • weak: type can change during execution

Language Examples

Java Data Structures

/

There are a number of commonly used Java data structures. Here are links to additional documentation and highlights of structural aspects: 

  • Array: fixed size, best for primitives 
  • List: fixed size, interface, ordered, allows duplicate
  • ArrayList: resizable , add to top, preferred unless need the capabilities of another structure
  • Vector: resizable, synchronized, add to top
  • Stack: LIFO, push/pop
  • Queue: FIFO, add to bottom/remove from top, interface
  • LinkedList: doubly-linked, push/pop, many other methods
  • Set: no duplicates, interface
  • HashMap: random access
  • TreeMap: sorted, efficient search
  • Binary Tree: each node has <=2 children
  • Binary Search Tree: sorted, fast lookup/add/remove
  • k-d Tree: k dimensional, space-partitioning, nearest neighbor search
  • Red-Black Tree: self-balancing, binary search tree, extra bit per node
  • Iterator: move forward and backward through data
  • Collections: perform operations on collections of data
  • Working with Java Lists: methods, iterators, collections
  • Data Structure Decisions: change, access, indexing, sizing
  • Common Java Array Manipulation Constructs: split, sort, binary search, iteration
  • Common Java ArrayList Manipulation Constructs: add, indexOf, remove, sort, binary search, interator
  • B-tree and Binary Search Tree Data Structures: like TreeMap
  • Sorting Algorithms: Collections sort, exchange, hybrid, insertion, merge
  • Big O Notation: O(1), O(log (n)), O(n), O(n log(n))
  • Update and Access Overview: The diagram below indicates how elements and values are updated and accessed. This is a broad overview of commonly used data structure classes, interfaces and objects ... please see the links above and below for more details. Some general observations are:
    • Arrays are different than the other structures in that they are accessed using bracketed index [n] references, such as myStringArray[3] instead of methods and can only contain primitives, not objects.
    • ArrayLists are generally preferred over Lists as they allow resizing. It's a very commonly used structure.
    • Vectors are much like ArrayLists with the additional characteristic that they are synchronized.
    • Queues and Stacks are specialized for LIFO and FIFO access.
    • LinkedLists are powerful structures that require more space for storage and time to execute some operations but are efficient for inserting and deleting objects in the existing order.
    • Sets are simple structures that don't allow duplicates.
    • HashMaps are commonly used when rapid, direct access to elements is the primary requirement.
    • TreeMaps are preferred when rapid search is the primary requirement.
    • Iterators and Collections operate on whole data structures.
    • ( ) empty parameter methods generally operate on the ends of a structure.
    • (element | object) only parameter methods generally operate on sets or the ends of structures.
    • (index | key) and (index | key, element | object) parameter methods generally operate on specific places within a structure.

Internet Protocol Suite Overview

/

Working with Java Lists

/

As shown in the diagram below, there are three major Java class groups used for working with lists: Lists (such as List, ArrayList, LinkedList, AbstractList, Stack and Vector), Iterators (Iterator and ListIterator) and Collections. Together, these classes and their methods provide a wide spectrum options for list construction, examination and manipulation. For an example of using these classes, look here.

Common Java ArrayList Manipulation Constructs

/

ArrayList data structures (also called Dynamic Arrays) are a frequently used programming function. ArrayLists have an advantage over arrays - ArrayLists are not fixed in size and can be dynamically changed by adding and deleting elements. Below are some common Java array manipulation constructs. For an overview of working with Java lists, look here.

Creating a new ArrayList

Creating a new ArrayList is coded as shown below using the String type with an initial capacity of 20 entries:

ArrayList mArrayList = new ArrayList<String>(int 20);

Constructing an ArrayList from an Existing List

The example below shows how to construct an ArrayList from the individual words in a String using an intermediary List object. Notice that the sequence of objects created is: String -> String array -> List -> ArrayList

String wordString = "this is a string of words";
String[] wordsArray = wordString.split(" ");
List<String> wordsList = Arrays.asList(wordsArray);
ArrayList wordsArrayList = new ArrayList<String>(wordsList);

add( )

The example below shows how to use the ArrayList add() method to add a String to wordsArrayList::

wordsArrayList.add("Example2");

indexOf( )

The example below shows how to use the indexOf() ArrayList method find the index of an entry:

int index = wordsArrayList.indexOf("Example2");

remove( )

The example below shows how to use the ArrayList remove() method using the entry index or the entry itself:

wordsArrayList.remove(index);
wordsArrayList.remove("Example2");

sort( )

The Collections sort() methods provide a variety of options for sorting ArrayList entries. Note that the ArrayList is sorted in place without returning a new ArrayList. This can be done because the array parameter is a value pointing to the ArrayList of objects. For example, the following statement would sort the words ArrayList from the example above using a modified MergeSort algorithm in an average O(n log(n)) time performance:

Collections.sort(wordsArrayList);

binarySearch( )

The Collections binarySearch() methods provide an efficient way to find an entry in a sorted ArrayList. For example, the following statement would find the index of the wordsArrayList entry for the String Example1 in an average of O(log(n)) time performance:

int entryIndex = Collections.binarySearch(wordsArrayList, "Example1");

iterator( )

The Iterator Class and ArrayList interator() method can be used to iterate over the entries of an ArrayList as shown in the example below :

Iterator mIterator = wordsArrayList.iterator();
while(mIterator.hasNext()){
System.out.println(mIterator.next());
};

Common Java Array Manipulation Constructs

/

Working with array data structures is one of the most frequently used programming functions. Arrays are implemented in a number of Java classes, such as String, Integer, and Boolean. Those arrays can be manipulated using the Java Arrays class (note that the Arrays class name is a plural). Below are some common Java array manipulation constructs.

split( )

The String split() method separates string characters into array entries using a supplied regular expression. For example, the following statement would create entries in the String array wordsArray using a blank character as a regular expression separator for processing the String wordString:

String wordString = "this is a string of words";
String[] wordsArray = wordString.split(" ");

sort( )

The Arrays sort() methods provide a variety of options for sorting array entries. Note that the array is sorted in place without returning a new array. This can be done because the array parameter is a value pointing to the array of objects. For example, the following statement would sort the words array from the split() example above using a Quicksort process in an average O(n log(n)) time performance:

Arrays.sort(wordsArray);

binarySearch( )

The Arrays binarySearch() methods provide an efficient way to find an entry in a sorted array. For example, the following statement would find the index of the array wordsArray entry for the String entryValue in an average of O(log(n)) time performance:

int entryIndex = Arrays.binarySearch(wordsArray, entryValue);

for( )

The for() construct can be used to iterate over the entries in an array. For example, the following statement would iterate over and print every entry in wordsArray:

for (String word : wordsArray) {System.out.print(word);}

If you want to know and use the index of each entry, then this construct can be used:

for (int i=0; i<wordsArray.length; i++) {System.out.print(wordsArray(i);}

Android Job Interview Topics

/

Because Android contains an extremely large number of Classes and Methods, it's impossible to hold all of the syntax and details in your head. For this reason, I've found that Android interview questions tend to be more conceptual in nature. For example, you might be asked how you'd approach a given problem using Android and Java constructs.

As you study the commonly used interview topics below, try to retain the main ideas and some relevant details. 

Android Fragments Overview

/

Android Fragments provide a mechanism to create modular sections of an Activity. You can see how Fragments fit into the overall Android structure in the blog post Android App Major Elements. You can see an example of Fragment use in the blog post Android Fragments.

Fragments provide a couple of significant benefits for Apps:

  • Fragments facilitate App adaptation to various screen sizes and dimensions. 
  • Fragments have their own life cycle that can be used to implement unique behavior for different App Fragments.

Below is an overview of Fragments and the Android elements they interact with for Fragment control.

Activity (Main)

The main Activity of an app uses the setContentView() method to establish a View.

Activity (for Fragment)

Activities can start and be started by Fragments.

View

The View class represents the basic building block for user interface components. A View occupies a rectangular area on the screen and is responsible for drawing and event handling. View is the base class for widgets, which are used to create interactive UI components (buttons, text fields, etc.). Views can be accessed via their ids or from the Root View.

Root View

The Root View is the base of the tree for all the Views for an app. It can be referenced using android.R.id.content.  

Layout (XML)

Layout XML can be used to define Views. When an app is compiled, the XML definitions are used to create View details. Note that this can include Fragment properties. If a Layout that includes a Fragment specification is used by the Activity setContentView() method, that Fragment will be automatically started by the Android operating system.

Fragment

A Fragment is a piece of an application's user interface or behavior that can be placed in an Activity. Sub classes of Fragment include: PreferenceFragment, DialogFragment and ListFragment.

Fragment Manager

The FragmentManager class is an Interface for interacting with Fragment objects.

Fragment Transaction

The FragmentTransaction class is used for performing Fragment operations.

Java vs. Ruby Programming Language Comparison

/

Java and Ruby are two popular programming languages that represent two very different approaches to structure and syntax. Java has a more formal, strict syntax. Ruby syntax is more forgiving and provides many shortcuts and abbreviations. Java is compiled and Ruby is interpreted.

The table below shows a sampling of Java and Ruby programming language elements that highlight these differences.

JavaRuby
Block {
   . . .
}		 def/class/do/if...
   . . .
end
Class
Definition		 public class Hello {
   . . .
} 		class Hello
   . . .
end
Class
Constructor		 public Hello(Strng msg) {
    defaultMsg=msg;
} 		def initialize(msg)
   . . .
end
Class
Instantiation		 Hello mHello=new Hello();
mHello=Hello.new("Hello Ruby")
Class
Variable		 static String myVariable; @@myVariable
Comment // Comment text. # Comment text.
Constant final static MY_CONSTANT; MY_CONSTANT
Conditional if (a>b) {
   . . .
}  else {
   . . .
} 		if a>b
   . . .
else
   . . .
end
Exception
Handling		 try { . . . }
catch { . . . } 		raise . . .
 
Global
Variable		 public class MyGlobals {
   public static String mG1
} 		$mG1
 
 
Importing import java.sql.*; require 'extensions'
Inheritance extends MyClass < MyClass
Instance
Variable		 // Declared outside methods
String mVariable; 		@mVariable
 
Iteration for (i=0; i<5; i++) {
    . . .
}

for (myElement : myCollection){
    . . .
}
 5.times do | i |
   . . .
end
Local
Variable		 String myVariable; my_variable
Method
Definition		 public void myIdea(String param) {
   . . .
} 		def myIdea(param="Starter")
   . . .
end
Method
Use		 myIdea(mParameter) myIdea m_parameter
Namespace
Reference		 packageName;
: :
Null Value null
nill
Statement
Separator		 ;
new line
Variable String mString="Hello Java";
mString="Hello Ruby"

Programming Language Constructs

/

There are hundreds of programming languages. Although most aren't commonly used, a software developer might use a number of them during their career. It's useful to understand the concepts that underlie these languages. Click here for a comparison of programming languages. 

Below are brief descriptions of some common and important programming constructs with links to more details.

Abstraction

Separating ideas from specific instances of those ideas. Click here for more details.

Access Modifier

Define characteristics of constructs such as classes and methods. Examples of modifiers are: public, private, package and protected:  Click here for more details.

Array

A data structure consisting of a collection of elements, each identified by at least one array index or key. Click here for more details.

Attribute

Defines a property of an object, element, or file. Click here for more details.

Block

Section of code grouped together. Click here for more information.

Branch

Sequence of statements triggered by a conditional. Click here for more information.

Callback

Pointer to a piece of executable code that is passed as an argument to other code, which is expected to call back (execute) the argument at some appropriate time. Click here for more details.

Class

Code template for creating objects. Think of architect's drawings. Click here for more details.

Conditional

Performs different actions depending on whether a condition is true or false. Click here for more details.

Constructor

In Object Oriented Programming, a block of code that's executed when an object is created. Click here for more details.

Container / Collection

An object made up of other objects. Click here for more details.

DOM (Document Object Module)

Convention for representation and interaction between objects in HTML documents. Click here for more details.

Dynamic Array

Variable sized data structure that allows adding and deleting elements. In Java, an ArrayList is one type of Dynamic Array. Click here for more information.

Encapsulation

Packing of data and functions into a single component. Click here for more details. 

Exception

Anomalous or failure event that may require special handling. Click here for more details. 

Expression

Combination of elements that produces a result. Click here for more details.

Garbage Collection

Reclaiming of unused memory. In some operating systems, such as Android, Garbage Collection is automatic. Click here for more details.

Hash

Used to provide direct access to data based on a calculated key. Click here for more details.

HTML (HyperText Markup Language)

A set of elements that can read by web browsers for displaying web pages. Click here for more details.

HTML Element

Individual component of an HTML document. Click here for more details.

HTTP Request

Indicates the desired action to be performed on an identified resource. Actions include: GET, POST, HEAD, OPTIONS, PUT, DELETE, TRACE, PATCH and CONNECT. Click here for more details.

Identifier

Names for objects and entities. Click here for more details.

Inheritance

Obtaining the capabilities on an object. Click here for more details.

Inner Class

A Class that is declared entirely within the body of another class or interface. An inner class cannot be instantiated without being bound to a top-level class. Click here for more details.

Instance

Specific realization of an object. Think of a house vs. the plans for a house. Click here for more details.

Iterator

An object that enables traversing a container, such as lists. Click here for more details.

JSON (JavaScript Object Notation)

Human-readable text used to transmit data objects consisting of attribute–value pairs. Often used to transmit data between a server and web application. Click here for more details.

Keyword

Word with a special meaning. Click here for more details.

List

A sequence of values, where the same value may occur more than once. Click here for more details.

Linked List

A data structure consisting of a group of nodes which together represent a sequence. Click here for more details.

Literal

Notation representing a fixed value. Click here for more details.

Loop

A sequence of statements which is specified once but can be carried out multiple times in succession. Click here for more details.

Metaclass

A class whose instances are classes. Click here for more details.

Method

Code that defines the run time behavior of objects. Click here for more details.

Mixin

A class which contains a combination of methods from other classes without using inheritance. Click here for more details. Not available in pure Java.

Object

In Object Oriented Programming, an object is an instance of a class. Click here for more details.

Operator

Perform actions on elements such as variables. Click here for more details.

Overloading

Ability to create multiple methods of the same name with different implementations. Click here for more details.

Overriding

In object oriented programming, is a language feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its superclasses or parent classes. Click here for more details.

Package

A Java package is a mechanism for organizing Java classes into namespace groups. Click here for more information.

Parameter

A reference or value passed to a function, procedure, subroutine, command, or program. Click here for more details.

Polymorphism

Provision of a single interface to entities of different types. Click here for more details.

Primitive

Smallest 'unit of processing' available to a programmer of a particular machine, or can be an atomic element of an expression in a language. Click here for more details. For example, in Java, primitive data types are: byte, short, int, long, float, double, boolean and char.

Reflection

Ability to modify an object's own properties at runtime. Click here for more details.

Regular Expression

Sequence of characters that can be used as a search pattern. Sometimes referred to as Regex or Regexen. Click here for more details.

Reserved Word

A word that cannot be used as an identifier, such as the name of a variable or function. Click here for more details.

Return

A value that is passed from a calculating function to an invoking function. Click here for more details.

Sort

Functions that put elements in a certain order. Sorting is used so often that many programming languages have built-in sort functions. Click here for more information.

Statement

Expresses some action to be carried out. Click here for more details.

Switch

Control mechanism used to allow the value of a variable or expression to change the control flow of program execution. Click here for more details.

Table

A collection of related data held in a structured format within a database. It consists of fields (columns), and rows. Click here for more details.

This

Refers to the object, class, or other entity that the currently running code is part of. Click here for more details.

Token

An object which represents the right to perform an operation. Click here for more details.

Type

Collection of rules for constructs such as variables and functions. Untyped languages allow any operation to be performed on any data type.  Click here for more details.

Variable

A storage location and associated name which contains a modifiable value. Click here for more details.

B-tree and Binary Search Tree Data Structures

/

B-tree and Binary Search Tree data structures are similar but different ways to store data. The advantage of using search trees is that the test for membership can be performed efficiently provided that the tree is reasonably balanced, that is, the leaves of the tree are at comparable depths.

B-tree Implementations

B-tree implementations are normally commercial. Languages don't typically provide direct B-tree support. To find B-tree implementations, search Google for B-tree software.

Binary Search Tree Implementations

Some languages do provide support for Binary Search Trees. In Java, see the TreeMap class, which implements a variant of the Binary Search Tree, the Red-Black Tree.

Binary Tree Data Structure Comparison

Both structures operate in the average in O(log n) time. Note that in the worst case, B-tree, at O(log n), is faster than Binary Search Tree at O(n).

P Versus NP Complexity Theory

/

The P Versus NP issue deals with whether every problem whose solution can be quickly verified by a computer can also be quickly solved by a computer. This is a major unsolved problem in computer science.

In common, practical terms, it deals with how to identify problems that are either extremely difficult or impossible to solve.  In order of difficulty from easy to hard, problems are classified as P, NP, NP-Complete and NP-Hard.

So why do we care? When approaching complex problems, it's useful to have at least some idea of whether the problem is precisely solvable, or if an approximation is the best that can be accomplished. 

Big O Notation

/

Big O notation is a way to characterize the time or resources needed to solve a computing problem.  It's particularly useful in comparing various computing algorithms under consideration. Below is a table summarizing Big O functions. The four most commonly referenced and important to remember are:

  • O(1)              Constant access time such as the use of a hash table.
  • O(log n)        Logarithmic access time such as a binary search of a sorted table.
  • O(n)              Linear access time such as the search of an unsorted list.
  • O(n log(n))   Multiple of log(n) access time such as using Quicksort or Mergesort.

Sorting Algorithms

/

Before delving into the large variety of sorting algorithms, it's important to understand that there are simple ways to perform sorts in most programming languages. For example, in Java, the Collections class contains a sort method that can be implemented as simply as:

Collections.sort(list);

where list is an object such as an ArrayList. Some aspects of the Java sort() method to note are:

  • You can also use the Java Comparator class methods to implement your own list item comparison functions for specialized sorting order needs.
  • The Java Collections class (plural) is different than the Collection class (singular).
  • Which sorting algorithm (see below) is used in the Collections.sort() implementation depends on the implementation approach chosen by the Java language developers. You can find implementation notes for Java Collections.sort() here. It currently uses a modified merge sort that performs in the range of Big O O(n log(n)).

If you don't want to use a built-in sort function and you're going to implement your own sort function, there's a large list of sorting algorithms to choose from.  Factors to consider in choosing a sort algorithm include:

  • Speed of the algorithm for the best, average and worst sort times. Most algorithms have sort times characterized by Big O functions of O(n), O(n log(n)) or O(n^2).
  • The relative importance of the best, average and worst sort times for the sort application.
  • Memory required to perform the sort.
  • Type of data to be sorted (e.g., numbers, strings, documents).
  • The size of the data set to be sorted.
  • The need for sort stability (preserving the original order of duplicate items).
  • Distribution and uniformity of values to be sorted.
  • Complexity of the sort algorithm.

For a comparison of sorting algorithms based on these and other values see: https://en.wikipedia.org/wiki/Sorting_algorithm#Comparison_of_algorithms.

Here's a quick reference for the major algorithms:

  • Exchange Sorts: based on swapping items
    • Bubble sort: for each pair of indices, swap the items if out of order, loop for items and list.
    • Cocktail sort: variation of bubble sort, passes alternately from top to bottom and bottom to top.
    • Comb sort: variation of bubble sort, selective swap of values
    • Gnome sort: also called the stupd sort, moves values back to just above a value less than it
    • Odd-even sort: developed originally for use with parallel processors, examines odd-even pairs and orders them, alternates pairs until list is ordered
    • Quicksort: divide list into two, with all items on the first list coming before all items on the second list.; then sort the two lists. Repeat. Often the method of choice. One of the fastest sort algorithms
  • Hybrid Sorts: mixture of sort techniques
    • Flashsort: Used on data sets with a known distribution, estimates used for where an element should be placed
    • Introsort: begin with quicksort and switch to heapsort when the recursion depth exceeds a certain level
    • Timsort: adaptative algorithm derived from merge sort and insertion sort. 
  • Insertion sorts: builds the final sorted array one item at a time
    • Insertion sort: determine where the current item belongs in the list of sorted ones, and insert it there
    • Library sort: like library shelves, space is created for new entries within groups such as first letters, space is removed at end of sort
    • Patience sorting: based on the solitaire card game, uses piles of "cards"
    • Shell sort: an attempt to improve insertion sort
    • Tree sort (binary tree sort): build binary tree, then traverse it to create sorted list
    • Cycle sort: in-place with theoretically optimal number of writes
  • Merge sorts: takes advantage of the ease of merging already sorted lists into a new sorted list
    • Merge sort: sort the first and second half of the list separately, then merge the sorted lists
    • Strand sort: repeatedly pulls sorted sublists out of the list to be sorted and merges them with the result array
  • Non-comparison sorts
    • Bead sort: can only be used on positive integers, performed using mechanics like beads on an abacus
    • Bucket sort: works by partitioning an array into a number of buckets, each bucket is then sorted individually using the best technique, the buckets are then merged
    • Burstsort: used for sorting strings, employs growable arrays
    • Counting sort: sorts a collection of objects according to keys that are small integers
    • Pigeonhole sort: suitable for sorting lists of elements where the number of elements and number of possible key values are approximately the same, uses auxiliary arrays for grouping values
    • Postman sort: variant of Bucket sort which takes advantage of hierarchical structure
    • Radix sort: sorts strings letter by letter
  • Selection sorts: in place comparison sorts
    • Heapsort: convert the list into a heap, keep removing the largest element from the heap and adding it to the end of the list
    • Selection sort: pick the smallest of the remaining elements, add it to the end of the sorted list
    • Smoothsort
  • Other
  • Unknown class

 

SQL Database Join Operations

/

It can be challenging to remember the details of all the SQL Join operations.  A convenient way to do this is to use Venn diagrams shown below. For examples of SQL Joins, go here. 

Commonly used SQL Join operations are:

  • inner join: requires each record in the two joined tables to have matching records.
  • outer join: does not require each record in the two joined tables to have a matching record.

Object Oriented Programming Data Structure Decisions

/

When it comes to organizing data in an Object Oriented Program, there are lots of choices and decisions to make. It can at times be difficult to think through all the criteria for selecting and implementing the right data structure.

The decision table below can help work through the data design process.