0% found this document useful (0 votes)
18 views31 pages

3 Arrays

The document provides information about linear arrays, including basic terminology, memory representation, traversing arrays, insertion and deletion, sorting with bubble sort, and searching with linear search and binary search. It discusses arrays as linear data structures where elements are stored in consecutive memory locations referenced by an index. Key concepts covered include size and indexes of arrays, traversing arrays using for and while loops, inserting and deleting elements through shifting elements, and sorting algorithms like bubble sort and searching techniques like linear and binary search. Pseudocode and C code examples are provided for merging, sorting, and searching arrays.

Uploaded by

Amar Thakur
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
18 views31 pages

3 Arrays

The document provides information about linear arrays, including basic terminology, memory representation, traversing arrays, insertion and deletion, sorting with bubble sort, and searching with linear search and binary search. It discusses arrays as linear data structures where elements are stored in consecutive memory locations referenced by an index. Key concepts covered include size and indexes of arrays, traversing arrays using for and while loops, inserting and deleting elements through shifting elements, and sorting algorithms like bubble sort and searching techniques like linear and binary search. Pseudocode and C code examples are provided for merging, sorting, and searching arrays.

Uploaded by

Amar Thakur
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 31

Lovely Professional University, Punjab

Data Structures
Lecture : Linear Array
Contents
• Basic Terminology
• Linear Array
• Memory Representation of Linear Array
• Traversing Array
• Insertion and Deletion in Array
• Sorting (Bubble Sort)
• Searching (Linear Search and Binary Search)
• Review Questions
Basic Terminology
• Linear Data Structures: A data structure is said to be linear if its
elements form a sequence or a linear list.

• Linear Array: is a list of a finite number n of homogeneous data


elements such that:

(a) the elements of the array are referenced by an index set


consisting of n consecutive numbers.

(b) the elements of the array are stored respectively in


successive memory locations.
Key Terms
• Size / Length of Array
• Index of Array
• Upper bound and Lower bound of Array
Memory Representation of Arrays
19 5 42 18 199

1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
Traversing Linear Array
• Suppose we have to count the number of element is an array
or print all the elements of array.

• Algorithm 1: (Using While Loop)

1. [Initialize Counter.] Set K = LB.


2. Repeat Step 3 and 4 while K<= UB.
3. [Visit Element.] Apply PROCESS to A[K].
4. [Increase Counter.] Set K = K+1.
[End of Step 2 Loop.]
5. Exit.
Algorithm 2: (Using for loop)

1. Repeat for K = LB to UB
Apply PROCESS to A[K].
[ End of Loop.]
2. Exit.

Question.1: Find the Number of elements in an array which are


greater than 25.

Question 2: Find out the sum of all the two digit numbers in an
array.
Insertion and Deletion in an Array
• Two types of insertion are possible:
• Insertion at the end of array
• Insertion in the middle of the array
Insertion into a Linear Array
• Algorithm: (Insertion of an element ITEM into Kth position in
a Linear Array A)

1. [Initialize Counter.] Set J = N.


2. Repeat Steps 3and 4 while J >= K.
3. [Move Jth element downward] Set A[J+1] = A[J].
4. [Decrease Counter.] Set J = J-1.
[End of Step 2 loop]
5. [Insert element.] Set A[K] = ITEM.
6. [Reset N] N = N+1.
7. Exit
Deletion into a Linear Array
Algorithm: (Delete Kth element from Linear Array A)

1. Repeat for J = K to N-1.


2. [Move (J+1)th element upward] Set A[J] = A[J+1].
[End of loop.]
3. [Reset the number of elements N] Set N = N-1.
4. Exit
Merging Algorithm

• Suppose A is a sorted list with r elements and B is a sorted list


with s elements. The operation that combines the element of A
and B into a single sorted list C with n=r + s elements is called
merging.

11
Merging Algorithm
 Algorithm: Merging (A, R,B,S,C)
Here A and B be sorted arrays with R and S elements
respectively. This algorithm merges A and B into an array
C with N=R+ S elements
 Step 1: Set NA=0, NB=0 and NC=0
 Step 2: Repeat while NA < R and NB < S:
if A[NA] ≤ B[NB], then:
Set C[NC] = A[NA]
Set NA = NA +1
else
Set C[NC] = B[NB]
Set NB = NB +1
[End of if structure]
Set NC= NC +1
[End of Loop]

12
Merging Algorithm
Step 3: If NA >=R, then:
Repeat while NB < S:
Set C[NC] = B[NB]
Set NB = NB+1
Set NC = NC +1
[End of Loop]
else
Repeat while NA < R:
Set C[NC] = A[NA]
Set NC = NC + 1
Set NA = NA +1
[End of loop]
[End of if structure]
Step 4: Return C[NC]
13
 #include <stdio.h>
Merge Program
 int main() {
 void merge_arrays(int A[], int R, int B[], int S, int C[]) {
 int NA = 0, NB = 0, NC = 0;  int A[] = {1, 3, 5, 7, 9};
 int R = sizeof(A) / sizeof(A[0]);
 while (NA < R && NB < S) {
 if (A[NA] <= B[NB]) {
 C[NC] = A[NA];  int B[] = {2, 4, 6, 8, 10};
 NA++;  int S = sizeof(B) / sizeof(B[0]);
 } else {
 C[NC] = B[NB];
 NB++;
 int C[R + S];
 }
 NC++;  merge_arrays(A, R, B, S, C);
 }

 while (NA < R) {  printf("Merged and sorted array: ");


 C[NC] = A[NA];  for (int i = 0; i < R + S; i++) {
 NA++;
  printf("%d ", C[i]);
NC++;
 }  }
 printf("\n");
 while (NB < S) {
 C[NC] = B[NB];
 NB++;  return 0;
 NC++;  }
 }
 }
14
Merging Algorithm
• Complexity of merging: The input consists of the total number
n=r+s elements in A and B. Each comparison assigns an
element to the array C, which eventually has n elements.
Accordingly, the number f(n) of comparisons cannot exceed n:
f(n) ≤ n = O(n)

15
Searching
1. Linear Search:
• Compares the item of interest with each element of Array
one by one.
• Traverses the Array sequentially to locate the desired
item.
Linear Search Algorithm
• LINEAR (DATA, N, ITEM, LOC)

1. [Insert ITEM at the end of DATA] Set Data [N+1]= ITEM.


2. [Initialize Counter] Set LOC=1.
3. [Search for ITEM.]
Repeat while DATA [LOC] != ITEM
Set LOC = LOC +1.
[End of loop.]
4. [Successful?] if LOC = N + 1, then Set LOC = 0.
5. Exit.
Binary Search
• BINARY ( DATA, LB, UB, ITEM, LOC )
1. [Initialize Segment Variables]
Set BEG = LB, END = UB and MID = INT ((BEG+END)/2).
2. Repeat Steps 3 and 4 while BEG <= END and DATA [MID] != ITEM.
3. If ITEM < DATA[MID], then:
Set END = MID - 1.
Else:
Set BEG = MID + 1.
[End of if Structure.]
4. Set MID = INT ((BEG+END)/2).
[End of Step 2 Loop.]
5. If DATA [MID] = ITEM, then: LOC=MID
Else:
Set LOC = NULL.
[End of if structure.]
6. Exit.
Binary Search Program
• #include <stdio.h>
int main() {
• int binary_search(int data[], int size, int item) {
• int data[] = {1, 3, 5, 7, 9, 11, 13, 15};
• int beg = 0;
• int size = sizeof(data) / sizeof(data[0]);
• int end = size - 1;
• int item = 7;
• int mid;

• while (beg <= end) {


• int index = binary_search(data, size, item);
• mid = (beg + end) / 2;

if (data[mid] == item) {
• if (index != -1) {
• return mid; // Element found, return its index
• printf("Element %d found at index %d\n",
• } else if (item < data[mid]) {
item, index);
• end = mid - 1; // Search in the left half
• } else {
• } else {
Limitations of Binary Search
• Although the complexity of Binary Search is
O (log n), it has some limitations:
1. the list must be sorted
2. one must have direct access to the middle element in any
sublist.
Selection Sort
Selection Sort
Selection Sort
// Selection sort in C
// function to print an array

void printArray(int array[], int size) {


#include <stdio.h> for (int i = 0; i < size; ++i) {

// function to swap the the position of two elements printf("%d ", array[i]);

void swap(int *a, int *b) {


}

printf("\n");
int temp = *a;
}
*a = *b;

*b = temp;
// driver code
}
int main() {
void selectionSort(int array[], int size) { int data[] = {20, 12, 10, 15, 2};

for (int step = 0; step < size - 1; step++) { int size = sizeof(data) / sizeof(data[0]);

int min_idx = step;


selectionSort(data, size);

printf("Sorted array in Acsending Order:\n");


for (int i = step + 1; i < size; i++) {
printArray(data, size);
// To sort in descending order, change > to < in this line.
}
// Select the minimum element in each loop.
Insertion Sort
Insertion Sort
Insertion Sort
// Insertion sort in C
// Function to print an array

void printArray(int array[], int size) {


#include <stdio.h>

void insertionSort(int array[], int size) {


for (int i = 0; i < size; i++) {

for (int step = 1; step < size; step++) { printf("%d ", array[i]);

int key = array[step]; }

int j = step - 1;
printf("\n");
// Compare key with each element on the left of it until an
}
element smaller than

// it is found.

// For descending order, change key<array[j] to // Driver code


key>array[j].
int main() {
while (key < array[j] && j >= 0) {
int data[] = {9, 5, 1, 4, 3};
Bubble Sort
Bubble Sort
Bubble Sort
Bubble Sort
#include <stdio.h> // print array
void printArray(int array[], int size) {
// perform the bubble sort for (int i = 0; i < size; ++i) {
void bubbleSort(int array[], int size) { printf("%d ", array[i]);
// loop to access each array element
}
for (int step = 0; step < size - 1; ++step) { printf("\n");
}
// loop to compare array elements
for (int i = 0; i < size - step - 1; ++i) { int main() {
int data[] = {-2, 45, 0, 11, -9};
// compare two adjacent elements
// change > to < to sort in descending order
if (array[i] > array[i + 1]) {
// find the array's length
int size = sizeof(data) / sizeof(data[0]);
// swapping occurs if elements
// are not in the intended order bubbleSort(data, size);
int temp = array[i];
array[i] = array[i + 1]; printf("Sorted Array in Ascending
array[i + 1] = temp; Order:\n");
}
}
printArray(data, size);
} }
}
Questions

You might also like