IBCS2 - November - Revision history

Admin: Blanked the page

2010-09-03T20:27:21Z

Blanked the page

Show changes

Admin at 17:09, 6 May 2010

2010-05-06T17:09:44Z

Admin: Removing all content from page

2009-10-21T15:42:32Z

Removing all content from page

Admin at 15:10, 31 August 2009

2009-08-31T15:10:27Z

Admin: Protected "IBCS2 - November" [edit=sysop:move=sysop]

2009-03-05T03:12:09Z

Protected "IBCS2 - November" [edit=sysop:move=sysop]

Admin: New page: == Tuesday (11/25/08) == * Holiday Assembly == Monday (11/24/08) == '''Warmup:''' * Which of the trees is invalid? Why? * Identify the root node in the binary tree on the board * Identif...

2008-11-26T18:28:52Z

New page: == Tuesday (11/25/08) == * Holiday Assembly == Monday (11/24/08) == '''Warmup:''' * Which of the trees is invalid? Why? * Identify the root node in the binary tree on the board * Identif...

New page

== Tuesday (11/25/08) ==
* Holiday Assembly

== Monday (11/24/08) ==
'''Warmup:'''
* Which of the trees is invalid? Why?
* Identify the root node in the binary tree on the board
* Identify all the parents and their children in the binary tree on the board
* Identify all the leaves in the binary tree on the board

'''Agenda:'''
* Introduction to Binary Trees
** [[Media:BinaryTrees.ppt]]
* BTNode class - the node class for a binary tree of numbers
** What attributes should we have in our BTNode?
** What methods should we have in our BTNode?
* BinaryTree class
* Introduction to Recursion
** [[Media:Recursion.ppt]]

== Friday (11/21/08) ==
* Implement BubbleSort in your CLinkedList
** NOTE: The inner loop of BubbleSort should traverse the list from head down to tail
* Print out your CLinkedList search(find) and sorting (selectionSort() and bubbleSort() methods
* Introduction to Binary Trees
** [[Media:BinaryTrees.ppt]]

== Monday - Thursday (11/17/08 - 11/20/08) ==
'''Warmup:'''
* Create a new Java file named AddressBookMainWarmup with a main method
* In the main method, do the following:
*# Create a '''new''' instance of AddressBook named myBook
*# Using a for loop, create '''new''' Contacts named a0, a1, a2, ... , a99, and add them to your AddressBook
*# Remove the Contact at index 99
*# Remove the Contact at index 0
*# Using a for loop, remove the Contacts from indexes 5 through 20
*# Print out all the contacts in your AddressBook using the AddressBook print()

'''Agenda:'''
* Demo your AddressBook that uses a CLinkedList
* LinkedList Search - Implement inside CLinkedList as: Contact find(String firstName, String lastName)
** Traverses the LinkedList and checks if the Contact at the current ContactNode matches the same first name and last name that you are looking for
** If it finds your Contact, then return the Contact, otherwise, return null
* LinkedList SelectionSort - Implement inside CLinkedList as: void selectionSort()
** Uses the selection sort algorithm to sort the CLinkedList
** Traversing the CLinkedList uses the same algorithm as print() and find()
** You should be comparing the first and last names of the Contact
** When swapping data (minimum swapped with front), you should swap the Contact objects

== Friday (11/14/08) ==
* By the end of today, you should be able to demo an AddressBook that uses a LinkedList
* Be sure to comment out the find(), selectionSort(), and bubbleSort() methods in your AddressBook class

== Wednesday (11/12/08) ==
* Demo your LinkedList class
* Contact class review
* Create a new class from your Node class and called ContactNode
* Create a new class called ContactLinkedList
* Convert your LinkedList to use ContactNode and call it ContactLinkedList
* Be sure to test your ContactLinkedList
* AddressBook class review
* Convert your AddressBook to use ContactLinkedList instead of array
** Comment out the methods for find(), selectionSort(), and bubbleSort(). We will convert these later
** Be sure to test your AddressBook with LOTS of contacts

== Thursday - Friday (11/6/08 - 11/7/08) ==
* Show Mr. Bui your Queue before-and-after diagrams
* LinkedLists cont'd
** Attributes: head, tail, size
** Constructors: default
** Methods:
*** isEmpty() - returns true if the LinkedList is empty, and false otherwise
*** void add(int num) - adds a new Node with num at the end of the LinkedList
*** int remove(int index) - removes the index-th Node and returns its data
**** There are SIX different scenarios when you remove a Node
*** void add(int num, int index)
**** There are FIVE different scenarios when you add a Node
**** DRAW the before-and-after pictures for all FIVE secenarios
*** print() - traverses the LinkedList and prints out each Node's data
* [[Media:LinkedList.java]]
* LinkedListTestMain - create as a class

== Wednesday (11/5/08) ==
* Print out your DynamicQueue.java -- I will grade them by hand
* Introduction to LinkedLists
** Attributes: head, tail, size
** Constructors: default
** Methods:
*** isEmpty() - returns true if the LinkedList is empty, and false otherwise
*** void add(int num) - adds a new Node with num at the end of the LinkedList
*** int remove(int index) - removes the index-th Node and returns its data
**** There are FIVE different scenarios when you remove a Node
*** print() - traverses the LinkedList and prints out each Node's data
*'''Homework:''' Draw the before-and-after diagrams for the remove() method

== Monday (11/3/08) ==
'''Warmup:'''
* On a separate sheep of paper, please answer the following questions:
** In a dynamically-sized queue's isEmpty() method, what are the two different cases or scenarios that you check for?
** In a dynamically-sized queue's add() method, what are the two different cases or scenarios?
*** Draw the before and after picture of each of the two scenarios.
** In a dynamically-sized queue's remove() method, what are the two different cases or scenarios?
*** Draw the before and after picture of each of the two scenarios.

'''Agenda:'''
* Secret ballot - Have you installed and used Java or JCreator on your computer at home?
* Demo DynamicQueues
* Introduction to Linked Lists

== Archives ==
* [[IBCS2 - October]]
* [[IBCS2 - September]]

← Older revision	Revision as of 17:09, 6 May 2010
Line 1:	Line 1:
	+	== Tuesday (11/24/09) ==
	+	'''Agenda:'''
	+	* Dossier - Data Structures
	+	* [[Media:CriterionB1_dataStructures.doc]]
	+	* Demo your LinkedList AddressBook
	+	* Create 3 new classes called ContactBinaryTreeNode, ContactBinaryTree, and ContactBTTestMain
	+	** [[Media:BinaryTreeNode.java]]
	+	** [[Media:BinaryTree.java]]
	+	** [[Media:BinaryTreeTestMain.java]]
	+	* Convert the 3 given binary tree classes to use Contacts instead of ints
	+	* Create and demo a BinaryTreeAddressBook

	+	'''Homework:'''
	+	* Demo BinaryTreeAddressBook - due (Tuesday 12/1/09)
	+	* Dossier - Data Structures rough draft - due (Thursday 12/3/09)
	+
	+	== Friday (11/20/09) ==
	+	'''Agenda:'''
	+	* Demo your LinkedList AddressBook. It should be able to do the following:
	+	** add a Contact
	+	** print list of Contacts
	+	** find a Contact
	+	** sort list of Contacts
	+	* Re-Introduction to Binary Tree
	+	** [[Media:BinaryTreeNode.java]]
	+	** [[Media:BinaryTree.java]]
	+	** [[Media:BinaryTreeTestMain.java]]
	+	* Create 3 new classes called ContactBTNode, ContactBinaryTree, and ContactBTTestMain
	+	* Convert the 3 given binary tree classes to use Contacts instead of ints
	+
	+	== Wednesday (11/18/09) ==
	+	'''Warmup:'''
	+	* What is the algorithm for a linear search?
	+	* What is the algorithm for a selection sort?
	+	* What is the algorithm for a bubble sort?
	+
	+	'''Agenda:'''
	+	* int find(String fn, String ln) in the ContactLinkedList
	+	** Add the find() option to your AddressBookMain and AddressBook
	+	** find() in the AddressBook should use the ContactLinkedList's find() and then ContactLinkedList's getContact()
	+	* void selectionSort() in the ContactLinkedList
	+	* You should move the bubbleSort() into the ContactLinkedList and complete the method yourself
	+	* Removing a Contact
	+	** Add a remove option to your AddressBookMain
	+	** Create a remove(String fn, String ln) method in your AddressBook
	+	** In the method, use the ContactLinkedList's find() method to get the index of the Contact
	+	** Check if the index is valid (not the error code), and if so, then use the ContactLinkedList's remove() method using that index
	+	* Demo a completely working AddressBook
	+
	+	== Monday (11/16/09) ==
	+	'''Warmup:'''
	+	* Open your Contact class and review the code
	+
	+	'''Agenda:'''
	+	* Contact class review as a class
	+	* Create a new class from your Node class and called ContactNode
	+	** Do this as a class...quickly
	+	* Create a new class called ContactLinkedList
	+	** Do this as a class...quickly
	+	* Convert your LinkedList to use ContactNode and call it ContactLinkedList
	+	** Go through one or two examples as a class
	+	* Be sure to test your ContactLinkedList
	+	* AddressBook class review as a class
	+	* Convert your AddressBook to use ContactLinkedList instead of an array
	+	** Comment out the parts for find(), selectionSort(), and bubbleSort(). We will convert these later
	+	** Be sure to test your AddressBook with LOTS of contacts
	+
	+	'''Homework:'''
	+	* Complete the AddressBook conversion over to ContactLinkedList by Wednesday (11/18/09)
	+	* Be ready to demo your AddressBookMain
	+
	+	== Thursday (11/12/09) ==
	+	'''Agenda:'''
	+	* Abstract data types review
	+	* Introduction to Binary Tree
	+	** [[Media:BinaryTreeNode.java]]
	+	** [[Media:BinaryTree.java]]
	+	** [[Media:BinaryTreeTestMain.java]]
	+	* Demo your LinkedList
	+	* Contact class review
	+	* Create a new class from your Node class and called ContactNode
	+	* Create a new class called ContactLinkedList
	+	* Convert your LinkedList to use ContactNode and call it ContactLinkedList
	+	* Be sure to test your ContactLinkedList
	+	* AddressBook class review
	+	* Convert your AddressBook to use ContactLinkedList instead of array
	+	** Comment out the methods for find(), selectionSort(), and bubbleSort(). We will convert these later
	+	** Be sure to test your AddressBook with LOTS of contacts
	+
	+	== Monday (11/9/09) ==
	+	'''Agenda:'''
	+	* Turn in homework
	+	* Demo DynamicQueue
	+	* Introduction to Linked Lists
	+	** [[Media:LinkedList.java]]
	+	** Attributes: head, tail, size
	+	** Constructors: default
	+	** Methods:
	+	*** isEmpty() - returns true if the LinkedList is empty, and false otherwise
	+	*** void add(int num) - adds a new Node with num at the end of the LinkedList
	+	*** void add(int num, int index) - adds a new Node with num at the index specified
	+	**** There are FIVE different scenarios when you add a Node
	+	**** DRAW the before-and-after pictures for all FIVE secenarios
	+	*** int remove(int index) - removes the index-th Node and returns its data
	+	**** There are SIX different scenarios when you remove a Node
	+	*** print() - traverses the LinkedList and prints out each Node's data
	+	** Create a main method to test out all the methods and scenarios of LinedList
	+
	+	'''Homework:'''
	+	* Complete the LinkedList class and all its methods by the beginning of class on Thursday (11/12/09)
	+	* Mr. Bui will give you his LinkedListMain on Thursday to test
	+
	+	== Thursday (11/5/09) ==
	+	'''Warmup:'''
	+	* Draw the before-and-after pictures for adding a Node to an empty Queue (be sure to use head and tail!)
	+	* Draw the before and after pictures for adding a Node to a non-empty Queue
	+	* Draw the before-and-after pictures for removing a Node from an empty Queue
	+	* Draw the before and after pictures for removing a Node from a non-empty Queue
	+
	+	'''Agenda:'''
	+	* Return 1st Quarter Exams
	+	* Dynamically-sized Queues
	+	** Create a new class called DynamicQueue
	+	*** [[Media:DynamicQueue.java]]
	+	** Test out your DynamicQueue using the original QueueMain file
	+	* Introduction to Linked Lists
	+	** [[Media:LinkedList.java]]
	+	** Attributes: head, tail, size
	+	** Constructors: default
	+	** Methods:
	+	*** isEmpty() - returns true if the LinkedList is empty, and false otherwise
	+	*** void add(int num) - adds a new Node with num at the end of the LinkedList
	+	*** void add(int num, int index) - adds a new Node with num at the index specified
	+	**** There are FIVE different scenarios when you add a Node
	+	**** DRAW the before-and-after pictures for all FIVE secenarios
	+	*** int remove(int index) - removes the index-th Node and returns its data
	+	**** There are SIX different scenarios when you remove a Node
	+	*** print() - traverses the LinkedList and prints out each Node's data
	+
	+	'''Homework:'''
	+	* Complete DynamicQueue!
	+	* Draw the before-and-after diagrams (all SIX scenarios) for the LinkedList's remove() method
	+
	+	== Monday (11/2/09) ==
	+	'''Warmup:'''
	+	* Assume that you have allocated memory for a new int array of 10000 elements. An int is 32-bits in size, and there are 8-bits in 1 byte. How many bytes of memory are you taking up?
	+	* If there are 1024 bytes in a kilobyte, how many kilobytes are you taking up?
	+
	+	'''Agenda:'''
	+	* Dynamically-sized Stacks
	+	** Create a new class called DynamicStack
	+	*** [[Media:DynamicStack.java]]
	+	** What attribute must we keep track of when we talk about stacks?
	+	** Create a Node reference for the most important stack attribute
	+	** Implement push(int num) using Nodes.
	+	*** push() should not return anything
	+	*** push() creates a new Node with the num, and set the new Node's next reference to the top
	+	*** Don't forget to update the top to be the new node!
	+	** Implement pop(), which should POP and return the value on top of the stack and update the top
	+	** Implement top(), which should just return the value on top of the stack
	+	** Implement isEmpty() which returns true if the stack is empty
	+	** Implement print() which should print your entire stack
	+	** TEST YOUR STACK USING MR. BUI'S STACK MAIN OR YOUR OWN MAIN METHOD
	+
	+	== Archives ==
	+	* [[IBCS2 - May]]
	+	* [[IBCS2 - April]]
	+	* [[IBCS2 - March]]
	+	* [[IBCS2 - February]]
	+	* [[IBCS2 - January]]
	+	* [[IBCS2 - December]]
	+	* [[IBCS2 - November]]
	+	* [[IBCS2 - October]]
	+	* [[IBCS2 - September]]

← Older revision		Revision as of 15:42, 21 October 2009
Line 1:		Line 1:
−	~~<!--~~
−	~~== Tuesday (11/25/08) ==~~
−	* Holiday Assembly

−	~~== Monday (11/24/08) ==~~
−	~~'''Warmup:'''~~
−	* Which of the trees is invalid? Why?
−	* Identify the root node in the binary tree on the board
−	* Identify all the parents and their children in the binary tree on the board
−	* Identify all the leaves in the binary tree on the board
−
−	~~'''Agenda:'''~~
−	* Introduction to Binary Trees
−	** [[Media:BinaryTrees.ppt]]
−	* BTNode class - the node class for a binary tree of numbers
−	** What attributes should we have in our BTNode?
−	** What methods should we have in our BTNode?
−	* BinaryTree class
−	* Introduction to Recursion
−	** [[Media:Recursion.ppt]]
−
−	~~== Friday (11/21/08) ==~~
−	* Implement BubbleSort in your CLinkedList
−	** NOTE: The inner loop of BubbleSort should traverse the list from head down to tail
−	* Print out your CLinkedList search(find) and sorting (selectionSort() and bubbleSort() methods
−	* Introduction to Binary Trees
−	** [[Media:BinaryTrees.ppt]]
−
−	~~== Monday - Thursday (11/17/08 - 11/20/08) ==~~
−	~~'''Warmup:'''~~
−	* Create a new Java file named AddressBookMainWarmup with a main method
−	* In the main method, do the following:
−	*# Create a '''new''' instance of AddressBook named myBook
−	*# Using a for loop, create '''new''' Contacts named a0, a1, a2, ... , a99, and add them to your AddressBook
−	*# Remove the Contact at index 99
−	*# Remove the Contact at index 0
−	*# Using a for loop, remove the Contacts from indexes 5 through 20
−	*# Print out all the contacts in your AddressBook using the AddressBook print()
−
−	~~'''Agenda:'''~~
−	* Demo your AddressBook that uses a CLinkedList
−	* LinkedList Search - Implement inside CLinkedList as: Contact find(String firstName, String lastName)
−	** Traverses the LinkedList and checks if the Contact at the current ContactNode matches the same first name and last name that you are looking for
−	** If it finds your Contact, then return the Contact, otherwise, return null
−	* LinkedList SelectionSort - Implement inside CLinkedList as: void selectionSort()
−	** Uses the selection sort algorithm to sort the CLinkedList
−	** Traversing the CLinkedList uses the same algorithm as print() and find()
−	** You should be comparing the first and last names of the Contact
−	** When swapping data (minimum swapped with front), you should swap the Contact objects
−
−	~~== Friday (11/14/08) ==~~
−	* By the end of today, you should be able to demo an AddressBook that uses a LinkedList
−	* Be sure to comment out the find(), selectionSort(), and bubbleSort() methods in your AddressBook class
−
−	~~== Wednesday (11/12/08) ==~~
−	* Demo your LinkedList class
−	* Contact class review
−	* Create a new class from your Node class and called ContactNode
−	* Create a new class called ContactLinkedList
−	* Convert your LinkedList to use ContactNode and call it ContactLinkedList
−	* Be sure to test your ContactLinkedList
−	* AddressBook class review
−	* Convert your AddressBook to use ContactLinkedList instead of array
−	** Comment out the methods for find(), selectionSort(), and bubbleSort(). We will convert these later
−	** Be sure to test your AddressBook with LOTS of contacts
−
−	~~== Thursday - Friday (11/6/08 - 11/7/08) ==~~
−	* Show Mr. Bui your Queue before-and-after diagrams
−	* LinkedLists cont'd
−	** Attributes: head, tail, size
−	** Constructors: default
−	** Methods:
−	*** isEmpty() - returns true if the LinkedList is empty, and false otherwise
−	*** void add(int num) - adds a new Node with num at the end of the LinkedList
−	*** int remove(int index) - removes the index-th Node and returns its data
−	**** There are SIX different scenarios when you remove a Node
−	*** void add(int num, int index)
−	**** There are FIVE different scenarios when you add a Node
−	**** DRAW the before-and-after pictures for all FIVE secenarios
−	*** print() - traverses the LinkedList and prints out each Node's data
−	* [[Media:LinkedList.java]]
−	* LinkedListTestMain - create as a class
−
−	~~== Wednesday (11/5/08) ==~~
−	* Print out your DynamicQueue.java -- I will grade them by hand
−	* Introduction to LinkedLists
−	** Attributes: head, tail, size
−	** Constructors: default
−	** Methods:
−	*** isEmpty() - returns true if the LinkedList is empty, and false otherwise
−	*** void add(int num) - adds a new Node with num at the end of the LinkedList
−	*** int remove(int index) - removes the index-th Node and returns its data
−	**** There are FIVE different scenarios when you remove a Node
−	*** print() - traverses the LinkedList and prints out each Node's data
−	*'''Homework:''' Draw the before-and-after diagrams for the remove() method
−
−	~~== Monday (11/3/08) ==~~
−	~~'''Warmup:'''~~
−	* On a separate sheep of paper, please answer the following questions:
−	** In a dynamically-sized queue's isEmpty() method, what are the two different cases or scenarios that you check for?
−	** In a dynamically-sized queue's add() method, what are the two different cases or scenarios?
−	*** Draw the before and after picture of each of the two scenarios.
−	** In a dynamically-sized queue's remove() method, what are the two different cases or scenarios?
−	*** Draw the before and after picture of each of the two scenarios.
−
−	~~'''Agenda:'''~~
−	* Secret ballot - Have you installed and used Java or JCreator on your computer at home?
−	* Demo DynamicQueues
−	* Introduction to Linked Lists
−
−	~~== Archives ==~~
−	* [[IBCS2 - October]]
−	* [[IBCS2 - September]]
−	~~-->~~

@@ Line 1: / Line 1: @@
 == Tuesday (11/25/08) ==
 * Holiday Assembly
@@ Line 111: / Line 112: @@
 * [[IBCS2 - October]]
 * [[IBCS2 - September]]

← Older revision	Revision as of 03:12, 5 March 2009
(No difference)