الگوریتم ایجاد هزارتو
شبه کد جاوا

class MazeBuilder implements Runnable {
    public static final int CW_TOP = 1;
    public static final int CW_BOT = 2;
    public static final int CW_LEFT = 4;
    public static final int CW_RIGHT = 8;
    static final int CW_VIRGIN = 16;
    public static final int CW_ALL = CW_TOP|CW_BOT|CW_LEFT|CW_RIGHT;
    static final int CW_BOUND_SHIFT = 5;
    static final int CW_TOP_BOUND = 32;
    static final int CW_BOT_BOUND = 64;
    static final int CW_LEFT_BOUND = 128;
    static final int CW_RIGHT_BOUND = 256;
    static final int CW_ALL_BOUNDS =
	CW_TOP_BOUND|CW_BOT_BOUND|CW_LEFT_BOUND|CW_RIGHT_BOUND;
    static final int CW_IN_ROOM = 512;
    
    public static int dirsx[] = { 1, 0, -1, 0 };
    public static int dirsy[] = { 0, 1, 0, -1 };
    int width, height, startx, starty;
    int cells[][], origdirs[][], dists[][];
    
    boolean can_go(int x, int y, int dx, int dy) {
	int bit = get_bit(dx, dy) << CW_BOUND_SHIFT;
	if ((cells[x][y] & bit) != 0)
	    return false;
	return (cells[x+dx][y+dy] & CW_VIRGIN) != 0;
    }
    
    int get_bit(int dx, int dy) {
	int bit = 0;
	switch (dx + dy * 2) {
	case 1:  bit = CW_RIGHT; break;
	case -1: bit = CW_LEFT;  break;
	case 2:  bit = CW_BOT;   break;
	case -2: bit = CW_TOP;   break;
	default: dbg("get_bit problem "+dx+" "+dy); break;
	}
	return bit;
    }

    Random random;
    Maze maze;
    
    int randno(int lo, int hi) {
	return (Math.abs(random.nextInt()) % (hi-lo+1)) + lo;
    }

    void delwall(int x, int y, int dx, int dy) {
	int bit;
	bit = get_bit(dx, dy);
	cells[x][y] &= ~bit;
	bit = get_bit(-dx, -dy);
	cells[x+dx][y+dy] &= ~bit;
    }

    void delbound(int x, int y, int dx, int dy) {
	int bit;
	bit = get_bit(dx, dy);
	cells[x][y] &= ~(bit << CW_BOUND_SHIFT);
	bit = get_bit(-dx, -dy);
	cells[x+dx][y+dy] &= ~(bit << CW_BOUND_SHIFT);
    }

    void addboundwall(int x, int y, int dx, int dy) {
	int bit = get_bit(dx, dy);
	cells[x][y] |= bit | (bit<<CW_BOUND_SHIFT);
	int bit2 = get_bit(-dx, -dy);
	cells[x+dx][y+dy] |= bit2 | (bit2<<CW_BOUND_SHIFT);
    }

    int partiters = 0;
    
    int grade_partition(Vector sl, Seg pe) {
	int x  = pe.x;
	int y  = pe.y;
	int dx = pe.dx;
	int dy = pe.dy;
	int lcount = 0, rcount = 0, splits = 0;
	int inc = 1;
	if (sl.size() >= 100)
	    inc = sl.size() / 50;
	for (int i = 0; i < sl.size(); i += inc) {
	    Seg se = (Seg) sl.elementAt(i);
	    int df1x = se.x-x;
	    int df1y = se.y-y;
	    int sendx = se.x + se.dx;
	    int sendy = se.y + se.dy;
	    int df2x = sendx - x;
	    int df2y = sendy - y;
	    int nx = dy;
	    int ny = -dx;
	    int dot1 = df1x * nx + df1y * ny;
	    int dot2 = df2x * nx + df2y * ny;
	    if (getSign(dot1) != getSign(dot2)) {
		if (dot1 == 0)
		    dot1 = dot2;
		else if (dot2 != 0) {
		    splits++;
		    continue;
		}
	    }
	    if (dot1 > 0 ||
		       (dot1 == 0 && se.GetDir() ==  pe.GetDir())) {
		rcount++;
	    } else if (dot1 < 0 ||
		       (dot1 == 0 && se.GetDir() == -pe.GetDir())) {
		lcount++;
	    } else {
		dbg("grade_partition problem: dot1 = "+dot1+", dot2 = "+dot2);
	    }
	}
	return Math.abs(lcount-rcount) + splits * 3;
    }
    
    Vector seglist;
    static int getSign(int num) {
	return (num < 0) ? -1 : (num > 0) ? 1 : 0;
    }
    void Initialize() {
	int x, y;

	for (x = 0; x != width; x++) {
	    for (y = 0; y != height; y++) {
		cells[x][y] = CW_VIRGIN | CW_ALL;
	    }
	    cells[x][0] |= CW_TOP_BOUND;
	    cells[x][height-1] |= CW_BOT_BOUND;
	} 
	for (y = 0; y != height; y++) {
	    cells[0][y] |= CW_LEFT_BOUND;
	    cells[width-1][y] |= CW_RIGHT_BOUND;
	}
    }
    
    void Generate() {
	int x, y;

	y = 0;
	int firstx = x = randno(0, width-1);
	int dir = 0;
	int origdir = dir;
	cells[x][y] &= ~CW_VIRGIN;
	while (true) { 
	    int dx = dirsx[dir], dy = dirsy[dir];
	    if (!can_go(x, y, dx, dy)) { 
		dir = (dir+1) & 3;
		if (origdir == dir) {
		    if (x == firstx && y == 0)
			break;
		    int odr = origdirs[x][y];
		    dx = dirsx[odr];
		    dy = dirsy[odr];
		    x -= dx;
		    y -= dy;
		    origdir = dir = randno(0, 3);
		}
	    } else {
		delwall(x, y, dx, dy);
		x += dx;
		y += dy;
		cells[x][y] &= ~CW_VIRGIN;
		origdirs[x][y] = dir;
		origdir = dir = randno(0, 3);
	    }
	}
یک پویا نمایی از ساخت یک هزارتو ۳۰ * ۲۰ با استفاده جستجوی عمق-اول.
یک پویا نمایی از ساخت یک هزارتوهای ۲۰* ۳۰ با استفاده از الگوریتم پریم.
یک نسخه سه بعدی از الگوریتم پریم. لایه‌های عمودی با شماره‌های ۱ تا ۴ از پایین به بالا برچسب‌گذاری شده‌اند. پله‌های رو به بالا با نماد "/" و پله‌های رو به پایین با نماد "\" و پله‌های دو طرفه با نماد "x" نشان داده شده‌اند. کد منبع نیز در کنار این توضیحات آورده شده‌است.