91074 – Algorithm Languages and User Interfaces

# 91074 – Algorithm Languages and User Interfaces

Télécharger la présentation

## 91074 – Algorithm Languages and User Interfaces

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. 91074 – Algorithm Languages and User Interfaces Sorting: Bubble Sort, Selection Sort, Insertion Sort, Quick Sort. Comparisons, Cost of an Algorithm.

2. Contents • Sorting Algorithms • Informal Instructions, Algorithms and Programs • High and Low Level Languages • Translating Between Languages • User Interfaces

3. Sorting Algorithms Sorting: Bubble Sort, Selection Sort, Insertion Sort, Quick Sort. Comparisons, Cost of an Algorithm.

4. Activity • In groups, sort a small number of cards numerically • What was your algorithm/strategy? – tell your group. • New Rules: only allowed to look at two cards at a time, only allowed to swap two, no other moves. • What was your algorithm/strategy?

5. Notes Sorting Algorithms: There are lots of ways computers sort lists. In this course we will look at Bubble sort, Selection Sort, Insertion Sort and Quick Sort. Cost of an Algorithm: For sorting giant lists (like a phone book) on a computer, speed is important. We call this the ‘cost of the algorithm’ and we measure it by how many comparisons the algorithm has to make for a set list size.

6. Bubble Sort Instructions • Compare the first two • If out of order swap them • Look at the next two, • Repeat Steps 2 and 3 until the (new) end of the list. • Repeat steps 1 – 4 until the list is sorted Called Bubble Sort because like bubbles in a glass, the next one makes it way to the top

7. Bubble Sort Cost E4E: Formula?

8. Example Bubble Sort Video Bubble Sort and Cost Video (sorting by height) youtube.com/watch?v=cdsfjU8qUss

9. Selection Sort • Compare the first two and find the biggest • Then compare the biggest with the next one • Remember which is the (new) biggest • Repeat steps 2 and 3 until the end • Swap the biggest one with the (new) last one • Repeat steps 1 to 5 until the list sorted Called Selection, because you are selecting the biggest one and swapping it to the end.

10. Selection Sort Cost E4E: Formula?

11. Insertion Sort • Compare the first two, and put them in order in a new list • Insert the next item into the right place in the new list by comparing it with each item until you find it’s place. • Repeat step 2 until the new list is sorted, and the old list is empty. Called Insertion, because you’re inserting into the correct position in a new list.

12. Insertion Sort Cost E4E: Formula?

13. Quick Sort (pivot) • Select the next (first) item and make it a pivot • Compare each item with the pivot, creating a list of smaller items and a list of bigger items. • Repeat steps 1 and 2 for each sublist, until the list is sorted Is one of a group of “divide and conquer” sorting algorithms Called Pivot, because you separate the list into smaller lists based on a pivot. ‘Pivot’, Friends on Youtube

14. Quick Sort Cost E4E4E: Formula?

15. Some Comparisons Which one is fastest, which is second fastest?Sorting lists of 20 Bubble Selection Insertion Quick Click to see them race

16. Some Comparisons Which one is fastest, which is second fastest?Sorting lists of 20 Bubble Selection Insertion Quick

17. Some Comparisons Bubble Sort vs Quick Sort (Youtube) Lists of 30 coloured blocks, Comparing swaps, not Comparisons • Which has the least comparisons? • Which has the least swaps? • Is comparisons or swaps the best way to measure “Cost of Algorithm?”

18. Comparing Sorting Comparisons Watch Pivot Video (youtube)

19. Practice Task Part A) Pick a sort, and six items. Step by step talk through sorting six items. E.g Carrot, Apple, Grape, Banana, Eggplant, Feijoa, - compare Carrot and Apple. (Out of order, so swap) • Compare Carrot and Grape (in order) • Compare Grape and … Part B) Do an insertion sort for 5, 6, 7 and 8 items, recording the cost. Part C) Explain how you calculated the cost and say why that is the cost.

20. Links Getting sort data quickly http://www.mundayweb.com/progs/applets/saas/Or search “MundaySaas” Running your own races http://www.sorting-algorithms.com/Has eight common sorts

21. Informal Instructions Algorithms and Programs Their Characteristics and Roles

22. Algorithm Notes • An algorithm is a precise unambiguous specification of how to accomplish some computational task in a finite number of well-defined steps. • An algorithm is distinct from a computer program. • An algorithmhas a cost (the number of steps it will perform) for a task. • Different algorithms for the same task may have different costs.

23. Informal Instructions, Algorithms and Programs Youtube Video (Eating a Chocolate) youtube.com/watch?v=cdsfjU8qUss

24. Friendship Algorithm

25. Characteristics of Informal Instructions, Algorithms, & Programs Informal Instructions: Vague, Imprecise, easy to read/create, interpreted many ways May have: gaps, bad spelling, incomplete Form: oral or written, Algorithms: Precise, single task, has inputs/outputs, made up of steps, has a cost, Form: code, flow chart, text Programs: Many tasks, made up of algorithms, single file, precise, self running, many tasksForm: file

26. When are they used (Roles)Informal Instructions, Algorithms, & Programs Informal Instructions: Humans, communication, ease, Algorithms: code, computer, part /functions in prog, Programs: a variety of functions, self contained

27. Programming Concepts Informal Instructions: Algorithms: Programs:

28. High and Low Level Languages Characteristics

29. High and Low Level Languages Video Youtube Video (Eating a Chocolate) youtube.com/watch?v=cdsfjU8qUss

30. Low Level Languages Machine Code (1GL) • 1st Generation Language (1GL) • Numbering system called “Binary” • Also called “Machine Code” • The only way to Program computers in the 1960s and 70s • Old Explanation of Binary (before 3GL)

31. Low Level Languages Machine Code (1GL) Binary Game

32. Low Level Languages Machine Code (1GL) Flight of the Conchords • Binary Solo Big Bang Theory • Chuck Norris of Numbers • Palindrome = Reverse , 1001001  1001001

33. Low Level Languages Machine Code (1GL) Characteristics • Lowest Level Language • Very Hard for humans to understand • Very slow to create code • No abstraction: Human knows exactly what’s going on • Directly interacting with hardware • Doesn’t need translating or compiling • Native Language of Computer

34. Low Level Languages Assembly (2GL)

35. Low Level Languages Assembly (2GL) • 2nd Generation Language (2GL) • One step up from Binary/Machine code • Has functions like Move (MOV), Compare (CMP), Increment (INC), Jump(JMP) • Uses Hexadecimal (like web colours #ffffff ) • Has no Compound functions like “If (this, then do this)” or “Loop (3 times)” • At the end it is “Assembled” into Binary • Used when you need exact control over code (e.g very small microchip, efficient code needed)

36. Low Level Languages Assembly (2GL) Assembler Example Hello World Ignore music and second half “The main problem with “assembler” jokes is, they are difficult to read”— scapegrace

37. Low Level Languages Assembly (2GL) Characteristics • Second Lowest Level Language • Hard for humans to understand • Slow to create code • Little abstraction: Human knows almost exactly what’s going on • Needs Assembling into Binary / Machine Code / 1GL translating or

38. High Level Languages (3GL) Common Programming Languages Like Basic, C, Java, C# and Scratch

39. High Level Languages (3GL) Features • Easier to Read and Write (and maintain) • Portable across different CPU families • Written as Text • Many High Level Languages, each with their own Syntax

40. High Level Languages (3GL) Brief History of 3GLs • 1957 Fortran (punch cards) • 1964 Basic  MS Visual Basic • 1972 C (text colouring)  C++ • 1995 Java (Object Oriented) • 2001 C# (OO, components) • 2007 Scratch (Drag n Drop)

41. High Level Languages (3GL) Characteristics • High Level Language • Lots of Abstraction into easily readable code • Easy for humans to understand • Quick to create code • Needs Translating into Machine code

42. HighLevel Languages (4GL) Lots of Abstraction

43. High Level Languages (4GL) Features • Flow charts and modules • 4GL creates the code for you • Often for a specific task e.g Managing a tax database

44. High Level Languages (4GL) Characteristics • Examples: Ruby on Rails, Oracle, Powerbuilder • High Level Language • Lots of Abstraction sometimes not even looking at code • Very Quick to create code • Needs Translating into Machine code “All 4GLs are designed to reduce programming effort, the time it takes to develop software, and the cost of software development. They are not always successful in this task, sometimes resulting in inelegant and unmaintainable code.” (wikipedia)

45. Comparison of Language Levels Challenge Question

46. Low and High Levels Invention of High Level Languages (3GL) High Level and Translators • 1983 Educational Cartoon BASIC Java C

47. Translating between High and Low Level Languages Compilers, and Interpreters