Input : A set S of planar points
Output : A convex hull for S
Step 1: If S contains no more than five points, use exhaustive searching to find the convex hull and return.
Step 2: Find a median line perpendicular to the X-axis which divides S into SL and SR SL lies to the left of SR .
Step 3: Recursively construct convex hulls for SL and SR. Denote these convex hulls by Hull(SL) and Hull(SR) respectively.
Step 4: Apply the merging procedure to merge Hull(SL) and Hull(SR) together to form a convex hull.
Time Complexity:
T(n) = 2T(n/2) + O(n)
= O(n log n)
This is an implementation of double-array structure for representing trie,
as proposed by Junichi Aoe [1].
Trie is a kind of digital search tree, an efficient indexing method with
O(1) time Complexity for searching. Comparably as efficient as hashing,
trie also provides flexibility on incremental matching and key spelling
manipulation. This makes it ideal for lexical analyzers, as well as spelling
dictionaries.
See the details of the implementation at [2]:
http://linux.thai.net/~thep/datrie/datrie.html
Historically, this was first implemented as C++ classes in a library called
midatrie [2], but later simplified and rewritten from scratch in C.
A combined space鈥搕ime block coding (STBC) and eigen-space tracking
(EST) scheme in multiple-input-multiple-output systems is
proposed. It is proved that the STBC-EST is capable of shifting
hardware Complexity from the receiver to the transmitter without
any bit error rate (BER) performance loss. A computation efficient
EST algorithm is also proposed, which makes the STBC-EST affordable.
Simulation results show that the STBC-EST with a modest
feedback requirement results in a negligible BER performance loss
compared with a dual system configuration.
An interactive water fountain.
A realistic water source in your pocket with full control.
Controls:
UP/DOWN - go closer/further
LEFT/RIGHT - rotate
# - stop rotation
1/7 - rotate camera up/down
3/9 - change water pressure
4/6 - change water rendering Complexity
2/8 - ascend/descend
0 - bullet time
5 - 25 FPS limiter on/off
* - HUD on/off
Heapsort
1.A heap is a binary tree satisfying the followingconditions:
-This tree is completely balanced.
-If the height of this binary tree is h, then leaves can be at level h or level h-1.
-All leaves at level h are as far to the left as possible.
-The data associated with all descendants of a node are smaller than the datum associated with this node.
Implementation
1.using a linear array not a binary tree.
-The sons of A(h) are A(2h) and A(2h+1).
2.time Complexity: O(n log n)
In the last decade the processing of polygonal meshes has
emerged as an active and very productive research area. This
can basically be attributed to two developments:
Modern geometry acquisition devices, like laser scanners
and MRT, easily produce raw polygonal meshes of
ever growing Complexity
Downstream applications like analysis tools (medical
imaging), computer aided manufacturing, or numerical
simulations all require high quality polygonal meshes
as input.
The need to bridge the gap between raw triangle soup data
and high-quality polygon meshes has driven the research on
ecient data structures and algorithms that directly operate
on polygonal meshes rather than on a (most often not
feasible) intermediate CAD representation.
Abstract—In this paper, we propose transform-domain algorithms to
effectively classify the characteristics of blocks and estimate the strength
of the blocky effect. The transform-domain algorithms require much
lower computational Complexity and much less memory than the spatial
ones. Along with the estimated blocky strength,
Exploring C++ uses a series of self–directed lessons to divide C++ into bite–sized chunks that you can digest as rapidly as you can swallow them. The book assumes only a basic understanding of fundamental programming concepts (variables, functions, expressions, statements) and requires no prior knowledge of C or any other particular language. It reduces the usually considerable Complexity of C++.
The included lessons allow you to learn by doing, as a participant of an interactive education session. You’ll master each step in a one sitting before you proceed to the next. Author Ray Lischner has designed questions to promote learning new material. And by responding to questions throughout the text, youll be engaged every step of the way.
If you are a C++ programmer who desires a fuller understanding of what is going on "under the hood," then Inside the C++ Object Model is for you!
Inside the C++ Object Model focuses on the underlying mechanisms that support object-oriented programming within C++: constructor semantics, temporary generation, support for encapsulation, inheritance, and "the virtuals"-virtual functions and virtual inheritance. This book shows how your understanding the underlying implementation models can help you code more efficiently and with greater confidence. Lippman dispells the misinformation and myths about the overhead and Complexity associated with C++, while pointing out areas in which costs and trade offs, sometimes hidden, do exist. He then explains how the various implementation models arose, points out areas in which they are likely to evolve, and why they are what they are. He covers the semantic implications of the C++ object model and how that model affects your programs.
