304 Pages·2013·4.65 MB·English

Save to my drive

Quick download

Download

BOOKS FOR PROFESSIONALS BY PROFESSIONALS® Kalicharan Advanced Topics in C RELATED C is the most widely used programming language of all time. It has been used to create almost every category of software imaginable and the list keeps growing every day. Cutting-edge applications, such as Arduino, embeddable and wearable computing are ready-made for C. Advanced Programming In C teaches concepts that any budding programmer should know. You’ll delve into topics such as sorting, searching, merging, recur- sion, random numbers and simulation, among others. You will increase the range of problems you can solve when you learn how to manipulate versatile and popular data structures such as binary trees and hash tables. This book assumes you have a working knowledge of basic programming con- cepts such as variables, constants, assignment, selection (if..else) and looping (while, for). It also assumes you are comfortable with writing functions and working with arrays. If you study this book carefully and do the exercises conscientiously, you would become a better and more agile programmer, more prepared to code today’s applications (such as the Internet of Things) in C. With Advanced Programming In C, you will learn: • What are and how to use structures, pointers, and linked lists • How to manipulate and use stacks and queues • How to use random numbers to program games, and simulations • How to work with files, binary trees, and hash tables • Sophisticated sorting methods such as heapsort, quicksort, and mergesort • How to implement all of the above using C Shelve in ISBN 978-1-4302-6400-2 Programming Languages / ANSI C User level: Intermediate 9 781430 264002 SOURCE CODE ONLINE www.apress.com For your convenience Apress has placed some of the front matter material after the index. Please use the Bookmarks and Contents at a Glance links to access them. Contents at a Glance About the Author ���������������������������������������������������������������������������������������������������������������xiii About the Technical Reviewer ��������������������������������������������������������������������������������������������xv Preface �����������������������������������������������������������������������������������������������������������������������������xvii ■ Chapter 1: Sorting, Searching, and Merging ���������������������������������������������������������������������1 ■ Chapter 2: Structures ������������������������������������������������������������������������������������������������������27 ■ Chapter 3: Pointers ����������������������������������������������������������������������������������������������������������51 ■ Chapter 4: Linked Lists ����������������������������������������������������������������������������������������������������69 ■ Chapter 5: Stacks and Queues ���������������������������������������������������������������������������������������103 ■ Chapter 6: Recursion �����������������������������������������������������������������������������������������������������133 ■ Chapter 7: Random Numbers, Games, and Simulation ��������������������������������������������������159 ■ Chapter 8: Working with Files ���������������������������������������������������������������������������������������183 ■ Chapter 9: Introduction to Binary Trees ������������������������������������������������������������������������213 ■ Chapter 10: Advanced Sorting ���������������������������������������������������������������������������������������241 ■ Chapter 11: Hashing ������������������������������������������������������������������������������������������������������265 Index ���������������������������������������������������������������������������������������������������������������������������������287 v Chapter 1 Sorting, Searching, and Merging In this chapter, we will explain the following: • How to sort a list of items using selection and insertion sort • How to add a new item to a sorted list so that the list remains sorted • How to sort an array of strings • How to sort related (parallel) arrays • How to search a sorted list using binary search • How to search an array of strings • How to write a program to do a frequency count of words in a passage • How to merge two sorted lists to create one sorted list 1.1 Sorting an Array: Selection Sort Sorting is the process by which a set of values are arranged in ascending or descending order. There are many reasons to sort. Sometimes we sort in order to produce more readable output (for example, to produce an alphabetical listing). A teacher may need to sort her students in order by name or by average score. If we have a large set of values and we want to identify duplicates, we can do so by sorting; the repeated values will come together in the sorted list. Another advantage of sorting is that some operations can be performed faster and more efficiently with sorted data. For example, if data is sorted, it is possible to search it using binary search—this is much faster than using a sequential search. Also, merging two separate lists of items can be done much faster than if the lists were unsorted. There are many ways to sort. In this chapter, we will discuss two of the “simple” methods: selection and insertion sort. In Chapter 10, we will look at more sophisticated ways to sort. We start with selection sort. Consider the following list of numbers stored in a C array, num: 1 Chapter 1 ■ Sorting, SearChing, and Merging Sorting num in ascending order using selection sort proceeds as follows: 1st pass • Find the smallest number in the entire list, from positions 0 to 6; the smallest is 15, found in position 4. • Interchange the numbers in positions 0 and 4. This gives us the following: 2nd pass • Find the smallest number in positions 1 to 6; the smallest is 33, found in position 5. • Interchange the numbers in positions 1 and 5. This gives us the following: 3rd pass • Find the smallest number in positions 2 to 6; the smallest is 48, found in position 5. • Interchange the numbers in positions 2 and 5. This gives us the following: 4th pass • Find the smallest number in positions 3 to 6; the smallest is 52, found in position 6. • Interchange the numbers in positions 3 and 6. This gives us the following: 5th pass • Find the smallest number in positions 4 to 6; the smallest is 57, found in position 4. • Interchange the numbers in positions 4 and 4. This gives us the following: 2 Chapter 1 ■ Sorting, SearChing, and Merging 6th pass • Find the smallest number in positions 5 to 6; the smallest is 65, found in position 6. • Interchange the numbers in positions 5 and 6. This gives us the following: The array is now completely sorted. Note that once the 6th largest (65) has been placed in its final position (5), the largest (79) would automatically be in the last position (6). In this example, we made six passes. We will count these passes by letting the variable h go from 0 to 5. On each pass, we find the smallest number from positions h to 6. If the smallest number is in position s, we interchange the numbers in positions h and s. In general, for an array of size n, we make n-1 passes. In our example, we sorted seven numbers in six passes. The following is a pseudocode outline of the algorithm for sorting num[0..n-1]: for h = 0 to n - 2 s = position of smallest number from num[h] to num[n-1] swap num[h] and num[s] endfor We can implement this algorithm as follows, using the generic parameter, list: void selectionSort(int list[], int lo, int hi) { //sort list[lo] to list[hi] in ascending order int getSmallest(int[], int, int); void swap(int[], int, int); for (int h = lo; h < hi; h++) { int s = getSmallest(list, h, hi); swap(list, h, s); } } The two statements in the for loop could be replaced by this: swap(list, h, getSmallest(list, h, hi)); We can write getSmallest and swap as follows: int getSmallest(int list[], int lo, int hi) { //return location of smallest from list[lo..hi] int small = lo; for (int h = lo + 1; h <= hi; h++) if (list[h] < list[small]) small = h; return small; } 3 Chapter 1 ■ Sorting, SearChing, and Merging void swap(int list[], int i, int j) { //swap elements list[i] and list[j] int hold = list[i]; list[i] = list[j]; list[j] = hold; } To test whether selectionSort works properly, we write Program P1.1. Only main is shown. To complete the program, just add selectionSort, getSmallest, and swap. Program P1.1 #include <stdio.h> #define MaxNumbers 10 int main() { void selectionSort(int [], int, int); int num[MaxNumbers]; printf("Type up to %d numbers followed by 0\n", MaxNumbers); int n = 0, v; scanf("%d", &v); while (v != 0 && n < MaxNumbers) { num[n++] = v; scanf("%d", &v); } if (v != 0) { printf("More than %d numbers entered\n", MaxNumbers); printf("First %d used\n", MaxNumbers); } //n numbers are stored from num[0] to num[n-1] selectionSort(num, 0, n-1); printf("\nThe sorted numbers are\n"); for (int h = 0; h < n; h++) printf("%d ", num[h]); printf("\n"); } The program requests up to ten numbers (as defined by MaxNumbers), stores them in the array num, calls selectionSort, and then prints the sorted list. The following is a sample run of the program: Type up to 10 numbers followed by 0 57 48 79 65 15 33 52 0 The sorted numbers are 15 33 48 52 57 65 79 Note that if the user enters more than ten numbers, the program will recognize this and sort only the first ten. 4 Chapter 1 ■ Sorting, SearChing, and Merging 1.1.1 Analysis of Selection Sort To find the smallest of k items, we make k-1 comparisons. On the first pass, we make n-1 comparisons to find the smallest of n items. On the second pass, we make n-2 comparisons to find the smallest of n-1 items. And so on, until the last pass where we make one comparison to find the smaller of two items. In general, on the jth pass, we make n-j comparisons to find the smallest of n-j+1 items. Hence: total number of comparisons = 1 + 2 + ...+ n-1 = ½ n(n-1) » ½ n2 We say selection sort is of order O(n2) (“big O n squared”). The constant ½ is not important in “big O” notation since, as n gets very big, the constant becomes insignificant. On each pass, we swap two items using three assignments. Since we make n-1 passes, we make 3(n-1) assignments in all. Using “big O” notation, we say that the number of assignments is O(n). The constants 3 and 1 are not important as n gets large. Does selection sort perform any better if there is order in the data? No. One way to find out is to give it a sorted list and see what it does. If you work through the algorithm, you will see that the method is oblivious to order in the data. It will make the same number of comparisons every time, regardless of the data. As we will see, some sorting methods, such as mergesort and quicksort (see Chapters 6 and 10) require extra array storage to implement them. Note that selection sort is performed “in place” in the given array and does not require additional storage. As an exercise, modify the programming code so that it counts the number of comparisons and assignments made in sorting a list using selection sort. 1.2 Sorting an Array: Insertion Sort Consider the same array as before: Now, think of the numbers as cards on a table that are picked up one at a time, in the order they appear in the array. Thus, we first pick up 57, then 48, then 79, and so on, until we pick up 52. However, as we pick up each new number, we add it to our hand in such a way that the numbers in our hand are all sorted. When we pick up 57, we have just one number in our hand. We consider one number to be sorted. When we pick up 48, we add it in front of 57 so our hand contains the following: 48 57 When we pick up 79, we place it after 57 so our hand contains the following: 48 57 79 When we pick up 65, we place it after 57 so our hand contains the following: 48 57 65 79 At this stage, four numbers have been picked up, and our hand contains them in sorted order. 5 Chapter 1 ■ Sorting, SearChing, and Merging When we pick up 15, we place it before 48 so our hand contains the following: 15 48 57 65 79 When we pick up 33, we place it after 15 so our hand contains the following: 15 33 48 57 65 79 Finally, when we pick up 52, we place it after 48 so our hand contains the following: 15 33 48 52 57 65 79 The numbers have been sorted in ascending order. The method described illustrates the idea behind insertion sort. The numbers in the array will be processed one at a time, from left to right. This is equivalent to picking up the numbers from the table, one at a time. Since the first number, by itself, is sorted, we will process the numbers in the array starting from the second. When we come to process num[h], we can assume that num[0] to num[h-1] are sorted. We insert num[h] among num[0] to num[h-1] so that num[0] to num[h] are sorted. We then go on to process num[h+1]. When we do so, our assumption that num[0] to num[h] are sorted will be true. Sorting num in ascending order using insertion sort proceeds as follows: 1st pass • Process num[1], that is, 48. This involves placing 48 so that the first two numbers are sorted; num[0] and num[1] now contain the following: The rest of the array remains unchanged. 2nd pass • Process num[2], that is, 79. This involves placing 79 so that the first three numbers are sorted; num[0] to num[2] now contain the following: The rest of the array remains unchanged. 3rd pass • Process num[3], that is, 65. This involves placing 65 so that the first four numbers are sorted; num[0] to num[3] now contain the following: 6 Chapter 1 ■ Sorting, SearChing, and Merging The rest of the array remains unchanged. 4th pass • Process num[4], that is, 15. This involves placing 15 so that the first five numbers are sorted. To simplify the explanation, think of 15 as being taken out and stored in a simple variable (key, say) leaving a “hole” in num[4]. We can picture this as follows: The insertion of 15 in its correct position proceeds as follows: • Compare 15 with 79; it is smaller, so move 79 to location 4, leaving location 3 free. This gives the following: • Compare 15 with 65; it is smaller, so move 65 to location 3, leaving location 2 free. This gives the following: • Compare 15 with 57; it is smaller, so move 57 to location 2, leaving location 1 free. This gives the following: • Compare 15 with 48; it is smaller, so move 48 to location 1, leaving location 0 free. This gives the following: 7

×