Corning Community College
CSCS2320 Data Structures
Lay the framework for our doubly-linked list: implement a deck of cards where you can display piles of cards, navigating through and showing each card in the deck (forward and backward).
You will want to go here to edit and fill in the various sections of the document:
A standard deck has 13 values on the face of the card:
A standard deck of playing cards are divided into four suits, which are also grouped into colors:
Reference: https://www.geeksforgeeks.org/introduction-to-stack-data-structure-and-algorithm-tutorials/
A doubly linked list is nearly similar to a singly linked list, as it is a list of structs, where each struct has a pointer to the next struct in the list.
However, in a doubly linked list, each struct also has a pointer which points to the last struct in the list. This means functions can be used to go back and forth through the list, instead of just going one way.
A separate struct can be created specifically for the stack. This struct will need pointers to the structs being used for the cards and piles.
Another option is to initialize the stack using the pile struct. since the stack is it's own pile, it does not need to be in a list with other piles.
struct Pile { // Other Data Needed for Pile Card* firstCard; }; void main(void) { Pile* Stack = (Pile*)malloc(sizeof(Pile)); // Set Stack to be Empty Stack->firstCard = NULL; }
LIFO and FILO are both used to describe a way to insert and retrieve data from a data structure.
LIFO stands for Last In First Out, which means the last element to be put into the data structure is the first to be retrieved. This is the main method for pushing and popping data from a stack.
FILO stands for First In Last Out, which is another term for the same process.
When pushing data to the stack, it is important to not push too much data onto the stack, as a stack overflow can occur.
In a stack overflow, there are so many elements pushed onto it, that the stack data starts overlapping with the program data in RAM, which can cause severe errors when the program then tries to read that data.
To solve this, make sure that whatever gets pushed to the stack gets popped at some point before moving on.
Freecell is a Solitaire card game where the goal is to move piles of cards around in order to get each card to four “foundations”.
The foundations are where you need to get each card to by the end of the game in order to win.
There are four foundations, each of them separated by suit. A card of any suit can go into any foundation, but once one suit is in a foundation, then only cards of that suit can go into only that foundation.
Foundations are also sorted by rank: to start a foundation, you need to place an Ace onto an empty foundation, then place the next value card of the same suit onto that Ace, and so on from Ace-King.
The tableau is the main playing area of the game. This is where the various piles of cards get moved around in order to get to cards that can be moved to a foundation.
To be successful in this project, the following criteria (or their equivalent) must be met:
Let's say you have completed work on the project, and are ready to submit, you would do the following:
lab46:~/src/SEMESTER/DESIG/PROJECT$ submit DESIG PROJECT file1 file2 file3 ... fileN
You should get some sort of confirmation indicating successful submission if all went according to plan. If not, check for typos and or locational mismatches.
I'll be evaluating the project based on the following criteria:
156:cgf0:final tally of results (156/156) *:cgf0:card structure and functional deck [52/52] *:cgf0:code and resources submitted to build cartridge [52/52] *:cgf0:ability to navigate through a dealt pile [52/52]