Scribd
Upload
49 views

Searching and Sorting Searching and Sorting

Searching and sorting are fundamental operations in computer science. Searching methods like linear search examine each element sequentially to find a target value, while binary search uses a divide and conquer approach, cutting the search space in half at each step. Common sorting algorithms like bubble sort, insertion sort, and selection sort work by repeatedly comparing and swapping adjacent elements, while more efficient methods like mergesort and radix sort exploit sorting properties. Sorted data enables faster search methods like binary search.

Uploaded by

salmanshokha
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
49 views

Searching and Sorting Searching and Sorting

Searching and sorting are fundamental operations in computer science. Searching methods like linear search examine each element sequentially to find a target value, while binary search uses a divide and conquer approach, cutting the search space in half at each step. Common sorting algorithms like bubble sort, insertion sort, and selection sort work by repeatedly comparing and swapping adjacent elements, while more efficient methods like mergesort and radix sort exploit sorting properties. Sorted data enables faster search methods like binary search.

Uploaded by

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

SEARCHING AND SORTING

SEARCHING AND SORTING


Searching

and sorting are fundamental operations in


computer programming

CSE 110 (Intro to


Computer Science)

Searching

and sorting go hand in hand

Sorted

data is much easier to search

Stony Brook University

LINEAR SEARCH
each element in turn to see if its the one
youre looking for

LINEAR SEARCH EXAMPLE

Examine

Original

list of numbers: 34, 6, 22, 10, 48, 63, 59, 77

On

average, you have to examine half of the data set to


find what youre looking for

Works
The

even if the list is unsorted

time required grows in a linear fashion

The

time needed increases at the same rate as the size


of the data set increases

It

takes 4 comparisons to find 10 in this list

We
It

look at 34, 6, 22, and finally 10

takes 8 comparisons to show that 11 is not in this list

We

need to look at every element in sequence

BINARY SEARCH
Method: choose

an element at random (usually the


middle) and decide whether to search the left or right half

At

each decision point, the space to be searched is cut in


half

Requires
Very

sorted data to work properly

efficient: only needs log2(n) comparisons

Twice

as much data only needs one more step

BINARY SEARCH EXAMPLE

PSEUDOCODE
If (range contains only one element):
Look for desired value
Else:
1. Get midpoint of range
2. Determine which half of the range is likely to contain
the desired value
3. Repeat the binary search on just that half of the range

SORTING TECHNIQUES
Many

Ex. Find

51

Start: [4, 10, 13, 14, 22, 29, 35, 37, 44, 51, 63]
Round

1: middle element is 29, so ignore whats to the left

Round

2: new middle element is 44, so go right again

Round

3: middle element is 51 (left bias) FOUND

sorting techniques exist: bubble sort, insertion sort,


selection sort, mergesort, quicksort, shell sort, radix sort,
etc.

These

techniques differ in their efficiency

Different

sorting techniques take different amounts of


time (and memory/disk space) to sort the same data

Some

sorting algorithms are better (faster) than others


for larger data sets

BUBBLE SORT

PSEUDOCODE

Method: compare

pairs of adjacent items, and swap them


if they are out of order
Elements bubble to

their proper places

At

the end of each pass, the largest remaining element is


in its proper place

This

is trivial to implement, but very inefficient

Each
For

Let N be the number of elements in the data set

Repeat N-1 times:


Repeat N-1 times:

pass may only sort a single value

if A[x] > A[x+1], swap them

N values, we need (N-1) passes

BUBBLE SORT EXAMPLE

BUBBLE SORT, ROUND 2

Start: [29, 10, 14, 37, 13]

Start: [10, 14, 29, 13, 37]

Round 1:

Round 2:

Compare 29 and 10, swap their order

Compare 10 and 14, leave them as-is

Compare 29 and 14, swap their order

Compare 14 and 29, leave them as-is

Compare 29 and 37, leave them as-is

Compare 29 and 13, swap their order

Compare 37 and 13, swap their order

Compare 29 and 37, leave them as-is

BUBBLE SORT, ROUND 3


Start: [10, 14, 13, 29, 37]
Round 3:
Compare 10 and 14, leave them as-is
Compare 14 and 13, swap their order
Compare 14 and 29, leave them as-is
Compare 29 and 37, leave them as-is

PSEUDOCODE

INSERTION SORT
Method: select

one element at a time and insert it into


its proper sorted position

Begin

by dividing the array into two regions: sorted and


unsorted
For

each pass, move the first unsorted item into its


proper position in the sorted region

Slightly

more efficient than bubble sort, since it swaps


fewer elements per round

INSERTION SORT EXAMPLE


Start: [

1. A[0] is sorted; A[1]-A[N-1] are unsorted


2. Repeat N times:
1. nextItem = first unsorted element
2. Shift sorted elements > nextItem over one position
(A[x] = A[x-1])
3. Insert nextItem into correct position

29 ][ 10, 14, 37, 13 ]

Move

10: [ 10, 29 ][ 14, 37, 13 ]

Move

14: [ 10, 14, 29 ][ 37, 13 ]

Move

37: [ 10, 14, 29, 37 ][ 13 ]

Move

13: [ 10, 13, 14, 29, 37 ][ ]

End: [

10, 13, 14, 29, 37 ]

Blue

values are sorted; black values are unsorted

SELECTION SORT
search for the largest unsorted item, and
put it into its sorted position

PSEUDOCODE

Repeatedly

Again, we

divide the data set into unsorted and sorted


regions (the sorted region goes at the end)

On

each pass, swap the largest unsorted item with the


last unsorted element
This

is more efficient than bubble and insertion sort;


it only needs one exchange per round

1. Repeat N-1 times:


1. Find the largest (unsorted) element
2. Swap A[last] with A[largest]
3. Mark the unsorted region as being one element smaller

SELECTION SORT EXAMPLE

RADIX SORT

Start: [ 29, 10, 14, 37, 13 ] [ ]


After 1st pass: [ 29, 10, 14, 13 ] [ 37 ]
After 2nd pass: [ 13, 10, 14 ] [ 29, 37 ]
After 3rd pass: [ 13, 10 ] [ 14, 29, 37 ]
After 4th pass: [ 10 ] [ 13, 14, 29, 37 ]
End: [ ] [ 10, 13, 14, 29, 37 ]

Blue values are unsorted; black values are sorted

Method: Form

groups (based on digits in the same place),


then combine those groups
i.e., all

items with 3 in the tens place

This

requires d iterations, where d is the number of digits


in the largest element

Worst-case

running time: O(dn)

PSEUDOCODE

AN ILLUSTRATION
Start:

for (J = d down to 1):

0123, 2154, 0222, 0004, 0283, 1560, 1061, 2150

Pass 1: group based on


the ones place

1. Initialize 10 groups to empty


2. for (I = 0 through N-1):
1. Place A[I] at the end of group K
2. Increment Kth counter
3. Replace A with group 0 + group 1 + etc.

RADIX SORT, ROUND 2


Start:

1560, 2150, 1061, 0222, 0123, 0283, 2154, 0004

Pass 2: group based on


the tens place

0
1
2
3
4
5
6
7
8
9

4
222, 123

2150, 2154
1560, 1061
283

0
1
2
3
4
5
6
7
8
9

1560, 2150
1061
222
123, 283
2154, 4

RADIX SORT, ROUND 3


Start:

0004, 0222, 0123, 2150, 2154, 1560, 1061, 0283

Pass 3: group based on


the hundreds place

0
1
2
3
4
5
6
7
8
9

4, 1061
123, 2150, 2154
222, 283

1560

RADIX SORT, ROUND 4


Start:

EXTRACTING DIGITS

0004, 1061, 0123, 2150, 2154, 0222, 0283, 1560

Pass 4: group based on


the thousands place
End result: a completely
sorted list of 4-digit
numbers in only 4 passes

0
1
2
3
4
5
6
7
8
9

4, 123, 222, 283


1061, 1560
2150, 2154

How
Use

do we extract the dth digit of an integer?

a combination of / and %

Ones
Tens

digit: n % 10

digit: (n / 10) % 10

Hundreds

digit: (n / 100) % 10

You might also like