ishikawa

#include <iostream>
#include <sstream>
#include <v8.h>

using namespace v8;

int main(int argc, const char **argv) {
  // Create a scope and environment
  HandleScope scope;
  Handle<Context> context = Context::New();

ishikawa

# Programming Pearls: column 14

class Heaps(object):
    """
    >>> h = Heaps()
    >>> len(h)
    0
    >>> h.extend([12, 20, 15, 3, 13, 23])
    >>> len(h)
    6

ishikawa

import java.util.NoSuchElementException;

/**
 * A binary heap is a heap data structure create using a binary tree.
 * 
 * @author Takanori Ishikawa <takanori.ishikawa@gmail.com>
 */
public class BinaryHeap<E extends Comparable<E>> {
	
	private E[] items;

ishikawa

/**
 * Heapsort (method) is a comparison-based sorting algorithm,
 * and is part of the selection sort family. Although somewhat
 * slower in practice on most machines than a good implementation of
 * quicksort, it has the advantage of a worst-case Θ(n log n) runtime.
 * Heapsort is an in-place algorithm, but is not a stable sort.
 * 
 * @author ishikawa
 *

ishikawa

package org.metareal;
import java.util.NoSuchElementException;


public class LinkedList <E> {

	private final Node<E> head;
	private Node<E> tail;

	public LinkedList() {

ishikawa

/**
 * http://en.wikipedia.org/wiki/Queue_(data_structure)
 */
public class Queue <E> {
	private LinkedList<E> elements = new LinkedList<E>();

	public int size() { return elements.size(); }
	public boolean isEmpty() { return elements.isEmpty(); }
	public E front() { return elements.get(0); }
	public E pop() { return elements.removeFirst(); }

ishikawa

/**
 * http://en.wikipedia.org/wiki/Stack_(data_structure)
 */
public class Stack <E> {
	private LinkedList<E> elements = new LinkedList<E>();

	public int size() { return elements.size(); }
	public boolean isEmpty() { return elements.isEmpty(); }
	public E top() { return elements.get(0); }
	public E pop() { return elements.removeFirst(); }

ishikawa

package org.metareal.graph;

import org.metareal.LinkedList;
import org.metareal.Queue;
import org.metareal.Stack;

public class GraphSearchAlgorithm {
	
	private final LinkedList<Integer>[] vertices;
	

ishikawa

/*
 * Programming Pearls 2nd Edition
 * Column 5: Binary Search
 */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <assert.h>

ishikawa

def compile_python_source(filepath, optimization=False):
    """
    Compile a source file to byte-code and write out
    the byte-code cache file. The source code is loaded
    from the file name *filepath*. The byte-code is cached
    in the normal manner (*filepath* + 'c' or 'o' if
    optimization is enabled).
    """
    from os import spawnv
    from sys import executable, platform