Arrays
This presentation is the property of its rightful owner.
Sponsored Links
1 / 112

Arrays PowerPoint PPT Presentation


  • 110 Views
  • Uploaded on
  • Presentation posted in: General

Arrays. Searching & Sorting. Briana B. Morrison CSE 1302C Spring 2010. Topics. Declaring arrays Instantiating arrays Operations on arrays Searching Sorting. Arrays and Their Properties. Hold several values of the same type (homogeneous) Based on a slot number (the index number)

Download Presentation

Arrays

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Arrays

Arrays

Searching & Sorting

Briana B. Morrison

CSE 1302C

Spring 2010


Topics

Topics

Declaring arrays

Instantiating arrays

Operations on arrays

Searching

Sorting


Arrays and their properties

Arrays and Their Properties

Hold several values of the same type (homogeneous)

Based on a slot number (the index number)

Instant access

Linear (one after the other)

Static – once their size is set, it’s set…


What arrays look like

What arrays look like

Things to notice

There are 7 slots, with index numbers 0 – 6

The name of the array is myArray

Easy to be off by one

1

2

3

4

5

6

0

myArray


Creating arrays

Creating Arrays

<data type>[] <name> = new <data type> [<size>];

new brings complex variables to life in C#

Notice that we can create an array of any data type, just by changing the data type!


Examples

Examples

An array of shorts:

short[] someArray = new short[50];

An array of floats:

float[] myArray = new float[25];

An array of booleans:

bool[] list = new bool[65];

An array of chars:

char[] characters = new char[255];


Initializing arrays with values

Initializing Arrays with Values

<data type>[] <name> = new <data type> [<size>] {VALUES};

Or

<data type>[] <name> = {VALUES};


Modifying an array

Modifying an Array

You must specify which slot you are putting information in

Example:

int[] myArray = new int[50];

myArray[3] = 12;

This won’t work:

int[] myArray = new int[50];

myArray = 12;

Data type on the left of = is an array

Data type on right of = is an int

0

1

2

3

4

49

12


Accessing information

Accessing Information

Copying information out of a particular slot

Example:

int clientAge;

clientAge = myArray[4];

This copies information from the fifth slot (slot four) into the variable clientAge


Initializing arrays large arrays

Initializing Arrays(large arrays)

For most arrays, you will use a loop to initialize

Problem: create an array of 50 bytes and fill each slot with the number 42

Solution:

byte[] myList = new byte[50];

for (int counter=0; counter < 50; counter++) {

myList[counter] = 42;

}


Operations on arrays

Operations on Arrays


Searching arrays

Searching Arrays

  • Sequential

  • What if array is sorted

  • Binary


Searching

Searching

  • Searching is the process of finding a target element within a group of items called the search pool

  • The target may or may not be in the search pool

  • We want to perform the search efficiently, minimizing the number of comparisons

  • Let's look at two classic searching approaches: linear search and binary search


Sequential search

Sequential Search

  • A Sequential Search can be used to determine if a specific value (the search key) is in an array.

  • Approach is to start with the first element and compare each element to the search key:

    • If found, return the index of the element that contains the search key.

    • If not found, return -1.

      • Because -1 is not a valid index, this is a good return value to indicate that the search key was not found in the array.


Code to perform a sequential search

Code to Perform a Sequential Search

public int findWinners( int key )

{

for ( int i = 0; i < winners.length; i++ )

{

if ( winners[i] == key )

return i;

}

return -1;

}


Sequential search of a sorted array

Sequential Search of a Sorted Array

  • When the array is sorted, we can implement a more efficient algorithm for a sequential search.

  • If the search key is not in the array, we can detect that condition when we find a value that is higher than the search key.

  • All elements past that position will be greater than the value of that element, and therefore, greater than the search key.


Sample code

Sample Code

public intsearchSortedArray( int key )

{

for ( inti = 0; i < array.length

&&array[i] <= key; i++ )

{

if ( array[i] == key )

return i;

}

return –1; // end of array reached without

// finding keyor

// an element larger than

// the key was found

}


Binary search

Binary Search

  • A Binary Search is like the "Guess a Number" game.

  • To guess a number between 1 and 100, we start with 50 (halfway between the beginning number and the end number).

  • If we learn that the number is greater than 50, we immediately know the number is not 1 - 49.

  • If we learn that the number is less than 50, we immediately know the number is not 51 - 100.

  • We keep guessing the number that is in the middle of the remaining numbers (eliminating half the remaining numbers) until we find the number.


Binary search1

Binary Search

  • The "Guess a Number" approach works because 1 - 100 are a "sorted" set of numbers.

  • To use a Binary Search, the array must be sorted.

  • Our Binary Search will attempt to find a search key in a sorted array.

    • If the search key is found, we return the index of the element with that value.

    • If the search key is not found,we return -1.


The binary search algorithm

The Binary Search Algorithm

  • We begin by comparing the middle element of the array and the searchkey.

  • If they are equal, wefound the searchkey and return the index of the middle element.

  • If the middle element's value isgreaterthan the searchkey, then the searchkeycannotbefound in elementswithhigherarray indexes. So, we continue oursearch in the lefthalf of the array.

  • If the middle element's value islessthan the searchkey, then the searchkeycannotbefound in elementswithlowerarray indexes. So, we continue oursearch in the right half of the array.


The binary search algorithm con t

The Binary Search Algorithm (con't)

  • As we keep searching, the subarray we search keeps shrinking in size. In fact, the size of the subarray we search is cut in half at every iteration.  

  • If the search key is not in the array, the subarray we search will eventually become empty. At that point, we know that we will not find our search key in the array, and we return –1.  


Example of a binary search

Example of a Binary Search

  • For example, we will search for the value 7 in this sorted array:

  • To begin, we find the index of the center element, which is 8, and we compare our search key (7) with the value 45.


Binary search example con t

Binary Search Example (con't)

  • Because 7 is less than 35, we eliminate all array elements higher than our current middle element and consider elements 0 through 7 the new subarray to search.

  • The index of the center element is now 3, so we compare 7 to the value 8.


Binary search example con t1

Binary Search Example (con't)

  • Because 7 is less than 8, we eliminate all array elements higher than our current middle element (3) and make elements 0 through 2 the new subarray to search.

  • The index of the center element is now 1, so we compare 7 to the value 6.


Binary search finding the search key

Binary Search: Finding the search key

  • Because 7 is greater than 6, we eliminate array elements lower than our current middle element (1) and make element 2 the new subarray to search.

  • The value of element 2 matches the search key, so our search is successful and we return the index 2.


Binary search example 2

Binary Search Example 2

  • This time, we search for a value not found in the array, 34. Again, we start with the entire array and find the index of the middle element, which is 8.

  • We compare our search key (34) with the value 45.


Binary search example 2 con t

Binary Search Example 2 (con't)

  • Because 34 is less than 45, we eliminate array elements higher than our current middle element and consider elements 0 through 7 the new subarray to search.

  • The index of the center element is now 3, so we compare 34 to the value 8.


Binary search example 2 con t1

Binary Search Example 2 (con't)

  • Because 34 is greater than 8, we eliminate array elements lower than our current middle element and consider elements 4 through 7 the new subarray to search.

  • The index of the center element is now 5, so we compare 34 to the value 15.


Binary search example 2 con t2

Binary Search Example 2 (con't)

  • Again, we eliminate array elements lower than our current middle element and make elements 6 and 7 the new subarray to search.

  • The index of the center element is now 6, so we compare 34 to the value 22.


Binary search 2 search key is not found

Binary Search 2: search key is not found

  • Next, we eliminate array elements lower than our current middle element and make element 7 the new subarray to search.

  • We compare 34 to the value 36, and attempt to eliminate the higher subarray, which leaves an empty subarray.

  • We have determined that 32 is not in the array. We return -1 to indicate an unsuccessful search.


Binary search code

Binary Search Code

public intbinarySearch( int [] array, int key )

{

int start = 0, end = array.length - 1;

while ( end >= start )

{

int middle = ( start + end ) / 2;

if ( array[middle] == key )

return middle; // key found

else if ( array[middle] > key )

end = middle - 1; // search left

else

start = middle + 1; // search right

}

return -1; // key not found

}


Sorting

Sorting

  • Sorting is the process of arranging a list of items in a particular order

  • The sorting process is based on specific value(s)

    • sorting a list of test scores in ascending numeric order

    • sorting a list of people alphabetically by last name

  • There are many algorithms, which vary in efficiency, for sorting a list of items


Sorting1

Sorting

  • When an array's elements are in random order, our Sequential Searchmethod needs to look at every element in the array before discovering that the search key is not in the array. This is inefficient; the larger the array, the more inefficient a Sequential Searchbecomes.

  • We could simplify the search by arranging the elements in numeric order, which is called sorting the array. Once the array is sorted, we can use various search algorithms to speed up a search, including binary search.


Sorting2

Sorting

  • We will review three different sorts:

    • Selection Sort

    • Bubble Sort

    • Insertion Sort


Selection sort

Selection Sort

  • In a Selection Sort, we select the smallest element in the array and place it at the beginning of the array. Then we select the next-smallest element and put it in the second position in the array, and so on.

  • To do this, we consider the unsorted portion of the array as a subarray. Werepeatedly select the smallest value in the currentsubarray and move it to the beginning of the subarray, thenconsider a new subarray by eliminating the elementsthat are in theirsorted locations. We continue until the subarray has only one element. Atthat time, the arrayissorted.


The selection sort algorithm

The Selection Sort Algorithm

To sort an arraywithnelements in ascendingorder:

1.  Consider the nelements as a subarraywithm = nelements.

2.  Find the index of the smallest value in thissubarray.

3.  Swap the values of the elementwith the smallest value and the element in the first position in the subarray.

4.  Consider a new subarray of m = m - 1 elements by eliminating the first element in the previoussubarray

5.  Repeatsteps 2 through 4 untilm = 1.


Selection sort1

Selection Sort

  • Algorithm:

    for index = 0 to length-2 do

    for index2 = index to length -1 do

    find minimum value

    swap minimum value with list[index]


Swapping values

Swapping Values

  • To swap two values, we define a temporary variable to hold the value of one of the elements, so that we don't lose that value during the swap.

    To swap elements a and b:

    • define a temporary variable, temp.

    • assign element a to temp.

    • assign element b to element a.

    • assign temp to element b.


Swapping example

Swapping Example

  • This code will swap elements 3 and 6 in an int array named array:

    int temp; // step 1

    temp = array[3]; // step 2

    array[3] = array[6]; // step 3

    array[6] = temp; // step 4


Sorting integers

The picture shows an array of six integers that we want to sort from smallest to largest.

Sorting Integers

[0][1] [2] [3] [4] [5]


Selection sort algorithm

Start by finding the smallest entry.

Selection Sort Algorithm

[0][1] [2] [3] [4] [5]


Selection sort algorithm1

Start by finding the smallest entry.

Swap the smallest

entry with the

first entry.

Selection Sort Algorithm

[0][1] [2] [3] [4] [5]


Selection sort algorithm2

Selection Sort Algorithm

  • Start by finding the smallest entry.

  • Swap the smallest

  • entry with the

  • first entry.

[0][1] [2] [3] [4] [5]


Selection sort algorithm3

Part of the array is now sorted.

Selection Sort Algorithm

Sorted side

Unsorted side

[0][1] [2] [3] [4] [5]


Selection sort algorithm4

Find the smallest element in the unsorted side.

Selection Sort Algorithm

Sorted side

Unsorted side

[0][1] [2] [3] [4] [5]


Selection sort algorithm5

Find the smallest element in the unsorted side.

Swap with the front of the unsorted side.

Selection Sort Algorithm

Unsorted side

Sorted side

[0][1] [2] [3] [4] [5]


Selection sort algorithm6

We have increased the size of the sorted side by one element.

Selection Sort Algorithm

Sorted side

Unsorted side

[0][1] [2] [3] [4] [5]


Selection sort algorithm7

The process continues...

Selection Sort Algorithm

Sorted side

Unsorted side

Smallest

from

unsorted

[0][1] [2] [3] [4] [5]


Selection sort algorithm8

The process continues

...

Selection Sort Algorithm

Sorted side

Unsorted side

Swap

with

front

[0][1] [2] [3] [4] [5]


Selection sort algorithm9

The process continues

...

Selection Sort Algorithm

Sorted side

is bigger

Sorted side

Unsorted side

[0][1] [2] [3] [4] [5]


Selection sort algorithm10

The process keeps adding one more number to the sorted side.

The sorted

side has the smallest numbers, arranged from small to large.

Selection Sort Algorithm

Sorted side

Unsorted side

[0][1] [2] [3] [4] [5]


Selection sort algorithm11

We can stop

when the

unsorted

side has just

one number,

since that

number

must be the

largest

number.

Sorted side

Unsorted side

Selection Sort Algorithm

[0][1] [2] [3] [4] [5]


Selection sort algorithm12

The array is now sorted.

We repeatedly selected the smallest element, and moved this element to the front of the

unsorted

side.

Selection Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort

Bubble Sort

  • The basic approach to a Bubble Sort is to make multiple passes through the array.

  • In each pass, we compare adjacent elements. If any two adjacent elements are out of order, we put them in order by swapping their values.

  • At the end of each pass, one more element has "bubbled" up to its correct position.

  • We keep making passes through the array until all the elements are in order.


Bubble sort algorithm

Bubble Sort Algorithm

  • To sort an array of nelements in ascendingorder, we use a nestedloop:

  • The outerloopexecutesn – 1 times.

  • For eachiteration of the outerloop, the innerloopstepsthrough all the unsortedelements of the array and does the following:

    • Compares the currentelementwith the nextelement in the array.

    • If the nextelementissmaller, it swaps the twoelements.


Bubble sort pseudocode

Bubble Sort Pseudocode

for i = 0 to last array index – 1 by 1

{

for j = 0 to ( last array index – i - 1 ) by 1

{

if ( 2 consecutive elements are not in order )

swap the elements

}

}


Bubble sort example

Bubble Sort Example

  • At the beginning, the array is:

  • We compare elements 0 (17) and 1 (26) and find they are in the correct order, so we do not swap.


Bubble sort example con t

Bubble Sort Example (con't)

  • The inner loop counter is incremented to the next element:

  • We compare elements 1 (26) and 2 (5), and find they are not in the correct order, so we swap them.


Bubble sort example con t1

Bubble Sort Example (con't)

  • The inner loop counter is incremented to the next element:

  • We compare elements 2 (26) and 3 (2), and find they are not in the correct order, so we swap them.

  • The inner loop completes, which ends our first pass through the array.


Bubble sort example 2 nd pass

Bubble Sort Example (2nd pass)

  • The largest value in the array (26) has bubbled up to its correct position.

  • We begin the second pass through the array. We compare elements 0 (17) and 1 (5) and swap them.


Bubble sort example 2 nd pass1

Bubble Sort Example (2nd pass)

  • We compare elements 1 (17) and 2 (2) and swap.

  • This ends the second pass through the array. The second-largest element (17) has bubbled up to its correct position.


Bubble sort 3 rd pass

Bubble Sort (3rd pass)

  • We begin the last pass through the array.

  • We compare element 0 (5) with element 1 (2) and swap them.


Bubble sort complete

Bubble Sort ( complete )

  • The third-largest value (5) has bubbled up to its correct position.

  • Only one element remains, so the array is now sorted.


Bubble sort code

Bubble Sort Code

for ( inti = 0; i < array.length - 1; i++ )

{

for ( int j = 0; j < array.length – i - 1; j++ )

{

if ( array[j] > array[j + 1] )

{

// swap the elements

int temp = array[j + 1];

array[j + 1] = array[j];

array[j] = temp;

}

} // end inner for loop

} // end outer for loop


Bubble sort algorithm1

The Bubblesort algorithm compares adjacent elements and exchanges them if they are out of order.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm2

The first two elements are compared, and are out of order, so they are exchanged.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm3

The first two elements are compared, and are out of order, so they are exchanged.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm4

Now the next two elements are compared. They are in order, so no exchange.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm5

And the process continues...

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm6

And the process continues…another exchange.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm7

And the process continues…another exchange.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm8

And the process continues…

Another exchange.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm9

And the process continues… another exchange. The biggest element is now in place.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm10

Now repeat from the first position to

length -1.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm11

Process continues...

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm12

Process continues…

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm13

Process continues… exchange occurs.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm14

Process continues… exchange occurs.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm15

Process continues… exchange occurs. At this point, the last two elements are in their final sorted order.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm16

Repeat from the beginning location.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm17

Process continues…

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm18

Process continues… exchange occurs.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm19

Process continues… exchange occurs.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm20

Process continues… exchange occurs.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm21

Process continues… exchange occurs.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm22

Repeat again from the beginning. Exchange must occur.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm23

Repeat again from the beginning. Exchange must occur.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm24

Process continues...

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm25

Process continues… exchange occurs.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm26

Last comparison requires no exchange.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Bubble sort algorithm27

Last comparison requires no exchange.

Bubble Sort Algorithm

[0][1] [2] [3] [4] [5]


Insertion sort

Insertion Sort

  • The basic approach to Insertion Sort is to make multiple passes through the array.

  • In each pass, we “insert” the first element in the unsorted side into its correct sorted position in the sorted side.

  • At the end of each pass, all the elements in the “sorted” side are sorted in relation to one another, but may not be in their final sorted position.

  • We keep making passes through the array until all the elements are in order.


Insertion sort1

Insertion Sort

  • Algorithm:

    for index = 0 to length-1 do

    Item = list[index]

    index2 = index -1

    placefound = false

    while not placefound and index2 >=0

    if item < list[index2] then

    list[index2 + 1] = list[index2]

    index2 = index2 - 1

    else

    placefound = true

    list[index2 +1] = item;


Insertion sort algorithm

The Insertionsort algorithm also views the array as having a sorted side and an unsorted side.

Insertion Sort Algorithm

[0][1] [2] [3] [4] [5]


Insertion sort algorithm1

The sorted

side starts

with just the

first element,

which is not

necessarily

the smallest

element.

Insertion Sort Algorithm

Sorted side

Unsorted side

[0][1] [2] [3] [4] [5]


Insertion sort algorithm2

The sorted

side grows

by taking

the front

element

from the

unsorted

side...

Sorted side

Unsorted side

Insertion Sort Algorithm

[0][1] [2] [3] [4] [5]


Insertion sort algorithm3

...and

inserting it in

the place

that keeps

the sorted

side

arranged

from small

to large.

Insertion Sort Algorithm

Unsorted side

Sorted side

[0][1] [2] [3] [4] [5]


Insertion sort algorithm4

In this example,

the new element

goes in front of the element that was already in the sorted side.

Insertion Sort Algorithm

Unsorted side

Sorted side

[0][1] [2] [3] [4] [5]


Insertion sort algorithm5

Sometimes

we are lucky

and the new

inserted item

doesn't need

to move at

all.

Sorted side

Unsorted side

Insertion Sort Algorithm

[0][1] [2] [3] [4] [5]


Insertion sort algorithm6

Sometimes we are lucky twice in a row.

Sorted side

Unsorted side

Insertion Sort Algorithm

[0][1] [2] [3] [4] [5]


Insertion sort algorithm7

Copy the new element to a separate location.

Sorted side

Unsorted side

Insertion Sort Algorithm

[0][1] [2] [3] [4] [5]


How to insert one element

Shift elements in the sorted side, creating an open space for the new element.

How to Insert One Element

[0][1] [2] [3] [4] [5]


How to insert one element1

Shift elements in the sorted side, creating an open space for the new element.

How to Insert One Element

[0][1] [2] [3] [4] [5]


How to insert one element2

Continue shifting elements...

How to Insert One Element

[0][1] [2] [3] [4] [5]


How to insert one element3

Continue shifting elements...

How to Insert One Element

[0][1] [2] [3] [4] [5]


How to insert one element4

...until you reach the location for the new element.

How to Insert One Element

[0][1] [2] [3] [4] [5]


How to insert one element5

Copy the new element back into the array, at the correct location.

Sorted side

Unsorted side

How to Insert One Element

[0][1] [2] [3] [4] [5]


How to insert one element6

The last element must also be inserted. Start by copying it...

Sorted side

Unsorted side

How to Insert One Element

[0][1] [2] [3] [4] [5]


Self test

How many shifts will occur before we copy this element back into the array? (Value is 15.)

Self Test

[0][1] [2] [3] [4] [5]


Self test1

Four items are shifted.

Self Test

[0][1] [2] [3] [4] [5]


Self test2

Four items are shifted.

And then the element is copied back into the array.

Self Test

[0][1] [2] [3] [4] [5]


Questions

Questions?


  • Login