Analysis of quick sort

Document Sample
Analysis of quick sort Powered By Docstoc
					Major Track   Focus              Courses           Contents                                                                                        Chapters   Instroctor
              Fundamental        Skills 2          Control Structures                                                                                         Sunday
              Programming                          selection statements, loop statements, which loop to use, the keywords break and continue
                                                   Concepts, creating a method, calling a method, passing parameters to methods, overloading
                                                   methods, the scope of local variables, method abstraction, the Math class, recursion.
              Basic Algorithms   Skills 2, Prog1    copying arrays, passing arrays to methods, returning arrays from methods, sorting arrays,
              and problem                          searching arrays, two-dimensional arrays
              OOP                                  defining classes for objects, constructors, accessing objects, using classes from the Java                 2
                                                   library, visibility modifiers, accessors, and mutators, data field encapsulation immutable
                                                   objects and classes, passing objects to methods, static variables, constants and methods, the
                                                   scope of variables, the this key word, array of objects, class abstraction and encapsulation,
                                                   inner classes
                                                   Introduction, the String class, the Character class, the Stringbuffer class, the                           2
                                                   StringTokenizer class, the Scanner class
              Fundamental        Prog1, DS         Introduction, superclass and subclass, using the key word super, overriding methods, the                   3
              Data Structures                      Object class, polymorphism, dynamic binding, and generic programming, casting objects
                                                   and the instanceof operator, the protected data type, the final classes, methods and

                                                   abstract class, interfaces                                                                                 2
              Event Driven                         Keyboard and mouse events, graphics and Validating user Input                                              1
              Recursion          Prog1, DS         Introduction to Recursion, Principle of designing successful Recursion, Examples:
                                                   Factorial function, Countdown
                                                   Iteration versus Recursion:
                                                   As simple Solution to a difficult Problem: Tower of Hanoi

                                 Prog1, Internet
                 Programming      Prog. languages   Programming Language Evaluation Criteria                                                   PLD
                 Languages                                                                                                                     Haddad
                 Programming                        Programming Methodologies, Implementation Methods, Compilation, interpretation,
                 Languages                          Language Design Trade-Offs
                 Design                             Syntax, Semantics, Variables, Data Types

                 Programming      Prog. languages   Programming Languages Paradigms: Imperative, Functional, Declarative, OOP,                 PLD
                 Languages                          Mark-up languages                                                                          Haddad
                 Implementation   Prog. languages
Algorithms and   Basic            DS, Algorithm     Measuring an Algorithm efficiency: Big Oh Notation
Complexity       Computability    Analysis          The Efficiency of the implementations of the ADT List
19%              and complexity                     Comparing the implementations
                                                    Specifications of the ADT Stack,
                                                    Using Stack to process Algebraic Expressions, Stack as balance checkers and applications
                                                    Array based implementation,
                                                    Vector based implementation
                                                    Linked based implementation for ADT LIST
                                                    Specification of ADT Queue
                                                    Specification ADT Dequeue,
                                                    Specification ADT Priority Queue
                                                    Linked Implementation of a Queue:
                                                    Circular Linked Implementation of a Queue

                 Algorithms       DS, Algorithm     Introduction to Sequential Search: An iterative Sequential Search of an Unsorted List ,
                 Search           Analysis          Binary Search of a sorted LIST
                 Algorithms                         Selection sort, Analysis                                                                   Haddad
                 Sorting                            Introductions to Insertion Sort, Analysis
                                                    Quick sort
                               Analysis of quick sort
                               Improvements on quick sort.
                               Merge sort                                                    Bnna
                               Analysis of Merge sort
                               Heap sort
                               Shell and radix sorting.

Hashing                        Hashing as a Dictionary implementation,                       Haddad
                               Collision, techniques for Resolving Collision
Algorithms   DS, Algorithm     Introduction to selection problem                             Banna
             Analysis          Finding the max and min
                               Finding the second largest key
                               Implementation of the tournament method
                               The selection problem
                               Lower bounds for finding the median

Trees        Data Structures   Trees Terminology: Binary trees, Operations on binary trees   Haddad
                               Tree Traversals of a Tree: Pre-Order, In-Order, Post-Order
                               Trees implementation, Binary Search trees

                               Tress implementation, Introduction to AVL trees
Graphs       Data Structures   Introduction to Graphs                                        Haddad

                               Prim's minimum spanning tree                                  Banna
                               Single Source (Dijkstra)shortest path algorithm.
                               Kruskal's minimum spanning tree algorithm.

                               The Knuth-Morris-Prat algorithm                               Banna
                               Construction of the Knuth-Morris-Prat flowchart.
                               The Boyer-Moore algorithm
                               P and Np
                               The class P and NP
                                    NP complete problems.

LOGIC and          Discrete         Propositional Calculus
Proofs                              Predicate Calculus
                                    Boolean Algebra

Functions,         Discrete Math    Sets
Relations, and                      Functions
Sets                                Number Theory
                                    Sequences and Summations

                   DS               Recursion
                   Algorithms       Recurrence

Graphs and Trees   Discrete Math,   Graphs
                   DS, Algorithms   Introduction to Graphs
                                    Graph Terminology
                                    Representing Graphs and Graph Isomorphism
                                    Euler and Hamilton Paths
                                    Shortest Path Problems
                 Proof techniques                    Direct Proof, Proof by Cases, Proof by Contradiction
                                                     Pigeonhole Principle, Proof by Minimum Counterexample
                 Automata            Computation      Regular Languages (RLs), representation of infinite RLs in finite form by Regular
                 Theorem             Theory          Expression (RE), generating RLs by REs, recognition of RLs by Finite Automata (FA);
                                                     Deterministic FA (DFA) and non-deterministic FA (NDFA) will be presented,; Converting
                                                     the NDFA to its equivalent DFA; Pumping theorem to check if a language is a RL;
                                                     Context-Free-Languages (CFLs), generating CFLs by Context-Free-Grammar (CFG),
                                                     converting CFG to Chomsky Normal Form (CNF), Top-Down and Bottom-Up parsing,
                                                     ambiguity, recognition of CFLs by Pushdown Automata (PDA); Extended pumping
                                                     theorem to check if a language is a CFL; Context-Sensitive-Languages (CSLs), generating
                                                     CSLs by Context Sensitive Grammar (CSG), recognition of CSLs by Turing
                                                     Machine(TM), Halting problem.

Discrete                             Discrete Math
Structures 18%
                 Basic Logic         Discrete Math
                                     Discrete Math

                 Discrete            Discrete Math
Systems 20%
Architecture     Digital Logic and   Logic Design
                 digital systems
                 Machine level       Assembly,
                 representation of   Architecture
                 Assembly level      Assembly,
                 machine             Architecture
                 Interfacing and     Assembly,
                 communications      Architecture
OS               Principles of OS    OS
                 Concurrency         OS
                Scheduling and    Assembly,
                dispatch          Architecture
                Memory            Assembly,
                management        Architecture
Networking                        Networks
Software Eng.   Requirements,     Systems
6%              specifications,   Analysis
                design,           Software
                validation,       Engineering
Information     Database          MIS
Management      Systems           DB1
                Data Modeling     DB1, DB2
Other 5.5%      HCI               HCI

                AI                AI

                Graphics          Computer
                                  Graphics, Multi-
                Social and        Ethics
                Web Computing     Internet
                                  Programming, e-

Shared By: