Sidebar
opus:fall2013:khoose2:journal
Table of Contents
Data Structures Journal
Data program list
To avoid future issues and clutter I will be listing all my files; names and descriptions. This will allow easier lookup and referencing in the future.
Programs
- Aug29th:ptr1.c(ptr1):demonstrates pointers, their addresses and how or what they point to.
- Aug30th:varsize.c(varsize): shows the data types and sizes in bytes, along with possible number ranges they could fit.(final:varsize2.c(varsize2))
- Sep4th:struct1.c(struct1):organizes entries of name, age and id#, then redistributes them as requested.
- Sep5th:link1.c(link1):creates a list of numbers until '-1' is entered, then outputs entered numbers in their entered order, singly linked list.
- September8th:truthtable1.c(truthtable1):displays a truth table of the Exclusive Disjunction/Non-equivalency Proposition, then asks for custom input and output the results.
- September9th:link2.c(link2):update to (link1) so it now requests numbers for insert and location of said insertion, singly linked lisy.(link3: final version)
- September20th:dubstep.c(dubstep):doubly linked list, insert, and remove listing program.
- September25th:dubstep1.c(dubstep1):the DLL code to be broken into the library sections.
- November-December:SLLMenu.c(SLLMenu): makes a singly linked list using menu navigation and options
- DLLMenu.c(DLLMenu): does the same but using a doubly linked list, also menu driven.
- binary.c(binarytree): creates a binary tree from input and helps navigate/control it using the menu.
- Due to scheduling issues the dates cannot be specific as to when programs were created, these last few were made after September 15th.
Aug 29th, 2013
Today we covered how to setup and use the IRC chat and join our class channel, then we were shown where the Opus was and how to edit it.
- I wrote a file, 'ptr1.c'. In /src/Data
lab46:~/src/DATA$ ./ptr1 [a] address is: 0x224BA9CC [a] contains: 12 [b] address is: 0x224BA9C0 [b] contains: 0x224BA9CC [b] dereferences to: 12 [a] address is: 0x224BA9CC [a] contains: 137 [b] address is: 0x224BA9C0 [b] contains: 0x224BA9CC [b] dereferences to: 137 [a] address is: 0x224BA9CC [a] contains: 2600 [b] address is: 0x224BA9C0 [b] contains: 0x224BA9CC [b] dereferences to: 2600 lab46:~/src/DATA$
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 int main()
5 {
6
7 int a, *b;
8 a=12;
9 b=&a;
10 fprintf(stdout, "[a] address is: 0x%X\n", &a);
11 fprintf(stdout, "[a] contains: %d\n", a);
12 // fprintf(stdout, "[a] dereferences to: %d\n", a);
13
14 fprintf(stdout, "[b] address is: 0x%X\n", &b);
15 fprintf(stdout, "[b] contains: 0x%X\n", b);
16 fprintf(stdout, "[b] dereferences to: %d\n",*b);
17
18 a=137;
19
20 fprintf(stdout, "[a] address is: 0x%X\n", &a);
21 fprintf(stdout, "[a] contains: %d\n", a);
22 // fprintf(stdout, "[a] dereferences to: %d\n", a);
23
24 fprintf(stdout, "[b] address is: 0x%X\n", &b);
25 fprintf(stdout, "[b] contains: 0x%X\n", b);
26 fprintf(stdout, "[b] dereferences to: %d\n",*b);
27
28 *b=2600;
29
30 fprintf(stdout, "[a] address is: 0x%X\n", &a);
31 fprintf(stdout, "[a] contains: %d\n", a);
32 // fprintf(stdout, "[a] dereferences to: %d\n", a);
33
34 fprintf(stdout, "[b] address is: 0x%X\n", &b);
35 fprintf(stdout, "[b] contains: 0x%X\n", b);
36 fprintf(stdout, "[b] dereferences to: %d\n",*b);
37 return(0);
38 }
Aug 30th, 2013
Today we began to cover the variable size program required to reacquaint ourselves with variable usage. When we finished for the day we had the following finished:
- This program is named 'varsize.c' turned into 'varsize' as an executable
lab46:~/src/DATA$ ./varsize a signed char is 1 bytes lower bound is: -128 Upper bound is: 127 -------- an unsigned char is 1 bytes lower bound is: 0 Upper bound is: 255 -------- lab46:~/src/DATA$
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 int main()
5 {
6 signed char sc=0;
7 unsigned char uc=0;
8
9 printf("a signed char is %hhu bytes\n", sizeof(sc));
10 printf("lower bound is: %hhd\n", ((unsigned char)(sc-1)/2)+1);
11 printf("Upper bound is: %hhd\n", ((unsigned char)(sc-1)/2));
12 printf("--------\n");
13 printf("an unsigned char is %hhu bytes \n", sizeof(uc));
14 printf("lower bound is: %hhu\n", uc);
15 printf("Upper bound is: %hhu\n", uc-1);
16 printf("--------\n");
17 return(0);
18 }
We are now given the challenge to expand this program to encompass all data types, or even to find bounds for some using a LOGICAL solution.
September 3rd, 2013
Today I finished the data size program for class and I have it listed below:
- This program is located in varsize2.c
- executable is varsize
lab46:~/src/DATA$ ls link ptr1 ptr2 struct1.c varsize.c varsize2.c link.c ptr1.c struct1 varsize varsize2 lab46:~/src/DATA$ ./varsize2 a signed char is 1 bytes lower bound is: -128 Upper bound is: 127 -------- an unsigned char is 1 bytes lower bound is: 0 Upper bound is: 255 -------- a signed short int is 2 bytes lower bound is: -32768 Upper bound is: 32767 -------- an unsigned short int is 2 bytes lower bound is: 0 Upper bound is: 65535 -------- a signed int is 4 bytes lower bound is: -2147483648 Upper bound is: 2147483647 -------- an unsigned int is 4 bytes lower bound is: 0 Upper bound is: 4294967295 -------- a signed long int is 8 bytes lower bound is: -9223372036854775808 Upper bound is: 9223372036854775807 -------- an unsigned long int is 8 bytes lower bound is: 0 Upper bound is: 18446744073709551615 -------- a signed float is 0.000000 bytes lower bound is: 0.500000 Upper bound is: -0.500000 -------- an unsigned float is 0.000000 bytes lower bound is: 0.000000 Upper bound is: -1.000000 -------- lab46:~/src/DATA$
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 int main()
5 {
6 signed char sc=0;
7 unsigned char uc=0;
8 signed short ssi=0;
9 unsigned short usi=0;
10 signed int si=0;
11 unsigned int ui=0;
12 signed long sl=0;
13 unsigned long ul=0;
14 signed long long sll=0;
15 unsigned long long ull=0;
16 float f=0;
17
18
19 printf(" ");
20 printf("a signed char is %hhd bytes\n", sizeof(sc));
21 printf("lower bound is: %hhd\n", ((unsigned char)(sc-1)/2)+1);
22 printf("Upper bound is: %hhd\n", ((unsigned char)(sc-1)/2));
23 printf("--------\n");
24 printf("an unsigned char is %hhu bytes \n", sizeof(uc));
25 printf("lower bound is: %hhu\n", uc);
26 printf("Upper bound is: %hhu\n", uc-1);
27 printf("--------\n");
28 printf("a signed short int is %hd bytes\n", sizeof(ssi));
29 printf("lower bound is: %hd\n", ((unsigned short)(ssi-1)/2)+1);
30 printf("Upper bound is: %hd\n", ((unsigned short)(ssi-1)/2));
31 printf("--------\n");
32 printf("an unsigned short int is %hu bytes \n", sizeof(usi));
33 printf("lower bound is: %hu\n", usi);
34 printf("Upper bound is: %hu\n", usi-1);
35 printf("--------\n");
36 printf("a signed int is %d bytes\n", sizeof(si));
37 printf("lower bound is: %d\n", ((unsigned int)(si-1)/2)+1);
38 printf("Upper bound is: %d\n", ((unsigned int)(si-1)/2));
39 printf("--------\n");
40 printf("an unsigned int is %u bytes \n", sizeof(ui));
41 printf("lower bound is: %u\n", ui);
42 printf("Upper bound is: %u\n", ui-1);
43 printf("--------\n");
44 printf("a signed long int is %ld bytes\n", sizeof(sl));
45 printf("lower bound is: %ld\n", ((unsigned long int)(sl-1)/2)+1);
46 printf("Upper bound is: %ld\n", ((unsigned long int)(sl-1)/2));
47 printf("--------\n");
48 printf("an unsigned long int is %lu bytes \n", sizeof(ul));
49 printf("lower bound is: %lu\n", ul);
50 printf("Upper bound is: %lu\n", ul-1);
51 printf("--------\n");
52 printf("a signed float is %f bytes\n", sizeof(f));
53 printf("lower bound is: %f\n", (( float)(f-1)/2)+1);
54 printf("Upper bound is: %f\n", ((float)(f-1)/2));
55 printf("--------\n");
56 printf("an unsigned float is %f bytes \n", sizeof(f));
57 printf("lower bound is: %f\n", f);
58 printf("Upper bound is: %f\n", f-1);
59 printf("--------\n");
60
61 return(0);
62 }
September 4th, 2013
Today we worked on structures and created a program that organized entries of names, ages, and ID#s, then spits them out as requested, it is listed below;
- The program below is titled 'struct1.c'
- Executable as 'struct1'
lab46:~/src/DATA$ ./struct1 Enter person #1's name: dan Enter dan's age:18 Enter dan's id number:1 Enter person #2's name: kell Enter kell's age:18 Enter kell's id number:2 Enter person #3's name: paul Enter paul's age:19 Enter paul's id number:3 Enter person #4's name: jon Enter jon's age:20 Enter jon's id number:4 Enter person #5's name: dick Enter dick's age:50 Enter dick's id number:5 Enter person #6's name: matt Enter matt's age:30 Enter matt's id number:6 Enter person #7's name: senator Enter senator's age:40 Enter senator's id number:7 Enter person #8's name: zach Enter zach's age:20 Enter zach's id number:8 Look up data for person #: 1 Name: kell Age: 18 ID: 2 lab46:~/src/DATA$
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 int main()
5 {
6 struct person {
7 char *name;
8 int age;
9 long int id;
10 };
11
12 typedef struct person Person;
13 // struct person People[8];
14 Person People[8];
15 int i=0;
16
17 for(i=0;i<8;i++)
18 {
19 printf("Enter person #%d's name: ",(i+1));
20 People[i].name=(char*)malloc(sizeof(char)*20);
21 scanf("%s", People[i].name);
22 printf("Enter %s's age:", People[i].name);
23 scanf("%d", &People[i].age);
24 printf("Enter %s's id number:", People[i].name);
25 scanf("%ld", &People[i].id);
26 }
27 i=-1;
28 while(i==-1)
29 {
30 printf("Look up data for person #: ");
31 scanf("%d", &i);
32 if(!((i>=0)&&(i<=7)))
33 {
34 printf("Invalid person #. Tme:%s\n. Try Again!\n");
35 i=-1;
36 }
37 }
38 printf("Name: %s\n", People[i].name);
39 printf("Age: %d\n", People[i].age);
40 printf("ID: %ld\n", People[i].id);
41 return(0);
42 }
September 5th,2013
Today we began doing linked lists, the program we began today would take input in the form of numbers. The program stops taking input once '-1' is entered, then outputs the previously input numbers in the order they were input. The program is shown below:
- This program is titled 'link.c'
- Executable as 'link'
lab46:~/src/DATA$ ls link ptr1 ptr2 struct1.c varsize.c varsize2.c link.c ptr1.c struct1 varsize varsize2 lab46:~/src/DATA$ ./link Enter a value(-1 to end): 2 Enter a value(-1 to end): 3 Enter a value(-1 to end): 4 Enter a value(-1 to end): 5 Enter a value(-1 to end): 6 Enter a value(-1 to end): 7 Enter a value(-1 to end): 8 Enter a value(-1 to end): 9 Enter a value(-1 to end): 10 Enter a value(-1 to end): 11 Enter a value(-1 to end): -1 2 ->3 ->4 ->5 ->6 ->7 ->8 ->9 ->10 ->11 ->NULL lab46:~/src/DATA$
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 struct node
5 {
6 int value;
7 struct node *next;
8 };
9
10 typedef struct node Node;
11
12 int main()
13 {
14 int input;
15 Node *list, *tmp;
16 list=tmp=NULL;
17 while(input!=-1)
18 {
19 printf("Enter a value(-1 to end): ");
20 scanf("%d", &input);
21 if(input!=-1)
22 {
23 if(list==NULL)
24 {
25 list=tmp=(Node*)malloc(sizeof(Node));
26 tmp->next=NULL;
27 list->value=input;
28 }
29 else
30 {
31 tmp->next=(Node*)malloc(sizeof(Node));
32 tmp->next->next=NULL;
33 tmp->next->value=input;
34 tmp=tmp->next;
35 }
36 }
37 }
38 tmp=list;
39 while(tmp!=NULL)
40 {
41 printf("%d ->", tmp->value);
42 tmp=tmp->next;
43 }
44 printf("NULL\n");
45 return(0);
46 }
September 6th, 2013
This Friday we had our progress checked by matt and began work on our modified linked list program, a branch off of 'link.c'
- This modification add an insert option.
- by numbering the entries so that they can be easily navigated.
- Inserted values do not overwrite, they are put between existing nodes
- every node's placement value, after the inserted node, is increased by one.
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 struct node
5 {
6 int value;
7 struct node *next;
8 };
9
10 typedef struct node Node;
11
12 int main()
13 {
14 int input;
15 Node *list, *tmp;
16 list=tmp=NULL;
17 while(input!=-1)
18 {
19 printf("Enter a value(-1 to end): ");
20 scanf("%d", &input);
21 if(input!=-1)
22 {
23 if(list==NULL)
24 {
25 list=tmp=(Node*)malloc(sizeof(Node));
26 tmp->next=NULL;
27 list->value=input;
28 }
29 else
30 {
31 tmp->next=(Node*)malloc(sizeof(Node));
32 tmp->next->next=NULL;
33 tmp->next->value=input;
34 tmp=tmp->next;
35 }
36 }
37 }
38 tmp=list;
39 input=0;
40 while(tmp!=NULL)
41 {
42 printf("[%d] %d ->", input,tmp->value);
43 tmp=tmp->next;
44 input=input+1;
45 }
46 printf("NULL\n");
47 //insert into list
48 printf("Which node would you like to insert before?");
49 scanf("%d",&input);
50 int seeker;
51 tmp=list;
52 Node *tmp2=NULL;
53 for(seeker=0;<=input;seeker++)
54 {
55 tmp=tmp->next;
56 }
57 printf("Enter a value to insert: ");
58 scanf("%d", &input);
59 tmp2=(node*)malloc(sizeof(Node));
60 tmp2->value=input;
61 tmp2->next=tmp->next;
62 tmp->next=tmp2;
63 return(0);
64 }
September 8th, 2013
As is my habit I said screw it and put this off till it was just about too late, it's a bit simple but it does as requested, here is my truth table program executing and its code.
- project0.c(project0)
lab46:~/src/Discreet$ lab46:~/src/Discreet$ ./project0 |--------------------------------------| |Exclusive Disjunction/Non-equivalence:| |--------------------------------------| | P | Q | PyQ | |--------------------------------------| | T | T | F | | T | F | T | | F | T | T | | F | F | F | |--------------------------------------| For the following step; 1=True 0=False Please input value for P:1 Please input value for Q:1 The result is: False lab46:~/src/Discreet$ ./project0 |--------------------------------------| |Exclusive Disjunction/Non-equivalence:| |--------------------------------------| | P | Q | PyQ | |--------------------------------------| | T | T | F | | T | F | T | | F | T | T | | F | F | F | |--------------------------------------| For the following step; 1=True 0=False Please input value for P:1 Please input value for Q:0 The result is: True lab46:~/src/Discreet$ ./project0 |--------------------------------------| |Exclusive Disjunction/Non-equivalence:| |--------------------------------------| | P | Q | PyQ | |--------------------------------------| | T | T | F | | T | F | T | | F | T | T | | F | F | F | |--------------------------------------| For the following step; 1=True 0=False Please input value for P:0 Please input value for Q:0 The result is: False lab46:~/src/Discreet$
1 #include<stdlib.h>
2 #include<stdio.h>
3
4 int main()
5 {
6 int p;
7 int q;
8 int pyq;
9
10
11
12 printf("|--------------------------------------|\n");
13 printf("|Exclusive Disjunction/Non-equivalence:|\n");
14 printf("|--------------------------------------|\n");
15 printf("| P | Q | PyQ |\n");
16 printf("|--------------------------------------|\n");
17 printf("| T | T | F |\n");
18 printf("| T | F | T |\n");
19 printf("| F | T | T |\n");
20 printf("| F | F | F |\n");
21 printf("|--------------------------------------|\n");
22
23
24
25 printf("\n For the following step; 1=True 0=False\n Please input value for :");
26 scanf("%d", &p);
27 printf("Please input value for Q:");
28 scanf("%d",&q);
29 pyq=p+q;
30
31
32
33
34 if(pyq==2)
35 {
36 printf("The result is: False\n");
37 }
38 else if(pyq==1)
39 {
40 printf("The result is: True\n");
41 }
42 else if(pyq==0)
43 {
44 printf("The result is: False\n");
45 }
46
47 return(0);
48 }
September9th, 2013
- link2.c(link2)
- capable or filling a list, then inserting before an indicated node, not menu driven.
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 struct node
5 {
6 int value;
7 struct node *next;
8 };
9
10 typedef struct node Node;
11
12 int main()
13 {
14 int input;
15 Node *list, *tmp;
16 list=tmp=NULL;
17 while(input!=-1)
18 {
19 printf("Enter a value(-1 to end): ");
20 scanf("%d", &input);
21 if(input!=-1)
22 {
23 if(list==NULL)
24 {
25 list=tmp=(Node*)malloc(sizeof(Node));
26 tmp->next=NULL;
27 list->value=input;
28 }
29 else
30 {
31 tmp->next=(Node*)malloc(sizeof(Node));
32 tmp->next->next=NULL;
33 tmp->next->value=input;
34 tmp=tmp->next;
35 }
36 }
37 }
38 tmp=list;
39 input=0;
40 while(tmp!=NULL)
41 {
42 printf("[%d] %d ->", input,tmp->value);
43 tmp=tmp->next;
44 input=input+1;
45 }
46 printf("NULL\n");
47 //insert into list
48 printf("Which node would you like to insert before?");
49 scanf("%d",&input);
50 int seeker;
51 tmp=list;
52 Node *tmp2=NULL;
53 for(seeker=0;seeker<(input-1);seeker++)
54 {
55 tmp=tmp->next;
56 }
57 printf("Enter a value to insert: ");
58 scanf("%d", &input);
59 tmp2=(Node*)malloc(sizeof(Node));
60 tmp2->value=input;
61 tmp2->next=tmp->next;
62 tmp->next=tmp2;
63 return(0);
64 }
September 11th,2013
link3.c
-this program asks you to fill a list, then to insert before a node including the first node if you would like, then it asks you to remove a node.
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 struct node {
5 int value;
6 struct node *next;
7 };
8
9 typedef struct node Node;
10
11 int main()
12 {
13 int input;
14 Node *list, *tmp;
15
16 list = tmp = NULL;
17 while (input != -1)
18 {
19 printf("Enter a value(-1 to end): ");
20 scanf("%d", &input);
21 if (input != -1)
22 {
23 if (list == NULL)
24 {
25 list = tmp = (Node *) malloc(sizeof(Node));
26 tmp->next = NULL;
27 list->value = input;
28 }
29 else
30 {
31 tmp->next = (Node *) malloc(sizeof(Node));
32 tmp->next->next = NULL;
33 tmp->next->value = input;
34 tmp = tmp->next;
35 }
36 }
37 }
38 tmp = list;
39 input = 0;
40 while (tmp != NULL)
41 {
42 printf("[%d] %d ->", input, tmp->value);
43 tmp = tmp->next;
44 input = input + 1;
45 }
46 printf("NULL\n");
47 //insert into list
48 printf("Which node would you like to insert before?");
49 scanf("%d", &input);
50 int seeker;
51
52 tmp = list;
53 Node *tmp2 = NULL;
54
55 for (seeker = 0; seeker < (input - 1); seeker++)
56 {
57 tmp = tmp->next;
58 }
59 if (input == 0)
60 {
61 printf("Enter value for new node: ");
62 scanf("%d", &input);
63 tmp2 = (Node *) malloc(sizeof(Node));
64 tmp2->value = input;
65 tmp2->next = NULL;
66 tmp2->next = tmp;
67 list = tmp2;
68 input = 0;
69 tmp = list;
70 while (tmp != NULL)
71 {
72 printf("[%d] %d ->", input, tmp->value);
73 tmp = tmp->next;
74 input = input + 1;
75 }
76 printf("NULL\n");
77 }
78 else
79 {
80 printf("Enter a value to insert: ");
81 scanf("%d", &input);
82 tmp2 = (Node *) malloc(sizeof(Node));
83 tmp2->value = input;
84 tmp2->next = tmp->next;
85 tmp->next = tmp2;
86 input = 0;
87 tmp = list;
88 while (tmp != NULL)
89 {
90 printf("[%d] %d ->", input, tmp->value);
91 tmp = tmp->next;
92 input = input + 1;
93 }
94 printf("NULL\n");
95 }
96 printf("Which node would you like to remove?: ");
97 scanf("%d", &input);
98 tmp = list;
99 for (seeker = 0; seeker < (input - 1); seeker++)
100 {
101 tmp = tmp->next;
102 }
103 if (input == 0)
104 {
105 list = tmp->next;
106 tmp->next = NULL;
107 }
108
109 else
110 {
111 tmp2 = tmp->next;
112 tmp->next = tmp2->next;
113 tmp2->next = NULL;
114 input = 0;
115 tmp = list;
116 }
117 tmp = list;
118 input = 0;
119 while (tmp != NULL)
120 {
121 printf("[%d] %d ->", input, tmp->value);
122 tmp = tmp->next;
123 input = input + 1;
124 }
125
126 printf("NULL\n");
127 return (0);
128 }
September 20, 2013
dubstep.c
- doubly linked list
- This is the beginning of our doubly linked list, a list similar to the singly but different in the fact that it is capable of going backwards through the list as well, where as the singly linked list is only capable of moving forward through a list of nodes.
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 struct node {
5 int value;
6 struct node *next;
7 struct node *prev;
8 };
9 typedef struct node Node;
10
11 struct list {
12 struct node *start;
13 struct node *end;
14 };
15 typedef struct list List;
16 List *build();
17 void displayf(List *);
18 void displayb(List *);
19 List *insert(List *, Node *, Node *);
20 List *getNode(List *, Node **);
21
22 main()
23 {
24 List *myList;
25 List *myList2;
26 Node *tmp;
27
28 myList = build();
29 displayf(myList);
30 //call insert here
31 myList=getNode(myList, &tmp);
32 myList2=insert(myList2, myList->end, tmp);
33 // displayb(myList);
34 return (0);
35 }
36
37 List *build()
38 {
39 Node *tmp = NULL;
40 List *myList = (List *) malloc(sizeof(List));
41
42 myList->start = myList->end = NULL;
43 int input = 0;
44
45 printf("Enter a value(-1 to quit): ");
46 scanf("%d", &input);
47 while (input != -1)
48 {
49 if (myList->start == NULL)
50 //went from start and end both =NULL to them both equalling a new node
51 {
52 myList->start = myList->end =
53 (Node *) malloc(sizeof(Node));
54 myList->start->value = input;
55 myList->end->prev = myList->start->next = NULL;
56 }
57 else
58 {
59 myList->end->next = (Node *) malloc(sizeof(Node));
60 myList->end->next->value = input;
61 myList->end->next->next = NULL;
62 myList->end->next->prev = myList->end;
63 myList->end = myList->end->next;
64 }
65 printf("Enter a value(-1 to quit): ");
66 scanf("%d", &input);
67 }
68 return (myList);
69 }
70
71 //Insert Section
72 List *insert(List *myList, Node *place, Node *newNode)
73 {
74 if (place == myList->start)
75 {
76 newNode->next = place;
77 place->prev = newNode;
78 newNode->prev = NULL;
79 myList->start = newNode;
80 }
81 //in case of before first node insertion
82 //links as before newnode appears, aasigning to where they are after appears
83 else
84 {
85 newNode->next = place;
86 place->prev->next = newNode;
87 newNode->prev = place->prev;
88 place->prev = newNode;
89 }
90 }
91 void displayf(List *myList)
92 {
93 Node *tmp;
94 int input;
95 tmp=myList->start;
96 input=0;
97 /* printf("[%d] %d ->", input, myList->start->value);
98 myList->start=myList->start->next;
99 input=input+1;
100 */
101 while (tmp != NULL)
102 {
103 printf("[%d] %d ->", input, tmp->value);
104 tmp = tmp->next;
105 input = input + 1;
106 }
107 printf("NULL\n");
108 }
109
110 //remove section
111 //passing by address, allows multiple value passing by single function
112 List *getNode(List *myList, Node **place)
113 {
114 //removal, start of list conditional
115 if(*place==myList->start)
116 {
117 myList->start=myList->start->next;
118 myList->start->prev=NULL;
119 (*place)->next=NULL;
120 }
121
122 //removal, end of list conditional
123 else if(*place==myList->end)
124 {
125 myList->end=myList->end->prev;
126 myList->end->next=NULL;
127 (*place)->prev=NULL;
128 }
129
130 //removal, every condition in between
131 else
132 {
133 (*place)->prev->next=(*place)->next;//skip over node one way
134 (*place)->next->prev=(*place)->prev;//skip over it the other
135 (*place)->prev=(*place)->next=NULL;//skipped over(cut off), NULL ends
136 }
137 return(myList);
138 }
October 10th,2013
peek.c
1 #include "stack.h"
2
3 Node *peek(Stack *myStack)
4 {
5 // exercise left to the implementer
6 }
pop.c
1 #include "stack.h"
2
3 Node *pop(Stack **myStack)
4 {
5 Node *tmp=NULL;
6 if((myStack)!=NULL)
7 {
7 tmp = getNode(&(*myStack) -> data, (*myStack) -> data -> end);
8 (*myStack) -> top = (*myStack) -> data -> end;
9 }
10 return (tmp);
11 }
push.c
1 #include "stack.h"
2
3 Stack *push(Stack *myStack, Node *newNode)
4 {
5 if ((myStack -> size <= 0) || ((myStack -> data -> qty) < (myStack -> si ze)))
6 {
7 myStack -> data = append(myStack -> data, myStack -> data -> end, ne wNode);
8 myStack -> top = myStack -> data -> end;
9 }
10
11 return(myStack);
12 }
stack.h
1 #ifndef _STACK_H
2 #define _STACK_H
3
4 #include "list.h"
5
6 struct stack {
7 List *data;
8 Node *top;
9 int size;
10 };
11 typedef struct stack Stack;
12
13 Stack *mkstack(int);
14 Stack *push (Stack *, Node *);
15 Node *pop (Stack **);
16 Node *peek (Stack *);
17
18 #endif
stackops.c
1 #include "stack.h"
2
3 Stack *mkstack(int size)
4 {
5 Stack *myStack;
6
7 myStack = (Stack *) malloc (sizeof(Stack));
8
9 myStack -> data = mklist();
10 myStack -> size = size;
11 myStack -> top = myStack -> data -> end;
12
13 return (myStack);
14 }
October 30,2013
binary tree: - Three traversals;
- Preorder
- in order
- post order
It did take me quite a while, and asking for help but I have the makings of a binary tree program, yet it has some running errors, segmentation that occurs at the start, I'm unsure how to fix it.
executable as: binary.c
binary.c
1 #include <stdio.h>
2 #include "stack.h"
3
4
5 List *displaytree(List *maple);
6 List *addtree(List *pine, Node *pos1, Node *pos2);
7
8 int main()
9 {
10 List *tree = ( List* )malloc( sizeof( List ) );
11 tree->start = tree->end = NULL;
12 Node *root;
13 int value0;
14 int choice;
15 fprintf(stdout, "What would you like for your root value? ");
16 fscanf(stdin, "%d", &value0);
17
18
19 root->value = value0;
20 tree = append( tree, tree->start, root);
21 tree = displaytree(tree);
22
23 while(choice!=-1)
24 {
25 fprintf(stdout, "|========================|\n");
26 fprintf(stdout, "| 1 to insert to tree |\n");
27 fprintf(stdout, "|========================|\n");
28 fprintf(stdout, "| 2 to remove from tree |\n");
29 fprintf(stdout, "|========================|\n");
30 fprintf(stdout, "| 3 to display tree |\n");
31 fprintf(stdout, "|========================|\n");
32 fprintf(stdout, "| -1 to quit |\n");
33 fprintf(stdout, "|========================|\n");
34 fprintf(stdout, "Which would you like to do?\n");
35 fscanf(stdin, "%d", &choice);
36
37 if(choice == 1)
38 {
39 int a;
40 fprintf(stdout, "What value are you adding? ");
41 fscanf(stdin, "%d", &a);
42 Node * tmp = (Node *)malloc(sizeof(Node));
43 tmp->value = a;
44 tree = addtree(tree, root, tmp);
45 }
46 else if(choice == 3)
47 {
48 displaytree(tree);
49 }
50 else if(choice == -1)
51 {
52 fprintf(stdout, "Goodbye\n");
53 }
54 else
55 {
56 fprintf(stdout, "Error, Invalid Input\n");
57 }
58 }
59 return(0);
60 }
61
62 List *displaytree( List * maple) //this section output the content of the tree for the user to see.
63 {
64 Node *tmp1 = maple->start;
65 Node *tmp2 = maple->start;
66 fprintf(stdout, "\t%d\n", tmp1->value);
67
68 if(tmp1->next != NULL || tmp1->prev != NULL)
69 {
70 tmp1 = tmp1->next;
71 tmp2 = tmp2->next;
72 while(tmp1->next = NULL)
73 {
74 fprintf(stdout, "\t%d\n", tmp1->value);
75 fprintf(stdout, "\t%d\n", tmp2->value);
76 }
77 }
78 return(maple);
79 }
80
81 List *addtree( List *pine, Node *pos1, Node *pos2) //this section allows for the addition of new leaves to the binary tree.
82 {
83 int count = 1;
84 while(count != pine->qty)
85 {
86 if(pos2->value < pos1->value)
87 {
88 if(pos1->prev != NULL)
89 {
90 fprintf(stdout, "Down Left\n");
91 pos1 = pos1->prev;
92 }
93 }
94 else if(pos2->value > pos1->value)
95 {
96 if(pos1->next != NULL)
97 {
98 fprintf(stdout, "Down Right\n");
99 pos1 = pos1->next;
100 }
101 }
102 else if(pos2->value == pos1->value)
103 {
104
105 }
106 count++;
107 }
108 if(pos2->value < pos1->value)
109 {
110 fprintf(stdout, "Added a node to the left\n");
111 pos1->prev = pos2;
112 pine->qty = (pine->qty) + 1;
113 }
114 else if(pos2->value > pos1->value)
115 {
116 fprintf(stdout, "Added a node to the right\n");
117 pos1->next = pos2;
118 pine->qty = (pine->qty) + 1;
119 }
120 else
121 {
122
123 }
124 pos1 = pine->start;
125 return(pine);
126 }
127
128 List *append(List *myList, Node *place, Node *newNode) //allows for the appending of a leaf after the position of another leaf.
129 {
130 if(place==myList->end)
131 {
132 newNode->prev=place;
133 place->next=newNode;
134 newNode->next=NULL;
135 myList->end=newNode;
136 }
137 else
138 {
139 newNode->prev=place;
140 place->next->prev=newNode;
141 newNode->next=place->next;
142 place->next=newNode;
143 }
144
145 return(myList);
146 }
147
148 List *taketree( List *cherry, Node *pos ) //removal function for the binary tree
149 {
150 Node *tmp1 = cherry->start;
151 Node *tmp0;
152 int count = 0;
153 while(count != cherry->qty)
154 {
155 if(tmp1->value > pos->value)
156 {
157 tmp0 = tmp1;
158 if(tmp1->prev != NULL)
159 {
160 fprintf(stdout, "Down Left\n");
161 tmp1 = tmp1->prev;
162 }
163 }
164 else if(tmp1->value < pos->value)
165 {
166 tmp0 = tmp1;
167 if(tmp1->next != NULL)
168 {
169 fprintf(stdout, "Down Right\n");
170 tmp1 = tmp1->next;
171 }
172 }
173 else if(tmp1->value == pos->value)
174 {
175
176 }
177 count++;
178 }
179 fprintf(stdout, "tmp0 is %d\n", tmp0->value);
180 fprintf(stdout, "Removing node %d\n", tmp1->value);
181 if(tmp1->next != NULL && tmp1->prev != NULL)
182 {
183 Node *tmp2;
184 if(tmp1->prev != NULL)
185 {
186 tmp2 = tmp1->prev;
187 }
188 else
189 {
190 tmp2 = NULL;
191 }
192
193 Node *tmp3;
194 if(tmp1->next != NULL)
195 {
196 tmp3 = tmp1->next;
197 }
198 else
199 {
200 tmp3 = NULL;
201 }
202 if(tmp2 != NULL)
203 {
204 while(tmp2->next != NULL && tmp2->prev != NULL)
205 {
206 if(tmp2->next != NULL)
207 {
208 tmp2 = tmp2->next;
209 }
210 else
211 {
212 }
213 }
214 if(tmp1 == tmp0->prev)
215 {
216 tmp0->prev = tmp2;
217 tmp2->next = tmp3;
218 }
219 else
220 {
221 tmp0->next = tmp2;
222 tmp2->next = tmp3;
223 }
224 }
225 else
226 {
227 while(tmp3->next != NULL && tmp3->prev != NULL)
228 {
229 if(tmp3->next != NULL)
230 {
231 tmp3 = tmp3->next;
232 }
233 else
234 {
235 }
236 }
237 if(tmp1 == tmp0->prev)
238 {
239 tmp0->prev = tmp3;
240 tmp2->next = tmp2;
241 }
242 else
243 {
244 tmp0->next = tmp3;
245 tmp2->next = tmp2;
246 }
247 }
248 }
249 else
250 {
251 if(tmp1 == tmp0->prev)
252 {
253 tmp0->prev = NULL;
254 }
255 else
256 {
257 tmp0->next = NULL;
258 }
259 }
260 /*
261 tmp1->next = NULL;
262 tmp1->prev = NULL;
263 */
264 free(tmp1);
265
266 return(cherry);
267 }
November 7th
After a long wait, and tons of work I have completed my Singly Linked list, which uses a menu to run, making it much easier to navigate. The following is both the code for the menu, and then the individual functions at the bottom of the program. Menu includes the following functions:
- build
- insert
- append
- remove
- display
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 struct node{
5 int value;
6 struct node*next;
7 };
8
9 typedef struct node Node;
10
11 Node *build(Node *);
12 Node *insert(Node *);
13 Node *append(Node *);
14 Node *removenode(Node *);
15 Node *display(Node *);
16
17 int main()
18 {
19 Node *list = NULL;
20 int option;
21
22 while(option!=-1)
23
24 {
25 fprintf(stdout, "|===========Menu===========|\n");
26 fprintf(stdout, "| 1.)Build list |\n");
27 fprintf(stdout, "| 2.)Insert to list |\n");
28 fprintf(stdout, "| 3.)Append to list |\n");
29 fprintf(stdout, "| 4.)Remove from list |\n");
30 fprintf(stdout, "| 5.)Display the list |\n");
31 fprintf(stdout, "|-1.)Quit |\n");
32 fprintf(stdout, "|==========================|\n");
33 fprintf(stdout, "Please select an option: ");
34 fscanf(stdin, "%d", &option);
35
36 if(option==1)
37 {
38 list=build(list);
39 }
40 else if(option==2)
41 {
42 list=insert(list);
43 }
44 else if(option==4)
45 {
46 list=removenode(list);
47 }
48 else if(option==5)
49 {
50 list=display(list);
51 }
52 else if(option=-1)
53 {
54 fprintf(stdout, "Goodbye\n");
55 }
56 else
57 {
58 fprintf(stdout, "Error, invalid input\n");
59 }
60 }
61
62 return(0);
63 }
64
65 Node *build(Node*list)
66 {
67 int input=0;
68 Node*tmp;
69 list=tmp=NULL;
70 while(input!=-1)
71 {
72 fprintf(stdout, "Enter a value (-1 to end): ");
73 fscanf(stdin, "%d", &input);
74
75 if(input!=-1)
76 {
77 if(list==NULL)
78 {
79 list=tmp=(Node*)malloc(sizeof(Node));
80 tmp->next=NULL;
81 list->value=input;
82 }
83 else
84 {
85 tmp->next=(Node*)malloc(sizeof(Node));
86 tmp->next->next=NULL;
87 tmp->next->value=input;
88 tmp=tmp->next;
89 }
90 }
91 }
92 tmp=list;
93
94 return(list);
95 }
96
97 Node *insert(Node*list)
98 {
99 //insert into list
100 int input=0;
101 Node*tmp;
102 fprintf(stdout, "Which node would you like to insert before? ");
103 fscanf(stdin, "%d", &input);
104 int seeker;
105 tmp=list;
106 Node*tmp2=NULL;
107 for(seeker=0; seeker<(input-1); seeker++)
108 {
109 tmp=tmp->next;
110 }
111 if(input==0)
112 {
113 fprintf(stdout, "Enter value for new node: ");
114 fscanf(stdin, "%d", &input);
115 tmp2=(Node*)malloc(sizeof(Node));
116 tmp2->value=input;
117 tmp2->next=NULL;
118 tmp2->next=tmp;
119 list=tmp2;
120 }
121 else
122 {
123 fprintf(stdout, "Enter a value to insert: ");
124 fscanf(stdin, "%d", &input);
125 tmp2=(Node*)malloc(sizeof(Node));
126 tmp2->value=input;
127 tmp2->next=tmp->next;
128 tmp->next=tmp2;
129 }
130 tmp=list;
131
132 return(list);
133 }
134 Node *append(Node*list)
135 {
136 //Append to list
137 int input=0;
138 Node*tmp;
139 fprintf(stdout, "Enter what node you would like to append to: ");
140 fscanf(stdin, "%d", &input);
141 int behind;
142 tmp=list;
143 Node*tmp3=NULL;
144 for(behind=0; behind<input; behind++)
145 {
146 tmp=tmp->next;
147 }
148
149 fprintf(stdout, "What value would you like to append: ");
150 fscanf(stdin, "%d", &input);
151 tmp3=(Node*)malloc(sizeof(Node));
152 tmp3->value=input;
153 tmp3->next=tmp->next;
154 tmp->next=tmp3;
155
156 tmp=list;
157
158 return(list);
159 }
160
161 Node *removenode(Node*list)
162 {
163 int input=0;
164 Node*tmp;
165 tmp=list;
166 Node*tmp2=NULL;
167 int begone;
168 fprintf(stdout, "Which node would you like to remove?: ");
169 fscanf(stdin, "%d", &input);
170
171 for(begone=0; begone<(input-1);begone++)
172 {
173 tmp=tmp->next;
174 }
175 if(input==0)
176 {
177 tmp2=tmp->next;
178 tmp->next=NULL;
179 list=tmp2;
180 }
181 else
182 {
183 tmp2=tmp->next;
184 tmp->next=tmp2->next;
185 tmp2->next=NULL;
186 }
187 tmp=list;
188 return(list);
189 }
190
191 Node *display(Node*list)
192 {
193 int input=0;
194 Node*tmp;
195 tmp=list;
196 while(tmp!=NULL)
197 {
198 fprintf(stdout, "[%d] %d -> ", input, tmp->value);
199 tmp=tmp->next;
200 input=input++;
201 }
202 fprintf(stdout, "NULL\n");
203
204 return(list);
205 }
206
November 14th
Thanks to some assistance I have the majority of the stack header files and have listed them below, these will be vital in the operation of this program:
list.h
1 #ifndef _LIST_H
2 #define _LIST_H
3
4 #include "node.h"
5
6 struct list {
7 Node *start;
8 Node *end;
9 int qty;
10 };
11 typedef struct list List;
12
13 List *mklist();
14 List *insert(List *, Node *, Node *);
15 List *append(List *, Node *, Node *);
16 List *removeNode(List *, Node **);
17 void displayf(List *);
18 void displayb(List *);
19 List *clearlist(List *);
20 List *sortlist(List *);
21
22 #endif
node.h
1 #ifndef _NODE_H
2 #define _NODE_H
3
4 #include <stdlib.h>
5
6 struct node {
7 struct node *next;
8 struct node *prev;
9 int value;
10 };
11 typedef struct node Node;
12
13 Node *mknode(int);
14 void rmnode(Node **);
15 Node *cpnode(Node *);
16
17 #endif
stack.h
1 #ifndef _STACK_H
2 #define _STACK_H
3 #include "list.h"
4
5 struct stack {
6 List *data;
7 Node *top;
8 int size;
9 };
10 typedef struct stack Stack;
11
12 Stack *mkstack(int);
13 Stack *push (Stack *, Node *);
14 Node *pop (Stack **);
15 Node *peek (Stack *);
16
17 #endif
November 21
After a few days of confusion I managed to get my hands of the completed files, which have been listed below.
peek.c
1 #include "stack.h"
2
3 Node *peek(Stack *myStack)
4 {
5 return(myStack->top);
6 }
pop.c
1 #include "stack.h"
2
3 Node *pop(Stack **myStack)
4 {
5 Node *tmp = NULL;
6
7 if ((*myStack) != NULL)
8 {
9 tmp = (*myStack) -> data -> end;
10 (*myStack) -> data = getNode((*myStack) -> data, (&tmp));
11 (*myStack) -> top = (*myStack) -> data -> end;
12 }
13
14 return (tmp);
15 }
push.c
1 #include "stack.h"
2
3 Stack *push(Stack *myStack, Node *newNode)
4 {
5 if ((myStack -> size <= 0) || ((myStack -> data -> qty) < (myStack -> size)))
6 {
7 myStack -> data = append(myStack -> data, myStack -> data -> end, newNode);
8 myStack -> top = myStack -> data -> end;
9 }
10
11 return(myStack);
12 }
stackops.c
1 #include "stack.h"
2
3 Stack *mkstack(int size)
4 {
5 Stack *myStack;
6
7 myStack = (Stack *) malloc (sizeof(Stack));
8
9 myStack -> data = mklist();
10 myStack -> size = size;
11 myStack -> top = myStack -> data -> end;
12
13 return (myStack);
14 }
November 28
I've been extremely busy with work and other personal matters along with having internet canceled due to parents not paying bills, but regardless I have acquired the queue files and assembled them here;
stack.h
1 #ifndef _STACK_H
2 #define _STACK_H
3
4 #include "list.h"
5
6 struct stack {
7 List *data;
8 Node *top;
9 int size;
10 };
11 typedef struct stack Stack;
12
13 Stack *mkstack(int);
14 Stack *push (Stack *, Node *);
15 Node *pop (Stack **);
16 Node *peek (Stack *);
17
18 #endif
node.h
1 #ifndef _NODE_H
2 #define _NODE_H
3
4 #include <stdlib.h>
5
6 struct node {
7 struct node *next;
8 struct node *prev;
9 int value;
10 };
11 typedef struct node Node;
12
13 Node *mknode(int);
14 void rmnode(Node **);
15 Node *cpnode(Node *);
16
17 #endif
list.h
1 #ifndef _LIST_H
2 #define _LIST_H
3
4 #include "node.h"
5
6 struct list {
7 Node *start;
8 Node *end;
9 int qty;
10 };
11 typedef struct list List;
12
13 List *mklist();
14 List *insert(List *, Node *, Node *);
15 List *append(List *, Node *, Node *);
16 List *removeNode(List *, Node **);
17 void displayf(List *);
18 void displayb(List *);
19 List *clearlist(List *);
20 List *sortlist(List *);
21
22 #endif
queue.h
1 #ifndef _QUEUE_H
2 #define _QUEUE_H
3
4 #include "stack.h"
5
6 struct queue {
7 List *data;
8 Node *front;
9 Node *back;
10 int bufsize;
11 };
12 typedef struct queue Queue;
13
14 Queue *mkqueue(int);
15 Queue *enqueue (Queue *, Node *);
16 Node *dequeue (Queue **);
17
18 #endif
dequeue.c
1 #include "queue.h"
2 #include "stack.h"
3 #include "list.h"
4 Node *dequeue(Queue **myQueue)
5 {
6 Node *tmp = NULL;
7
8 if ((*myQueue) != NULL)
9 {
10 tmp = (*myQueue) -> data -> start;
11 (*myQueue) -> data = getNode((*myQueue) -> data, (&tmp));
12 (*myQueue) -> front = (*myQueue) -> data -> start;
13 }
14
15 return (tmp);
16 }
enqueue.c
1 #include "queue.h"
2 #include "stack.h"
3 #include "list.h"
4
5 Queue *enqueue(Queue *myQueue, Node *newNode)
6 {
7 if ((myQueue -> bufsize <= 0) || ((myQueue -> data -> qty) < (myQueue -> bufsize)))
8 {
9 myQueue -> data = append(myQueue -> data, myQueue -> data -> end, newNode);
10 myQueue -> back = myQueue -> data -> end;
11 }
12
13 return(myQueue);
14 }
mkqueue.c
1 #include "queue.h"
2 #include "stack.h"
3 #include "list.h"
4
5
6 Queue *mkqueue(int size)
7 {
8 Queue *myQueue= (Queue *)malloc(sizeof(Queue));
9 myQueue->data = mklist(size);
10 myQueue->front=myQueue->data->start;
11 myQueue->back=myQueue->data->end;
12 return(myQueue);
13 }
queuetest.c
1 #include <stdio.h>
2 #include "queue.h"
3 #include "stack.h"
4
5 int main()
6 {
7 Node *tmp;
8 Queue *myQueue;
9 myQueue = mkqueue(0);
10 tmp = create(1);
11 tmp -> value = fgetc(stdin);
12 fgetc(stdin);
13 myQueue = enqueue(myQueue, tmp);
14 myQueue->data->start = myQueue -> front = tmp;
15 myQueue->data->start->prev = NULL;
16
17 while(tmp->value != '\n')
18 {
19 tmp->next = create(1);
20 tmp->next->value = fgetc(stdin);
21 tmp->next->prev = tmp;
22 fgetc(stdin);
23 tmp=tmp->next;
24 myQueue = enqueue(myQueue, tmp);
25 myQueue->data->end=myQueue->back = tmp;
26 }
27
28 fprintf(stdout, "String is: ");
29 while(tmp != NULL)
30 {
31 tmp = dequeue(&myQueue);
32 fprintf(stdout, "%c", tmp->value);
33 rmnode((&tmp));
34 if(myQueue->back == myQueue->front)
35 {
36 tmp = NULL;
37 }
38 }
39 fprintf(stdout, "\n");
40 return(0);
41 }
DATE
DATE
DATE
opus/fall2013/khoose2/journal.txt · Last modified: 2013/12/13 12:22 by khoose2
Except where otherwise noted, content on this wiki is licensed under the following license: CC Attribution-Share Alike 4.0 International
