Free generalized search tree software for linux

Archive Search is an extension which displays an archived versions of the webpage.

Displays an archived versions of the webpage.

First click: Internet Archive
Second click: Google cache
Third click: Yahoo
Fourth click: MSN

Fluent CFD Search is an extension providing a classic first Fluent CFD Software Search toolbar.

Fluent is leading software company in CFD. It also include search on Airpak and Icepak which are other two products from Fluent.

GGTL is a library designed to make it easier to program games in C. Generic Game-Tree Library provides an AI that is able to play most 2 player strategic games.
Nim, Tic-Tac-Toe, Reversi (aka Othello), Connect-4 and Chess are all examples of games that can all be implemented using GGTL.
GGTL comes with game-specific extensions that enables it to play Nim and Reversi almost out of the box. Please see the documentation for details.
Enhancements:
- "clock()" is used as a fallback for sub-second timing if "gettimeofday()" is not found.
- An internal typedef was dropped, and a header declaration for a function that didnt exist was removed.
- Some build system refactoring was done.

WebService::GoogleHack::Search is a Perl module used to query Google.

SYNOPSIS

use WebService::GoogleHack::Search;

#create an object of type search
my $search = GoogleHack::Search->new();

#Query Google.
$search->searchPhrase($searchString);

#The results variable will now contain the results of your query.

#Printing the searchtime

print "n Search Time".$search->{searchTime};

#Printing the snippet element 0

print "nnSnippet".$search->{snippet}->[0];

This module provides a simple interface to the Google API. It is used by the GoogleHack module.

pro-search is a crawler for FTP servers, SMB shares, HTTP servers, and DC++ networks.

Generic Data Structures Library (GDSL) is a collection of routines for generic data structures manipulation.
Generic Data Structures Library is a portable and re-entrant library fully written from scratch in pure ANSI C. It is designed to offer for C programmers common data structures with powerful algorithms, and hidden implementation.
Available structures are lists, queues, stacks, hash tables, binary trees, binary search trees, red-black trees, 2D arrays, and permutations.
GDSL provides a modern Applications Programming Interface (API) for C programmers, while allowing wrappers to be written for very high level languages.
The library covers the following data structures:
- Low-level doubly-linked nodes
- Low-level doubly-linked low-level lists
- Low level binary trees
- Low level binary search trees
- Binary search trees
- Red-black trees
- 2D arrays
- Hash tables
- Lists
- Queues
- Stacks
- Permutations
Enhancements:
- A bug that was introduced in gdsl_hash_insert in the previous release was fixed.
- A missing include in gdsl.h was fixed.

Tree::Binary::Search is a binary search tree for Perl.

SYNOPSIS

use Tree::Binary::Search;

my $btree = Tree::Binary::Search->new();

$btree->useNumericComparison();

$btree->insert(5 => "Five");
$btree->insert(2 => "Two");
$btree->insert(1 => "One");
$btree->insert(3 => "Three");
$btree->insert(4 => "Four");
$btree->insert(9 => "Nine");
$btree->insert(8 => "Eight");
$btree->insert(6 => "Six");
$btree->insert(7 => "Seven");

# this creates the following tree:
#
# +-------(5)----------+
# | |
# +-(2)-+ +-(9)
# | | |
# (1) (3)-+ +----(8)
# | |
# (4) (6)-+
# |
# (7)
#

$btree->exists(7); # return true

$btree->update(7 => "Seven (updated)");

$btree->select(9); # return Nine

$btree->min_key(); # returns 1

$btree->min(); # returns One

$btree->max_key(); # return 9

$btree->max(); # return Nine

$btree->delete(5);

# this results in the following tree:
#
# +-------(6)-------+
# | |
# +-(2)-+ +-(9)
# | | |
# (1) (3)-+ +-(8)
# | |
# (4) (7)
#

This module implements a binary search tree, which is a specialized usage of a binary tree. The basic principle is that all elements to the left are less than the root, all elements to the right are greater than the root. This reduces the search time for elements in the tree, by halving the number of nodes that need to be searched each time a node is examined.

Binary search trees are a very well understood data-structure and there is a wealth of information on the web about them.

Trees are a naturally recursive data-structure, and therefore, tend to lend themselves well to recursive traversal functions. I however, have chosen to implement the tree traversal in this module without using recursive subroutines. This is partially a performance descision, even though perl can handle theoreticaly unlimited recursion, subroutine calls to have some overhead. My algorithm is still recursive, I have just chosen to keep it within a single subroutine.