C Programming Data Structures 4th Edition E.

Balagurusamy download

https://ebookgate.com/product/c-programming-data-structures-4th-
edition-e-balagurusamy/

Get Instant Ebook Downloads – Browse at https://ebookgate.com

 Get Your Digital Files Instantly: PDF, ePub, MOBI and More
Quick Digital Downloads: PDF, ePub, MOBI and Other Formats

Programming in ANSI C 6th Edition E. Balagurusamy

https://ebookgate.com/product/programming-in-ansi-c-6th-edition-
e-balagurusamy/

Computer Programming 1st Edition E. Balagurusamy

https://ebookgate.com/product/computer-programming-1st-edition-e-
balagurusamy/

C Programming Program design including data structures

5ed. Edition Malik D.S.

https://ebookgate.com/product/c-programming-program-design-
including-data-structures-5ed-edition-malik-d-s/

Data Structures and Algorithms in C 4th Edition Adam

Drozdek

https://ebookgate.com/product/data-structures-and-algorithms-
in-c-4th-edition-adam-drozdek/
C Programming Program Design Including Data Structures
7th Edition D. S. Malik

https://ebookgate.com/product/c-programming-program-design-
including-data-structures-7th-edition-d-s-malik/

C Programming Program Design Including Data Structures

6th Edition D. S. Malik

https://ebookgate.com/product/c-programming-program-design-
including-data-structures-6th-edition-d-s-malik/

Data Structures and Other Objects Using C 4th Edition

Michael Main

https://ebookgate.com/product/data-structures-and-other-objects-
using-c-4th-edition-michael-main/

Data Structures Using C 2nd Edition D. S. Malik

https://ebookgate.com/product/data-structures-using-c-2nd-
edition-d-s-malik/

Data Structures Other Objects using Java 4th Edition

Michael Mann

https://ebookgate.com/product/data-structures-other-objects-
using-java-4th-edition-michael-mann/
 As per the
Revised
Syllabus Effective
August 2007

C Programming
and
Data Structures
Fourth Edition
About the Author
E Balagurusamy, former Vice Chancellor, Anna University, Chennai, is currently Member, Union
Public Service Commission, New Delhi. He is a teacher, trainer, and consultant in the fields of Informa-
tion Technology and Management. He holds an ME (Hons) in Electrical Engineering and Ph.D in
Systems Engineering from the Indian Institute of Technology, Roorkee. His areas of interest include
Object-Oriented Software Engineering, Electronic Business, Technology Management, Business
Process Re-engineering, and Total Quality Management.
A prolific writer, he has authored a large number of research papers and several books. His best
selling books, among others include:
· Programming in C#, 2/e
· Programming in Java, 3/e
· Object-Oriented Programming with C++, 4/e
· Programming in BASIC, 3/e
· Programming in ANSI C, 4/e
· Numerical Methods
· Reliability Engineering
A recipient of numerous honours and awards, he has been listed in the Directory of Who’s Who of
Intellectuals and in the Directory of Distinguished Leaders in Education.
 As per the
Revised
Syllabus Effective
August 2007

C Programming
and
Data Structures
Fourth Edition

E Balagurusamy
Member, UPSC
New Delhi

Tata McGraw-Hill Publishing Company Limited

NEW DELHI
McGraw-Hill Offices
New Delhi New York St Louis San Francisco Auckland Bogotá Caracas
Kuala Lumpur Lisbon London Madrid Mexico City Milan Montreal
San Juan Santiago Singapore Sydney Tokyo Toronto
Published by the Tata McGraw-Hill Publishing Company Limited,
7 West Patel Nagar, New Delhi 110 008.

Copyright © 2009, by Tata McGraw-Hill Publishing Company Limited.

No part of this publication may be reproduced or distributed in any form or by any means, electronic, mechanical,
photocopying, recording, or otherwise or stored in a database or retrieval system without the prior written permis-
sion of the publishers. The program listings (if any) may be entered, stored and executed in a computer system, but
they may not be reproduced for publication.
This edition can be exported from India only by the publishers,
Tata McGraw-Hill Publishing Company Limited.
ISBN-13: 978-0-07-0084759
ISBN-10: 0-07-0084750
Managing Director—Ajay Shukla
General Manager: Publishing—SEM & Tech Ed: Vibha Mahajan
Sponsoring Editor—Shalini Jha
Senior Copy Editor—Dipika Dey
Junior Manager—Production, Anjali Razdan
Marketing General Manager—Higher Education & Sales: Michael J. Cruz
Product Manager—SEM & Tech Ed: Biju Ganesan
Controller—Production: Rajender P. Ghansela
Asst. General Manager— Production: B. L. Dogra

Information contained in this work has been obtained by Tata McGraw-Hill, from sources believed to be
reliable. However, neither Tata McGraw-Hill nor its authors guarantee the accuracy or completeness of any
information published herein, and neither Tata McGraw-Hill nor its authors shall be responsible for any
errors, omissions, or damages arising out of use of this information. This work is published with the under-
standing that Tata McGraw-Hill and its authors are supplying information but are not attempting to render
engineering or other professional services. If such services are required, the assistance of an appropriate
professional should be sought.

Typeset at Script Makers, 19, A1-B, DDA Market, Paschim Vihar, New Delhi 110 063, and printed at Shakti
Packers, 5C/9, New Rohtak Road, Karol Bagh, New Delhi-110 005
Cover: SDR Printers
DALZCRBFRAALX
 Contents

Foreword xi
Preface xiii
Road Map to the Syllabus xv
The C99 Standard xvii

UNIT I
1. Algorithms 1.3–1.15
1.1 Introduction ......................................................................................................................... 1.3
1.1.1 Algorithm/pseudocode .......................................................................................... 1.3
1.1.2 Flow Chart............................................................................................................ 1.4
1.2 Three Basic Operations ....................................................................................................... 1.5
1.2.1 Sequence .............................................................................................................. 1.5
1.2.2 Selection ............................................................................................................... 1.6
1.2.3 Iteration .............................................................................................................. 1.13
Review Questions and Exercises ..................................................................................... 1.14
2. Overview of C 2.1–2.12
2.1 Introduction ......................................................................................................................... 2.1
2.2 Importance of C .................................................................................................................. 2.1
2.3 Sample C Programs ............................................................................................................. 2.2
2.4 Program Development Steps ............................................................................................... 2.5
2.5 Structure of a C Program .................................................................................................... 2.9
Review Questions and Exercises ..................................................................................... 2.11
3. Constants, Variables, and Data Types 3.1–3.26
3.1 Introduction ........................................................................................................................ .3.1
3.2 Character Set ....................................................................................................................... 3.1
3.3 C Tokens ............................................................................................................................. 3.1
3.4 Keywords and Identifiers .................................................................................................... 3.2
3.5 Constants ............................................................................................................................. 3.3
3.6 Variables ............................................................................................................................. 3.7
3.7 Basic Data Types and Sizes ................................................................................................ 3.8
3.8 Declaration of Variables ................................................................................................... 3.11
3.9 Assigning Values to Variables .......................................................................................... 3.14
3.10 Defining Symbolic Constants ........................................................................................... 3.21
Review Questions and Exercises ................................................................................... 3.24
vi Contents
4. Operators and Expressions 4.1–4.22
4.1 Introduction ......................................................................................................................... 4.1
4.2 Arithmetic Operators .......................................................................................................... 4.1
4.3 Relational Operators ........................................................................................................... 4.4
4.4 Logical Operators ............................................................................................................... 4.5
4.5 Assignment Operators ......................................................................................................... 4.5
4.6 Increment and Decrement Operators .................................................................................. 4.7
4.7 Conditional Operator .......................................................................................................... 4.8
4.8 Bitwise Operators ............................................................................................................... 4.8
4.9 Special Operators ................................................................................................................ 4.9
4.10 Arithmetic Expressions ..................................................................................................... 4.11
4.11 Evaluation of Expressions ................................................................................................ 4.11
4.12 Precedence of Arithmetic Operators ................................................................................. 4.12
4.13 Some Computational Problems ......................................................................................... 4.14
4.14 Type Conversions in Expressions ..................................................................................... 4.15
4.15 Operator Precedence and Associativity ............................................................................ 4.18
Case Studies ..................................................................................................................... 4.19
Review Questions and Exercises ..................................................................................... 4.20
5. Managing Input and Output Operations 5.1–5.25
5.1 Introduction ......................................................................................................................... 5.1
5.1.1 Input/Output Statements and Header Files ........................................................... 5.1
5.2 Reading a Character ............................................................................................................ 5.2
5.3 Writing a Character ............................................................................................................ 5.4
5.4 Formatted Input ................................................................................................................... 5.5
5.5 Formatted Output .............................................................................................................. 5.14
Case Studies ..................................................................................................................... 5.21
Review Questions and Exercises ..................................................................................... 5.24
6. Decision Making and Branching 6.1–6.29
6.1 Introduction ......................................................................................................................... 6.1
6.2 Decision Making with If Statement .................................................................................... 6.1
6.3 Simple If Statement ............................................................................................................. 6.2
6.4 The If K Else Statement ..................................................................................................... 6.5
6.5 Nesting of If ... Else Statements .......................................................................................... 6.7
6.6 The Else If Ladder ............................................................................................................ 6.11
6.7 The Switch and Break Statements .................................................................................... 6.13
6.8 The ? : Operator ................................................................................................................ 6.17
6.9 The Goto Statement .......................................................................................................... 6.20
6.9.1 Label .................................................................................................................. 6.20
Case Studies ..................................................................................................................... 6.22
Review Questions and Exercises ..................................................................................... 6.26
7. Decision Making and Looping 7.1–7.30
7.1 Introduction ......................................................................................................................... 7.1
7.2 The While Statement ........................................................................................................... 7.3
7.3 The Do Statement ................................................................................................................ 7.4
 Contents vii
7.4 The For Statement ............................................................................................................... 7.6
7.5 Jumps in Loops ................................................................................................................. 7.14
7.6 Structured Programming ................................................................................................... 7.20
Case Studies ..................................................................................................................... 7.21
Review Questions and Exercises ..................................................................................... 7.27

UNIT II

8. Arrays 8.3–8.31
8.1 Introduction ......................................................................................................................... 8.3
8.2 One-Dimensional Arrays .................................................................................................... 8.3
8.3 Two-Dimensional Arrays.................................................................................................... 8.8
8.4 Initializing Two-Dimensional Arrays ............................................................................... 8.13
8.5 Multidimensional Arrays .................................................................................................. 8.15
Case Studies ..................................................................................................................... 8.17
Review Questions and Exercises ..................................................................................... 8.28
9. Handling of Character Strings 9.1–9.23
9.1 Introduction ......................................................................................................................... 9.1
9.2 Declaring and Initializing String Variables ........................................................................ 9.2
9.3 Reading Strings from Terminal ........................................................................................... 9.2
9.4 Writing Strings to Screen .................................................................................................... 9.5
9.5 Arithmetic Operations on Characters ................................................................................. 9.8
9.6 Putting Strings Together ................................................................................................... 9.10
9.7 Comparison of Two Strings .............................................................................................. 9.12
9.8 String-Handling Functions ................................................................................................ 9.13
9.9 Table of Strings ................................................................................................................. 9.15
Case Studies ..................................................................................................................... 9.18
Review Questions and Exercises ..................................................................................... 9.22
10. User-Defined Functions 10.1–10.50
10.1 Introduction ....................................................................................................................... 10.1
10.1.1 Standard Library Functions ................................................................................ 10.1
10.2 Need for User-Defined Functions ..................................................................................... 10.4
10.3 A Multi-Function Program ................................................................................................ 10.5
10.4 The Form of C Functions .................................................................................................. 10.7
10.5 Return Values and their Types .......................................................................................... 10.8
10.6 Calling a Function ............................................................................................................. 10.9
10.7 Category of Functions ..................................................................................................... 10.10
10.8 No Arguments and no Return Values ............................................................................. 10.10
10.9 Arguments but no Return Values .................................................................................... 10.12
10.10 Arguments with Return Values ....................................................................................... 10.14
10.11 Handling of Non-Integer Functions ................................................................................ 10.18
10.12 Nesting of Functions ....................................................................................................... 10.21
10.13 Recursion ........................................................................................................................ 10.22
10.14 Functions with Arrays ..................................................................................................... 10.23
10.15 The Scope and Lifetime of Variables in Functions—Storage Classes ............................ 10.26
viii Contents
10.16 ANSI C Functions ........................................................................................................... 10.36
10.17 The Preprocessor ............................................................................................................. 10.39
10.18 ANSI Additions .............................................................................................................. 10.42
Case Study ...................................................................................................................... 10.45
Review Questions and Exercises ................................................................................. 10.49

UNIT III

11. Pointers 11.3–11.32

11.1 Introduction ....................................................................................................................... 11.3
11.2 Understanding Pointers ..................................................................................................... 11.3
11.3 Accessing the Address of a Variable ................................................................................ 11.5
11.4 Declaring and Initializing Pointers ................................................................................... 11.6
11.5 Accessing a Variable Through its Pointer ........................................................................ 11.7
11.6 Pointer Expressions .......................................................................................................... 11.9
11.7 Pointer Increments and Scale Factor—Address Arithmetic ............................................ 11.11
11.8 Pointers and Arrays......................................................................................................... 11.12
11.9 Pointers and Character Strings ........................................................................................ 11.15
11.10 Pointers and Functions .................................................................................................... 11.17
11.11 Pointers and Structures ................................................................................................... 11.23
Case Studies ................................................................................................................... 11.25
Review Questions and Exercises ................................................................................... 11.31

UNIT IV

12. Structures and Unions 12.3–12.25

12.1 Introduction ....................................................................................................................... 12.3
12.2 Structure Definition—Declaring Structures ..................................................................... 12.3
12.3 Giving Values to Members ............................................................................................... 12.5
12.4 Structure Initialization ...................................................................................................... 12.6
12.5 Comparison of Structure Variables ................................................................................... 12.8
12.6 Arrays of Structures .......................................................................................................... 12.8
12.7 Arrays within Structures ................................................................................................. 12.11
12.8 Structures within Structures—Nested Structures ............................................................ 12.12
12.9 Structures and Functions ................................................................................................. 12.15
12.10 Unions ............................................................................................................................. 12.17
12.11 Size of Structures ............................................................................................................ 12.19
12.12 Bit Fields ......................................................................................................................... 12.19
Case Study ...................................................................................................................... 12.21
Review Questions and Exercises ................................................................................. 12.24

UNIT V

13. File Management in C 13.3–13.22

13.1 Introduction ....................................................................................................................... 13.3
13.2 Defining and Opening a File ............................................................................................. 13.7
 Contents ix
13.3 Closing a File .................................................................................................................... 13.8
13.4 Input/Output Operations on Files ...................................................................................... 13.9
13.5 Error Handling During I/O Operations ........................................................................... 13.12
13.6 Random Access to Files .................................................................................................. 13.14
13.7 Command Line Arguments ............................................................................................. 13.17
Case Study ...................................................................................................................... 13.19
Review Questions and Exercises ................................................................................... 13.21

UNIT VI

14. Data Structures 14.3–14.21

14.1 Introduction to Data Structures ......................................................................................... 14.3
14.2 Stacks ................................................................................................................................ 14.3
14.3 Queues .............................................................................................................................. 14.6
14.4 Circular Queues .............................................................................................................. 14.10
14.5 Applications of Stacks .................................................................................................... 14.11
Review Questions and Exercises ................................................................................... 14.21

UNIT VII

15. Dynamic Memory Allocation and Linked Lists 15.3–15.47

15.1 Introduction ....................................................................................................................... 15.3
15.2 Dynamic Memory Allocation ............................................................................................ 15.3
15.3 Linked Lists ...................................................................................................................... 15.9
15.3.1 Self-Referential Structure .................................................................................. 15.9
15.3.2 Singly Linked List ............................................................................................ 15.10
15.4 Advantages of Linked Lists ............................................................................................ 15.12
15.5 Types of Linked Lists...................................................................................................... 15.12
15.6 Pointers Revisited ........................................................................................................... 15.14
15.7 Basic List Operations...................................................................................................... 15.15
15.8 Application of Linked Lists ............................................................................................ 15.24
15.9 Circular Linked Lists ...................................................................................................... 15.25
15.10 Doubly Linked Lists ....................................................................................................... 15.25
15.11 Doubly Linked List Operations ...................................................................................... 15.26
15.12 Doubly Linked Circular Lists ......................................................................................... 15.35
15.13 Stacks and Queues using Linked List ............................................................................. 15.36
Case Studies ................................................................................................................... 15.40
Review Questions and Exercises ................................................................................... 15.46
16. Binary Trees and Graphs 16.1–16.25
16.1 Binary Trees—Representation and Terminology .............................................................. 16.1
16.2 Binary Tree Traversal ....................................................................................................... 16.2
16.3 Graphs ............................................................................................................................... 16.8
16.4 Graph Representation in C ................................................................................................ 16.9
16.5 Graph Traversal .............................................................................................................. 16.13
Review Questions and Exercises ................................................................................. 16.24
x Contents

UNIT VIII

17. Sorting and Searching Techniques 17.3–17.25

17.1 Introduction ....................................................................................................................... 17.3
17.2 Sorting ............................................................................................................................... 17.3
17.2.1 Sorting Efficiency .............................................................................................. 17.4
17.2.2 Exchange Sorting—Bubble Sort ........................................................................ 17.5
17.2.3 Exchange Sorting—Quick Sort .......................................................................... 17.7
17.2.4 Selection Sort ................................................................................................... 17.11
17.2.5 Merge Sort........................................................................................................ 17.13
17.2.6 Simple Insertion sort ........................................................................................ 17.15
17.2.7 Shell Sort .......................................................................................................... 17.17
17.3 Searching ........................................................................................................................ 17.18
17.3.1 Linear Search ................................................................................................... 17.18
17.3.2 Binary Search ................................................................................................... 17.20
17.3.3 Indexed Sequential Search ............................................................................... 17.23
Review Questions ........................................................................................................... 17.24
Appendix A
ASCII Values of Characters .......................................................................................A.1
Appendix B
Multiple Choice Questions .............................................................................. B.1–B.9
Appendix C
Solved Question Papers – C Programming and Data Structures
(May/June 2008) ............................................................................................... C.1–C.76
Bibliography .......................................................................................................................B.1
Chapter
1
Foreword

It gives me great pleasure to introduce C Programming and Data Structures by Dr E Balagurusamy,

publication of which heralds the completion of a book that caters completely and effectively to the
students of JNTU.
The need for a good textbook for this subject can be easily understood. Numerous books are available
to the students for the subject, but almost none of them have the right combination of simplicity, rigour,
pedagogy and syllabus compatibility. These books usually do not address one or more of the specific
problems faced by students of this subject in JNTU. There has always been a need for a good book
relevant to the requirements of the students and dealing with all aspects of the course. I am sure that the
present book will be able to fill this void.
The book has been organized and executed with lot of care and dedication. The author has been an
outstanding teacher and a pioneer of IT education in India. A conscious attempt has been made to
simplify concepts to facilitate better understanding of the subject.
Dr Balagurusamy deserves our praise and thanks for accomplishing this trying task. McGraw-Hill
Education, a prestigious publishing house, also deserves a pat on the back for doing an excellent job.

DR K. RAJAGOPAL
Vice-Chancellor
Jawaharlal Nehru Technological University
Hyderabad
Chapter
1
Preface

C is a general-purpose structured programming language that is powerful, efficient and compact. C

combines the features of high-level language with the elements of the assembler and is thus close to both
man and machine. The growth of C during the last few years has been phenomenal. It has emerged as the
language of choice for most applications due to speed, portability and compactness of code. It has now
been implemented on virtually every sort of computer, from micro to mainframe.
For many years, the de facto standard for implementing the language has been the original C Refer-
ence Manual by Kernighan and Ritchie published in 1978. During these years of growth and popularity,
C has undergone many changes. Numerous different features and facilities have been developed and
marketed. This has resulted in minor problems in terms of portability of programs. Consequently, the
American National Standard Institute (ANSI) constituted a committee to look into the language features
and produce a more comprehensive and unambiguous definition of C. The result is ANSI C. Most com-
pilers have already adopted ANSI standards.
This book incorporates all the features of ANSI C that are essential for a C programmer. The ANSI
standards are explained in detail in appropriate places. For the convenience of readers, these places
have been noted in the text by a special mention. A major highlight of this revised edition is the
inclusion of updated information on compiler C99 standard, with relevant theory and programs.
Another important addition in this edition is Appendix C containing 2008 solved question papers (4 sets).
The concept of ‘learning by example’ has been stressed throughout the book. Every important feature of
the language is treated in depth followed by a complete program example to illustrate its use. Case studies
at the end of the chapters not only describe the common ways in which C features are put together but
also show real-life applications. Wherever necessary, pictorial descriptions of concepts are included to
facilitate better understanding.
This book contains more than 100 examples and programs. All the programs have been tested using
compilers compatible to both UNIX and MS-DOS operating systems and, wherever appropriate, the
nature of output has been discussed. These programs also demonstrate the general principles of a good
programming style. 200 multiple choice questions are given to help the students test their conceptual
understanding of the subject.
The book also offers detailed discussions on Data Structures, Standard Library Functions,
Bit Fields, Linked Lists, Doubly Linked Lists, Queues, Stacks and Graphs with sample codes and
algorithms. Chapter 17 provides comprehensive information on Sorting and Searching techniques. Both
these topics are explained with sample codes. The various pros and cons of each of these techniques are
also covered.
xiv Preface
This edition comes with a CD which provides
More than 600 objective/review/debugging questions (8 units)
100 Programming exercises
Model question paper
2006 and 2007 solved question paper
Computer programs for lab
The objective of the supplementry CD is to make the students learn the programming language and
enable them to write their own programs using C and data structures.
The author is grateful to Mr A Rama Rao, Layola Institute of Technology & Management, Guntur
and Mr P Chenna Reddy, JNTU College of Engineering, Pulivendula for their useful comments and
suggestions.

E BALAGURUSAMY
Chapter
1
Road Map to the Syllabus
(Effective from August 2007)

Jawaharlal Nehru Technological University Hyderabad

I Year B.Tech T P C
4 0 6
C Programming and Data Structures
Objectives
· To make the student learn a programming language.
· To teach the student to write programs in C to solve the problems.
· To introduce the student to simple linear and non-liner data structures such as lists, stacks,
queues, trees and graphs.
Syllabus
Unit I
Algorithm / pseudo code, flowchart, program development steps, structure of C program, a simple C
program, identifiers, basic data types and sizes, constants, variables, arithmetic, relational and logical
operators, increment and decrement operators, conditional operator, bit-wise operators, assignment
operators, expressions, type conversions, conditional expressions, precedence and order of evaluation.
Input-output statements, statements and blocks, if and switch statements, loops- while, do-while and
for statements, break, continue, goto and labels, programming examples.

CHAPTER 1 – ALGORITHMS
CHAPTER 2 – OVERVIEW OF C
CHAPTER 3 – CONSTANTS, VARIABLES, AND DATA TYPES
Go To CHAPTER 4 – OPERATORS AND EXPRESSIONS
CHAPTER 5 – MANAGING INPUT AND OUTPUT OPERATIONS
CHAPTER 6 – DECISION MAKING AND BRANCHING
CHAPTER 7 – DECISION MAKING AND LOOPING

Unit II
Designing structured programs, functions, basics, parameter passing, storage classes- extern, auto,
register, static, scope rules, block structure, user-defined functions, standard library functions, recursive
functions, header files, C preprocessor, C program examples.

CHAPTER 7 – DECISION MAKING AND LOOPING

Go To
CHAPTER 10 – USER-DEFINED FUNCTIONS
xvi Road Map to the Syllabus
Unit III
Arrays- concepts, declaration, definition, accessing elements, storing elements, arrays and functions,
two-dimensional and multi-dimensional arrays, applications of arrays. pointers- concepts, initialization
of pointer variables, pointers and function arguments, address arithmetic, character pointers and
functions, pointers to pointers, pointers and multidimensional arrays, dynamic memory managements
functions, command line arguments, C program examples.

CHAPTER 8 – ARRAYS
Go To CHAPTER 9 – HANDLING OF CHARACTER
STRINGS
CHAPTER 11 – POINTERS
Unit IV
Derived types- structures- declaration, definition and initialization of structures, accessing structures,
nested structures, arrays of structures, structures and functions, pointers to structures, self-referential
structures, unions, typedef, bitfields, C program examples.

CHAPTER 12 – STRUCTURES AND UNIONS

Go To CHAPTER 15 – DYNAMIC MEMORY ALLOCATION
AND LINKED LISTS
Unit V
Input and output – concept of a file, text files and binary files, streams, standard I/o, formatted I/o, file
I/o operations, error handling, C program examples.

Go To CHAPTER 13 – FILE MANAGEMENT IN C

Unit VI
Searching – linear and binary search methods, sorting – bubble sort, selection sort, insertion sort, quick
sort, merge sort.

CHAPTER 17 – SORTING AND SEARCHING

Go To
TECHNIQUES

Unit VII
Introduction to data structures, singly linked lists, doubly linked lists, circular list, representing stacks
and queues in C using arrays and linked lists, infix to post fix conversion, postfix expression evaluation.
CHAPTER 14 – DATA STRUCTURES
Go To CHAPTER 15 – DYNAMIC MEMORY ALLOCATION
AND LINKED LISTS
Unit VIII
Trees- binary trees, terminology, representation, traversals, graphs—terminology, representation, graph
traversals (dfs and bfs)

Go To CHAPTER 16 – BINARY TREES AND GRAPHS

 The C99 Standard

Computer languages are not static; they evolve, reacting to changes in methodologies, applications gen-
erally accepted practices, and hardware. C is no exception. In the case of C, two evolutionary paths were
set in motion. The first is the continuing development of the C language. The second is C++, for which
C provided the starting point. While most of the focus of the past several years has been on C++, the
refinement of C has continued unabated.
For example, reacting to the internationalization of the computing environment, the original C89
standard was amended in 1995 to include various wide-character and multibyte functions. Once the
1995 amendment was complete, work began on updating the language, in general. The end result is, of
course, C99. In the course of creating the 1999 standard, each element of the C language was thoroughly
reexamined, usage patterns were analyzed, and future demands were anticipated. As expected, C's rela-
tionship to C++ provided a backdrop for the entire process. The resulting C99 standard is a testimonial
to the strengths of the original. Very few of the key elements of C were altered. For the most part, the
changes consist of a small number of carefully selected additions to the language and the inclusion of
several new library functions. Thus C is still C!
Here we will examine those features added by C99, and the few differences between C99 and C89.

C99

Perhaps the greatest cause for concern that accompanies the release of a new language standard is the
issue of compatibility with its predecessor. Does the new specification render old programs obsolete?
Have important constructs been altered? Do I have to change the way that I write code? The answers to
these types of questions often determine the degree to which the new standard is accepted and, in the
longer term, the viability of the language itself. Fortunately, the creation of C99 was a controlled, even-
handed process that reflects the fact that several experienced pilots were at the controls. Put simply: If
you liked C the way it was, you will like the version of C defined by C99. What many programmers
think of as the world's most elegant programming language, still is! In this chapter we will examine the
changes and additions made to C by the 1999 standard. Many of these changes were mentioned in
passing in Part One. Here they are examined in closer detail. Keep in mind, however, that as of this
writing, there are no widely used compilers that support many of C99’s new features. Thus, you may
need to wait a while before you can ‘test drive’ such exciting new constructs as variable-length arrays,
restricted pointers, and the long long data type.
xviii The C99 Standard
C89 vs. C99: AN OVERVIEW

There are three general categories of changes between C89 and C99:
· Features added to C89
· Features removed from C89
· Features that have been changed or enhanced
Many of the differences between C89 and C99 are quite small, and clarify nuances of the C language.
This book will concentrate on the larger changes that affect the way programs are written.

Features Added

Perhaps the most important features added by C99 are the new keywords:
· inline
· restrict
_Bool
_Complex
_Imaginary
Other major additions include
· Variable-length arrays
· Support for complex arithmetic
· The long long int data type
· The //comment
· The ability to intersperse code and data
· Additions to the preprocessor
· Variable declarations inside the for statement
· Compound literals
· Flexible array structure members
· Designated initializers
· Changes to the printf( ) and scanf( ) family of functions
· The _ _func_ _ predefined identifier
· New libraries and headers
Most of the features added by C99 are innovations created by the standardization committee, of
which many were based on language extensions offered by a variety of C implementations. In a few
cases, however, features were borrowed from C++. The inline keyword and // style comments are exam-
ples. It is important to understand that C99 does not add C++-style classes, inheritance, or member
functions. The consensus of the committee was to keep C as C.

Features Removed

The single most important feature removed by C99 is the ‘'implicit int’ rule. In C89, in many cases when
no explicit type specifier is present, the type int is assumed. This is not allowed by C99. Also removed
is implicit function declaration. In C89, if a function was not declared before it is used, an implicit
declaration is assumed. This is not supported by C99. Both of these changes may require existing code
to be rewritten if compatibility with C99 is desired.
 The C99 Standard xix
Features Changed

C99 incorporates several changes to existing features. For the most part, these changes expand features
or clarify their meaning. In a few cases, the changes restrict or narrow the applicability of a feature.
Many such changes are small, but a few are quite important, including:
· Increased translation limits
· Extended integer types
· Expanded integer type promotion rules
· Tightening of the return statement
As it affects existing programs, the change to return has the most significant effect because it might
require that code be rewritten slightly.
Throughout the remainder of this chapter, we will examine the major differences between C89 and
C99.

RESTRICT-QUALIFIED POINTERS

One of the most important innovations in C99 is the restrict type qualifier. This qualifier applies only to
pointers. A pointer qualified by restrict is initially the only means by which the object it points to can be
accessed. Access to the object by another pointer can occur only if the second pointer is based on the
first. Thus, access to the object is restricted to expressions based on the restrict-qualified pointer.
Pointers qualified by restrict are primarily used as function parameters, or to point to memory allocated
via malloc( ). The restrict qualifier does not change the semantics of a program. By qualifying a
pointer with restrict, the compiler is better able to optimize certain types of routines by making the
assumption that the restrict-qualified pointer is the sole means of access to the object. For example, if
a function specifies two restrict-qualified pointer parameters, the compiler can assume that the pointers
point to different (that is, non-overlapping) objects. For example, consider what has become the classic
example of restrict: the memcpy( ) function.
In C89, it is prototyped as shown here:
void *memcpy(void *str1, const void *str2, size_t size);
The description for memcpy( ) states that if the objects pointed to by str1 and str2 overlap, the
behaviour is undefined. Thus, memcpy( ) is guaranteed to work for only non-overlapping objects. In
C99, restrict can be used to explicitly state in memcpy( )’s prototype what C89 must explain with
words.
Here is the C99 prototype for memcpy( ):
void *memcpy
(void * restrict str1, const void * restrict str2, size_t size);
By qualifying str1 and str2 with restrict, the prototype explicitly asserts that they point to non-overlap-
ping objects. Because of the potential benefits that result from using restrict, C99 has added it to the
prototypes for many of the library functions originally defined by C89.

Inline

C99 adds the keyword inline, which applies to functions. By preceding a function declaration with
inline, you are telling the compiler to optimize calls to the function. Typically, this means that the
xx The C99 Standard
function’s code will be expanded in line, rather than called. However, inline is only a request to the
compiler, and can be ignored. Specifically, C99 states that using inline ‘suggests that calls to the func-
tion be as fast as possible.’ The inline specifier is also supported by C++, and the C99 syntax for inline
is compatible with C++.
To create an in-line function, precede its definition with the inline keyword. For example, in the
following program, calls to the function max( ) are optimized:
#include <stdio.h>
inline int max(int a, int b)
{
return a > b ? a : b;
}
int main(void)
{
int x=5, y=10;
printf("Max of %d and %d is: %d\n", x, y, max(x, y));
return 0;
}
For a typical implementation of inline, the preceding program is equivalent to this one:
#include <stdio.h>
int main(void)
{
int x=5, y=10;
printf("Max of %d and %d is: %d\n", x, y, (x>y ? x : y));
return 0;
}
The reason that inline functions are important is that they help you create more efficient code while
maintaining a structured, function-based approach. As you probably know, each time a function is
called, a significant amount of overhead is generated by the calling and return mechanism. Typically,
arguments are pushed onto the stack and various registers are saved when a function is called, and then
restored when the function returns. The trouble is that these instructions take time.
However, when a function is expanded in line, none of those operations occur. Although expanding
function calls in line can produce faster run times, it can also result in larger code size because of
duplicated code. For this reason, it is best to inline only very small functions. Further, it is also a good
idea to inline only those functions that will have significant impact on the performance of your program.
Remember: Although inline typically causes a function’s code to be expanded in line, the com-
piler can ignore this request or use some other means to optimize calls to the function.

NEW BUILT-IN DATA TYPES

C99 adds several new built-in data types. Each is examined here.
 The C99 Standard xxi
_Bool

C99 adds the _Bool data type, which is capable of storing the values 1 and 0 (true and false). _Bool is
an integer type. As many readers know, C++ defines the keyword bool, which is different from _Bool.
Thus, C99 and C++ are incompatible on this point. Also, C++ defines the built-in Boolean constants
true and false, but C99 does not. However, C99 adds the header <stdbool.h>, which defines the macros
bool, true, and false. Thus, code that is compatible with C/C++ can be easily created.
The reason that _Bool rather than bool is specified as a keyword is that many existing C programs
have already defined their own custom versions of bool. By defining the Boolean type as _Bool, C99
avoids breaking this preexisting code. However, for new programs, it is best to include <stdbool.h> and
then use the bool macro.

_Complex and _Imaginary

C99 adds support for complex arithmetic, which includes the keywords _Complex and _Imaginary,
additional headers, and several new library functions. However, no implementation is required to imple-
ment imaginary types, and freestanding implementations (those without operating systems) do not have
to support complex types. Complex arithmetic was added to C99 to provide better support for numerical
programming.
The following complex types are defined:
· float _Complex
· float _Imaginary
· double _Complex
· double _Imaginary
· long double _Complex
· long double _Imaginary
The reason that _Complex and _Imaginary, rather than complex and imaginary, are specified as
keywords, is that many existing C programs have already defined their own custom complex data types
using the names complex and imaginary. By defining the keywords _Complex and _Imaginary, C99
avoids breaking this preexisting code.
The header <complex.h> defines (among other things) the macros complex and imaginary, which
expand to Complex and _Imaginary. Thus, for new programs, it is best to include <complex.h> and
then use the complex and imaginary macros.

The long long Integer Types

C99 adds the long long int and unsigned long long int data types. A long long int has a range of at
least–(263–1) to 263–1. An unsigned long long int has a minimal range of 0 to 264–1. The long long
types allow 64-bit integers to be supported as a built-in type.

Array Enhancements

C99 has added two important features to arrays: variable length and the ability to include type qualifiers
in their declarations.
xxii The C99 Standard
Variable-Length Arrays

In C89, array dimensions must be declared using integer constant expressions, and the size of an array is
fixed at compile time. C99 changes this for certain circumstances. In C99, you can declare an array
whose dimensions are specified by any valid integer expression, including those whose value is known
only at run time. This is called a variable-length array (VLA). However, only local arrays (that is,
those with block scope or prototype scope) can be of variable length.
Here is an example of a variable-length array:
void f(int dim1, int dim2)
{
int matrix[dim1] [dim2]; /* a variable-length, 2-D array */
/* . . . */
}
Here, the size of matrix is determined by the values passed to f( ) in dim1 and dim2. Thus, each call to
f( ) can result in matrix being created with different dimensions.
It is important to understand that variable-length arrays do not change their dimensions during their
lifetime. (That is, they are not dynamic arrays.) Rather, a variable-length array can be created with a
different size each time its declaration is encountered.
You can specify a variable-length array of an unspecified size by using * as the size.
The inclusion of variable-length arrays causes a small change in the sizeof operator. In general, sizeof is
a compile-time operator. That is, it is normally translated into an integer constant whose value is equal
to the size of the type or object when a program is compiled. However, when it is applied to a variable-
length array, sizeof is evaluated at run time. This change is necessary because the size of a variable-
length array cannot be known until run time.
One of the major reasons for the addition of variable-length arrays to C99 is to support numeric
processing. Of course, it is a feature that has widespread applicability. But remember, variable-length
arrays are not supported by C89 (or by C++).

Use of Type Qualifiers in an Array Declaration

In C99 you can use the keyword static inside the brackets of an array declaration when that declaration
is for a function parameter. It tells the compiler that the array pointed to by the parameter will always
contain at least the specified number of elements. Here is an example:
int f(char str [static 80])
{
// here, str is always a pointer to an 80-element array
// . . .
}
In this example, str is guaranteed to point to the start of an array of chars that contains at least 80
elements.
You can also use the keywords restrict, volatile, and const inside the brackets, but only for function
parameters. Using restrict specifies that the pointer is the sole initial means of access to the object.
 The C99 Standard xxiii
Using const states that the same array is always pointed to (that is, the pointer always points to the same
object). The use of volatile is allowed, but meaningless.

Single-Line Comments

C99 adds the single-line comment to C. This type of comment begins with // and runs to the end of
the line.
For example:
// This is a comment
int i; // this is another comment
Single-line comments are also supported by C++. They are convenient when only brief, single-line
remarks are needed. Many programmers use C’s traditional multiline comments for longer descriptions,
reserving single-line comments for “play-by-play” explanations.
Interspersed Code and Declarations In C89, within a block, all declarations must precede the first
code statement. This rule does not apply for C99.
For example:
#include <stdio.h>
int main(void)
{
int i;
i = 10;
int j; // wrong for C89; OK for C99 and C++
j = i;
printf(“%d %d”, i, j);
return 0;
}
Here, the statement i = 10; comes between the declaration of i and the declaration of j. This is not
allowed by C89. It is allowed by C99 (and by C++). The ability to intersperse declarations and code is
widely used in C++.
Adding this feature to C makes it easier to write code that will be used in both environments.

PREPROCESSOR CHANGES

C99 makes a number of small changes to the preprocessor.

Variable Argument Lists

Perhaps the most important change to the preprocessor is the ability to create macros that take a variable
number of arguments. This is indicated by an ellipsis (. . .) in the definition of the macro. The built-in
preprocessing identifier _ _VA_ARGS_ _ determines where the arguments will be substituted.
xxiv The C99 Standard
For example, given this definition
#define MyMax(. . .) max(__VA_ARGS__)
this statement
MyMax(a, b);
is transformed into
max(a, b);

There can be other arguments prior to the variable ones. For example, given
#define compare(compfunc, . . .) compfunc(__VA_ARGS__)
this statement
compare(strcmp, “one”, “two”);
is transformed into
strcmp(“one”, “two”);
As the example shows, _ _VA_ARGS_ _ is replaced by all of the remaining arguments.

The _Pragma Operator

C99 includes another way to specify a pragma in a program: the _Pragma operator. It has the following
general form:
_Pragma (“directive”)
Here, directive is the pragma being invoked. The addition of the _Pragma operator allows pragmas to
participate in macro replacement.

Built-in Pragmas

C99 defines the following built-in pragmas:

Pragma Meaning
STDC FP_CONTRACT ON/OFF/DEFAULT When on, floating-point expressions are
treated as indivisible units that are handled
by hardware-based methods. The default
state is implementation defined.
STDC FENV_ACCESS ON/OFF/DEFAULT Tells the compiler that the floating-point en-
vironment might be accessed. The default
state is implementation defined.
STDC CX_LIMITED_RANGE ON/OFF/DEFAULT When on, tells the compiler that certain for-
mulas involving complex values are safe. The
default state is off.
You should refer to your compiler’s documentation for details concerning these pragmas.
 The C99 Standard xxv
Additional Built-in Macros

C99 adds the following macros to those already supported by C89:

_ _STDC_HOSTED_ _ 1 if an operating system is present.

_ _STDC_VERSION_ _ 199901L or greater. Represents version of C.

_ _STDC_IEC_559_ _ 1 if IEC 60559 floating-point arithmetic is supported.

_ _STDC_IEC_599_COMPLEX_ _ 1 if IEC 60559 complex arithmetic is supported.

_ _STDC_ISO_10646_ _ A value of the form yyyymmL that states the year and
month of the ISO/IEC 10646 specification supported by the
compiler.

Declaring Variables within a for Loop

C99 enhances the for loop by allowing one or more variables to be declared within the initialization
portion of the loop. A variable declared in this way has its scope limited to the block of code controlled
by that statement. That is, a variable declared within a for loop will be local to that loop. This feature
has been included in C because often the variable that controls a for loop is needed only by that loop. By
localizing this variable to the loop, unwanted side effects can be avoided.
Here is an example that declares a variable within the initialization portion of a for loop:
#include <stdio.h>
int main(void)
{
// declare i within for
for(int i=0; i < 10; i++)
printf(“%d ”, i);
return 0;
}
Here, i is declared within the for loop, rather than prior to it.
As mentioned, a variable declared within a for is local to that loop. Consider the following program.
Notice that the variable i is declared twice: at the start of main( ) and inside the for loop.
#include <stdio.h>
int main(void)
{
int i = -99;
// declare i within for
for(int i=0; i < 10; i++)
printf(“%d”, i);
printf(“\n”);
xxvi The C99 Standard
printf(“Value of i is: %d”, i); // displays-99
return 0;
}
This program displays the following:
0123456789
Value of i is: -99
As the output shows, once the for loop ends, the scope of the i declared within that loop ends. Thus, the
final printf( ) statement displays –99, the value of the i declared at the start of main( ).
The ability to declare a loop-control variable inside the for has been available in C++ for quite some
time, and is widely used. It is expected that most C programmers will do the same.

Compound Literals

C99 allows you to define compound literals, which are array, structure, or union expressions designat-
ing objects of the given type. A compound literal is created by specifying a parenthesized type name,
which is then followed by an initialization list, which must be enclosed between curly braces. When the
type name is an array, its size must not be specified. The object created is unnamed.
Here is an example of a compound literal:
double *fp = (double[]) {1.0, 2.0, 3.0};
This creates a pointer to double, called fp, which points to the first of a three-element array of double
values.
A compound literal created at file scope exists throughout the lifetime of the program. A compound
literal created within a block is a local object that is destroyed when the block is left.

Flexible Array Structure Members

C99 allows you to specify an unsized array as the last member of a structure. (The structure must have
at least one other member prior to the flexible array member.) This is referred to as a flexible array
member. It allows a structure to contain an array of variable size. The size of such a structure returned
by sizeof does not include memory for the flexible array.
Typically, memory to hold a structure containing a flexible array member is allocated dynamically,
using malloc( ). Extra memory must be allocated beyond the size of the structure to accommodate the
desired size of the flexible array.
For example, given
struct mystruct {
int a;
int b;
float fa[]; // flexible array
};
the following statement allocates room for a 10-element array:
 The C99 Standard xxvii
struct mystruct *p;
p = (struct mystruct *) malloc(sizeof(struct mystruct) + 10 *
sizeof(float));
Since sizeof(struct mystruct) yields a value that does not include any memory for fa, room for the 10-
element array of floats is added by the expression
10 * sizeof(float)
when malloc( ) is called.

Designated Initializers

A new feature of C99 that will be especially helpful to those programmers working with sparse arrays is
designated initializers. Designators take two forms: one for arrays and one for structures and unions.
For arrays, the following form is used,
[index] = val
where index specifies the element being initialized to the value val. For example:
int a[10] = { [0] = 100, [3] = 200 };
Here, only elements 0 and 3 are initialized.
For structure or union members, the form used is:
. member-name
Using a designator with a structure allows an easy means of initializing only selected members of a
structure.
For example:
struct mystruct {
int a;
int b;
int c;
} ob = { .c = 30, .a = 10 };
Here, b is uninitialized.
Using designators also allows you to initialize a structure without knowing the order of its members.
This is useful for predefined structures, such as div_t, or for structures defined by some third party.

Additions to the printf( ) and scanf( ) Family of Functions

C99 adds to the printf( ) and scanf( ) family of functions the ability to handle the long long int and
unsigned long long int data types. The format modifier for long long is ll.
For example, the following fragment shows how to output a long long int and an unsigned long long
int:
long long int val;
unsigned long long int u_val;
printf(“%lld %llu”, val, val2);
xxviii The C99 Standard
The II can be applied to the d, i, o, u, and x format specifiers for both printf( ) and scanf( ).
C99 adds the hh modifier, which is used to specify a char argument when using the d, i, o, u, or x
format specifiers. Both the ll and hh specifiers can also be applied to the n specifier.
The format specifiers a and A, which were added to printf( ), cause a floating-point value to be
output in a hexadecimal format. The format of the value is
[-]0xh.hhhhp+d
When A is used, the x and the p are uppercase. The format specifiers a and A were also added to
scanf( ), and read a floating-point value.
In a call to printf( ), C99 allows the 1 modifier to be added to the %f specifier (as in %lf), but it has
no effect. In C89, %lf is undefined for printf( ).

NEW LIBRARIES IN C99

C99 adds several new libraries and headers. They are shown here:
Header Purpose
<complex.h> Supports complex arithmetic.
<fenv.h> Gives access to the floating-point status flags and other
aspects of the floating-point environment.
<inttypes.h> Defines a standard, portable set of integer type names.
Also supports functions that handle greatest-width inte-
gers.
<iso646.h> Added in 1995 by Amendment 1. Defines macros that
correspond to various operators, such as && and ^.
<stdbool.h> Supports Boolean data types. Defines the macros bool,
true, and false, which help with C++ compatibility.
<stdint.h> Defines a standard, portable set of integer type names.
This header is included by <inttypes.h>.
<tgmath.h> Defines type-generic floating-point macros.
<wchar.h> Added in 1995 by Amendment 1. Supports multibyte and
widecharacter functions.
<wctype.h> Added in 1995 by Amendment 1. Supports multibyte and
widecharacter classification functions.

The _ _func_ _ Predefined Identifier

C99 defines _ _func_ _, which specifies the name (as a string literal) of the function in which
_ _func_ _ occurs.
For example:
void StrUpper(char *str)
 The C99 Standard xxix
{
static int i = 0;
i++;
printf(“%s has been called %d time(s).\n”, __func__, i);
while(*str) {
*str = toupper(*str);
str++;
}
}
When called the first time, StrUpper( ) will display this output:
StrUpper has been called 1 time(s).

INCREASED TRANSLATION LIMITS

The term ‘translation limits’ refers to the minimum number of various elements that a C compiler must
be able to handle. These include such things as the length of identifiers, levels of nesting, number of case
statements, and number of members allowed in a structure or union. C99 has increased several of these
limits beyond the already generous ones specified by C89.
Here are some examples:
Limit C89 C99
Nesting levels of blocks 15 127
Nesting levels of conditional inclusion 8 63
Significant characters in an internal identifier 31 63
Significant characters in an external identifier 6 31
Members of a structure or union 127 1023
Arguments in a function call 31 127

Implicit int No Longer Supported

Several years ago, C++ dropped the implicit int rule, and with the advent of C99, C follows suit. In C89,
the implicit int rule states that in the absence of an explicit type specifier, the type int is assumed. The
most common use of the implicit int rule was in the return type of functions. In the past, C programmers
often omitted the int when declaring functions that returned an int value.
For example, in the early days of C, main( ) was often written like this:
main ()
{
/* . . . */
}
xxx The C99 Standard
In this approach, the return type was simply allowed to default to int. In C99 (and in C++) this default no
longer occurs, and the int must be explicitly specified, as it is for all of the programs in
this book.
Here is another example. In the past a function such as
int isEven(int val)
{
return !(val%2);
}
would often have been written like this:
/* use integer default */
isEven (int val)
{
return !(val%2);
}
In the first instance, the return type of int is explicitly specified. In the second, it is assumed by default.
The implicit int rule does not apply only to function return values (although that was its most
common use).
For example, for C89 and earlier, the isEven( ) function could also be written like this:
isEven(const val)
{
return ! (val%2);
}
Here, the parameter val also defaults to int—in this case, const int. Again, this default to int is not
supported by C99.
Note Technically, a C99-compatible compiler can accept code containing implied ints after re-
porting a warning error. This allows old code to be compiled. However, there is no requirement
that a C99-compatible compiler accept such code.

Implicit Function Declarations Have Been Removed

In C89, if a function is called without a prior explicit declaration, then an implicit declaration of that
function is created. This implicit declaration has the following form:
extern int name( );
Implicit function declarations are no longer supported by C99.
Note Technically, a C99-compatible compiler can accept code containing implied function dec-
larations after reporting a warning error. This allows old code to be compiled. However, there is
no requirement that a C99-compatible compiler accept such code.
 The C99 Standard xxxi
Restrictions on return

In C89, a function that has a non-void return type (that is, a function that supposedly returns a value)
could use a return statement that did not include a value. Although this creates undefined behaviour, it
was not technically illegal. In C99, a non-void function must use a return statement that returns a
value. That is, in C99, if a function is specified as returning a value, any return statement within it must
have a value associated with it. Thus, the following function is technically valid for C89, but invalid for
C99:
int f(void)
{
/* . . . */
return ; // in C99, this statement must return a value
}

Extended Integer Types

C99 defines several extended integer types in <stdint.h>. Extended types include exact-width, mini-
mum-width, maximum-width, and fastest integer types.
Here is a sampling:

Extended Type Meaning

int16_t An integer consisting of exactly 16 bits

int_least16_t An integer consisting of at least 16 bits
int_fast32_t Fastest integer type that has at least 32 bits
intmax_t Largest integer type
uintmax_t Largest unsigned integer type
The extended types make it easier for you to write portable code.
For loop changes In a for-loop, the first expression may be a declaration, with a scope encompassing
only the loop.
for (decl; pred; inc)
stmt;
is equivalent to:
{
decl;
for (; pred; inc)
stmt;
}
Type specifiers or data types Type specifiers: new combinations added for:
· _Bool
· float _Complex, double _Complex, long double _Complex
· signed and unsigned long long int.
xxxii The C99 Standard
New type long long (signed and unsigned), at least 64 bits wide.
Note: It seems that these type specifiers may occur in any order, e.g, _Complex double long
or signed long int long would be legal.
The implementation of the complex types is defined by the standard to use cartesian coordinates (real
and imaginary part), i.e. forbids an implementation using polar coordinates (distance from [0,0] and an
angle). Furthermore, the same paragraph also specifies that a complex type has the same alignment
requirements as an array of two elements of the corresponding floating types, the first must be the real
part and the second the imaginary part.
Objects of the new boolean type _Bool may have one of the two values zero or one.

Format Modifiers for Printf( ) Added by C99

C99 adds several format modifiers to printf( ): hh, ll, j, z, and t. The hh modifier can be applied to d, i,
o, u, x, X, or n. It specifies that the corresponding argument is a signed or unsigned char value or, in
the case of n, a pointer to a signed char variable. The ll modifier also can be applied to d, i, o, u, x, X,
or n. It specifies that the corresponding argument is a signed or unsigned long long int value or, in the
case of n, a pointer to a long long int. C99 also allows the l to be applied to the floating-point specifiers
a, A, e, E, f, F, g, and G, but it has no effect. The j format modifier, which applies to d, i, o, u, x, X, or
n, specifies that the matching argument is of type intmax_t or uintmax_t. These types are declared in
<stdint.h> and specify greatest-width integers. The z format modifier, which applies to d, i, o, u, x, X,
or n, specifies that the matching argument is of type size_t. This type is declared in <stddef.h> and
specifies the result of sizeof.
The t format modifier, which applies to d, i, o, u, x, X, or n, specifies that the matching argument is of
type ptrdiff_t. This type is declared in <stddef.h> and specifies the difference between two pointers.

Sample code

#include <stdio.h>
int main(void)
{
/* This prints ''this is a test" left justified
in 20 character field.
*/
printf(“%-20s”, “this is a test”);
/* This prints a float with 3 decimal places in a 10
character field. The output will be " 12.235".
*/
printf(“%10.3f”, 12.234657);
return 0;
}

Changes to the Integer Promotion Rules

C99 enhances the integer promotion rules. In C89, a value of type char, short int , or an int bit-field can
be used in place of an int or unsigned int in an expression. If the promoted value can be held in an int,
the promotion is made to int; otherwise, the original value is promoted to unsigned int.
 The C99 Standard xxxiii
In C99, each of the integer types is assigned a rank. For example, the rank of long long int is greater
than int, which is greater than char, and so on. In an expression, any integer type that has a rank less
than int or unsigned int can be used in place of an int or unsigned int.

THE PRINTF( ) FORMAT SPECIFIERS

Code Format
%a Hexadecimal output in the form 0xh.hhhhp+d (C99 only).
%A Hexadecimal output in the form 0Xh.hhhhP+d (C99 only).
%c Character.
%d Signed decimal integers.
%i Signed decimal integers.
%e Scientific notation (lowercase e).
%E Scientific notation (uppercase E).
%f Decimal floating point.
%F Decimal floating point (C99 only; produces uppercase INF, INFINITY,
or NAN when applied to infinity or a value that is not a number. The %f
specifier produces lowercase equivalents.)
%g Uses %e or %f, whichever is shorter.
%G Uses %E or %F, whichever is shorter.
%o Unsigned octal.
%s String of characters.
%u Unsigned decimal integers.
%x Unsigned hexadecimal (lowercase letters).
%X Unsigned hexadecimal (uppercase letters).
%p Displays a pointer.
%n The associated argument must be a pointer to an integer. This specifier
causes the number of characters written (up to the point at which the
%n is encountered) to be stored in that integer.
%% Prints a percent sign.

RESTRICT-QUALIFIED POINTERS

The C99 standard has added a new type qualifier that applies only to pointers: restrict. A pointer
qualified by restrict is initially the only means by which the object it points to is accessed. Access to the
object by another pointer can occur only if the second pointer is based on the first. Thus, access to the
object is restricted to expressions based on the restrict-qualified pointer. Pointers qualified by restrict
are primarily used as function parameters or to point to memory allocated via malloc( ). By qualifying
a pointer with restrict, the compiler is better able to optimize certain types of routines. For example, if
a function specifies two restrict-qualified pointer parameters, then the compiler can assume that the
pointers point to different (that is, non-overlapping) objects. The restrict qualifier does not change the
semantics of a program.
xxxiv The C99 Standard

1. /* Write a program to test the given string is palindrome or not. implement the program
by using _Bool datatype */
#include<stdio.h>
#include<string.h>
enum _Bool{false,true}; // _Bool DataType which is capable of
storing the vales 0 and 1
enum _Bool IsPalindrome(char string[]) // _Bool datatype
{
int left,right,len=strlen(string);
enum _Bool matched=true; // _Bool datatype
if(len==0)
return 0;
left=0;
right=len-1;
/* Compare the first and last letter,second & second last & so
on */
while(left<right&&matched)
{
if(string[left]!=string[right])
matched=false;
else
{
left++;
right--;
}
}
return matched;
}

int main()
{
char string[40];
clrscr();
printf("****Program to test if the given string is a
palindrome****\n");
printf("Enter a string:");
scanf("%s",string);
if(IsPalindrome(string))
printf("The given string %s is a palindrome\n",string);
else
printf("The given string %s is not a palindrome\n",string);
getch();
return 0;
}
 The C99 Standard xxxv

2. /* In C89, within a block, all declarations must precede the first code statement. This rule
does not apply for C99 */
#include<stdio.h>
int main(void)
{
int i;
i=10;
int j; //wrong for c89; ok for c99
j=i;
clrscr();
printf("%d %d",i,j);
return 0;
getch();
}
3. /* Write a program to print the signed and unsigned numbers by using C99 standards*/
#include<stdio.h>
int main(void)
{
int i= -99;
{
for(int i=0; i<10; i++) //declare i within for
printf("%d",i);
printf("\n");
}
printf("Value of i is: %d",i); //display-99
return 0;
}
4. /* Write a program to open the file by using C99 standards */
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
FILE *fp;
if((fp=fopen("test","wb"))==NULL);
{
printf("cannot open file.\n");
exit(1);
fprintf(fp,"this is a test %d %f", 10,20.01); // fprintf
fclose(fp);
return 0;
}
}
xxxvi The C99 Standard

5. /* Write a C program that uses functions to perform the following operations by using
C99 standards(_Complex, _Imaginary):
(i) Reading a complex number
(ii) Writing a complex number
(iii) Addition of two complex numbers
(iv) Multiplication of two complex numbers
(Note: represent complex number using a structure.) */
#include<stdio.h>
#include<math.h>
#include<complex.h>

void _Complex(int opern);

struct comp
{
double realpart;
double _Imaginary;
};

void main()
{
int opern;
clrscr();
printf("\n\n \t\t\t***** MAIN MENU *****");
printf("\n\n Select your option: \n1 : ADD\n2 : MULTIPLY\n0 :
EXIT \n\n\t\t Enter your Option [ ]\b\b");

scanf("%d",&opern);

switch(opern)
{
case 0:
exit(0);
case 1:
case 2:
_Complex(opern);
default:
main();
}

void _Complex(int opern)

 The C99 Standard xxxvii

{
struct comp w1, w2, w;
printf("\n Enter two Complex Numbers (x+iy):\n Real Part of
First Number:");
scanf("%lf",&w1.realpart);
printf("\n Imaginary Part of First Number:");
scanf("%lf",&w1._Imaginary);
printf("\n Real Part of Second Number:");
scanf("%lf",&w2.realpart);
printf("\n Imaginary Part of Second Number:");
scanf("%lf",&w2._Imaginary);
switch(opern)
{
/*addition of complex number*/
case 1:
w.realpart = w1.realpart+w2.realpart;
w._Imaginary = w1._Imaginary+w2._Imaginary;
break;

/*multiplication of complex number*/

case 2:
w.realpart=(w1.realpart*w2.realpart)-
(w1._Imaginary*w2._Imaginary);

w._Imaginary=(w1.realpart*w2._Imaginary)+(w1._Imaginary*w2.realpart);
break;
}

if (w._Imaginary>0)
printf("\n Answer = %lf+%lfi",w.realpart,w._Imaginary);
else
printf("\n Answer = %lf%lfi",w.realpart,w._Imaginary);
getch();
main();
}
6. /* Write a program to find the maximum number by using C99 standards(inline keyword)
*/
#include <stdio.h>
inline int max(int a, int b) // inline keyword
{
return a > b ? a : b;
xxxviii The C99 Standard

}
int main(void)
{
int x=5, y=10;
printf("Max of %d and %d is: %d\n", x,y,max(x,y));

return 0;
}
7. /* Write a C program to generate Pascal's Triangle by using C99 standards */
#include<stdio.h>
#include<conio.h>

void main()
{
int bin,q,r;
clrscr();
bin=1;
q=0;

printf("Rows you want to input:");

scanf("%d",&r);

printf("\nPascal's Triangle:\n");

while(q<r)
{
for(int p=40-3*q;p>0;--p) // declare p with in for
printf(" ");
for(int x=0;x<=q;++x) // declare x with in for
{
if((x==0)||(q==0))
bin=1;
else
bin=(bin*(q-x+1))/x;
printf("%6d",bin);
}

printf("\n");
++q;
}
getch();
}
 The C99 Standard xxxix

8. /* Write a C program to generate all the prime numbers between 1 and n, where n is a
value supplied by the user by using C99 standards.(long long int,declare variables with in
for loop) */
#include <stdio.h>

void main()
{
long long int no,check; // long long int
clrscr();
printf("<-----------------------PRIME NO. SERIES--------------
---------->");
printf("\n\n\n\t\t\tINPUT THE VALUE OF N: ");
scanf("%d",&no);
printf("\n\nTHE PRIME NO. SERIES B/W 1 TO %lld : \n\n",no);

for(int counter = 1; counter <= no; counter++) // declare

counter with in for
{
check = 0;
//THIS LOOP WILL CHECK A NO TO BE PRIME NO. OR NOT.

for(int counter1 = counter-1; counter1 > 1 ; counter1--)

if(counter%counter1 == 0)
{
check++; // INCREMENT CHECK IF NO. IS NOT A PRIME NO.
break;
}
if(check == 0)
printf("%d\t",counter);
}
getch();
}
9. /* Write a program to print text and numbers by using C99 standards */
#include<stdio.h>
int main(void)
{
printf("%-20s","this is a test"); // left justified
printf("%10.3f",12.234657);
return 0;
}
xl The C99 Standard

10. /* Write a program for addition of matrices by using the restrict keyword */
void fadd(double a[static restrict 10],
const double b[static restrict 10]) // restrict keyword, restricrts a and b
{
int i;
for(i=0; i<10; i++)
{
if(a[i] < 0.0)
return;
a[i] += b[i];
}
return;
}
11. /* Write a C program to find the roots of a quadratic equation by using format modifiers
in C99. */
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
float a,b,c,root1,root2;
clrscr();
printf("\n Enter values of a,b,c for finding roots of a qua-
dratic eq:\n");
scanf("%f%f%f",&a,&b,&c);
/*checking condition*/
if(b*b>4*a*c)
{
root1=-b+sqrt(b*b-4*a*c)/2*a;
root2=-b-sqrt(b*b-4*a*c)/2*a;
printf("\n*****ROOTS ARE*****\n");
printf("\nroot1=%1.3f\nroot2=%1.2f",root1,root2); //format
modifiers for printf()
}
else
printf("\n Imaginary Roots.");
getch();
}
 The C99 Standard xli

12. /* Write a C program to find the sum of individual digits of a positive integer by using long
long int in C99 standards*/
#include<stdio.h>
#include<conio.h>
void main()
{
long long int num, k=1, sum=0; // long long int
clrscr();
printf("Enter the number whose digits are to be added:");
scanf("%lld",&num);
while(num!=0)
{
k=num%10;
sum=sum+k;
k=num/10;
num=k;
}
printf("Sum of the digits:%lld",sum);
getch();
}
UNIT I
Chapter
1
Algorithms

1.1 INTRODUCTION

There is a tremendous similarity between the human actions and the way a computer performs various
functions. Nicholas Wirth—the inventor of a computer language—‘Pascal’ used to say “A program is
equal to algorithm + data”. In the next few chapters, we will explore the meaning of these terms; first
learning about and clearly analyzing human actions and then showing how computers also act similarly,
thereby demystifying the complexity that surrounds computers.
We perform hundreds of activities during a day. An activity could be anything from brushing teeth to
making tea and from going to work to having dinner. There are two basic ways to describe in detail, any
of these activities:
1. By describing the process step-by-step—called as algorithm.
2. By representing the various steps in the form of a diagram—called as flow chart.

1.1.1 Algorithm/pseudocode

The term algorithm is very popular in the computer literature. An algorithm is also called pseudocode.
At first, it might sound very complex. However, it is very simple to understand. In fact, we all perform
hundreds of algorithms in our daily life without even realizing it!
Algorithm is the step-by-step method of performing any task. When we break up a big task into
smaller steps, what we actually do is to create an algorithm. In other words, we perform hundreds of
algorithms. Brushing teeth, making tea, getting ready for school or office, are all different algorithms.
For example, when making a cup of tea, we follow the algorithm as shown in Fig. 1.1 (with a few
variations, of course!).
An interesting observation: Many steps can be further sub-divided into still smaller sub-steps. For
example, we can write an algorithm for Step 1 (Boil water) by writing detailed steps for boiling water.
However, it is up to an individual as to how detailed steps one should describe. Each step can be called
as an instruction. Also, we can notice that steps 4 and 5 can be executed in parallel, i.e. we can boil
milk while we wait. In actual life, there is a tremendous amount of parallelism in many of our actions.
We normally hear, see and feel simultaneously to comprehend a situation. Within this also, when we see
1.4 C Programming and Data Structures
a picture, for example, actually we see millions of spots of the picture to generate an image on our retina
while we compare all dots in parallel with already stored millions of images to identify an object instan-
taneously! Therefore, parallel computing was developed to speed up things and ultimately try to
imitate human actions in artificial intelligence. We need not discuss these in detail in later chapters,
but continue with serial algorithms for now.
Begin
1. Boil water.
2. Put tea powder in the kettle.
3. Pour boiled water in the kettle.
4. Wait for three minutes.
5. Boil milk.
6. Put boiled milk in a cup.
7. Add sugar to the cup.
8. Empty the kettle in the cup.
9. Stir the cup with a spoon.
End

Fig. 1.1 Algorithm for making tea

1.1.2 Flow Chart

There is another way to write the steps involved in any process. This is by making use of various
symbols. The symbols form a diagram that represents the steps in a pictorial fashion similar to an
algorithm. This is also very easy to understand. Such a diagram is called flow chart. In its simplest
form, a flow chart consists of a series of rectangles connected to each other by arrows. The rectangles
represent the various steps and the arrows designate the flow. A flow chart for our tea-making example
could be drawn as in Fig. 1.2.

Fig. 1.2 Flow chart for making tea

 Algorithms 1.5
As can be seen, these are very primary concepts that we learn since childhood. We learn to make tea
by observing someone making tea: just like any other activity. Thus, the algorithm for making tea was
recorded in our brain long back somewhere deep—in our memory. There is another part of our memory
which stores the details of our current activity or thoughts. Whenever we want to make tea, somehow
this algorithm is brought back from our deep memory into the current memory (i.e. it is ‘remembered’)
and then it is actually executed. This concept of storing something in memory, retrieving it back in the
current memory (i.e. ‘remembering’ it) whenever needed and actually performing a task is very primi-
tive, yet extremely important, as we shall see, due to its similarity with computers.

1.2 THREE BASIC OPERATIONS

The tea-making algorithm and flow chart discussed earlier were quite simple. One step followed another
in a sequential fashion. However, things are not so simple in real life! There are so many ifs and buts.
For example, consider the following statements:
∑ If it is 9 am, I must go to the office.
∑ If it is raining, take your umbrella with you.
∑ Read each line and say it loudly until the end of this page.
How do we take care of such things in an algorithm and a flow chart? And how many different kinds
of situations we must cater to? This section attempts to answer these questions.
In general, the steps in an algorithm can be divided in three basic categories as listed below:
∑ Sequence—A series of steps that we perform one after the other
∑ Selection—Making a choice from multiple available options
∑ Iteration—Performing repetitive tasks
These three basic categories of activities combined in different ways can form the basis for describ-
ing any algorithm. It might sound surprising initially. But it is true. Think of any situation in our daily
life and try to fit it in one of the three categories: it works!
Let us now look at each of the categories in more detail.

1.2.1 Sequence

A sequence is a series of steps that we follow in any algorithm without any break, i.e. unconditionally.
The algorithm for making tea described in Fig. 1.1 belongs to this category. Figure 1.3 describes another
algorithm in this category for ‘boiling water’. What this means is that we have exploded further the step
or instruction 1 in the algorithm for making tea given in Fig. 1.1. We can explode all such steps in Fig.
1.1 in the following way.
Begin
1. Take a utensil.
2. Take the utensil to the water tap.
3. Open the tap.
4. Fill the utensil with water.
5. Close the tap.
6. Put the utensil on the gas or in the oven.
7. Start the gas or the oven.
8. Wait until the water boils.
9. Switch off the gas or the oven.
End

Fig. 1.3 Algorithm for boiling water

1.6 C Programming and Data Structures

We will not draw the flow chart for boiling water. It should be clear by now that it is a matter of
writing all of the above 9 steps in rectangles one after the other; each connected to its successor by an
arrow.

1.2.2 Selection

We will quickly realize that only ‘sequence’ is not good enough to express an algorithm. Quite a few of
our actions depend on certain events. Thus, there is a need to be able to make a choice from many
available options. Therefore, there is a process of selection. A selection statement generally takes the
form as shown in Fig. 1.4.
1. If
2. Then
3. End-if

Fig. 1.4 Selection

We take so many decisions, small and big, in our daily life without even realizing it. For example, if
it is hot, we switch on the fan. We can depict this selection process as shown in Fig. 1.5.
1. If it is hot
2. Then switch on the fan
3. End-if

Fig. 1.5 Example of a selection

Note that End-if is an additional step that indicates the end of the selection process. A question may
be asked: is End-if really necessary? Let us illustrate this by the following selection process that does
not have an End-if. Refer to Fig. 1.6.
1. If the guest wants tea
2. Then make tea
3. Offer biscuits

Fig. 1.6 Importance of End-if

What do we do if the guest does not want tea? Do we offer him biscuits? It is not clear from the
selection process described above. It can be argued and proved either way. That is, we are not sure
whether the Offer biscuits portion is a part of our If condition or not. A miserly person would always say
that he considers Offer biscuits as a part of the condition, and hence would only offer biscuits to some-
one who wants tea! Hence, it is always better to end a selection process with an End-if to avoid any
confusion at least for our algorithms. Different computer programming languages have different con-
ventions.
The position and placement of End-if instructions can change the meaning of the entire algorithm as
shown in Fig. 1.7 (a) and 1.7 (b). Let us study the algorithm shown in Fig. 1.7 (a). If the guest wants tea,
the algorithm will execute step 2 after step 1 (i.e. make tea), then fall through step 3 and then step 4 (i.e.
offer biscuits). Thus, if the guest wants tea, he gets the biscuits, too! Now, let us trace the algorithm if
the guest does not want tea. In this case, the algorithm will follow step 3 after step 1 (i.e. skip the tea)
and then fall through step 4 (i.e. offer biscuits). Thus, biscuits will be offered regardless of tea. If we
study algorithm shown in Fig. 1.7 (b), we will notice that biscuits are offered only with tea. If the guest
Other documents randomly have
different content
 PLEASE READ THIS BEFORE YOU DISTRIBUTE OR USE THIS WORK

To protect the Project Gutenberg™ mission of promoting the free

distribution of electronic works, by using or distributing this work (or
any other work associated in any way with the phrase “Project
Gutenberg”), you agree to comply with all the terms of the Full
Project Gutenberg™ License available with this file or online at
www.gutenberg.org/license.

Section 1. General Terms of Use and

Redistributing Project Gutenberg™
electronic works
1.A. By reading or using any part of this Project Gutenberg™
electronic work, you indicate that you have read, understand, agree
to and accept all the terms of this license and intellectual property
(trademark/copyright) agreement. If you do not agree to abide by all
the terms of this agreement, you must cease using and return or
destroy all copies of Project Gutenberg™ electronic works in your
possession. If you paid a fee for obtaining a copy of or access to a
Project Gutenberg™ electronic work and you do not agree to be
bound by the terms of this agreement, you may obtain a refund
from the person or entity to whom you paid the fee as set forth in
paragraph 1.E.8.

1.B. “Project Gutenberg” is a registered trademark. It may only be

used on or associated in any way with an electronic work by people
who agree to be bound by the terms of this agreement. There are a
few things that you can do with most Project Gutenberg™ electronic
works even without complying with the full terms of this agreement.
See paragraph 1.C below. There are a lot of things you can do with
Project Gutenberg™ electronic works if you follow the terms of this
agreement and help preserve free future access to Project
Gutenberg™ electronic works. See paragraph 1.E below.
1.C. The Project Gutenberg Literary Archive Foundation (“the
Foundation” or PGLAF), owns a compilation copyright in the
collection of Project Gutenberg™ electronic works. Nearly all the
individual works in the collection are in the public domain in the
United States. If an individual work is unprotected by copyright law
in the United States and you are located in the United States, we do
not claim a right to prevent you from copying, distributing,
performing, displaying or creating derivative works based on the
work as long as all references to Project Gutenberg are removed. Of
course, we hope that you will support the Project Gutenberg™
mission of promoting free access to electronic works by freely
sharing Project Gutenberg™ works in compliance with the terms of
this agreement for keeping the Project Gutenberg™ name associated
with the work. You can easily comply with the terms of this
agreement by keeping this work in the same format with its attached
full Project Gutenberg™ License when you share it without charge
with others.

1.D. The copyright laws of the place where you are located also
govern what you can do with this work. Copyright laws in most
countries are in a constant state of change. If you are outside the
United States, check the laws of your country in addition to the
terms of this agreement before downloading, copying, displaying,
performing, distributing or creating derivative works based on this
work or any other Project Gutenberg™ work. The Foundation makes
no representations concerning the copyright status of any work in
any country other than the United States.

1.E. Unless you have removed all references to Project Gutenberg:

1.E.1. The following sentence, with active links to, or other

immediate access to, the full Project Gutenberg™ License must
appear prominently whenever any copy of a Project Gutenberg™
work (any work on which the phrase “Project Gutenberg” appears,
or with which the phrase “Project Gutenberg” is associated) is
accessed, displayed, performed, viewed, copied or distributed:
 This eBook is for the use of anyone anywhere in the United
States and most other parts of the world at no cost and with
almost no restrictions whatsoever. You may copy it, give it away
or re-use it under the terms of the Project Gutenberg License
included with this eBook or online at www.gutenberg.org. If you
are not located in the United States, you will have to check the
laws of the country where you are located before using this
eBook.

1.E.2. If an individual Project Gutenberg™ electronic work is derived

from texts not protected by U.S. copyright law (does not contain a
notice indicating that it is posted with permission of the copyright
holder), the work can be copied and distributed to anyone in the
United States without paying any fees or charges. If you are
redistributing or providing access to a work with the phrase “Project
Gutenberg” associated with or appearing on the work, you must
comply either with the requirements of paragraphs 1.E.1 through
1.E.7 or obtain permission for the use of the work and the Project
Gutenberg™ trademark as set forth in paragraphs 1.E.8 or 1.E.9.

1.E.3. If an individual Project Gutenberg™ electronic work is posted

with the permission of the copyright holder, your use and distribution
must comply with both paragraphs 1.E.1 through 1.E.7 and any
additional terms imposed by the copyright holder. Additional terms
will be linked to the Project Gutenberg™ License for all works posted
with the permission of the copyright holder found at the beginning
of this work.

1.E.4. Do not unlink or detach or remove the full Project

Gutenberg™ License terms from this work, or any files containing a
part of this work or any other work associated with Project
Gutenberg™.

1.E.5. Do not copy, display, perform, distribute or redistribute this

electronic work, or any part of this electronic work, without
prominently displaying the sentence set forth in paragraph 1.E.1
with active links or immediate access to the full terms of the Project
Gutenberg™ License.

1.E.6. You may convert to and distribute this work in any binary,
compressed, marked up, nonproprietary or proprietary form,
including any word processing or hypertext form. However, if you
provide access to or distribute copies of a Project Gutenberg™ work
in a format other than “Plain Vanilla ASCII” or other format used in
the official version posted on the official Project Gutenberg™ website
(www.gutenberg.org), you must, at no additional cost, fee or
expense to the user, provide a copy, a means of exporting a copy, or
a means of obtaining a copy upon request, of the work in its original
“Plain Vanilla ASCII” or other form. Any alternate format must
include the full Project Gutenberg™ License as specified in
paragraph 1.E.1.

1.E.7. Do not charge a fee for access to, viewing, displaying,

performing, copying or distributing any Project Gutenberg™ works
unless you comply with paragraph 1.E.8 or 1.E.9.

1.E.8. You may charge a reasonable fee for copies of or providing

access to or distributing Project Gutenberg™ electronic works
provided that:

• You pay a royalty fee of 20% of the gross profits you derive
from the use of Project Gutenberg™ works calculated using the
method you already use to calculate your applicable taxes. The
fee is owed to the owner of the Project Gutenberg™ trademark,
but he has agreed to donate royalties under this paragraph to
the Project Gutenberg Literary Archive Foundation. Royalty
payments must be paid within 60 days following each date on
which you prepare (or are legally required to prepare) your
periodic tax returns. Royalty payments should be clearly marked
as such and sent to the Project Gutenberg Literary Archive
Foundation at the address specified in Section 4, “Information
 about donations to the Project Gutenberg Literary Archive
Foundation.”

• You provide a full refund of any money paid by a user who

notifies you in writing (or by e-mail) within 30 days of receipt
that s/he does not agree to the terms of the full Project
Gutenberg™ License. You must require such a user to return or
destroy all copies of the works possessed in a physical medium
and discontinue all use of and all access to other copies of
Project Gutenberg™ works.

• You provide, in accordance with paragraph 1.F.3, a full refund of

any money paid for a work or a replacement copy, if a defect in
the electronic work is discovered and reported to you within 90
days of receipt of the work.

• You comply with all other terms of this agreement for free
distribution of Project Gutenberg™ works.

1.E.9. If you wish to charge a fee or distribute a Project Gutenberg™

electronic work or group of works on different terms than are set
forth in this agreement, you must obtain permission in writing from
the Project Gutenberg Literary Archive Foundation, the manager of
the Project Gutenberg™ trademark. Contact the Foundation as set
forth in Section 3 below.

1.F.

1.F.1. Project Gutenberg volunteers and employees expend

considerable effort to identify, do copyright research on, transcribe
and proofread works not protected by U.S. copyright law in creating
the Project Gutenberg™ collection. Despite these efforts, Project
Gutenberg™ electronic works, and the medium on which they may
be stored, may contain “Defects,” such as, but not limited to,
incomplete, inaccurate or corrupt data, transcription errors, a
copyright or other intellectual property infringement, a defective or
damaged disk or other medium, a computer virus, or computer
codes that damage or cannot be read by your equipment.

1.F.2. LIMITED WARRANTY, DISCLAIMER OF DAMAGES - Except for

the “Right of Replacement or Refund” described in paragraph 1.F.3,
the Project Gutenberg Literary Archive Foundation, the owner of the
Project Gutenberg™ trademark, and any other party distributing a
Project Gutenberg™ electronic work under this agreement, disclaim
all liability to you for damages, costs and expenses, including legal
fees. YOU AGREE THAT YOU HAVE NO REMEDIES FOR
NEGLIGENCE, STRICT LIABILITY, BREACH OF WARRANTY OR
BREACH OF CONTRACT EXCEPT THOSE PROVIDED IN PARAGRAPH
1.F.3. YOU AGREE THAT THE FOUNDATION, THE TRADEMARK
OWNER, AND ANY DISTRIBUTOR UNDER THIS AGREEMENT WILL
NOT BE LIABLE TO YOU FOR ACTUAL, DIRECT, INDIRECT,
CONSEQUENTIAL, PUNITIVE OR INCIDENTAL DAMAGES EVEN IF
YOU GIVE NOTICE OF THE POSSIBILITY OF SUCH DAMAGE.

1.F.3. LIMITED RIGHT OF REPLACEMENT OR REFUND - If you

discover a defect in this electronic work within 90 days of receiving
it, you can receive a refund of the money (if any) you paid for it by
sending a written explanation to the person you received the work
from. If you received the work on a physical medium, you must
return the medium with your written explanation. The person or
entity that provided you with the defective work may elect to provide
a replacement copy in lieu of a refund. If you received the work
electronically, the person or entity providing it to you may choose to
give you a second opportunity to receive the work electronically in
lieu of a refund. If the second copy is also defective, you may
demand a refund in writing without further opportunities to fix the
problem.

1.F.4. Except for the limited right of replacement or refund set forth
in paragraph 1.F.3, this work is provided to you ‘AS-IS’, WITH NO
OTHER WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO WARRANTIES OF
MERCHANTABILITY OR FITNESS FOR ANY PURPOSE.

1.F.5. Some states do not allow disclaimers of certain implied

warranties or the exclusion or limitation of certain types of damages.
If any disclaimer or limitation set forth in this agreement violates the
law of the state applicable to this agreement, the agreement shall be
interpreted to make the maximum disclaimer or limitation permitted
by the applicable state law. The invalidity or unenforceability of any
provision of this agreement shall not void the remaining provisions.

1.F.6. INDEMNITY - You agree to indemnify and hold the Foundation,

the trademark owner, any agent or employee of the Foundation,
anyone providing copies of Project Gutenberg™ electronic works in
accordance with this agreement, and any volunteers associated with
the production, promotion and distribution of Project Gutenberg™
electronic works, harmless from all liability, costs and expenses,
including legal fees, that arise directly or indirectly from any of the
following which you do or cause to occur: (a) distribution of this or
any Project Gutenberg™ work, (b) alteration, modification, or
additions or deletions to any Project Gutenberg™ work, and (c) any
Defect you cause.

Section 2. Information about the Mission

of Project Gutenberg™
Project Gutenberg™ is synonymous with the free distribution of
electronic works in formats readable by the widest variety of
computers including obsolete, old, middle-aged and new computers.
It exists because of the efforts of hundreds of volunteers and
donations from people in all walks of life.

Volunteers and financial support to provide volunteers with the

assistance they need are critical to reaching Project Gutenberg™’s
goals and ensuring that the Project Gutenberg™ collection will
remain freely available for generations to come. In 2001, the Project
Gutenberg Literary Archive Foundation was created to provide a
secure and permanent future for Project Gutenberg™ and future
generations. To learn more about the Project Gutenberg Literary
Archive Foundation and how your efforts and donations can help,
see Sections 3 and 4 and the Foundation information page at
www.gutenberg.org.

Section 3. Information about the Project

Gutenberg Literary Archive Foundation
The Project Gutenberg Literary Archive Foundation is a non-profit
501(c)(3) educational corporation organized under the laws of the
state of Mississippi and granted tax exempt status by the Internal
Revenue Service. The Foundation’s EIN or federal tax identification
number is 64-6221541. Contributions to the Project Gutenberg
Literary Archive Foundation are tax deductible to the full extent
permitted by U.S. federal laws and your state’s laws.

The Foundation’s business office is located at 809 North 1500 West,

Salt Lake City, UT 84116, (801) 596-1887. Email contact links and up
to date contact information can be found at the Foundation’s website
and official page at www.gutenberg.org/contact

Section 4. Information about Donations to

the Project Gutenberg Literary Archive
Foundation
Project Gutenberg™ depends upon and cannot survive without
widespread public support and donations to carry out its mission of
increasing the number of public domain and licensed works that can
be freely distributed in machine-readable form accessible by the
widest array of equipment including outdated equipment. Many
small donations ($1 to $5,000) are particularly important to
maintaining tax exempt status with the IRS.

The Foundation is committed to complying with the laws regulating

charities and charitable donations in all 50 states of the United
States. Compliance requirements are not uniform and it takes a
considerable effort, much paperwork and many fees to meet and
keep up with these requirements. We do not solicit donations in
locations where we have not received written confirmation of
compliance. To SEND DONATIONS or determine the status of
compliance for any particular state visit www.gutenberg.org/donate.

While we cannot and do not solicit contributions from states where

we have not met the solicitation requirements, we know of no
prohibition against accepting unsolicited donations from donors in
such states who approach us with offers to donate.

International donations are gratefully accepted, but we cannot make

any statements concerning tax treatment of donations received from
outside the United States. U.S. laws alone swamp our small staff.

Please check the Project Gutenberg web pages for current donation
methods and addresses. Donations are accepted in a number of
other ways including checks, online payments and credit card
donations. To donate, please visit: www.gutenberg.org/donate.

Section 5. General Information About

Project Gutenberg™ electronic works
Professor Michael S. Hart was the originator of the Project
Gutenberg™ concept of a library of electronic works that could be
freely shared with anyone. For forty years, he produced and
distributed Project Gutenberg™ eBooks with only a loose network of
volunteer support.
Project Gutenberg™ eBooks are often created from several printed
editions, all of which are confirmed as not protected by copyright in
the U.S. unless a copyright notice is included. Thus, we do not
necessarily keep eBooks in compliance with any particular paper
edition.

Most people start at our website which has the main PG search
facility: www.gutenberg.org.

This website includes information about Project Gutenberg™,

including how to make donations to the Project Gutenberg Literary
Archive Foundation, how to help produce our new eBooks, and how
to subscribe to our email newsletter to hear about new eBooks.
Welcome to Our Bookstore - The Ultimate Destination for Book Lovers
Are you passionate about books and eager to explore new worlds of
knowledge? At our website, we offer a vast collection of books that
cater to every interest and age group. From classic literature to
specialized publications, self-help books, and children’s stories, we
have it all! Each book is a gateway to new adventures, helping you
expand your knowledge and nourish your soul
Experience Convenient and Enjoyable Book Shopping Our website is more
than just an online bookstore—it’s a bridge connecting readers to the
timeless values of culture and wisdom. With a sleek and user-friendly
interface and a smart search system, you can find your favorite books
quickly and easily. Enjoy special promotions, fast home delivery, and
a seamless shopping experience that saves you time and enhances your
love for reading.
Let us accompany you on the journey of exploring knowledge and
personal growth!

ebookgate.com