Bubble sort program in C

Bubble sort is a simple and intuitive sorting algorithm. It repeatedly swaps adjacent
elements if they are in the wrong order until the array is sorted. In this algorithm, the
largest element "bubbles up" to the end of the array in each iteration. Bubble sort is
inefficient for large data sets, but it is useful for educational purposes and small data
sets. In this article, we will implement the bubble sort algorithm in C programming
language.

Bubble sort Algorithm

In this article, we will discuss the Bubble sort Algorithm. The working procedure of
bubble sort is simplest. This article will be very helpful and interesting to students as
they might face bubble sort as a question in their examinations. So, it is important to
discuss the topic.

Bubble sort works on the repeatedly swapping of adjacent elements until they are not in
the intended order. It is called bubble sort because the movement of array elements is
just like the movement of air bubbles in the water. Bubbles in water rise up to the
surface; similarly, the array elements in bubble sort move to the end in each iteration.

Although it is simple to use, it is primarily used as an educational tool because the

performance of bubble sort is poor in the real world. It is not suitable for large data sets.
The average and worst-case complexity of Bubble sort is O(n2), where n is a number of
items.

Bubble short is majorly used where -

o complexity does not matter

o simple and shortcode is preferred

Algorithm
In the algorithm given below, suppose arr is an array of n elements. The
assumed swap function in the algorithm will swap the values of given array elements.

1. begin BubbleSort(arr)
2. for all array elements
3. if arr[i] > arr[i+1]
4. swap(arr[i], arr[i+1])
5. end if
6. end for
7. return arr
8. end BubbleSort

Working of Bubble sort Algorithm

Now, let's see the working of Bubble sort Algorithm.

To understand the working of bubble sort algorithm, let's take an unsorted array. We
are taking a short and accurate array, as we know the complexity of bubble sort is O(n2).

Let the elements of array are -

First Pass
Sorting will start from the initial two elements. Let compare them to check which is
greater.

Here, 32 is greater than 13 (32 > 13), so it is already sorted. Now, compare 32 with 26.

Here, 26 is smaller than 36. So, swapping is required. After swapping new array will look
like -
Now, compare 32 and 35.

Here, 35 is greater than 32. So, there is no swapping required as they are already sorted.

Now, the comparison will be in between 35 and 10.

Here, 10 is smaller than 35 that are not sorted. So, swapping is required. Now, we reach
at the end of the array. After first pass, the array will be -

Now, move to the second iteration.

Second Pass
The same process will be followed for second iteration.

Here, 10 is smaller than 32. So, swapping is required. After swapping, the array will be -
Now, move to the third iteration.

Third Pass
The same process will be followed for third iteration.

Here, 10 is smaller than 26. So, swapping is required. After swapping, the array will be -

Now, move to the fourth iteration.

Fourth pass
Similarly, after the fourth iteration, the array will be -

Hence, there is no swapping required, so the array is completely sorted.

Bubble sort complexity

Now, let's see the time complexity of bubble sort in the best case, average case, and
worst case. We will also see the space complexity of bubble sort.

1. Time Complexity
 Case Time Complexity

Best Case O(n)

Average Case O(n2)

Worst Case O(n2)

o Best Case Complexity - It occurs when there is no sorting required, i.e. the array
is already sorted. The best-case time complexity of bubble sort is O(n).
o Average Case Complexity - It occurs when the array elements are in jumbled
order that is not properly ascending and not properly descending. The average
case time complexity of bubble sort is O(n2).
o Worst Case Complexity - It occurs when the array elements are required to be
sorted in reverse order. That means suppose you have to sort the array elements
in ascending order, but its elements are in descending order. The worst-case time
complexity of bubble sort is O(n2).

2. Space Complexity

Space Complexity O(1)

Stable YES

o The space complexity of bubble sort is O(1). It is because, in bubble sort, an extra
variable is required for swapping.
o The space complexity of optimized bubble sort is O(2). It is because two extra
variables are required in optimized bubble sort.

Now, let's discuss the optimized bubble sort algorithm.

Optimized Bubble sort Algorithm

In the bubble sort algorithm, comparisons are made even when the array is already
sorted. Because of that, the execution time increases.
 To solve it, we can use an extra variable swapped. It is set to true if swapping requires;
otherwise, it is set to false.

It will be helpful, as suppose after an iteration, if there is no swapping required, the

value of variable swapped will be false. It means that the elements are already sorted,
and no further iterations are required.

This method will reduce the execution time and also optimizes the bubble sort.

Algorithm for optimized bubble sort

1. bubbleSort(array)
2. n = length(array)
3. repeat
4. swapped = false
5. for i = 1 to n - 1
6. if array[i - 1] > array[i], then
7. swap(array[i - 1], array[i])
8. swapped = true
9. end if
10. end for
11. n=n-1
12. until not swapped
13. end bubbleSort

Implementation of Bubble sort

Now, let's see the programs of Bubble sort in different programming languages.

Program: Write a program to implement bubble sort in C language.

1. #include<stdio.h>
2. void print(int a[], int n) //function to print array elements
3. {
4. int i;
5. for(i = 0; i < n; i++)
6. {
7. printf("%d ",a[i]);
8. }
9. }
10. void bubble(int a[], int n) // function to implement bubble sort
11. {
12. int i, j, temp;
13. for(i = 0; i < n; i++)
14. {
15. for(j = i+1; j < n; j++)
16. {
17. if(a[j] < a[i])
18. {
19. temp = a[i];
20. a[i] = a[j];
21. a[j] = temp;
22. }
23. }
24. }
25. }
26. void main ()
27. {
28. int i, j,temp;
29. int a[5] = { 10, 35, 32, 13, 26};
30. int n = sizeof(a)/sizeof(a[0]);
31. printf("Before sorting array elements are - \n");
32. print(a, n);
33. bubble(a, n);
34. printf("\nAfter sorting array elements are - \n");
35. print(a, n);
36. }

Output
 Selection Sort Algorithm
In this article, we will discuss the Selection sort Algorithm. The working procedure of selection
sort is also simple. This article will be very helpful and interesting to students as they might face
selection sort as a question in their examinations. So, it is important to discuss the topic.

In selection sort, the smallest value among the unsorted elements of the array is selected in every
pass and inserted to its appropriate position into the array. It is also the simplest algorithm. It is
an in-place comparison sorting algorithm. In this algorithm, the array is divided into two parts,
first is sorted part, and another one is the unsorted part. Initially, the sorted part of the array is
empty, and unsorted part is the given array. Sorted part is placed at the left, while the unsorted
part is placed at the right.

In selection sort, the first smallest element is selected from the unsorted array and placed at the
first position. After that second smallest element is selected and placed in the second position.
The process continues until the array is entirely sorted.

The average and worst-case complexity of selection sort is O(n2), where n is the number of
items. Due to this, it is not suitable for large data sets.

Selection sort is generally used when -

o A small array is to be sorted

o Swapping cost doesn't matter
o It is compulsory to check all elements

Now, let's see the algorithm of selection sort.

Algorithm
1. SELECTION SORT(arr, n)
2.
3. Step 1: Repeat Steps 2 and 3 for i = 0 to n-1
4. Step 2: CALL SMALLEST(arr, i, n, pos)
5. Step 3: SWAP arr[i] with arr[pos]
6. [END OF LOOP]
7. Step 4: EXIT
8.
9. SMALLEST (arr, i, n, pos)
10. Step 1: [INITIALIZE] SET SMALL = arr[i]
11. Step 2: [INITIALIZE] SET pos = i
12. Step 3: Repeat for j = i+1 to n
13. if (SMALL > arr[j])
14. SET SMALL = arr[j]
15. SET pos = j
16. [END OF if]
17. [END OF LOOP]
18. Step 4: RETURN pos

Working of Selection sort Algorithm

Now, let's see the working of the Selection sort Algorithm.

To understand the working of the Selection sort algorithm, let's take an unsorted array. It will be
easier to understand the Selection sort via an example.

Let the elements of array are -

Now, for the first position in the sorted array, the entire array is to be scanned sequentially.

At present, 12 is stored at the first position, after searching the entire array, it is found that 8 is
the smallest value.

So, swap 12 with 8. After the first iteration, 8 will appear at the first position in the sorted array.
For the second position, where 29 is stored presently, we again sequentially scan the rest of the
items of unsorted array. After scanning, we find that 12 is the second lowest element in the array
that should be appeared at second position.

Now, swap 29 with 12. After the second iteration, 12 will appear at the second position in the
sorted array. So, after two iterations, the two smallest values are placed at the beginning in a
sorted way.

The same process is applied to the rest of the array elements. Now, we are showing a pictorial
representation of the entire sorting process.

Now, the array is completely sorted.

Selection sort complexity
Now, let's see the time complexity of selection sort in best case, average case, and in worst case.
We will also see the space complexity of the selection sort.

1. Time Complexity
Case Time Complexity
Best Case O(n2)
Average Case O(n2)
Worst Case O(n2)

o Best Case Complexity - It occurs when there is no sorting required, i.e. the array
is already sorted. The best-case time complexity of selection sort is O(n2).
o Average Case Complexity - It occurs when the array elements are in jumbled
order that is not properly ascending and not properly descending. The average
case time complexity of selection sort is O(n2).
o Worst Case Complexity - It occurs when the array elements are required to be
sorted in reverse order. That means suppose you have to sort the array elements
in ascending order, but its elements are in descending order. The worst-case time
complexity of selection sort is O(n2).

2. Space Complexity

Space Complexity O(1)

Stable YES
o The space complexity of selection sort is O(1). It is because, in selection sort, an
extra variable is required for swapping.

Implementation of selection sort

Now, let's see the programs of selection sort in different programming languages.
 Program: Write a program to implement selection sort in C language.

1. #include <stdio.h>
2.
3. void selection(int arr[], int n)
4. {
5. int i, j, small;
6.
7. for (i = 0; i < n-1; i++) // One by one move boundary of unsorted subarray
8. {
9. small = i; //minimum element in unsorted array
10.
11. for (j = i+1; j < n; j++)
12. if (arr[j] < arr[small])
13. small = j;
14. // Swap the minimum element with the first element
15. int temp = arr[small];
16. arr[small] = arr[i];
17. arr[i] = temp;
18. }
19. }
20.
21. void printArr(int a[], int n) /* function to print the array */
22. {
23. int i;
24. for (i = 0; i < n; i++)
25. printf("%d ", a[i]);
26. }
27.
28. int main()
29. {
30. int a[] = { 12, 31, 25, 8, 32, 17 };
31. int n = sizeof(a) / sizeof(a[0]);
32. printf("Before sorting array elements are - \n");
33. printArr(a, n);
34. selection(a, n);
35. printf("\nAfter sorting array elements are - \n");
36. printArr(a, n);
37. return 0;
38. }

Output:

After the execution of above code, the output will be -

Insertion Sort Algorithm

In this article, we will discuss the Insertion sort Algorithm. The working procedure of
insertion sort is also simple. This article will be very helpful and interesting to students
as they might face insertion sort as a question in their examinations. So, it is important
to discuss the topic.

Insertion sort works similar to the sorting of playing cards in hands. It is assumed that
the first card is already sorted in the card game, and then we select an unsorted card. If
the selected unsorted card is greater than the first card, it will be placed at the right
side; otherwise, it will be placed at the left side. Similarly, all unsorted cards are taken
and put in their exact place.

The same approach is applied in insertion sort. The idea behind the insertion sort is that
first take one element, iterate it through the sorted array. Although it is simple to use, it
is not appropriate for large data sets as the time complexity of insertion sort in the
average case and worst case is O(n2), where n is the number of items. Insertion sort is
less efficient than the other sorting algorithms like heap sort, quick sort, merge sort, etc.

Insertion sort has various advantages such as -

o Simple implementation
 o Efficient for small data sets
o Adaptive, i.e., it is appropriate for data sets that are already substantially sorted.

Now, let's see the algorithm of insertion sort.

Algorithm
The simple steps of achieving the insertion sort are listed as follows -

Step 1 - If the element is the first element, assume that it is already sorted. Return 1.

Step2 - Pick the next element, and store it separately in a key.

Step3 - Now, compare the key with all elements in the sorted array.

Step 4 - If the element in the sorted array is smaller than the current element, then
move to the next element. Else, shift greater elements in the array towards the right.

Step 5 - Insert the value.

Step 6 - Repeat until the array is sorted.

Working of Insertion sort Algorithm

Now, let's see the working of the insertion sort Algorithm.

To understand the working of the insertion sort algorithm, let's take an unsorted array. It
will be easier to understand the insertion sort via an example.

Let the elements of array are -

Initially, the first two elements are compared in insertion sort.

Here, 31 is greater than 12. That means both elements are already in ascending order.
So, for now, 12 is stored in a sorted sub-array.
Now, move to the next two elements and compare them.

Here, 25 is smaller than 31. So, 31 is not at correct position. Now, swap 31 with 25.
Along with swapping, insertion sort will also check it with all elements in the sorted
array.

For now, the sorted array has only one element, i.e. 12. So, 25 is greater than 12. Hence,
the sorted array remains sorted after swapping.

Now, two elements in the sorted array are 12 and 25. Move forward to the next
elements that are 31 and 8.

Both 31 and 8 are not sorted. So, swap them.

After swapping, elements 25 and 8 are unsorted.

So, swap them.

Now, elements 12 and 8 are unsorted.

So, swap them too.

Now, the sorted array has three items that are 8, 12 and 25. Move to the next items that
are 31 and 32.

Hence, they are already sorted. Now, the sorted array includes 8, 12, 25 and 31.

Move to the next elements that are 32 and 17.

17 is smaller than 32. So, swap them.

Swapping makes 31 and 17 unsorted. So, swap them too.

Now, swapping makes 25 and 17 unsorted. So, perform swapping again.

Now, the array is completely sorted.

Insertion sort complexity

Now, let's see the time complexity of insertion sort in best case, average case, and in
worst case. We will also see the space complexity of insertion sort.

1. Time Complexity

Case Time Complexity

Best Case O(n)
Average Case O(n2)
Worst Case O(n2)

o Best Case Complexity - It occurs when there is no sorting required, i.e. the array
is already sorted. The best-case time complexity of insertion sort is O(n).
o Average Case Complexity - It occurs when the array elements are in jumbled
order that is not properly ascending and not properly descending. The average
case time complexity of insertion sort is O(n2).
o Worst Case Complexity - It occurs when the array elements are required to be
sorted in reverse order. That means suppose you have to sort the array elements
in ascending order, but its elements are in descending order. The worst-case time
complexity of insertion sort is O(n2).

2. Space Complexity

Space Complexity O(1)

Stable YES
 o The space complexity of insertion sort is O(1). It is because, in insertion sort, an
extra variable is required for swapping.

Implementation of insertion sort

Now, let's see the programs of insertion sort in different programming languages.

Program: Write a program to implement insertion sort in C language.

1. #include <stdio.h>
2.
3. void insert(int a[], int n) /* function to sort an aay with insertion sort */
4. {
5. int i, j, temp;
6. for (i = 1; i < n; i++) {
7. temp = a[i];
8. j = i - 1;
9.
10. while(j>=0 && temp <= a[j]) /* Move the elements greater than temp to one posi
tion ahead from their current position*/
11. {
12. a[j+1] = a[j];
13. j = j-1;
14. }
15. a[j+1] = temp;
16. }
17. }
18.
19. void printArr(int a[], int n) /* function to print the array */
20. {
21. int i;
22. for (i = 0; i < n; i++)
23. printf("%d ", a[i]);
24. }
25.
26. int main()
27. {
28. int a[] = { 12, 31, 25, 8, 32, 17 };
29. int n = sizeof(a) / sizeof(a[0]);
30. printf("Before sorting array elements are - \n");
31. printArr(a, n);
32. insert(a, n);
33. printf("\nAfter sorting array elements are - \n");
34. printArr(a, n);
35.
36. return 0;
37. }

Output:

Program to take a number from user and to get the square root
Let's consider an example to print the square root of a number by taking an input from
the user and then use the sqrt() function in C.

ADVERTISEMENT

1. #include <stdio.h>
2. #include <conio.h>
3. #include <math.h>
4.
5. int main ()
6. {
7. // declare an integer variable
8. int x;
9. double res;
10. printf (" Enter any number to get the square root: ");
11. scanf (" %d", &x);
12. // use the sqrt() function to return integer values
13. res = sqrt(x);
14. printf (" \n The square root of %d is: %.2lf", x, res);
15.
16. return 0;
17. }

Output:

Enter any number to get the square root: 625

The square root of 625 is: 25.00

Library function in C
Introduction:
In the world of programming, libraries are one of the most important and useful tools
available. They are prewritten pieces of code that can be used to perform specific tasks,
such as sorting or searching data, without the need to write the code from scratch. C is
a popular programming language that has a wide range of libraries available for use. In
this article, we will explore the concept of library functions in C and how they can be
used to simplify programming tasks.

What is a library function in C?

In C programming language, a library function is a prewritten piece of code that
performs a specific task. These functions are included in precompiled libraries, which
can be linked to a program to provide additional functionality. Library functions can be
categorized into two types: Standard Library Functions and User-defined Library
Functions.

Standard Library Functions:

The standard library functions are a set of functions that are provided by the C
programming language. These functions are included in the standard library, which is
part of the C language specification.
The standard C library is also known as the libc library. It is a collection of functions
and macros that are part of the C programming language. These functions provide a
wide range of functionality, including input/output operations, string
manipulation, memory allocation, mathematical calculations, and more.

Some of the common standard library functions in C include:

1. Input/output functions: These input/output functions are used to read input

from the user or write output to the screen or a file. Examples include printf(),
scanf(), and gets().
2. String manipulation functions: These string manipulation functions are used
to manipulate strings in C. Examples include strlen(), strcpy(), and strcat().
3. Mathematical functions: These mathematical functions are used to
perform mathematical operations in C. Examples include sin(),
cos(), and sqrt().
4. Time functions: These time functions are used to retrieve the current time or
perform time-related calculations. Examples
include time(), localtime(), and strftime().

User-defined Library Functions:

User-defined library functions are functions that are created by the programmer and
added to a library for later use. These functions can be written in C or any other
programming language that can be compiled into a library. User-defined library
functions can be used to simplify complex programming tasks, reuse code,
and improve code maintainability.

Creating a User-defined Library Function:

To create a user-defined library function, the following steps can be taken:

1. Write the function code: Write the code for the function that performs the
required task.
2. Create a header file: Create a header file for the function that contains the
function prototype.
3. Compile the code: Compile the code into an object file using a compiler.
 4. Create the library: Create a library by combining the object file with other
required object files.
5. Link the library: Link the library to the program that will use the function.

Advantages of Using Library Functions:

There are several advantages of using library functions which includes:

1. Saves time: Library functions provide prewritten code that can be used to
perform common programming tasks, saving programmers time and effort.
2. Increases productivity: With library functions, programmers can quickly develop
complex programs without worrying about the low-level details.
3. Improves code readability: Library functions provide a standardized way of
performing common tasks, making the code more readable and easier to
maintain.
4. Reduces bugs: The use of library functions reduces the chances of introducing
bugs into the program since the code has already been tested and debugged.

Library Functions vs Custom Functions:

Library Functions:
In C, functions can be defined within the code of a program, but these are not
considered library functions. Library functions are pre-written functions that are
included in a library and can be used in multiple programs without the need to write the
code again.

Linking Libraries:

To use library functions in a C program, the library needs to be linked with the
program during the compilation process. It can be done in two ways: static
linking and dynamic linking.

Static Linking: In static linking, the library functions are copied into the executable file
during compilation. It means that the executable file includes all the necessary code and
can be run independently of the library.
 Dynamic Linking: In dynamic linking, the library functions are not copied into the
executable file. Instead, the program references the library functions at runtime. It
means that the library file needs to be present on the system when the program is run.

Header Files:

Header files are used to declare the prototypes for the functions included in the library.
The header file contains the function declarations, as well as any
necessary macros, constants, and types. Header files are included in the source code
using the #include directive.

For example, if we wanted to use the printf() function from the standard C library, we
would include the stdio.h header file at the top of our code:

1. #include <stdio.h>
2. int main()
3. {
4. printf("Hello, World!");
5. return 0;
6. }

In this example, we include the stdio.h header file, which declares the prototype for
the printf() function. It allows us to use the printf() function without having to write
the code ourselves.

Custom Library Functions:

On the other hand, custom functions are functions that are written specifically for a
program and cannot be used in other programs without copying the code. In addition
to standard library functions, programmers can also create their own custom library
functions to encapsulate common functionality and reduce code duplication. Custom
library functions can be defined in separate source files and compiled into a library,
which can then be linked with multiple programs.

To create a custom library function, the function needs to be defined in a source file
with a .c extension, and the function prototype needs to be declared in a header file
with a .h extension. After that, the source file is compiled into an object file with a .o
extension, and the object files for all the functions in the library are combined into a
single library file with a .a or .so extension, depending on whether static or dynamic
linking is used.
 Example:

Here's an example of a custom library function that calculates the factorial of a number:

1. int factorial(int n)
2. {
3. if (n == 0) {
4. return 1;
5. } else {
6. return n * factorial(n - 1);
7. }
8. }

In this example, we define a recursive function called factorial() that calculates the
factorial of a given number. After that, we can compile this source file into an object file
using a command like:

1. gcc -c factorial.c -o factorial.o

We can then combine this object file with other object files to create a library file using a
command like:

1. arrcslibmylib.afactorial.o

It creates a static library file called libmylib.a that can be linked with other programs
using the -lmylib option during compilation.

Header Files:

Header files are used to declare the function prototypes for library functions,
both standard and custom. A function prototype is a declaration of a function's
name, return type, and parameter types, but without the function body. Header files
also include any necessary macros, constants, and types that are needed by the
functions.

For example, here's the header file for our factorial() function:

1. int factorial(int n);

 In this example, we declare the prototype for the factorial() function, which takes an
integer parameter and returns an integer value.

When using library functions in a program, the corresponding header files need to be
included using the #include directive.

For example:

1. #include "factorial.h"
2.
3. int main()
4. {
5. int n = 5;
6. int result = factorial(n);
7. printf("Factorial of %d is %d\n", n, result);
8. return 0;
9. }

In this example, we include the factorial.h header file, which declares the prototype for
the factorial() function. After that, we call the factorial() function with a value
of 5 and print the result using printf().

Common Library Functions:

There are many standard library functions available in C, including:

1. string.h: functions for manipulating strings, such as strcpy() and strlen().

2. stdio.h: input/output functions, such as printf() and scanf().
3. math.h: mathematical functions, such as sin() and sqrt().
4. time.h: functions for working with dates and times, such
as time() and localtime().
5. ctype.h: functions for working with characters, such as isalpha() and toupper().

Some examples of using library functions in C:

Example 1:

Let's take an example using the string.h library to manipulate strings.

1. #include <stdio.h>
2. #include <string.h>
3.
4. int main()
5. {
6. char str1[20] = "Hello";
7. char str2[20] = "World";
8.
9. // concatenate str2 to str1
10. strcat(str1, str2);
11.
12. // print the concatenated string
13. printf("%s", str1);
14.
15. return 0;
16. }

Output:

HelloWorld

In this example, we include the string.h library and use the strcat() function to
concatenate the str2 string onto the end of the str1 string. After that, we
use printf() to print the resulting concatenated string.

Example 2:

Let's take an example using the math.h library to perform mathematical calculations.

1. #include <stdio.h>
2. #include <math.h>
3.
4. int main()
5. {
6. double x = 4.0;
7.
8. // calculate the square root of x
9. double y = sqrt(x);
10.
11. // print the result
12. printf("The square root of %f is %f", x, y);
13.
14. return 0;
15. }

Output:

The square root of 4.000000 is 2.000000

Explanation:

In this example, we include the math.h library and use the sqrt() function to calculate
the square root of the variable x. After that, we use printf() to print the result.

Example 3:

Let's take an example using the time.h library to work with dates and times.

1. #include <stdio.h>
2. #include <time.h>
3.
4. int main()
5. {
6. time_t t = time(NULL);
7. struct tm *tm = localtime(&t);
8.
9. // print the current date and time
10. printf("Current date and time: %s", asctime(tm));
11.
12. return 0;
13. }

Output:

Current date and time: Mon May 8 17:07:05 2023

Explanation:

In this example, we include the time.h library and use the time() function to get the
current time, which is then passed to the localtime() function to convert it to a local
time structure. After that, we use printf() and the asctime() function to print
the current date and time in a readable format.

These examples demonstrate how library functions can be used to simplify

programming tasks and improve code readability. By using pre-written code from
libraries, programmers can focus on the higher-level logic of their programs without
needing to worry about lower-level details.

Conclusion:
In conclusion, library functions in C are a powerful tool that can simplify programming
tasks and improve code maintainability. Standard library functions provide a wide
range of functionality that is part of the C language specification, while user-defined
library functions can be created by the programmer and added to a library for later
use. Using library functions saves time, increases productivity, improves code
readability, and reduces bugs. By utilizing library functions, programmers can focus on
solving complex problems without worrying about the low-level details.