One-Dimensional and Multi-Dimensional Arrays, Searching & Sorting, Parameter passing to Functions Array Data Structures & Algorithms

Concepts of Data Collections Arrays in C Syntax Usage Array based algorithms

Concepts of Data Collections Sets, Lists, Vectors, Matrices and beyond

Sets & Lists The human language concept of a collection of items is expressed mathematically using Sets Sets are not specifically structured, but structure may be imposed on them Sets may be very expressive but not always easily represented Example: The set of all human emotions. Lists are representations of sets that simply list all of the items in the set Lists may be ordered or unordered. Some useful lists include data values and the concept of position within the list. Example representations: { 0, 5, -2, 4 } { TOM, DICK } First Second

Vectors, Matrices and beyond Many examples of lists arise in mathematics and they provide a natural basis for developing programming syntax and grammar Vectors are objects that express the notion of direction and size (magnitude) The 3-dimensional distance vector D has components { D x, D y, D z } along the respective x, y and z axes, with magnitude D = sqrt(D x 2 +D y 2 +D z 2 ) We use descriptive language terminology such as The xth component of D... Or, D-sub-x

Vectors, Matrices and beyond Higher dimensional objects are often needed to represent lists of lists. Matrices are one example that sometimes can be represented in tabular form 2-dimensional tables (row, column) 3- and higher are hard to visualize, but are meaningful Beyond this, mathematics works with objects called tensors and groups (and other entities), and expresses the access to object members (data values) using properties and indices based on topologies (loosely put, shape structures)

Vectors, Matrices and beyond In this course we focus on an introduction to the basic properties and algorithms associated with vectors and matrices, and lists (later) These objects are mathematically defined as ordered, structured lists The ordering derives from the property that each element of the list exists at a specific position Enumerated starting at 0 and incrementing by 1 to a maximum value The structure determines the mechanism and method of access to the list and its member elements

Arrays in C Syntax Memory structure Usage Functions

Arrays in C Syntax How to declare and reference 1D arrays using subscript notation Memory structure How is RAM allocated the meaning of direct access through subscripting Usage Some simple illustrative examples Functions How to deal with arrays as function arguments

Arrays in C - Syntax Consider the array declarations int StudentID [ 1000 ] ; float Mark [ 1000 ] ; char Name [ 30 ] ; Each of the declarations defines a storage container for a specific maximum number of elements Up to 1000 Student (integer) ID values Up to 1000 (real) Marks A Name of up to 30 characters

Arrays in C - Syntax Each array is referred to by its declared name float A [ 100 ] ;... where A refers to the entire collection of 100 storages On the other hand, each separate element of A is referenced using the subscript notation A[0] = 12.34 ; /* assign 12.34 to the first element */ /* NOTE: subscripts always start from 0 */ A[K] = 0.0 ; /* assign 0 to the (K+1)th element */ Note: Although a bit clumsy in human natural language, we can change our use of language so that A[K] always refers to the Kth element (not K+1), always starting from 0 as the 0th element.

Arrays in C - Syntax It is not necessary to initialize or reference all elements of an array in a program Unlike scalar variables declared as primitive data types, these uninitialized, non-referenced array elements are not flagged as warnings by the compiler There are good reasons to declare arrays of larger size than might be required in a particular execution run of a program At the outset, design the program to accommodate various sizes of data sets (usually acquired as input), up to a declared maximum size This avoids the need to modify and recompile the program each time it is used.

Arrays in C - Syntax This is a good time to introduce another compiler pre- processor directive, #define: #define is used to define constant expression symbols in C programs. The value of such symbols is that they localize positions of program modification. Example: #define MAX_SIZE 1000 int main ( ) { int SID [ MAX_SIZE ] ; float Mark [ MAX_SIZE ] ;..... } #define directives are normally located at the beginning of the program source code, after #include directives, and before function prototypes and the main function. In the example, by using the defined symbol MAX_SIZE, changes to SID and Mark array sizes can be accomplished by simply changing the value assigned to MAX_SIZE and recompiling.

Arrays in C Memory structure Now consider the declaration int A [ 9 ] ; The entire allocation unit is called A the array name There must be 9 integer sized allocations in RAM Each element is located contiguously (in sequence and touching) RAM AA[0] A[8]

Arrays in C Memory structure Arrays are often called direct access storage containers The reference to A[K] is translated by the compiler to First, calculate the relative address offset K * sizeof int Second, add RAO to base address of A, or simply &A[0] &A[K] == &A[0] + K*sizeof int RAM A[0] A[ K ] sizeof int RAO Direct Access :: Since the cost of the address computation is always the same (constant) and it provides the actual RAM address location where the data is stored. The sizeof, operator is a compile-time operator (not an executable instruction or operator) that determines the RAM storage size allocated to a data structure. When sizeof is applied to a primitive data type, it provides the size of allocated storage, in bytes. Try running a program with statements such as: printf( The size of int is %d bytes\n, sizeof int ) ; 01K01K

Arrays in C Usage Referencing arrays is straightforward using the subscript notation B = A[ 5 ] ; /* assign 6 th element of A to B */ A [ J ] < A [ K ] /* relational expression */ B = 0.5*( A[J] A[J-1] ); /* finite difference */ printf( %d %d %d\n, A[0], A[mid], A[N-1] ) ; scanf ( %d%lf%lf, &N, &R[K], R ) ; /* Note */

Arrays in C Average vs Median Problem: Input N real numbers and find their average and median. Assume the values are already sorted from lowest to highest Assume no more than 1000 values will be inputted Solution: Declarations float X [1000], Sum, Ave, Median ; int N, Mid ;

Arrays in C Average vs Median Declarations float A [1000], Sum = 0.0, Ave, Median ; int N, Mid, K ; Input Data printf( Enter number of values in list ) ; scanf( %d, &N ) ; /* Enter all real values into array X */ for( K=0; K < N; K++ ) { scanf( %f, &A[K] ) ; /* NOTE: & must be used */ Sum += A[K] ; }

Arrays in C Average vs Median Compute Average and Median Ave = Sum / (float) N ; /* real division */ Mid = N / 2 ; /* (integer) midpoint of list */ Median = A [ Mid ] ; Report results printf( Average = %, Ave ); printf( Median = %f\n, Median );

Arrays in C Related arrays Problem: Obtain student marks from testing and store the marks along with ID numbers Assume marks are float and IDs are int data types Solution Related arrays Define two arrays, one for IDs and one for marks int SID [ 100 ] ; float Mark [ 100 ] ; Coordinate input of data (maintain relationships) for( K = 0 ; K < N ; K++ ) scanf( %d%f, &SID[K], &Mark[K] ) ;

Arrays in C Functions Passing arrays as parameters in functions requires some care and some understanding. We begin with an example. Calculate the dot product of two 3-vectors U and V. Components: U[0], U[1], U[2] V[0], V[1], V[2] Mathematics: The dot product is defined as DotProd( U, V ) ::= U[0]*V[0] + U[1]*V[1] + U[2]*V[2] Since the dot product operation is required often, it would make a useful function. U V U. V

Arrays in C Functions Solution function: double DotProd3 ( double U[3], double V[3] ) { return U[0] * V[0] + U[1] * V[1] + U[2] * V[2] ; } Note the arguments which specify that arrays of type double with exactly three (3) elements will be passed. Note that the limitation to 3 elements is reflected in the design of the function name: DotProd3

Arrays in C Functions Extend this to dot product of N-dimensional vectors: double DotProdN ( double U[ ], double V[ ], int N ) { double DPN = 0.0 ; int K ; for( K = 0 ; K < N ; K++ ) DPN += U[K] * V[K] ; return DPN ; } Note the array arguments do not specify a maximum array size. This provides flexibility of design since now the function can handle any value of N. It is up to the programmer to ensure that the actual input arrays and N conform to the assumptions.

Arrays in C Functions An alternative to the same code is to use pointer references: double DotProdN ( double * U, double * V, int N ) { double DPN = 0.0 ; int K ; for( K = 0 ; K < N ; K++ ) DPN += U[K] * V[K] ; return DPN ; } Note the array arguments are now expressed as pointer references. This maintains the same flexibility as previously.

Arrays in C Functions A final alternative to the same code is to use pointer references altogether: double DotProdN ( double * U, double * V, int N ) { double DPN = 0.0 ; int K ; for( K = 0 ; K < N ; K++, U++, V++ ) DPN += *U * *V ; return DPN ; } The U and V variables are address pointers to the array components. U++ and V++ perform the action of updating the pointers by an amount equal to the size of the array data type (in this case double is usually 8 bytes), thus pointing to the next array component in sequence. Pointers are not the same as ints ! If A is an int (say, 5), then A++ always evaluates to the next (or successor) value in sequence (ie. 6). On the other hand, if P is a pointer (say, int *, with value &A[K]), then P++ evaluates to the next (or successor) value in sequence, which is usually the next element of an array (ie. &A[K=1]).

Arrays in C Functions The previous examples have illustrated the various ways that are used to pass array arguments to functions. double DotProd3 ( double U[3], double V[3] ); double DotProdN ( double U[ ], double V[ ], int N ); double DotProdN ( double * U, double * V, int N ); There are important differences When the size of the array is specified explicitly (eg. double U[3]), some C compilers will allocate storage space for all array elements within the function stack frame If arrays are declared within the function body, they are almost always allocated within the stack frame When the array size is not stated explicitly, a pointer to the array is allocated (much smaller in size than the entire array)

Arrays in C Functions C compilers may perform code and storage optimization Create the most efficient executable code Create the most efficient use of RAM storage By allocating array storage within stack frames, a significant amount of wasted space occurs due to avoidable duplication of storage allocations It also follows that a wastage of time occurs since it is necessary to copy data from arrays declared in the calling point code to arrays declared in the called point. Pointers solve most of these problems (with a small, but acceptable, increase in processing time) Optimization is a difficult problem and is still the subject of much research

Array Based Algorithms Searching Sorting

Array Based Algorithms Searching How to locate items in a list Simplicity versus speed and list properties Sorting Putting list elements in order by relative value Promoting efficient search

Search Algorithms Searching is a fundamentally important part of working with arrays Example: Given a student ID number, what is the Mark they obtained on the test? Do this for all students who enquire. Constructing a good, efficient algorithm to perform the search is dependent on whether the IDs are in random order or sorted. Random order use sequential search Sorted order use divide-and-conquer approach

Search Algorithms - Random If a list is stored in random order a possible search technique is to look at the list elements in random order search int srchID, K ; printf( Enter your SID ) ; scanf( %d, &srchID ) ; for( K=rand() % N ; srchID != SID[ K ] ; K=rand() % N ) ; printf( SID = %d, Mark = %f\n, SID[K], Mark[K] ); PROBLEM 1: No guarantee that rand() will produce a result and exit the for loop, especially if the item does not exist. PROBLEM 2: It is possible that an array element position will be accessed that has not had data stored (will stop the program as an error uninitialized data access violation).

Search Algorithms - Linear If a list is stored in random order a better search technique is to look at the list elements in order, from the beginning of the list until the element is found or the list elements are exhausted int srchID, K, N = 100 ; /* Assume 100 elements */ printf( Enter your SID ) ; scanf( %d, &srchID ) ; /* Perform the search */ for( K=0; KN ? ) Sequential (Linear)O( N ) Divide & Conquer (Binary)O( log N ) In the best case, any search algorithm may be successful after only one (1) probe Usually, one is interested in worst case and average case in choosing an algorithm. N

Sorting Algorithms.... Putting things in order........ order things Putting in....

Sorting Algorithms From our discussion of binary search we understand the need for the data to be ordered within lists in order to promote fast searching using Binary Search It is also important to understand that not every list should be sorted study each case carefully Sorting algorithms are designed to perform the ordering required There are literally hundreds of specialized sorting algorithms, with varying efficiencies We will focus on a sorting algorithm called Selection Sort

Sorting Algorithms - Selection Selection Sort relies on being able to find the largest (or smallest) element in a sublist Each time the proper value is found, it is exchanged with the element at the end of the sublist We re-apply this technique by shrinking the size of the sublist, until there is no remaining sublist (or a sublist of size 1 element which is already sorted). We consider the example.......... 82 45 31 72 56 62 87 90

Sorting Algorithms - Selection 82 45 31 72 56 62 87 90 82 45 31 72 56 62 87 90 82 45 31 72 56 62 87 90 62 45 31 72 56 82 87 90 62 45 31 72 56 82 87 90 62 45 31 56 72 82 87 90 1234

Sorting Algorithms - Selection 56 45 31 62 72 82 87 90 31 45 56 62 72 82 87 90 31 45 56 62 72 82 87 90 62 45 31 56 72 82 87 90 56 45 31 62 72 82 87 90 31 45 56 62 72 82 87 90 5867

Sorting Algorithms - Selection From the example we note that the final step 8 is not actually required, since a sub-list of one (1) element is automatically sorted (by definition). Hence, it took 7 steps to complete the sort. In general, for a list of size N elements, it takes N-1 steps. Each step consists of two parts: First, search an unordered sub-list for the largest element The size of the sub-list is N-K for step K (starting from K=0) Second, exchange (swap) the largest element with the last element in the sub-list Upon completion of each step it should be noted that the sorted sub-list grows by one element while the unsorted sub-list shrinks by one element.

Sorting Algorithms - Selection Start with a sub-list of N unsorted values, and a sub-list of 0 sorted values. The unsorted sub-list has subscripts in the subrange [0..N-1] The sorted sub-list has subscripts in the subrange [N..N] which is not occupied physically (hence, it does not exist, it is the empty set) For K from 0 to N-1, in increments of 1, perform Search the unordered sub-list [0..N-1-K] for the largest value and store its position P Exchange the largest element with the last element in the sub- list using positions P and N-1-K. /* The exchange adds the largest element to the beginning of the sorted sub-list, while removing it from the end of the unsorted sub-list */ 31 45 56 62 72 82 87 90 0 N-1 (N-1-K)

Sorting Algorithms - Selection void SelectionSort ( double List[ ], int N ) { int J, K, P ; double Temp ; for( J = 0 ; J < N-1 ; J++ ) { P = 0 ; for( K = 0 ; K < N - J ; K++ ) if( List[P] < List[K] ) P = K ; Temp = List[P] ; List[P] = List[N-1-J] ; List[N-1-J] = Temp ; } } Swapping of array elements must be done with some care and thought. Three statements are required, and a temporary storage variable must be used. Temp List[P] List[N-1-J] 62 56 1 62 2 3 56 62

Sorting Algorithms - Selection void SelectionSort ( double List[ ], int N ) { int J, K, P ; double Temp ; for( J = 0 ; J < N-1 ; J++ ) { P = 0 ; for( K = 0 ; K < N - J ; K++ ) if( List[P] < List[K] ) P = K ; Temp = List[P] ; List[P] = List[N-1-J] ; List[N-1-J] = Temp ; } } /* Define a dswap function */ void dswap ( double * A, double * B ) { double T ; T = *A ; *A = *B ; *B = T ; return ; } dswap ( &List[P], &List[N-1-J] ) ;

Sorting Algorithms - Selection void SelectionSort ( double List[ ], int N ) { int J, K, P ; double Temp ; for( J = 0 ; J < N-1 ; J++ ) { P = 0 ; for( K = 0 ; K < N - J ; K++ ) if( List[P] < List[K] ) P = K ; Temp = List[P] ; List[P] = List[N-1-J] ; List[N-1-J] = Temp ; } How many operations must be performed? Sum from J = 0 to N-2 Sum from K = 0 to N-1-J Core loop logic (CoreOps) Gauss dealt with this problem and developed several formulae which bear his name. In this case the answer is: N ( N 1 ) CoreOps

Sorting Algorithms - Selection The maximum number of operations required to sort a list of N elements in ascending order is N ( N 1 ) CoreOps The CoreOps consist of several fetches, one comparison and either 1 or 2 assignments (stores) This is, essentially, a constant value Thus, the time complexity of the Selection Sort algorithm is O( N 2 )

Sorting Algorithms There are many other sorting algorithms BubbleSort InsertionSort QuickSort MergeSort Some of these are iterative, while others are recursive. A number of sorting algorithms exhibit time complexities of O( N 2 ), but some achieve better efficiencies (eg. O( N log N ) ) under certain circumstances. Additional algorithms will be discussed later in 60-141 and other computer science courses

Bubble Sort void BubbleSort ( double List[ ], int N ) { int J, K ; for( J = 0 ; J < N-1 ; J++ ) for( K=0; K

Recursive Binary Search Binary Search can be expressed very elegantly using recursion int BinSearch ( float VS, float V[ ], int Lo, int Hi ) { int Mid ; if( Lo > Hi ) return -1 ; Mid = ( Lo + Hi ) / 2 ; if( VS == V[Mid] ) return Mid ; if( VS < V[Mid] ) return BinSearch( VS, V, Lo, Mid-1 ); else return BinSearch( VS, V, Mid+1, Hi ); } Example usage for calling: P = BinSearch( VS, V, 0, N-1 ) ; if( P == -1 ) printf( Value %lf not found, VS ) ; else printf( Value %lf found at position %d\n, VS, P ) ;

Recursive Functions Many algorithms are beautifully and elegantly expressed using recursion Programming recursion requires some experience to perfect, however it is considered a more natural way of thinking to most humans It is true, in general, that any iterative algorithm can be expressed as a recursive algorithm and vice versa. In practice, it is not so obvious ! Students will be tested on recursion.

Towers of Hanoi Problem: Move all plates from A to either B or C, such that at all times smaller plates are on top of larger plates. ABC

Towers of Hanoi Problem: Move all plates from A to either B or C, such that at all times smaller plates are on top of larger plates. !! DONE !! ABC

Towers of Hanoi Base Case 1 :: Move plate from A to B ABC

Towers of Hanoi Base Case 1 :: Move plate from A to B Hanoi ( A, B, C, 1 ) ; /* Move from A to B, C not used */ ABC

Towers of Hanoi Base Case 2 :: ABC

Towers of Hanoi Base Case 2 :: Move top plate from A to C ABC

Towers of Hanoi Base Case 2 :: Move top plate from A to C Move bottom plate from A to B ABC

Towers of Hanoi Base Case 2 :: Move top plate from A to C Move bottom plate from A to B Move top plate from C to B Hanoi ( A, B, C, 2 ) ; /* Move from A to B, but use C */ ABC An intriguing idea starts to emerge.... Hanoi ( A, B, C, 2 ) was accomplished by First applying : Hanoi ( A, C, B, 1 ) Then applying : Hanoi ( A, B, C, 1 ) And, finally : Hanoi ( C, B, A, 1 )

Towers of Hanoi Base Case 3 :: Move top plate from A to B Move middle plate from A to C Move top plate from B to C Move bottom plate from A to B Move top plate from C to A Move middle plate from C to B Move top plate from A to B ABC

Towers of Hanoi Base Case 3 :: Move top plate from A to B Move middle plate from A to C Move top plate from B to C Move bottom plate from A to B Move top plate from C to A Move middle plate from C to B Move top plate from A to B ABC This seems to be getting complicated, until we realize that Hanoi ( A, B, C, 3 ) can be expressed as : Hanoi ( A, C, B, 2 ) ; Hanoi ( &A[2], &B[2], C, 1 ) ; Hanoi ( C, B, A, 2 ) ;

Towers of Hanoi Problem: Move all plates from A to either B or C, such that at all times smaller plates are on top of larger plates. ABC In general, applying mathematical induction, we find that Hanoi ( A, B, C, N ) can be expressed as : void Hanoi ( int A[ ], int B[ ], int C[ ], int N ) { if( N == 1 ) { B[0] = A[0] ; return ; } if( N == 2 ) { C[0] = A[0] ; A[0] = B[0] ; C[0] = B[0] ; return ; } Hanoi ( A, C, B, N-1 ) ; Hanoi ( &A[N-1], &B[N-1], C, 1 ) ; Hanoi ( C, B, A, N-1 ) ; return ; }

Towers of Hanoi Problem: Move all plates from A to either B or C, such that at all times smaller plates are on top of larger plates. !! DONE !! ABC Most people are able to grasp the sequence of movements to solve the Towers of Hanoi problem. The solution is recursive, built up from handling base cases of N=1, 2 and 3 plates. Once the pattern is understood, it is then reapplied to arbitrary N. Programming an iterative algorithm is much harder, however. ( Try it but in your spare time :)

Multi-Dimensional Arrays Consider the case of student marks (0.0 to 10.0) for several assignments, all stored in a 2- dimensional array of float values #define MAX_STUDS 120 #define NUM_ASSIGNS 10 float Mark [ MAX_STUDS ] [ NUM_ASSIGNS ] ; Assume data is in a file called InData.dat. StudentNumber AssignNumber

Multi-Dimensional Arrays We assume that the input file InData.dat has been prepared as follows: The file may be empty, in which case the end-of-file indicator can be checked using EOF A non-empty file contains (at the least) One line containing two integer values greater or equal to zero These correspond to the number of students and number of assignments, respectively The rest of the file contains A line containing an integer, the Student Number, followed by A line containing the marks as floating point values. The number of marks corresponds to the number of assignments specified. The file terminates when the end-of-file indicator arises and is checked using EOF. Marks must be inserted according to the Student Number value (in the range from 0 to MAX_STUDS-1). StudentNumber AssignNumber

Multi-Dimensional Arrays /* Input from InData.dat using input redirection cmdprompt:>a.out < InData.dat */ #define MAX_STUDS 120 #define NUM_ASSIGNS 10 float Mark [ MAX_STUDS ] [ NUM_ASSIGNS ] ; int NumberStudents, NumberAssignments, StudNum ; int S, A ; /* Utility integers */ /* Test input file for data */ if( (A=scanf( %d%d, &NumberStudents, &NumberAssignments )) == EOF ) return 0 ; /* Data exists, so input data until EOF is encountered */ for( S=0 ; S < NumberStudents ; S++ ) { if ( (A=scanf( %d, &StudNum )) == EOF ) break; /* A record exists so input assignment marks */ for( A=0 ; A < NumberAssignments ; A++ ) scanf( %f, &Mark[ StudNum ][A] ) ; }

Multi-Dimensional Arrays N-D Arrays as function arguments Unlike 1-D arrays, all array maximum dimensions must be declared explicitly (except for the leftmost dimension) Example InputMarks( NS, NA, Mark ) Prototype void InputMarks( int, int, float [][ NUM_ASSIGNS ] ) ; Function Definition void InputMarks( int NS, int NA, float M[][ NUM_ASSIGNS ] ) { /* variable defns, logic */ return ; }

Multi-Dimensional Arrays Memory allocation of 2D arrays is done (typically) using Row Major Ordering. The compiler must know, in advance, what size of allocation to provide for each row The actual number of rows is not important 123 456 789 101112 1 2 3 4 5 6 7 8 9 10 11 12

Multi-Dimensional Arrays Memory allocation of 2D arrays is done (typically) using Row Major Ordering. The compiler must know, in advance, what size of allocation to provide for each row The actual number of rows is not important The compiler replaces subscript references by Base address pointer plus relative offset The Base address is just the address of the first element in the 2D array, or &A[0][0] The relative offset is given by Rowsub * ( #Columns * sizeof elementtype) + Colsub * sizeof elementtype To compute this expression requires the #Columns void InputMarks( int, int, float [] [NUM_ASSIGNS] ) ; Rowsub * ( #Columns * sizeof elementtype) + Colsub * sizeof elementtype Higher dimensional arrays must specify all lower dimensions maximum values, leaving only the highest dimension unspecified. Example prototype statement for a 3D array: int Func( int Array [ ] [ MAX_ROW ] [ MAX_COL ], int Page, int Row, int Col ) ; The allocation is understood in terms of Page Major Ordering which requires that the compiler know MAX_ROW and MAX_COL in advance.

Multi-Dimensional Arrays Working with 2-D arrays necessitates thought and care about the operations to be performed on them and how they are defined and referenced Matrix Transpose - Transpose( A, AT, NR, NC ) Interchange rows and columns Prototype: void Transpose( float [ ] [MC], float [ ] [MR], int, int ) ; The result array must be defined to be of suitable size If we define: float A [MR] [MC]; then we must define: float AT [MC] [MR]; Key statement for( r=0; r A[ r2 ][ 0 ] ) for( c=0 ; c

One-Dimensional and Multi-Dimensional Arrays, Searching & Sorting, Parameter passing to Functions Array Data Structures & Algorithms

Text of One-Dimensional and Multi-Dimensional Arrays, Searching & Sorting, Parameter passing to Functions...

One Dimensional Arrays (Part2) Sorting Algorithms Searching Algorithms Character Strings The string Class. 1

Arrays The concept of arrays Using arrays Arrays as arguments Processing an arrays data Multidimensional arrays Sorting data in an array Searching with

Multi -Dimensional Arrays

Multi-Dimensional Arrays

Arrays Chapter 6. Outline Array Basics Arrays in Classes and Methods Sorting Arrays Multidimensional Arrays

30. Sorting 1-dimensional Arrays

Insight Through Computing1 30. Sorting 1-dimensional Arrays Bubble Sort Insertion Sort

Numpy Arrays - Marquette UniversityNumPy Arrays • NumPy Arrays are containers for numerical values • Numpy arrays have dimensions • Vectors: one-dimensional • Matrices: two-dimensional

Sorting Algorithms - Clark Science Center · Sorting Stuff in Java. int[] arrays double[] arrays ﬂoat[] arrays String[] arrays import java.util.Arrays; ... • How can we still

Chapter 8: Collections: Arrays. 2 Objectives One-Dimensional Arrays Array Initialization The Arrays Class: Searching and Sorting Arrays as Arguments The

Sorting Arrays 12

CS 141 Computer Programming 1 1 Arrays. Outline Introduction Arrays Declaring Arrays Examples Using Arrays Sorting Arrays Multiple-Subscripted

Two Dimensional Arrays

Declaration of arrays One-dimensional arrays …atitech.unitbv.ro/ungureanu/docs/Programming_I_-_Courses/...One-dimensional arrays Strings Multi-dimensional arrays Array declaration

Matrices or 2-Dimensional Arrays or Arrays of Arrays

18. Two-Dimensional Arrays

Arrays. Topics Tables of Data Arrays – Single Dimensional Parsing a String into Multiple Tokens Arrays - Multi-dimensional

Single Dimensional Arrays

11/15: Ch. 7: Arrays What is an array? Declaring & allocating arrays Sorting & searching arrays

1 Chapter 7 – Arrays 7.1 Creating and Accessing Arrays 7.2 Using Arrays 7.3 Some Additional Types of Arrays 7.4 Sorting and Searching 7.5 Two-Dimensional

Arrays Chapter 8. Overview u General discussion u Variable arrays u Control arrays u Multi-dimensional variable arrays Two-dimensional Three-dimensional

Lecture 7: Arrays Tami Meredith. Roadmap Variables Arrays Array indices & Using arrays Array size versus length Two dimensional arrays Sorting an array

Single-Dimensional Arrays and Multidimensional Arrays

Chapter 9 Sorting and Searching Arrays

More Arrays Arrays and classes Multi-dimensional Arrays Dynamic arrays

1 Sorting Arrays Chapter 14. 2 Agenda Review of Arrays Sorting Arrays Bubble Sort Selection Sort Finding the smallest element in array Multidimensional

Tirgul no. 6 Topics covered : b Constructors – types of constructors b Two-dimensional and Multi-dimensional arrays in java. b Sorting an array of numbers

Sorting and Shuffling Arrays

Arrays Multi-dimensional initialize & display Sample programs Sorting Searching Part II

Arrays One-Dimensional initialize & display Arrays as Arguments Two-dimensional initialize & display Part I

Documents

One-Dimensional and Multi-Dimensional Arrays, Searching & Sorting, Parameter passing to Functions Array Data Structures & Algorithms

Text of One-Dimensional and Multi-Dimensional Arrays, Searching & Sorting, Parameter passing to Functions...