Homework / Quiz

1
Homework / Quiz

• Exam 2
• Solutions Posted
• Questions?
• Continuing KR Chapter 6
• HW6 is on line due class 22

2
Self Referential structs, KR 6.5

• Look at this binary tree structure (Pg. 139)

now
is
the
for
men
of
time
all
party
their
to
good
aid
come
3
Self Referential structs

• struct tnode / the tree node struct
  /
• char word / points to the word at this
  node /
• int count / has a count of occurances
  /
• struct tnode left / a word lt one at this
  node /
• struct tnode right / a word gt one at this
  node /
• OK to have a pointer to a struct of same type in
  its own definition
• NOT OK to have a struct itself in its own
  definition!

4
Tree of struct tnodes
tnode root
char word int count tnode left tnode right
keyword \0

char word int count tnode left tnode right



char word int count tnode left tnode right


5
Self Referential structs

• Each node is a struct tnode with a string value
  and a count of occurrences
• Each node also contains a pointer to a left child
  and a right child
• Each child is another struct tnode

6
Declarations / Prototypes

• include ltstdio.hgt
• include ltctype.hgt (see functions in App. B2,
  pp. 248-249, KR)
• include ltstring.hgt (see functions in App. B3,
  pp. 249-250, KR)
• include getch.h
• define MAXWORD 100
• int getword(char word, int lim)
• struct tnode addtree(struct tnode , char )
• void treeprint(struct tnode )

7
Main program

• int main( )
• struct tnode root / ptr to root for
  binary tree /
• char wordMAXWORD / word to get from
  stdin /
• root NULL / initially, no tnodes
  in tree /
• / OK that root pointer points to NULL
  initially /
• while (getword(word, MAXWORD) ! EOF) /
  getword from stdin /
• if (isalpha(word0)) / from ctype.h
  library /
• root addtree(root, word) / expect not
  NULL anymore /
• treeprint(root) / print it out in
  order /
• return 0

8
treeprint ( )

• To print out tree contents in order
• void treeprint (struct tnode p)
• if (p ! NULL)
• treeprint (p-gtleft)
• printf (4d s\n, p-gtcount, p-gtword)
• treeprint (p-gtright)

9
getword ( )

• int getword(char word, int lim)
• int c char w word
• while isspace(c getch()) / skip spaces c
  first non-space /
• if (c ! EOF) wc / c might be EOF here
  (empty word) /
• if(!isalpha(c)) / c (identifier) starts
  with alpha /
• w '\0' return c / if not, word empty /
• for( --lim gt 0 w)
• if (!isalnum(w getch())) / identfier
  alpha or digits /
• ungetch(w) break / e.g., might be
  needed later /
• w '\0'
• return word0

10
addtree ( )

• struct tnode talloc(void) / allocate. return
  ptr to tnode /
• char strdup(char ) / allocate space, copy
  word there /
• struct tnode addtree(struct tnode p, char w)
• int cond
• /for empty tree, root is NULL /
• if (p NULL) / nothing at this
  node yet /
• p talloc() / allocate a new
  node /
• p-gtword strdup(w) / allocate space,
  copy word there /
• p-gtcount 1 / count is 1
  /
• p-gtleft p-gtright NULL / this works
  see precedence /
• else if ((cond strcmp(w, p-gtword)) 0)
  / string.h /
• p-gtcount / repeated word,
  increment count /
• else if (cond lt 0) / note cond
  remembers strcmp above /
• p-gtleft addtree(p-gtleft, w) / less
  go left subtree /
• else / more, go to right
  subtree /
• p-gtright addtree(p-gtright, w)
• return p

11
addtree( )

• Note, that addtree is recursive. If it adds a
  node, it might need to add root or any left or
  right child anywhere down the tree
• We pass struct tnode p as first argument, and
  also pass back the same type - always a pointer
  to the node at the current recursive nesting
  level
• Any time a new node is created root, p-gtleft
  or p-gtright in node above will be set for the
  FIRST time based on return value from addtree

12
addtree ( )

• When main calls addtree, the return sets root
  value each time even if the root already pointed
  to tnode
• Allows for possible addition of a pointer to a
  node
• Why do we need to return a struct tnode p when
  we have struct tnode p as an argument?
• Can't we just set it via argument, return void
  from addtree, and write (in main)?
• addtree(root, word)
• instead of
• root addtree(root, word)

13
addtree ( )

• No, root is already a pointer, struct tnode ,
  but it is the pointer root itself that must be
  modified
• To modify root, we would need to declare addtree
  with a pointer to a struct tnode as the first
  arg
• void addtree(struct tnode pptr, char w)
• struct tnode p pptr
• Call it from main recursively by invocation
• addtree(root, word)
• Then, addtree could set the value for root
  directly
• pptr p
• Same is true when adding a left or right child

14
talloc ( )

• How to write talloc to allocate a tnode and
  return a pointer.
• struct tnode talloc(void)
• return (struct tnode ) malloc
  (sizeof(struct tnode))

15
strdup ( )

• strdup ( ) creates space for a character string,
  copies a word into it (up to null terminator) and
  returns the char pointer
• char strdup(char s)
• p (char ) malloc (strlen(s)1) / 1 for
  '\0' /
• if (p ! NULL) / if malloc didnt fail
  /
• strcpy(p, s) / library function in
  string.h /
• return p

16
Intro to HW6

• Memory model for malloc( ) and free( )
• Before any calls to alloc( )
• allocbuf
• After two calls to alloc( ) and before call to
  freef( )
• allocbuf
• After call to freef( ) on first block alloc gave
  out
• allocbuf

Free
Free
In Use
In Use
Free
Free
In Use
17
Intro to HW6

• Fragmentation with malloc( ) and free( )
• Before call to alloc( ) for a large memory block
• allocbuf
• alloc can NOT provide a large contiguous block
• of memory - even though there is theoretically
• sufficient free memory! Memory is fragmented!!

In use
Free
In use
Free
In use
Free
In use
18
Intro to HW6

• Not possible to defragment allocbuf memory
  after the fact as you would do for a disk
• On a disk, the pointers to memory are in the disk
  file allocation table and can be changed
• With malloc, programs are holding pointers to
  memory they own - so cant be changed!!
• Can only defragment as blocks are freed by using
  program

19
Intro to HW6

• Initial structures in allocbuf
• Structures after two calls to alloc()

blockl
blockr
Free Memory
blockl
blockl
blockl
blockr
blockr
blockr
Inuse 1
Inuse 2
Free Memory
20
Intro to HW6

• Structures after free call on first block only
• Structures after free call on second block only

blockl
blockl
blockl
blockr
blockr
blockr
Free Memory
Inuse 2
Free Memory
blockl
blockl
blockr
blockr
Inuse 1
Free Memory
Note effect of coalesce!
21
Intro to HW6

• Four possible states for block being freed
• Between two blocks that are still in-use
• Above a free block and below an in-use block
• Above an in-use block and below a free block
• Above a free block and below a free block
• When freeing a block, coalesce with adjacent free
  blocks to avoid unnecessary fragmentation of
  allocbuf (allows alloc to serve later requests
  for large amounts of memory)