DOCSLIB.ORG

Bubble Sort: an Archaeological Algorithmic Analysis

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Bubble Sort: an Archaeological Algorithmic Analysis Bubble Sort: An Archaeological Algorithmic Analysis Owen Astrachan 1 Computer Science Department Duke University [email protected] Abstract 1 Introduction Text books, including books for general audiences, in- What do students remember from their first program- variably mention bubble sort in discussions of elemen- ming courses after one, five, and ten years? Most stu- tary sorting algorithms. We trace the history of bub- dents will take only a few memories of what they have ble sort, its popularity, and its endurance in the face studied. As teachers of these students we should ensure of pedagogical assertions that code and algorithmic ex- that what they remember will serve them well. More amples used in early courses should be of high quality specifically, if students take only a few memories about and adhere to established best practices. This paper is sorting from a first course what do we want these mem- more an historical analysis than a philosophical trea- ories to be? Should the phrase Bubble Sort be the first tise for the exclusion of bubble sort from books and that springs to mind at the end of a course or several courses. However, sentiments for exclusion are sup- years later? There are compelling reasons for excluding 1 ported by Knuth [17], “In short, the bubble sort seems discussion of bubble sort , but many texts continue to to have nothing to recommend it, except a catchy name include discussion of the algorithm after years of warn- and the fact that it leads to some interesting theoreti- ings from scientists and educators. For example, in a cal problems.” Although bubble sort may not be a best popular new breadth-first text [6] bubble sort is given practice sort, perhaps the weight of history is more than equal footing with selection sort and quicksort in online enough to compensate and provide for its longevity. student exercises. Starting with Knuth’s premise that “bubble sort seems Categories and Subject Descriptors K.3.2 to have nothing to recommend it”[17], we trace the ori- [Computers & Education]: Computer & Infor- gins and continued popularity of the algorithm from its mation Science Education — Computer Science earliest days as an unnamed sort to its current status Education as perhaps the most popular O(n2) sort (see below) de- General Terms Algorithms, Measurement, Theory spite wide-spread ridicule. We began this study with the intent to document (and ridicule) the continued popu- Keywords Analysis, Performance, Bubble sort larity of bubble sort, but the algorithmic archaeological investigation has proven more interesting than casting aspersions. Our initial premise that bubble sort should not be stud- 1 This work was supported by NSF grants CAREER ied is reflected in [23] with a warning for potential mis- 9702550 and CRCD 0088078. use. Permission to make digital or hand copies of all or part of this work for personal or classroom use is granted without fee For N<50, roughly, the method of straight inser- provided that copies are not made or distributed for profit tion is concise and fast enough. We include it with or commercial advantage and that copies bear this notice N 2 and the full citation on the first page. To copy otherwise, some trepidation: it is an algorithm, whose po- or republish, to post on servers or to redistribute to lists, tential for misuse (by using it for too large an N)is require prior specific permission and/or a fee. great. The resultant waste of computer time is so SIGCSE ’03, February 19-23, Reno, Nevada, USA. awesome, that we were tempted not to include any Copyright 2003 ACM 1-58113-648-X/03/0002....$5.00 1A discussion of bubble sort with warnings that the per- formance is bad and the code isn’t simple (arguably) is like telling someone “don’t think about pink elephants.” 2 N routine at all. We will draw the line, however, 2.1 Bubble Sort, The Code at the inefficient N 2 algorithm bubble sort.Ifyou Taking the description of bubble sort in [17] as definitive know what bubble sort is, wipe it from your mind; 2 if you don’t know, make a point of never finding the code below is bubble sort. This version “bubbles” out! the largest elements to the end of the vector. void BubbleSort(Vector a, int n) This sentiment is similar to the reference to bubble sort { found in [1], where it says of bogo sort, “The archetypical for(int j=n-1; j > 0; j--) perversely awful algorithm (as opposed to bubble sort, for(int k=0; k < j; k++) which is merely the generic bad algorithm).” if (a[k+1] < a[k]) Swap(a,k,k+1); In Section 2 we trace the origin of the algorithm, both } in name and in code. In Section 3 we analyze the perfor- mance of the algorithm and the simplicity of the code. Nearly every description of bubble sort describes how In Section 4 we summarize our study. to terminate the sort early if the vector becomes sorted. This optimization requires checking if any swaps are made and terminating if no swaps are made after j it- 2 Origins of Bubble Sort erations of the inner loop. Another optimization is to alternate the direction of In an effort to determine why bubble sort is popular we bubbling each time the inner loop iterates. This is traced its origins. Knuth [17] does not provide informa- shaker sort or cocktail shaker sort (see, e.g., [17, 13]). tion on the origin of the name, though he does provide a 1956 reference [10] to an analysis of the algorithm. 2.2 A Sort by Any Other Name . That paper refers to “sorting by exchange”, but not to bubble sort. An extensive bibliography and sequence of Nomenclature is interesting. An early (1963) Fortran articles from the 1962 ACM Conference on Sorting [11] textbook [22] refers to the following code as “jump- do not use the term bubble sort, although the “sorting down” sort. by exchange” algorithm is mentioned. With no obvious definitive origin of the name “bubble sort”, we investi- void JumpDownSort(Vector a, int n) gated its origins by consulting early journal articles as { well as professional and pedagogical texts. for(int j=n-1; j > 0; j--) for(int k=0; k < j; k++) An early (1959) book on programming [21] devotes a if (a[j] < a[k]) chapter to sorting, but uses the term exchange sort- Swap(a,k,j); ing rather than bubble sort. The same term is used } in a 1962 [4] JACM article as well as in the earlier (1961, submitted 1959) [9] JACM article referenced as Bubble sort as we’ve identified it is called a “push- the definitive source. Iverson uses the name “bubble down” sort. In another early (1962) work [19] the sort” in 1962 [13]; this appears to be the first use of the “jump-down” version is presented first in the book, with term in print. As we note below, each work cited in [13] no name. The bubble sort follows also with no name. uses a phrase other than “bubble sort” to describe the In two early works [3, 10] the jump-down sort is referred algorithm we describe in Section 2.1. This reinforces the to as selection sort. Bubble sort is also covered, but re- claim that Iverson is the first to use the term, though ferred to as sorting by repeated comparison and exchang- obviously not conclusively. However, we could find no ing, respectively. In the latter paper, one of the earliest work published after 1962 with a reference to bubble works comparing algorithms, the exchange/bubble sort sort in an earlier publication than Iverson’s. is described thus: “Exchanging requires at least twice as many non-housekeeping comparisons as Inserting and Despite these earlier publications the algorithm offi- for most computers will be inferior”. cially enters the ACM algorithm repository as Algo- rithm 175 [25] in 1963 where it is named Shuttle Sort. In moving from bubble sort to jump-down sort the only Soon thereafter [14] the published algorithm is found to change to the code above is that one array index has k j be “not free from errors”, a gentle way of saying the been changed from +1 to . How does this differ from m published code is wrong. There a modified version of bubble sort? After iterations of the outer loop the m the code (that stops early when no swaps are made) is last elements are in their final position—the same given and the author says that in this form the code 2This code is close to legal in both C++ and Java and was “studied in this form on the ORDVAC computer, should be readable by anyone with a working knowledge of Aberdeen Proving Ground, in 1955.” Algol-like languages. invariant as bubble sort. However, items are not “bub- of selection sort (e.g., [3, 10]) in which only the ver- bled” to the top; this code implements what is essen- sion described in Section 2.1 as “jump-down” sort is tially a selection sort, but the current maximal element described, no separate minimum index variable is kept, is stored/swapped into location a[j]oneachpass.We and the minimal element selected in each pass of selec- see why early works sometimes refer to jump-down as tion sort is replaced by “a series of 9’s ...sothatsaid selection sort. item will never again be selected.” [10]. Another early work [7] is referenced in [18] with the 2.3 Origins of Popularity following warning.
Load more

Recommended publications
  • CS 758/858: Algorithms
    CS 758/858: Algorithms ■ COVID Prof. Wheeler Ruml Algorithms TA Sumanta Kashyapi This Class Complexity http://www.cs.unh.edu/~ruml/cs758 4 handouts: course info, schedule, slides, asst 1 2 online handouts: programming tips, formulas 1 physical sign-up sheet/laptop (for grades, piazza) Wheeler Ruml (UNH) Class 1, CS 758 – 1 / 25 COVID ■ COVID Algorithms This Class Complexity ■ check your Wildcat Pass before coming to campus ■ if you have concerns, let me know Wheeler Ruml (UNH) Class 1, CS 758 – 2 / 25 ■ COVID Algorithms ■ Algorithms Today ■ Definition ■ Why? ■ The Word ■ The Founder This Class Complexity Algorithms Wheeler Ruml (UNH) Class 1, CS 758 – 3 / 25 Algorithms Today ■ ■ COVID web: search, caching, crypto Algorithms ■ networking: routing, synchronization, failover ■ Algorithms Today ■ machine learning: data mining, recommendation, prediction ■ Definition ■ Why? ■ bioinformatics: alignment, matching, clustering ■ The Word ■ ■ The Founder hardware: design, simulation, verification ■ This Class business: allocation, planning, scheduling Complexity ■ AI: robotics, games Wheeler Ruml (UNH) Class 1, CS 758 – 4 / 25 Definition ■ COVID Algorithm Algorithms ■ precisely defined ■ Algorithms Today ■ Definition ■ mechanical steps ■ Why? ■ ■ The Word terminates ■ The Founder ■ input and related output This Class Complexity What might we want to know about it? Wheeler Ruml (UNH) Class 1, CS 758 – 5 / 25 Why? ■ ■ COVID Computer scientist 6= programmer Algorithms ◆ ■ Algorithms Today understand program behavior ■ Definition ◆ have confidence in results, performance ■ Why? ■ The Word ◆ know when optimality is abandoned ■ The Founder ◆ solve ‘impossible’ problems This Class ◆ sets you apart (eg, Amazon.com) Complexity ■ CPUs aren’t getting faster ■ Devices are getting smaller ■ Software is the differentiator ■ ‘Software is eating the world’ — Marc Andreessen, 2011 ■ Everything is computation Wheeler Ruml (UNH) Class 1, CS 758 – 6 / 25 The Word: Ab¯u‘Abdall¯ah Muh.ammad ibn M¯us¯aal-Khw¯arizm¯ı ■ COVID 780-850 AD Algorithms Born in Uzbekistan, ■ Algorithms Today worked in Baghdad.
    [Show full text]
  • Data Structures & Algorithms
    DATA STRUCTURES & ALGORITHMS Tutorial 6 Questions SORTING ALGORITHMS Required Questions Question 1. Many operations can be performed faster on sorted than on unsorted data. For which of the following operations is this the case? a. checking whether one word is an anagram of another word, e.g., plum and lump b. findin the minimum value. c. computing an average of values d. finding the middle value (the median) e. finding the value that appears most frequently in the data Question 2. In which case, the following sorting algorithm is fastest/slowest and what is the complexity in that case? Explain. a. insertion sort b. selection sort c. bubble sort d. quick sort Question 3. Consider the sequence of integers S = {5, 8, 2, 4, 3, 6, 1, 7} For each of the following sorting algorithms, indicate the sequence S after executing each step of the algorithm as it sorts this sequence: a. insertion sort b. selection sort c. heap sort d. bubble sort e. merge sort Question 4. Consider the sequence of integers 1 T = {1, 9, 2, 6, 4, 8, 0, 7} Indicate the sequence T after executing each step of the Cocktail sort algorithm (see Appendix) as it sorts this sequence. Advanced Questions Question 5. A variant of the bubble sorting algorithm is the so-called odd-even transposition sort . Like bubble sort, this algorithm a total of n-1 passes through the array. Each pass consists of two phases: The first phase compares array[i] with array[i+1] and swaps them if necessary for all the odd values of of i.
    [Show full text]
  • 13 Basic Sorting Algorithms
    Concise Notes on Data Structures and Algorithms Basic Sorting Algorithms 13 Basic Sorting Algorithms 13.1 Introduction Sorting is one of the most fundamental and important data processing tasks. Sorting algorithm: An algorithm that rearranges records in lists so that they follow some well-defined ordering relation on values of keys in each record. An internal sorting algorithm works on lists in main memory, while an external sorting algorithm works on lists stored in files. Some sorting algorithms work much better as internal sorts than external sorts, but some work well in both contexts. A sorting algorithm is stable if it preserves the original order of records with equal keys. Many sorting algorithms have been invented; in this chapter we will consider the simplest sorting algorithms. In our discussion in this chapter, all measures of input size are the length of the sorted lists (arrays in the sample code), and the basic operation counted is comparison of list elements (also called keys). 13.2 Bubble Sort One of the oldest sorting algorithms is bubble sort. The idea behind it is to make repeated passes through the list from beginning to end, comparing adjacent elements and swapping any that are out of order. After the first pass, the largest element will have been moved to the end of the list; after the second pass, the second largest will have been moved to the penultimate position; and so forth. The idea is that large values “bubble up” to the top of the list on each pass. A Ruby implementation of bubble sort appears in Figure 1.
    [Show full text]
  • Fall, 2016 Lab #3
    Texas Christian University CoSc 20803 - Fall, 2016 Lab #3 Points: 100 points Language: Java Due Date: Midnight, Thursday, Nov 17, 2016 (complete Java project and manually-generated Excel spreadsheet ZIPped together and submitted with TURNIN). Purpose: The purpose of this assignment is to allow you to evaluate the performance of several different sorting algorithms on data in various degrees of disorder. Processing: You should implement the following sorting algorithms and gather statistics as noted below: Method #1 Method #2 Method #3 Method #4 Bubblesort Cocktail Shaker Sort Shell Sort Quick Sort (pp. 230-232) (discussed in class) (discussed in class) (pp. 232-236) Input: Three input data sets will be provided (each of which contains 5000, 4-byte alphanumeric keys). The files are: Ascending.dat, Descending.dat, and Random.dat (obtainable from the CoSc Department’s class website: GUI: For this lab you should develop a manual data collection program that employs a VERY SIMPLE graphical user interface. Your program should accommodate input from the user specifying: a) the integer number of records to be sorted, b) the name of the input file to be used as the source of data (via a JFileChooser()), and c) the sorting method to use. Your program should allow the sorting methods listed above to be performed. Statistics: You should sort, ascendingly, alphanumeric keys in each of the three data files provided, keeping statistics for each file and for each sort method. Keep track of: (i) the number of key compares (Ki:Kj) and (ii) the number of key moves (e.g., Ki <--- Kj).
    [Show full text]
  • Sorting Partnership Unless You Sign Up! Brian Curless • Homework #5 Will Be Ready After Class, Spring 2008 Due in a Week
    Announcements (5/9/08) • Project 3 is now assigned. CSE 326: Data Structures • Partnerships due by 3pm – We will not assume you are in a Sorting partnership unless you sign up! Brian Curless • Homework #5 will be ready after class, Spring 2008 due in a week. • Reading for this lecture: Chapter 7. 2 Sorting Consistent Ordering • Input – an array A of data records • The comparison function must provide a – a key value in each data record consistent ordering on the set of possible keys – You can compare any two keys and get back an – a comparison function which imposes a indication of a < b, a > b, or a = b (trichotomy) consistent ordering on the keys – The comparison functions must be consistent • Output • If compare(a,b) says a<b, then compare(b,a) must say b>a • If says a=b, then must say b=a – reorganize the elements of A such that compare(a,b) compare(b,a) • If compare(a,b) says a=b, then equals(a,b) and equals(b,a) • For any i and j, if i < j then A[i] ≤ A[j] must say a=b 3 4 Why Sort? Space • How much space does the sorting • Allows binary search of an N-element algorithm require in order to sort the array in O(log N) time collection of items? • Allows O(1) time access to kth largest – Is copying needed? element in the array for any k • In-place sorting algorithms: no copying or • Sorting algorithms are among the most at most O(1) additional temp space.
    [Show full text]
  • Sorting Algorithm 1 Sorting Algorithm
    Sorting algorithm 1 Sorting algorithm In computer science, a sorting algorithm is an algorithm that puts elements of a list in a certain order. The most-used orders are numerical order and lexicographical order. Efficient sorting is important for optimizing the use of other algorithms (such as search and merge algorithms) that require sorted lists to work correctly; it is also often useful for canonicalizing data and for producing human-readable output. More formally, the output must satisfy two conditions: 1. The output is in nondecreasing order (each element is no smaller than the previous element according to the desired total order); 2. The output is a permutation, or reordering, of the input. Since the dawn of computing, the sorting problem has attracted a great deal of research, perhaps due to the complexity of solving it efficiently despite its simple, familiar statement. For example, bubble sort was analyzed as early as 1956.[1] Although many consider it a solved problem, useful new sorting algorithms are still being invented (for example, library sort was first published in 2004). Sorting algorithms are prevalent in introductory computer science classes, where the abundance of algorithms for the problem provides a gentle introduction to a variety of core algorithm concepts, such as big O notation, divide and conquer algorithms, data structures, randomized algorithms, best, worst and average case analysis, time-space tradeoffs, and lower bounds. Classification Sorting algorithms used in computer science are often classified by: • Computational complexity (worst, average and best behaviour) of element comparisons in terms of the size of the list . For typical sorting algorithms good behavior is and bad behavior is .
    [Show full text]
  • Sorting Algorithms
    Sorting Algorithms Chapter 12 Our first sort: Selection Sort • General Idea: min SORTED UNSORTED SORTED UNSORTED What is the invariant of this sort? Selection Sort • Let A be an array of n ints, and we wish to sort these keys in non-decreasing order. • Algorithm: for i = 0 to n-2 do find j, i < j < n-1, such that A[j] < A[k], k, i < k < n-1. swap A[j] with A[i] • This algorithm works in place, meaning it uses its own storage to perform the sort. Selection Sort Example 66 44 99 55 11 88 22 77 33 11 44 99 55 66 88 22 77 33 11 22 99 55 66 88 44 77 33 11 22 33 55 66 88 44 77 99 11 22 33 44 66 88 55 77 99 11 22 33 44 55 88 66 77 99 11 22 33 44 55 66 88 77 99 11 22 33 44 55 66 77 88 99 11 22 33 44 55 66 77 88 99 Selection Sort public static void sort (int[] data, int n) { int i,j,minLocation; for (i=0; i<=n-2; i++) { minLocation = i; for (j=i+1; j<=n-1; j++) if (data[j] < data[minLocation]) minLocation = j; swap(data, minLocation, i); } } Run time analysis • Worst Case: Search for 1st min: n-1 comparisons Search for 2nd min: n-2 comparisons ... Search for 2nd-to-last min: 1 comparison Total comparisons: (n-1) + (n-2) + ... + 1 = O(n2) • Average Case and Best Case: O(n2) also! (Why?) Selection Sort (another algorithm) public static void sort (int[] data, int n) { int i, j; for (i=0; i<=n-2; i++) for (j=i+1; j<=n-1; j++) if (data[j] < data[i]) swap(data, i, j); } Is this any better? Insertion Sort • General Idea: SORTED UNSORTED SORTED UNSORTED What is the invariant of this sort? Insertion Sort • Let A be an array of n ints, and we wish to sort these keys in non-decreasing order.
    [Show full text]
  • Sorting Networks
    Sorting Networks Uri Zwick Tel Aviv University May 2015 Comparators 푥 min(푥, 푦) 푦 max(푥, 푦) 푥 min(푥, 푦) 푦 max(푥, 푦) Can we use comparators to build efficient sorting networks? Comparator networks A comparator network is a network composed of comparators. There are 푛 input wires, each feeding a single comparator. Each output of a comparator is either an output wire, or feeds a single comparator. The network must be acyclic. Number of output wires must also be 푛. “Standard form” Exercise: Show that any comparator network is equivalent to a network in standard form. A simple sorting network 5 comparators 3 levels Insertion sort 푆표푟푡(푛) Selection/bubble sort 푆표푟푡(푛) Selection/bubble Sort 푛 푛−1 Size = Depth = 2푛 − 1 2 Exercise: Any sorting network that only compares 푛 푛−1 adjacent lines must be of size at least 2 Exercise: Prove that the network on the next slide, whose depth is 푛, is a sorting network Odd-Even Transposition Sort 푛 푛−1 Size = Depth = 푛 2 The 0-1 principle Theorem: If a network sort all 0-1 inputs, then it sort all inputs The 0-1 principle Lemma: Let 푓 be a monotone non-decreasing function. Then, if a network maps 푥1, 푥2, . , 푥푛 to 푦1, 푦2, . , 푦푛, then it maps 푓(푥1), 푓(푥2), . , 푓(푥푛) to 푓(푦1), 푓(푦2), . , 푓(푦푛) Proof: By induction on the number of comparisons using 푓 min 푎, 푏 = min(푓 푎 , 푓 푏 ) 푓 max 푎, 푏 = max(푓 푎 , 푓 푏 ) The 0-1 principle Proof: Suppose that a network is not a sorting network.
    [Show full text]
  • Sorting Algorithm 1 Sorting Algorithm
    Sorting algorithm 1 Sorting algorithm A sorting algorithm is an algorithm that puts elements of a list in a certain order. The most-used orders are numerical order and lexicographical order. Efficient sorting is important for optimizing the use of other algorithms (such as search and merge algorithms) which require input data to be in sorted lists; it is also often useful for canonicalizing data and for producing human-readable output. More formally, the output must satisfy two conditions: 1. The output is in nondecreasing order (each element is no smaller than the previous element according to the desired total order); 2. The output is a permutation (reordering) of the input. Since the dawn of computing, the sorting problem has attracted a great deal of research, perhaps due to the complexity of solving it efficiently despite its simple, familiar statement. For example, bubble sort was analyzed as early as 1956.[1] Although many consider it a solved problem, useful new sorting algorithms are still being invented (for example, library sort was first published in 2006). Sorting algorithms are prevalent in introductory computer science classes, where the abundance of algorithms for the problem provides a gentle introduction to a variety of core algorithm concepts, such as big O notation, divide and conquer algorithms, data structures, randomized algorithms, best, worst and average case analysis, time-space tradeoffs, and upper and lower bounds. Classification Sorting algorithms are often classified by: • Computational complexity (worst, average and best behavior) of element comparisons in terms of the size of the list (n). For typical serial sorting algorithms good behavior is O(n log n), with parallel sort in O(log2 n), and bad behavior is O(n2).
    [Show full text]
  • Sorting Algorithms
    International Research Journal of Engineering and Technology (IRJET) e-ISSN: 2395 -0056 Volume: 03 Issue: 02 | Feb-2016 www.irjet.net p-ISSN: 2395-0072 SORTING ALGORITHMS Neelam Yadav*, Sangeeta Kumari** *HOD in CSE Dept, DAV college, Kanina **Lecture in CSE Dept, DAV College, Kanina --------------------------------------------------------------------------------------------------------------------------------------------------------------- Abstract: This paper presents different type of sorting that Memory usage are present in data structure for example quick, insertion, Stability: stable sorting algorithms maintains the relative heap and merge. Each algorithm tries to solve sorting order if records with equal keys. problem using different formats. These four algorithms have their own pros and cons. This pa per presents a detailed study Sorting algorithms are sometimes characterized by big O of how these algorithm works and compares them on the notation. This notation indicates performances of basis of various parameters to reach a conclusion. algorithms and the amount of time that the algorithms take. The different cases that are popular in sorting Keywords: Quick Sort, Selection Sort, Insertion Sort, Bubble algorithms are:- Sort, Shell Sort, Cocktail Sort, Comparison, Other Performance Parameters. - O(n) is fair, graph increases in the smooth path. 1. INTRODUCTION - O(n^2): this is inefficient because a small increase in input increases the graph tremendously. A sorting algorithm is an algorithm that arranges the elements of a list in a certain order; the order can be - O(n log n): this is considered as efficient, because it increasing or decreasing. Till now many sorting algorithm shows the slower pace increase in the graph as the size of has been discovered. Some of them were comparison based array or data is increased.
    [Show full text]
  • PART III Basic Data Types
    PART III Basic Data Types 186 Chapter 7 Using Numeric Types Two kinds of number representations, integer and floating point, are supported by C. The various integer types in C provide exact representations of the mathematical concept of “integer” but can represent values in only a limited range. The floating-point types in C are used to represent the mathematical type “real.” They can represent real numbers over a very large range of magnitudes, but each number generally is an approximation, using a limited number of decimal places of precision. In this chapter, we define and explain the integer and floating-point data types built into C and show how to write their literal forms and I/O formats. We discuss the range of values that can be stored in each type, how to perform reliable arithmetic computations with these values, what happens when a number is converted (or cast) from one type to another, and how to choose the proper data type for a problem. We would like to think of numbers as integer values, not as patterns of bits in memory. This is possible most of the time when working with C because the language lets us name the numbers and compute with them symbolically. Details such as the length (in bytes) of the number and the arrangement of bits in those bytes can be ignored most of the time. However, inside the computer, the numbers are just bit patterns. This becomes evident when conditions such as integer overflow occur and a “correct” formula produces a wrong and meaningless answer.
    [Show full text]
  • Searching and Sorting Charlie Li 2019-02-16 Content
    Searching and sorting Charlie Li 2019-02-16 Content • Searching • Linear Search • Binary Search • Ternary Search • Sorting • Selection Sort, Insertion Sort, Bubble Sort • Quick Sort, Merge Sort • Counting Sort, Radix Sort Searching • Usage • Generally, it is used to find any root or optimal value of some function f(x). • In particular, it can be used to locate a certain object or optimal value in an array Searching • 4 types of questions we can ask • For array, • Find the position of certain object in the array • Find the optimal (e.g. smallest or largest) element in the array • For function f(x), • Find the root of f(x) = y • Find the optimal (e.g. smallest or largest) point of f(x) Linear Search • Aka sequential search, dictionary search • The is one of the naïve ways to locate certain object or to find an optimal element in an array (and even for linked-list (appears in DS(I))) Linear Search • Example: • Find any 3 in the following array Index 0 1 2 3 4 5 Value 1 5 1 3 4 2 Not 3 Not 3 Not 3 Found Linear Search • Example: • Find any 0 in the following array Index 0 1 2 3 4 5 Value 1 5 1 3 4 2 Not 0 Not 0 Not 0 Not 0 Not 0 Not 0 Not Found Linear Search • For your reference, the code looks like this: • The idea is similar to find the optimal value. Linear Search • One can easily see that the above algorithm is always true without any restriction on the array a.
    [Show full text]