#include <iostream>
#include <string.h>

#pragma warning(disable : 4996)
#define MaxWordSize 100

// Declare a structure that holds data in a node
typedef struct {
	int num;
} NodeDataInt;

// Declare a structure that holds data in a node
typedef struct {
	char word[MaxWordSize + 1];
	int freq;
} NodeDataChar;


// define what a node will look like
typedef struct treenodeInt {
	NodeDataInt data;
	struct treenode* left, * right;
} t2;

// define what a node will look like
typedef struct treenodeChar {
	NodeDataChar data;
	struct treenode *left, *right;
} t3;


// main method
int main()
{
	// Node with integer data
	NodeDataInt aNode;
	aNode.num = 100;
	std::cout << "aNode.num: " << aNode.num << "\n";
	
	// Node with character data
	NodeDataChar aNodeChar;
	strcpy(aNodeChar.word, "Hello Word");
	std::cout << "aNodeChar.word: " << aNodeChar.word << "\n";

	//syntax error
	//t2.data.num = 1000;

	// example using tree node with int data
	t2 aTNode;
	aTNode.data.num = 1000;
	std::cout << "aTNode.data.num: " << aTNode.data.num << "\n";

	// example using tree node with char data
	t3 aTNodeChar;
	strcpy(aTNodeChar.data.word, "1000 Hello Node Char Data");
	std::cout << "aTNodeChar.data.word: " << aTNodeChar.data.word << "\n";

	
}

// Ref: typedef and struct
// https://www.w3resource.com/c-programming-exercises/c-snippets/difference-between-typedef-struct-and-struct-definitions-with-example.php#google_vignette
// https://www.tutorialspoint.com/cprogramming/c_pointers.htm
// https://www.geeksforgeeks.org/typedef-in-c/

#pragma warning(disable : 4996)

#include <iostream>
#include <string.h>

// Declare a structure that holds data in a node
typedef struct {
	int num;
} NodeData;

// define what a node will look like
typedef struct treenode {
	NodeData data;
	struct treenode *left, *right;
} t1;

// main method
int main()
{
	std::cout << "Hello World 2!\n";		
}

#pragma warning(disable : 4996)
#include <iostream>
#include <string.h>

//struct
struct student {
	char name[50];
	int age;
	float height;
};

struct student s1 = { " Nina Chase", 12, 1.55 };
struct student s2 = { " Shyann Morris", 12, 1.65 };

//typedef struct
typedef struct {
	char name[50];
	int age;
	float height;
} studentType;

studentType s11 = { " Nina Chase", 12, 1.55 };
studentType s22 = { " Shyann Morris", 12, 1.65 };

//typedef struct
typedef struct studentTypeStart {
	char name[50];
	int age;
	float height;
} studentTypeEnd;

studentTypeEnd s33 = { " Shyann Morris", 12, 1.65 };
struct studentTypeStart s44 = { " struct studentTypeStart Shyann Morris", 12, 1.65 };
studentTypeStart s55 = { " Shyann Morris studentTypeStart", 12, 1.65 };

studentTypeEnd *stuPtr;


// main method
int main()
{
	std::cout << "Hello World 2!\n";
	std::cout << s11.name << "\n";
	std::cout << s33.name << "\n";
	std::cout << s55.name << "\n";
	std::cout << s44.name << "\n";
	
}

// print the graph
void printGraph(Graph G) {
	for (int j = 1; j <= G->numV; j++) {
		printf("%s: ", G->vertex[j].id);
		GEdgePtr p = G->vertex[j].firstEdge;
		while (p != NULL) {
			printf("%s %d ", G->vertex[p->child].id, p->weight);
			p = p->nextEdge;
		}
		printf("\n");
	}
}

//build the graph
void buildGraph(FILE* in, Graph G) {
	int j, k, numEdges, weight;
	char name[MaxWordSize], nodeID[MaxWordSize], adjID[MaxWordSize];

	// read the names of the vertices 
	// and store them in the graph array
	for (j = 1; j <= G->numV; j++) {
		fscanf(in, "%s", name);
		G->vertex[j] = newGVertex(name);
		strcpy(G->vertex[j].id, name);
		
	}

	// process edge data for each vertex
	for (j = 1; j <= G->numV; j++) { 

		// information about the parent vertex
		fscanf(in, "%s %d", nodeID, &numEdges); 

		// information about each edge from the parent vertex
		for (k = 1; k <= numEdges; k++) { 
			fscanf(in, "%s %d", adjID, &weight);
			addEdge(nodeID, adjID, weight, G);
		}
	}
}

define MaxWordSize 100

#define MaxWordSize 100

//edge of a graph
typedef struct gEdge{
	// child is the location of the child vertex
	int child, weight; 
	struct gEdge *nextEdge;
} GEdge, *GEdgePtr;

typedef struct{
	char id[MaxWordSize];
	int parent, cost, discover, finish, inDegree;
	GEdgePtr firstEdge;
} GVertex;

//main method 
int main() {

	return 0;
}

Create a Hash Table to store numbers. Also, search numbers in that Hash Table. Write Code in C

define _CRT_SECURE_NO_WARNINGS

include

include

include

define MaxNumbers 50

// to divide with

define N 100

define Empty 0

define STORAGESIZE 100

int hashTable[STORAGESIZE + 1];

//initialize hash table
void initializeHashTable() {

for (int counter = 0; counter < STORAGESIZE; counter++) {
    hashTable[counter] = 0;
}

}

//find a number and return found/not-found
int searchHashTable(int numberToFind) {

int hashSearchPosition = numberToFind % N + 1;

if (hashTable[hashSearchPosition] == numberToFind) {
    printf("%d %s %d", numberToFind, " Found at ", hashSearchPosition );
    return 1;
}
else {

    for (int pos = hashSearchPosition + 1; pos < STORAGESIZE; pos++) {
        if (hashTable[pos] == numberToFind) {
            printf("%d %s %d", numberToFind, " Found at ", pos);
            return 1;

        }
    }

}

printf("Number Not Found");
return -1;

}

//find next position after a collission
int findNextAvailablePosition(int index) {

for (int pos = index + 1; pos < STORAGESIZE; pos++) {
    if (hashTable[pos] == 0) {
        return pos;
    }
}

return -1;

}

//insert data into hash table
int insertToHashTable(int l_numberToInsert) {

int hashPosition = l_numberToInsert % N + 1;

if ( hashTable[hashPosition] > 0) {
    //collision
    //so find the next position
    hashPosition = findNextAvailablePosition(hashPosition);
}

//error finding a position 
if (  (hashPosition >= STORAGESIZE) || ((hashPosition == -1)) ) {
    // indicates error
    return -1;
}

hashTable[hashPosition] = l_numberToInsert;

// 1 indicates success
return 1;

}

//flow of the work
int main() {

//initialize
initializeHashTable();

//read data from file
FILE *in = fopen("input.txt", "r");

int numberToInsert = 0; 

//convertWordToNumber()

//insertion
//insert data into the hash table
while ( fscanf(in, "%d", &numberToInsert) == 1 ) {
    insertToHashTable(numberToInsert);
}


//take input from user to search
printf("\n%s\n", "Give a number to search");
int numberToSearch = 56;
scanf("%d", &numberToSearch);

//find the number in the hash
searchHashTable(numberToSearch);

}

Store Words in a Hash Table. Also, search a word in that Hash Table

define _CRT_SECURE_NO_WARNINGS

include

include

include

//#define MaxNumbers 100

define MaxWordLen 50

define Empty 0

define STORAGESIZE 15

// to divide with

define N 15

char hashTable[STORAGESIZE][MaxWordLen];

//initialize hash table
void initializeHashTable() {
for (int counter = 0; counter < STORAGESIZE; counter++) {
strcpy(hashTable[counter], “”);
}
}

// from Noel Kalicharan
// Advanced topics in C
int convertWordToNumber(char wordToInsert[]) {
/*
intj, wordNum = 0;
intweight = 3;
while (word[j] != ‘\0’) {
wordNum += weight * word[j++];
weight += 2;
}
location = wordNum % n + 1;

return location;

*/

int j = 0, wordNum = 0;
int weight = 3; 

while (wordToInsert[j] != '\0') {
    wordNum += weight * wordToInsert[j++];
    weight += 2;
}

return wordNum;

}

//find next position after a collission
int findSearchedWordPosition(int hashSearchPosition, char l_wordToSearch[]) {

int pos;
for (pos = hashSearchPosition + 1; pos < STORAGESIZE; pos++) {
    //if (hashTable[pos] == numberToFind) {
    if (hashTable[pos] && strcmp(hashTable[pos], l_wordToSearch) == 0) {
        printf("%s %s %d", l_wordToSearch, " Found at ", pos);
        return pos;
    }
}

if (pos >= STORAGESIZE) {
    for (int pos = 0; pos < hashSearchPosition; pos++) {
        if (hashTable[pos] && strcmp(hashTable[pos], l_wordToSearch) == 0) {
            printf("%s %s %d", l_wordToSearch, " Found at ", pos);
            return pos;

        }
    }
}


return -1;

}

//find a number and return found/not-found
int searchHashTable(char l_wordToSearch[]) {

int numberForTheWord = convertWordToNumber(l_wordToSearch);
int hashSearchPosition = numberForTheWord % N + 1;

if ( hashTable[hashSearchPosition] && (strcmp(hashTable[hashSearchPosition], l_wordToSearch) == 0)   ) {
    printf("%s %s %d", l_wordToSearch, " Found at ", hashSearchPosition);
    return 1;
}
else {

    int wordFoundPosition = findSearchedWordPosition(hashSearchPosition, l_wordToSearch);
    if (wordFoundPosition > 0) {
        printf("%s %s %d", l_wordToSearch, " Found at ", wordFoundPosition);
        return 1;
    }



}

printf("Word Not Found");
return -1;

}

//find next position after a collission
int findNextAvailablePosition(int index) {

int pos;
for (pos = index + 1; pos < STORAGESIZE; pos++ ) {
    //if (hashTable[pos] == 0) {
    if (strcmp(hashTable[pos], "") == 0){
        return pos;
    }
}

if (pos >= STORAGESIZE) {
    for (int pos = 0; pos < index; pos++) {
        //if (hashTable[pos] == 0) {
        if (strcmp(hashTable[pos], "") == 0) {
            return pos;
        }
    }
}


return -1;

}

//insert data into hash table
int insertToHashTable(int l_position_to_insert, char wordToInsert[]) {

//find position to insert
//remainder
int hashPosition = l_position_to_insert % N + 1;

char word[MaxWordLen];
//strcpy(word, hashTable[hashPosition]);

if (  strcmp(hashTable[hashPosition], "") != 0) {
    //collision
    //so find the next position
    hashPosition = findNextAvailablePosition(hashPosition);
}

//error finding a position 
if ((hashPosition > STORAGESIZE) || ((hashPosition == -1))) {
    // indicates error
    printf("\n%s %s\n", "Did not find a Position for ", wordToInsert);
    return -1;
}

strcpy(hashTable[hashPosition], wordToInsert);

// 1 indicates success
return 1;

}

//flow of the work
int main() {

//initialize
initializeHashTable();

//read data from file
FILE *in = fopen("input.txt", "r");

char wordToInsert[MaxWordLen];


//insertion
//insert data into the hash table
while (fscanf(in, "%s", &wordToInsert) == 1) {
    int positionToInsert = convertWordToNumber(wordToInsert);
    insertToHashTable(positionToInsert, wordToInsert);
}

//take input from user to search
//int numberToSearch;
char wordToSearch[MaxWordLen];
printf("\nPlease type the word to search\n");
scanf("%s", wordToSearch);

//find the number in the hash
searchHashTable(wordToSearch);

}

• Last one (E) becomes the root

• Some immediate (backward) right ones ones (L A T) up until middle (you can choose)  also becomes parents (downward right side parent)

• – Then put some immediate ones (backward) ( N F ) as left  children to come to root

Then take alternate (K P) to have the parents on the left side of the tree

• Come back from the last, with the remaining ones (G D)

• and make right children (left sub tree)