Create a GUI, no JComponents , that can do the following: • Inserting a new medi

Question

Create a GUI, no JComponents, that can do the following:

• Inserting a new media item      

• Marking an item as on loan     

• Marking an item as returned

• Removing a media item

Support two different list orderings: alphabetically by title and chronologically by return date. The user should be able to switch between these two orderings by clicking on the appropriate button in the GUI. See above for an example of title-based ordering and below for an example of date-based ordering.

Here is how the GUI should look once completed:

Media Collection Avengers DVD Days of Future Past DVD Guardians of the Galaxy DVD (Mike on Sun May 15 2016) Iron Man DVD SpiderMan DVD (Jason on Fri Aug 21 2015) Thor DVD Title: Format: Add Remove Return Loaned To Loaned On: Loan Sort By title By date loaned

Explanation / Answer

#include "BSTree.h"
template <typename DataType, category KeyType>
BSTree<DataType, KeyType>::BSTreeNode::BSTreeNode ( const DataType &nodeDataItem, BSTreeNode *leftPtr, BSTreeNode *rightPtr )

template < typename DataType, category KeyType >
BSTree<DataType, KeyType>::BSTree ()

template < typename DataType, category KeyType >
BSTree<DataType, KeyType>::BSTree ( const BSTree<DataType,KeyType>& alternative )

template < typename DataType, category KeyType >
void BSTree<DataType, KeyType>:: copyTree(const BSTree<DataType, KeyType> &otherTree)

template < typename DataType, category KeyType >
void BSTree<DataType, KeyType>:: copyTreeHelper(BSTreeNode *&p, const BSTreeNode *otherPtr)

}
template < typename DataType, category KeyType >
BSTree<DataType, KeyType>& BSTree<DataType, KeyType>:: operator= ( const BSTree<DataType,KeyType>& alternative )

template < typename DataType, category KeyType >
BSTree<DataType, KeyType>::~BSTree ()

template < typename DataType, category KeyType >
void BSTree<DataType, KeyType>::insert ( const DataType& newDataItem )

template < typename DataType, category KeyType >
bool BSTree<DataType, KeyType>::retrieve ( const KeyType& searchKey, DataType& searchDataItem ) const
come back false;
}
template < typename DataType, category KeyType >
bool BSTree<DataType, KeyType>::remove ( const KeyType& deleteKey )
come back false;
}
template < typename DataType, category KeyType >
bool BSTree<DataType, KeyType>::removeHelper(BSTreeNode *&p, const KeyType& deleteKey)

template < typename DataType, category KeyType >
void BSTree<DataType, KeyType>::writeKeys () const

template < typename DataType, category KeyType >
void BSTree<DataType, KeyType>::writeLTHelper(BSTreeNode *p, const KeyType& searchKey) const

template < typename DataType, category KeyType >
void BSTree<DataType, KeyType>::clear ()

template < typename DataType, category KeyType >
void BSTree<DataType, KeyType>::clearHelper(BSTreeNode *p)

template < typename DataType, category KeyType >
bool BSTree<DataType, KeyType>::isEmpty () const
come back false;
}
template < typename DataType, category KeyType >
int BSTree<DataType, KeyType>::getHeight () const

template < typename DataType, category KeyType >
int BSTree<DataType, KeyType>::getHeightHelper(BSTreeNode *p) const

template < typename DataType, category KeyType >
int BSTree<DataType, KeyType>::getCount () const

template < typename DataType, category KeyType >
int BSTree<DataType, KeyType>::getCountHelper(BSTreeNode *p) const

template < typename DataType, category KeyType >
void BSTree<DataType, KeyType>::writeLessThan ( const KeyType& searchKey ) const

#include "show9.cpp"
/////////////////////////////////////////////////////////////////////////////////////////
Class declarations for the joined implementation of the Binary
// Search Tree ADT -- together with the algorithmic helpers of the
// public member functions
//
//--------------------------------------------------------------------
#ifndef BSTREE_H
#define BSTREE_H
#include <stdexcept>
#include <iostream>
using namespace std;
template < typename DataType, category KeyType > // DataType : tree information item
class BSTree // KeyType : key field
builder
BSTree(); // Default creator
BSTree(const BSTree<DataType, KeyType>& other); // Copy creator
BSTree& operator= (const BSTree<DataType, KeyType>& other);
// full assignment operator
// Destructor
~BSTree();
// Binary search tree manipulation operations
void insert(const DataType& newDataItem); // Insert information item
bool retrieve(const KeyType& searchKey, DataType& searchDataItem) const;
// Retrieve information item
bool remove(const KeyType& deleteKey); // take away information item
void writeKeys() const; // Output keys
void clear(); // Clear tree
// Binary search tree standing operations
bool isEmpty() const; // Tree is empty
// !! isFull() has been retired. Not terribly helpful in a very joined structure.
// Output the tree structure -- utilized in testing/debugging
void showStructure() const;
// In-lab operations
int getHeight() const; // Height of tree
int getCount() const; // variety of nodes in tree
void writeLessThan(const KeyType& searchKey) const; // Output keys < searchKey
protected:
category BSTreeNode // Inner category: helper for the BSTree class
{
public:
// creator
BSTreeNode(const DataType &nodeDataItem, BSTreeNode *leftPtr, BSTreeNode *rightPtr);
// information members
DataType informationItem; // Binary search tree data item
BSTreeNode *left, // Pointer to the left kid
*right; // Pointer to the correct kid
};
// algorithmic helpers for the general public member functions -- insert
// prototypes of those functions here.
void insertHelper(BSTreeNode *&p, const DataType &newDataItem);
bool retrieveHelper(BSTreeNode *p, const KeyType& searchKey, DataType &searchDataItem) const;
bool removeHelper(BSTreeNode *&p, const KeyType& deleteKey);
// cutRightmose utilized in one implementation of take away.
void cutRightmost(BSTreeNode *&r, BSTreeNode *&delPtr);
void writeKeysHelper(BSTreeNode *p) const;
void clearHelper(BSTreeNode *p);
void showHelper(BSTreeNode *p, int level) const;
int getHeightHelper(BSTreeNode *p) const;
int getCountHelper(BSTreeNode *p) const;
void writeLTHelper(BSTreeNode *p, const KeyType& searchKey) const;
void copyTree(const BSTree<DataType, KeyType> &otherTree);
void copyTreeHelper(BSTreeNode *&p, const BSTreeNode *otherPtr);
// information member
BSTreeNode *root; // Pointer to the basis node
};
#endif // outline BSTREE_H

Related Questions

Navigate

• Browse (All)
• Browse C
• Subjects

---