Data Structures go with Algorithms
  
  Usually the problem is that there is a brute force way to solve a
  problem but the solution does not scale up.  DS and their algs are
  invented to allow more efficient computer solutions.
  
  Thus in  algorithm analysis (287 I think) and in DS we care about
  time and space requirements for programs.
  
  Example of linear vs. n*2 time performance.
  
  --
  
  Data Models --abstractions used to describe programs: like lists,
  logic, graphs, C++:  Need values objects can take (and the operations
  on the objects. Static part represents information, Dynamic part the
  operations you can do.
   These abstractions can be implemented in various ways
  by different data structures (lists as arrays or as structs and ptrs).
  
  Abstract Data Types (ADT), or Classes, or Modules: e.g. Dictionary,
  Queue, Set.  a Collection of
  operations that can be performed on a data type, its interface.
  in C++, the data and methods of the class.
  ADT can have more than one abstract
  data model (e.g. dictionary ADT can  be list,  tree, or hash table).
  And in turn each 
  
  Data Structures-- ways to implement data models in a computer language
  that are not directly provided by that  language.  E.g. common lisp
  provides hash tables, perl provides associative tables, etc.
  
  Algorithms -- precise spec. of a  sequence of steps.
  
  --
  Tools:
  
  iteration,
  
  
  #include
  
  class Cell {
    int element;
    Cell * next;
   
  public:
    Cell() {element = 0; next = NULL;} //construct
    ~Cell();                           //destruct
    setNext( Cell *list) {next = list;}
    setElement( int val) {element = val;}
    Cell * getNext() {return next;}
    int getElement() {return element;}
  };
  
  main()
    {
  Cell *cl, *ctemp, *ccursor;
  
  cl = new Cell();
  cl->setElement(1);
  ccursor = cl;
  
  ctemp = new Cell();
  ctemp->setElement(2);
  ccursor->setNext(ctemp);
  ccursor=ctemp;
  
  ctemp = new Cell();
  ctemp->setElement(3);
  ccursor->setNext(ctemp);
  ccursor=ctemp;
  
  while (cl != NULL)
    {
      cout << cl->getElement() << "  ";
              cl = cl->getNext();
    }
    }
  
  
  recursion,
  
  #include
  
  class Cell {
    int element;
    Cell * next;
   
  public:
    Cell() {element = 0; next = NULL;} //construct
    ~Cell();                           //destruct
    setNext( Cell *list) {next = list;}
    setElement( int val) {element = val;}
    Cell * getNext() {return next;}
    int getElement() {return element;}
    PrtList1();
    PrtList2();
  };
  
  Cell::PrtList1() {
   if(next != NULL)
     next->PrtList1();
      cout << element << "  ";
  }    
  
  
  Cell::PrtList2() {
  
   if(this != NULL)
      { cout << element << "  ";
      next->PrtList2();}
  }    
  
  
  main()
    {
  Cell *cl, *ctemp, *ccursor;
  
  cl = new Cell();
  cl->setElement(1);
  ccursor = cl;
  
  ctemp = new Cell();
  ctemp->setElement(2);
  ccursor->setNext(ctemp);
  ccursor=ctemp;
  
  ctemp = new Cell();
  ctemp->setElement(3);
  ccursor->setNext(ctemp);
  ccursor=ctemp;
  
  cl ->PrtList1();
  cl ->PrtList2();
    }
  
  
  
  
  
  
  Big-Oh analysis,
  induction,  
  combinatorics,
  recurrences,
  probability