Table of Contents for
Intermediate C Programming

Version ebook / Retour

Cover image for bash Cookbook, 2nd Edition Intermediate C Programming by Yung-Hsiang Lu Published by CRC Press, 2015
  1. Front Cover
  2. Contents (1/2)
  3. Contents (2/2)
  4. List of Figures (1/2)
  5. List of Figures (2/2)
  6. List of Tables
  7. Foreword
  8. Preface
  9. Author, Reviewers, and Artist
  10. Rules in Software Development
  11. Source Code
  12. I. Computer Storage: Memory and File
  13. 1. Program Execution (1/2)
  14. 1. Program Execution (2/2)
  15. 2. Stack Memory (1/5)
  16. 2. Stack Memory (2/5)
  17. 2. Stack Memory (3/5)
  18. 2. Stack Memory (4/5)
  19. 2. Stack Memory (5/5)
  20. 3. Prevent, Detect, and Remove Bugs (1/2)
  21. 3. Prevent, Detect, and Remove Bugs (2/2)
  22. 4. Pointers (1/6)
  23. 4. Pointers (2/6)
  24. 4. Pointers (3/6)
  25. 4. Pointers (4/6)
  26. 4. Pointers (5/6)
  27. 4. Pointers (6/6)
  28. 5. Writing and Testing Programs (1/4)
  29. 5. Writing and Testing Programs (2/4)
  30. 5. Writing and Testing Programs (3/4)
  31. 5. Writing and Testing Programs (4/4)
  32. 6. Strings (1/3)
  33. 6. Strings (2/3)
  34. 6. Strings (3/3)
  35. 7. Programming Problems and Debugging (1/4)
  36. 7. Programming Problems and Debugging (2/4)
  37. 7. Programming Problems and Debugging (3/4)
  38. 7. Programming Problems and Debugging (4/4)
  39. 8. Heap Memory (1/3)
  40. 8. Heap Memory (2/3)
  41. 8. Heap Memory (3/3)
  42. 9. Programming Problems Using Heap Memory (1/4)
  43. 9. Programming Problems Using Heap Memory (2/4)
  44. 9. Programming Problems Using Heap Memory (3/4)
  45. 9. Programming Problems Using Heap Memory (4/4)
  46. 10. Reading and Writing Files (1/3)
  47. 10. Reading and Writing Files (2/3)
  48. 10. Reading and Writing Files (3/3)
  49. 11. Programming Problems Using File (1/2)
  50. 11. Programming Problems Using File (2/2)
  51. II. Recursion
  52. 12. Recursion (1/4)
  53. 12. Recursion (2/4)
  54. 12. Recursion (3/4)
  55. 12. Recursion (4/4)
  56. 13. Recursive C Functions (1/4)
  57. 13. Recursive C Functions (2/4)
  58. 13. Recursive C Functions (3/4)
  59. 13. Recursive C Functions (4/4)
  60. 14. Integer Partition (1/5)
  61. 14. Integer Partition (2/5)
  62. 14. Integer Partition (3/5)
  63. 14. Integer Partition (4/5)
  64. 14. Integer Partition (5/5)
  65. 15. Programming Problems Using Recursion (1/5)
  66. 15. Programming Problems Using Recursion (2/5)
  67. 15. Programming Problems Using Recursion (3/5)
  68. 15. Programming Problems Using Recursion (4/5)
  69. 15. Programming Problems Using Recursion (5/5)
  70. III. Structure
  71. 16. Programmer-Defined Data Types (1/6)
  72. 16. Programmer-Defined Data Types (2/6)
  73. 16. Programmer-Defined Data Types (3/6)
  74. 16. Programmer-Defined Data Types (4/6)
  75. 16. Programmer-Defined Data Types (5/6)
  76. 16. Programmer-Defined Data Types (6/6)
  77. 17. Programming Problems Using Structure (1/4)
  78. 17. Programming Problems Using Structure (2/4)
  79. 17. Programming Problems Using Structure (3/4)
  80. 17. Programming Problems Using Structure (4/4)
  81. 18. Linked Lists (1/3)
  82. 18. Linked Lists (2/3)
  83. 18. Linked Lists (3/3)
  84. 19. Programming Problems Using Linked List (1/2)
  85. 19. Programming Problems Using Linked List (2/2)
  86. 20. Binary Search Trees (1/4)
  87. 20. Binary Search Trees (2/4)
  88. 20. Binary Search Trees (3/4)
  89. 20. Binary Search Trees (4/4)
  90. 21. Parallel Programming Using Threads (1/5)
  91. 21. Parallel Programming Using Threads (2/5)
  92. 21. Parallel Programming Using Threads (3/5)
  93. 21. Parallel Programming Using Threads (4/5)
  94. 21. Parallel Programming Using Threads (5/5)
  95. IV. Applications
  96. 22. Finding the Exit of a Maze (1/5)
  97. 22. Finding the Exit of a Maze (2/5)
  98. 22. Finding the Exit of a Maze (3/5)
  99. 22. Finding the Exit of a Maze (4/5)
  100. 22. Finding the Exit of a Maze (5/5)
  101. 23. Image Processing (1/3)
  102. 23. Image Processing (2/3)
  103. 23. Image Processing (3/3)
  104. 24. Huffman Compression (1/10)
  105. 24. Huffman Compression (2/10)
  106. 24. Huffman Compression (3/10)
  107. 24. Huffman Compression (4/10)
  108. 24. Huffman Compression (5/10)
  109. 24. Huffman Compression (6/10)
  110. 24. Huffman Compression (7/10)
  111. 24. Huffman Compression (8/10)
  112. 24. Huffman Compression (9/10)
  113. 24. Huffman Compression (10/10)
  114. A. Linux
  115. B. Version Control
  116. C. Integrated Development Environments (IDE) (1/3)
  117. C. Integrated Development Environments (IDE) (2/3)
  118. C. Integrated Development Environments (IDE) (3/3)
Linked Lists 303
while (head != NULL)
4
{5
printf("%d", head -> value);6
head = head -> next;7
}8
printf("\n\n");9
}10
11
static void List_print2Help(Node * head)12
{13
if (head == NULL)14
{15
return ;16
}17
printf("%d", head -> value);18
List_print2Help(head -> next);19
}20
21
void List_print2(Node * head)22
{23
printf("\nPrintthewholelist:\n");24
List_print2Help(head);25
printf("\n\n");26
}27
List print2 is the recursive function. It prints the message and then calls a helper
function. The helper function goes through the nodes one by one until reaching the end of
the list.
18.7 Destro ying a Linked List
List destroy destroys the whole list, releasing the memory for each node. The non-
recursive method keeps a pointer p for the node after the node to be deleted. The recursive
method uses the call stack to keep the value of head. Note that line 18 must be after line
17 because head -> next does not exist after free (head).
void List_destroy(Node * head)
1
{2
while (head != NULL)3
{4
Node * p = head -> next;5
free (head);6
head = p;7
}8
}9
10
void List_destroy2(Node * head)11
{12
if (head == NULL)13
304 Intermediate C Programming
{
14
return ;15
}16
List_destroy2(head -> next);17
free (head); // must be after the recursive call18
}19
The following main function shows how to use the linked list functions we have developed
in this chapter.
// file: main.c
1
#include "list.h"2
#include <stdlib.h>3
#include <stdio.h>4
int main(int argc , char * argv[])5
{6
Node * head = NULL; /* must initialize it to NULL */7
head = List_insert(head, 917);8
head = List_insert(head, -504);9
head = List_insert(head, 326);10
List_print(head);11
head = List_delete(head, -504);12
List_print(head);13
head = List_insert(head, 138);14
head = List_insert(head, -64);15
head = List_insert(head, 263);16
List_print(head);17
if (List_search(head, 138) != NULL)18
{19
printf("138isinthelist\n");20
}21
else22
{23
printf("138isnotinthelist\n");24
}25
if (List_search(head, 987) != NULL)26
{27
printf("987isinthelist\n");28
}29
else30
{31
printf("987isnotinthelist\n");32
}33
head = List_delete(head, 263); // delete the first Node34
List_print(head);35
head = List_delete(head, 917); // delete the last Node36
List_print(head);37
List_destroy(head); // delete all Nodes38
return EXIT_SUCCESS;39
}40
The output of this program is:
Linked Lists 305
insert 917
insert -504
insert 326
Print the whole list:
326 -504 917
delete -504
Print the whole list:
326 917
insert 138
insert -64
insert 263
Print the whole list:
263 -64 138 326 917
138 is in the list
987 is not in the list
delete 263
Print the whole list:
-64 138 326 917
delete 917
Print the whole list:
-64 138 326
This page intentionally left blankThis page intentionally left blank