04 - 15 Jan - Heap Sort
•
0 likes•107 views
This document discusses heap sort and how to implement a min heap. It shows the steps of heap sort by organizing elements into a min heap where the first element is always the minimum. It explains that a min heap can support fast insertion and deletion of minimum elements in O(log n) time by maintaining the heap property that a node is larger than its children. The key aspects are using a complete binary tree structure represented as an array and algorithms for heapify, insert, and delete min that utilize the tree's structure.
Report
Share
Report
Share
Download to read offline
Recommended
Lec23
Priority queues are data structures that support efficient insertion and removal of elements based on priority. There are two main types - min priority queues, which remove the minimum element first, and max priority queues, which remove the maximum element first. Common operations like insertion and removal have logarithmic time complexity when implemented using heaps. Priority queues have applications in sorting, scheduling tasks, and computing Huffman codes for data compression.
LEC 8-DS ALGO(heaps).pdf
The document discusses binary heaps and algorithms for building, inserting, and deleting elements from heaps. It begins by defining min-heaps and max-heaps, and the heap property that parent nodes are smaller than child nodes in min-heaps and larger in max-heaps. It then covers algorithms for inserting new elements by placing them at the bottom and bubbling up, deleting the minimum/maximum element by replacing it with the last element and bubbling down. The document concludes by explaining that building a heap from a list of elements can be done in linear time by placing elements in an array and percolating them down level-by-level.
Kruskal & Prim's Algorithm
This presentation summarizes Kruskal's algorithm and Prim's algorithm for finding minimum spanning trees in graphs. Kruskal's algorithm works by selecting the shortest edge in a network that does not create a cycle, repeating until all vertices are connected. Prim's algorithm starts with any vertex and selects the shortest edge connected to vertices already in the tree, repeating until all vertices are connected. Both algorithms are demonstrated on a example network to connect five villages to a market town, finding the minimum total edge length of 18 using either algorithm by connecting edges of length 2, 3, 4, 4, and 5.
Lec24
The document describes how to initialize a max heap from an input array by starting at the rightmost non-leaf node and bubbling elements up to satisfy the max heap property. It then discusses leftist trees, which can also be used as priority queues like heaps but allow faster melding of two trees. Leftist trees maintain the property that the left child has a greater or equal s-value than the right child for each node.
Lec25
The document discusses tournament trees and their applications. Tournament trees are binary trees used to model single-elimination tournaments. They have n external nodes representing players and n-1 internal nodes representing matches. Winner trees store the winner at each internal node, while loser trees store the loser. Tournament trees can be used to sort values in O(n log n) time by repeatedly extracting the winner and replacing it.
sorting algorithm graphical method
This document describes and compares several common sorting algorithms, including bubble sort, selection sort, and insertion sort. It provides pseudocode examples to illustrate how each algorithm works and analyzes their time complexities. Specifically, it shows the steps to sort sample data using each algorithm through multiple iterations and compares their performance, with bubble, selection, and insertion sorts having O(n2) time and others like merge and quicksort having O(n log n) time.
Minimum Spanning Tree
The document discusses algorithms for finding the minimum spanning tree of a graph. It describes Kruskal's algorithm and Prim's algorithm. Kruskal's algorithm works by sorting the edges by weight and then adding edges one by one if they do not form cycles. Prim's algorithm starts with one node and iteratively adds the lowest cost edge connecting an added node to an unadded node. Both algorithms run in O(ElogV) time where E is the number of edges and V is the number of vertices.
one main advantage of bubble sort as compared to others
Bubble sort is a simple sorting algorithm that compares adjacent elements and swaps them if they are in the wrong order. It repeats this process, making multiple passes through the list, until it is fully sorted. While simple to implement, bubble sort has a poor worst-case performance of O(n2) time complexity, making it impractical for large datasets. It is often used to introduce sorting concepts but not recommended for real-world use due to its inefficient runtime.
Recommended
Lec23
Priority queues are data structures that support efficient insertion and removal of elements based on priority. There are two main types - min priority queues, which remove the minimum element first, and max priority queues, which remove the maximum element first. Common operations like insertion and removal have logarithmic time complexity when implemented using heaps. Priority queues have applications in sorting, scheduling tasks, and computing Huffman codes for data compression.
LEC 8-DS ALGO(heaps).pdf
The document discusses binary heaps and algorithms for building, inserting, and deleting elements from heaps. It begins by defining min-heaps and max-heaps, and the heap property that parent nodes are smaller than child nodes in min-heaps and larger in max-heaps. It then covers algorithms for inserting new elements by placing them at the bottom and bubbling up, deleting the minimum/maximum element by replacing it with the last element and bubbling down. The document concludes by explaining that building a heap from a list of elements can be done in linear time by placing elements in an array and percolating them down level-by-level.
Kruskal & Prim's Algorithm
This presentation summarizes Kruskal's algorithm and Prim's algorithm for finding minimum spanning trees in graphs. Kruskal's algorithm works by selecting the shortest edge in a network that does not create a cycle, repeating until all vertices are connected. Prim's algorithm starts with any vertex and selects the shortest edge connected to vertices already in the tree, repeating until all vertices are connected. Both algorithms are demonstrated on a example network to connect five villages to a market town, finding the minimum total edge length of 18 using either algorithm by connecting edges of length 2, 3, 4, 4, and 5.
Lec24
The document describes how to initialize a max heap from an input array by starting at the rightmost non-leaf node and bubbling elements up to satisfy the max heap property. It then discusses leftist trees, which can also be used as priority queues like heaps but allow faster melding of two trees. Leftist trees maintain the property that the left child has a greater or equal s-value than the right child for each node.
Lec25
The document discusses tournament trees and their applications. Tournament trees are binary trees used to model single-elimination tournaments. They have n external nodes representing players and n-1 internal nodes representing matches. Winner trees store the winner at each internal node, while loser trees store the loser. Tournament trees can be used to sort values in O(n log n) time by repeatedly extracting the winner and replacing it.
sorting algorithm graphical method
This document describes and compares several common sorting algorithms, including bubble sort, selection sort, and insertion sort. It provides pseudocode examples to illustrate how each algorithm works and analyzes their time complexities. Specifically, it shows the steps to sort sample data using each algorithm through multiple iterations and compares their performance, with bubble, selection, and insertion sorts having O(n2) time and others like merge and quicksort having O(n log n) time.
Minimum Spanning Tree
The document discusses algorithms for finding the minimum spanning tree of a graph. It describes Kruskal's algorithm and Prim's algorithm. Kruskal's algorithm works by sorting the edges by weight and then adding edges one by one if they do not form cycles. Prim's algorithm starts with one node and iteratively adds the lowest cost edge connecting an added node to an unadded node. Both algorithms run in O(ElogV) time where E is the number of edges and V is the number of vertices.
one main advantage of bubble sort as compared to others
Bubble sort is a simple sorting algorithm that compares adjacent elements and swaps them if they are in the wrong order. It repeats this process, making multiple passes through the list, until it is fully sorted. While simple to implement, bubble sort has a poor worst-case performance of O(n2) time complexity, making it impractical for large datasets. It is often used to introduce sorting concepts but not recommended for real-world use due to its inefficient runtime.
Lec9
1. There are three cases to consider when deleting a node x from a tree: x has no children, x has one child, or x has two children.
2. If x has two children, its successor y is found and removed instead of x, and y's key is copied to x.
3. The expected time to insert n random keys into an initially empty binary search tree is O(n log n). This is because the average height of the resulting tree is O(log n).
Sorting
The document provides information on various sorting and searching algorithms, including bubble sort, insertion sort, selection sort, quick sort, sequential search, and binary search. It includes pseudocode to demonstrate the algorithms and example implementations with sample input data. Key points covered include the time complexity of each algorithm (O(n^2) for bubble/insertion/selection sort, O(n log n) for quick sort, O(n) for sequential search, and O(log n) for binary search) and how they work at a high level.
Nikit
The document describes bucket sort and radix sort algorithms. It provides examples to illustrate how each algorithm works. Specifically:
1) Bucket sort works by counting the number of objects that fall into multiple "buckets" based on a certain value like size or weight. It then places the objects in the correct order.
2) Radix sort sorts data based on individual digits of a number, starting from the least significant digit to the most significant. It repeatedly performs bucket sorts on each digit to fully sort the data.
3) Examples show the step-by-step process of bucket sort and LSD radix sort on sample input data to produce a sorted output.
2.4 mst prim’s algorithm
The document discusses spanning trees and minimum spanning trees for graphs. A spanning tree is a minimal set of edges that connect all vertices of a connected, undirected graph without cycles. A minimum spanning tree is a spanning tree for a connected, undirected and weighted graph where the sum of the weights of the edges is minimized. Prim's algorithm is presented for finding a minimum spanning tree. The algorithm initializes the minimum spanning tree to be empty and selects the minimum weight edge connecting a vertex in the tree to one not in the tree, adding it to the tree iteratively until all vertices are included. An example run-through of Prim's algorithm on a weighted graph is shown step-by-step.
A presentation on prim's and kruskal's algorithm
This slides are for a presentation on Prim's and Kruskal's algorithm. Where I have tried to explain how both the algorithms work, their similarities and their differences.
05 - 18 Jan - The Sorting Wrap-Up
This document discusses sorting algorithms and finding medians using heaps. It describes how heapify takes linear time overall to turn an array into a heap. To sort an array using a heap, repeatedly extract the maximum element and place it at the end of the array, requiring O(n log n) time. Finding medians can be done by storing the first half of elements in a max-heap and the second half in a min-heap.
Sorting ppt
This Presentation includes different types of sorting and there introduction as well as their algorithm in data structure
Lec10
Quicksort is a divide and conquer algorithm that works by partitioning an array around a pivot element and recursively sorting the subarrays. It has average case performance of O(n log n) but worst case of O(n^2). Randomized quicksort improves the algorithm by choosing the pivot randomly, ensuring the worst case is also O(n log n) on average.
Radix sorting
This document discusses radix sorting and provides details on its implementation. Radix sorting is a non-comparative sorting algorithm that uses bucket sorting to sort integers by their individual digits in multiple passes. Pseudocode and C code examples are provided to demonstrate how radix sorting works by distributing numbers into buckets based on their digits and recombining the buckets in sorted order. The time complexity of radix sorting is linear for a constant number of digits.
Work-stealing Tree Data Structure
This document proposes a work-stealing tree approach for scheduling highly irregular data-parallel workloads. It describes how a work-stealing tree can adapt to workload irregularity by allowing workers to steal and expand subtrees. This achieves near-optimal speedup, unlike static approaches. The key aspects discussed are how the work-stealing tree is constructed and traversed during scheduling, and how choosing nodes to steal based on most elements generates the fewest nodes to minimize overhead.
Smalltalk
Smalltalk is an object-oriented programming language and environment. It uses everything is an object and message passing paradigms. Some key aspects include: objects can have methods and fields, method calls use message passing syntax instead of function syntax, types are dynamically checked, and it has features like closures, reflection, and automatic memory management via garbage collection. The Smalltalk environment has been used for over 50 years and current implementations like Squeak and Pharo remain actively developed.
Lec8
This document discusses ordered dictionaries and binary search trees (BSTs). It describes how BSTs can support dictionary operations like search, minimum, maximum, and successor in O(h) time, where h is the height of the tree. The height of a BST after n insertions can be O(n) in the worst case, such as when keys are inserted in ascending or descending order.
Searching algorithms
The document discusses different types of searching algorithms. It describes sequential search which searches an unsorted list sequentially until the target item is found or the entire list is searched. The average runtime is O(n) as the item could be anywhere in the list. Binary search is described as more efficient for sorted lists, repeatedly dividing the search space in half and comparing the target to the middle element. Indexes are also summarized, including clustered vs unclustered indexes and different approaches to storing data entries.
Merge sort
Mergesort is a divide and conquer algorithm that works as follows:
1) Recursively sort the left and right halves of the array.
2) Merge the two sorted halves into a new sorted array.
3) Repeat until the entire array is sorted.
It has superior time complexity of O(n log n) in all cases but requires O(n) additional space for the auxiliary array used during merging.
Stacks overview with its applications
Stacks are linear data structures where elements are inserted and removed from the same end, known as the top. Common stack operations include push to add an element, pop to remove the top element, and peek to view the top element without removing it. Stacks are often implemented using arrays or linked lists and have O(1) time complexity for operations. Some applications of stacks include reversing data, converting numbers between bases, expression conversions, and backtracking problems like N-Queens.
Sorting2
The document discusses various sorting algorithms and their time complexities, including:
1) Quicksort, which has an average case time complexity of O(n log n) but a worst case of O(n^2). It works by recursively partitioning an array around a pivot element.
2) Heapsort, which also has a time complexity of O(n log n). It uses a binary heap to extract elements in sorted order.
3) Counting sort and radix sort, which can sort in linear time O(n) when the input has certain properties like a limited range of values or being represented by a small number of digits.
Ctrie Data Structure
Description of the Ctrie data structure - a lock-free, concurrent map with atomic, constant-time snapshots.
Sign Sign 2
The document discusses rewriting mathematical expressions to eliminate the "sign sign phenomenon" by applying rules such as: adding a negative number is equivalent to subtracting a positive number; subtracting a negative number is equivalent to adding a positive number; and the opposite of a negative number is a positive number. It provides examples of rewriting expressions such as -9+(-4), -(-4)+(-3), and -5--9 according to these rules.
Lec23
Radix sort considers the structure of keys and sorts based on comparing bits in the same position. Bucket sort is used to stably sort based on individual bits, with time complexity O(bn) for b-bit keys. While comparison-based sorting requires Ω(n log n) time, radix sort circumvents this lower bound by exploiting key structure rather than just comparisons.
Lec5
This document summarizes techniques for hashing, including hash functions, open addressing, linear probing, and double hashing. It discusses choosing good hash functions that distribute keys uniformly. For open addressing, it describes linear probing, which probes successive table locations when collisions occur, and double hashing, which uses two hash functions to determine probe positions. Analysis shows the expected number of probes is related to the load factor for these probing techniques.
Computer notes - Maze Generator
The document discusses algorithms for generating mazes using union-find data structures. It explains that a maze can be represented as a grid of cells where each cell is initially isolated by walls. A union-find structure tracks connected components of cells as walls are removed. A random maze is generated by repeatedly selecting random walls to remove, performing a union operation to connect the neighboring cells, until the entrance and exit cells are in the same connected component. Pseudocode is provided for a MakeMaze algorithm that uses this approach.
06 - 20 Jan - Divide and Conquer
The document discusses algorithms for finding the closest pair of points from a set of n points given as (x,y) coordinates. It presents three approaches: computing all pairwise distances which is O(n^2); sorting the points and comparing adjacent pairs which is the time to sort plus O(n); and divide and conquer which splits the points, solves subproblems recursively, and merges in O(n log n) time.
More Related Content
What's hot
Lec9
1. There are three cases to consider when deleting a node x from a tree: x has no children, x has one child, or x has two children.
2. If x has two children, its successor y is found and removed instead of x, and y's key is copied to x.
3. The expected time to insert n random keys into an initially empty binary search tree is O(n log n). This is because the average height of the resulting tree is O(log n).
Sorting
The document provides information on various sorting and searching algorithms, including bubble sort, insertion sort, selection sort, quick sort, sequential search, and binary search. It includes pseudocode to demonstrate the algorithms and example implementations with sample input data. Key points covered include the time complexity of each algorithm (O(n^2) for bubble/insertion/selection sort, O(n log n) for quick sort, O(n) for sequential search, and O(log n) for binary search) and how they work at a high level.
Nikit
The document describes bucket sort and radix sort algorithms. It provides examples to illustrate how each algorithm works. Specifically:
1) Bucket sort works by counting the number of objects that fall into multiple "buckets" based on a certain value like size or weight. It then places the objects in the correct order.
2) Radix sort sorts data based on individual digits of a number, starting from the least significant digit to the most significant. It repeatedly performs bucket sorts on each digit to fully sort the data.
3) Examples show the step-by-step process of bucket sort and LSD radix sort on sample input data to produce a sorted output.
2.4 mst prim’s algorithm
The document discusses spanning trees and minimum spanning trees for graphs. A spanning tree is a minimal set of edges that connect all vertices of a connected, undirected graph without cycles. A minimum spanning tree is a spanning tree for a connected, undirected and weighted graph where the sum of the weights of the edges is minimized. Prim's algorithm is presented for finding a minimum spanning tree. The algorithm initializes the minimum spanning tree to be empty and selects the minimum weight edge connecting a vertex in the tree to one not in the tree, adding it to the tree iteratively until all vertices are included. An example run-through of Prim's algorithm on a weighted graph is shown step-by-step.
A presentation on prim's and kruskal's algorithm
This slides are for a presentation on Prim's and Kruskal's algorithm. Where I have tried to explain how both the algorithms work, their similarities and their differences.
05 - 18 Jan - The Sorting Wrap-Up
This document discusses sorting algorithms and finding medians using heaps. It describes how heapify takes linear time overall to turn an array into a heap. To sort an array using a heap, repeatedly extract the maximum element and place it at the end of the array, requiring O(n log n) time. Finding medians can be done by storing the first half of elements in a max-heap and the second half in a min-heap.
Sorting ppt
This Presentation includes different types of sorting and there introduction as well as their algorithm in data structure
Lec10
Quicksort is a divide and conquer algorithm that works by partitioning an array around a pivot element and recursively sorting the subarrays. It has average case performance of O(n log n) but worst case of O(n^2). Randomized quicksort improves the algorithm by choosing the pivot randomly, ensuring the worst case is also O(n log n) on average.
Radix sorting
This document discusses radix sorting and provides details on its implementation. Radix sorting is a non-comparative sorting algorithm that uses bucket sorting to sort integers by their individual digits in multiple passes. Pseudocode and C code examples are provided to demonstrate how radix sorting works by distributing numbers into buckets based on their digits and recombining the buckets in sorted order. The time complexity of radix sorting is linear for a constant number of digits.
Work-stealing Tree Data Structure
This document proposes a work-stealing tree approach for scheduling highly irregular data-parallel workloads. It describes how a work-stealing tree can adapt to workload irregularity by allowing workers to steal and expand subtrees. This achieves near-optimal speedup, unlike static approaches. The key aspects discussed are how the work-stealing tree is constructed and traversed during scheduling, and how choosing nodes to steal based on most elements generates the fewest nodes to minimize overhead.
Smalltalk
Smalltalk is an object-oriented programming language and environment. It uses everything is an object and message passing paradigms. Some key aspects include: objects can have methods and fields, method calls use message passing syntax instead of function syntax, types are dynamically checked, and it has features like closures, reflection, and automatic memory management via garbage collection. The Smalltalk environment has been used for over 50 years and current implementations like Squeak and Pharo remain actively developed.
Lec8
This document discusses ordered dictionaries and binary search trees (BSTs). It describes how BSTs can support dictionary operations like search, minimum, maximum, and successor in O(h) time, where h is the height of the tree. The height of a BST after n insertions can be O(n) in the worst case, such as when keys are inserted in ascending or descending order.
Searching algorithms
The document discusses different types of searching algorithms. It describes sequential search which searches an unsorted list sequentially until the target item is found or the entire list is searched. The average runtime is O(n) as the item could be anywhere in the list. Binary search is described as more efficient for sorted lists, repeatedly dividing the search space in half and comparing the target to the middle element. Indexes are also summarized, including clustered vs unclustered indexes and different approaches to storing data entries.
Merge sort
Mergesort is a divide and conquer algorithm that works as follows:
1) Recursively sort the left and right halves of the array.
2) Merge the two sorted halves into a new sorted array.
3) Repeat until the entire array is sorted.
It has superior time complexity of O(n log n) in all cases but requires O(n) additional space for the auxiliary array used during merging.
Stacks overview with its applications
Stacks are linear data structures where elements are inserted and removed from the same end, known as the top. Common stack operations include push to add an element, pop to remove the top element, and peek to view the top element without removing it. Stacks are often implemented using arrays or linked lists and have O(1) time complexity for operations. Some applications of stacks include reversing data, converting numbers between bases, expression conversions, and backtracking problems like N-Queens.
Sorting2
The document discusses various sorting algorithms and their time complexities, including:
1) Quicksort, which has an average case time complexity of O(n log n) but a worst case of O(n^2). It works by recursively partitioning an array around a pivot element.
2) Heapsort, which also has a time complexity of O(n log n). It uses a binary heap to extract elements in sorted order.
3) Counting sort and radix sort, which can sort in linear time O(n) when the input has certain properties like a limited range of values or being represented by a small number of digits.
Ctrie Data Structure
Description of the Ctrie data structure - a lock-free, concurrent map with atomic, constant-time snapshots.
Sign Sign 2
The document discusses rewriting mathematical expressions to eliminate the "sign sign phenomenon" by applying rules such as: adding a negative number is equivalent to subtracting a positive number; subtracting a negative number is equivalent to adding a positive number; and the opposite of a negative number is a positive number. It provides examples of rewriting expressions such as -9+(-4), -(-4)+(-3), and -5--9 according to these rules.
Lec23
Radix sort considers the structure of keys and sorts based on comparing bits in the same position. Bucket sort is used to stably sort based on individual bits, with time complexity O(bn) for b-bit keys. While comparison-based sorting requires Ω(n log n) time, radix sort circumvents this lower bound by exploiting key structure rather than just comparisons.
Lec5
This document summarizes techniques for hashing, including hash functions, open addressing, linear probing, and double hashing. It discusses choosing good hash functions that distribute keys uniformly. For open addressing, it describes linear probing, which probes successive table locations when collisions occur, and double hashing, which uses two hash functions to determine probe positions. Analysis shows the expected number of probes is related to the load factor for these probing techniques.
What's hot (20)
Viewers also liked
Computer notes - Maze Generator
The document discusses algorithms for generating mazes using union-find data structures. It explains that a maze can be represented as a grid of cells where each cell is initially isolated by walls. A union-find structure tracks connected components of cells as walls are removed. A random maze is generated by repeatedly selecting random walls to remove, performing a union operation to connect the neighboring cells, until the entrance and exit cells are in the same connected component. Pseudocode is provided for a MakeMaze algorithm that uses this approach.
06 - 20 Jan - Divide and Conquer
The document discusses algorithms for finding the closest pair of points from a set of n points given as (x,y) coordinates. It presents three approaches: computing all pairwise distances which is O(n^2); sorting the points and comparing adjacent pairs which is the time to sort plus O(n); and divide and conquer which splits the points, solves subproblems recursively, and merges in O(n log n) time.
Types Of Recursion in C++, Data Stuctures by DHEERAJ KATARIA
The document discusses recursion and provides examples of recursion including nested recursion. It explains recursion using functions like the Ackermann function and Fibonacci numbers. It discusses excessive recursion and how it can lead to many repeated computations. The document also covers backtracking as a method for systematically trying sequences of decisions to find a solution. It provides the example of solving the eight queens problem using backtracking and recursion.
Queue
A queue is a first-in, first-out (FIFO) data structure where insertion is done at the rear end and deletion is done at the front end. It can be implemented using either an array or linked list. Basic operations on a queue include enqueue, which inserts an item at the rear, and dequeue, which removes an item from the front. A circular queue addresses the issue of empty spaces in a linear queue by connecting the rear end to the front so the queue can migrate in a circular fashion.
Notes DATA STRUCTURE - queue
B is inserted at index 1 (back) of the circular queue. back is incremented by 1 using modulo arithmetic to handle wrap-around. count is also incremented.
From previous slide: front = 0, back = 1, count = 2 queue
front = 0
7 0
A back = 2
6 1
B C
back = (1 + 1) % 8
back = 2 % 8
back = 2 5 2
0 queue[2] = C
8√ 2 4 3
Queue Data Structure
The document discusses queue data structures. A queue is a linear data structure where additions are made at the end/tail and removals are made from the front/head, following a First-In First-Out (FIFO) approach. Common queue operations include add, remove, check if empty, check if full. A queue can be stored using either a static array or dynamic linked nodes. The key aspects are maintaining references to the head and tail of the queue.
Queue data structure
A queue is a non-primitive linear data structure that follows the FIFO (first-in, first-out) principle. Elements are added to the rear of the queue and removed from the front. Common operations on a queue include insertion (enqueue) and deletion (dequeue). Queues have many real-world applications like waiting in lines and job scheduling. They can be represented using arrays or linked lists.
Viewers also liked (7)
Types Of Recursion in C++, Data Stuctures by DHEERAJ KATARIA
Types Of Recursion in C++, Data Stuctures by DHEERAJ KATARIA
Similar to 04 - 15 Jan - Heap Sort
Advanced s and s algorithm.ppt
This document provides an overview of several advanced sorting algorithms: Shell sort, Quick sort, Heap sort, and Merge sort. It describes the key ideas, time complexities, and provides examples of implementing each algorithm to sort sample data sets. Shell sort improves on insertion sort by sorting elements in a two-dimensional array. Quick sort uses a pivot element and partitions elements into left and right subsets. Heap sort uses a heap data structure and sorts by swapping elements. Merge sort divides the list recursively and then merges the sorted halves.
Chapter 8 advanced sorting and hashing for print
Shell sort improves on insertion sort by first sorting elements that are already partially sorted. It does this by using a sequence of increment values to sort sublists within the main list. The time complexity of shell sort is O(n^3/2).
Quicksort uses a divide and conquer approach. It chooses a pivot element and partitions the list into two sublists based on element values relative to the pivot. The sublists are then recursively sorted. The average time complexity of quicksort is O(nlogn) but it can be O(n^2) in the worst case.
Mergesort follows the same divide and conquer strategy as quicksort. It recursively divides the list into halves until single elements
Sorting in data structures and algorithms , it has all the necessary points t...
1) The document discusses various sorting algorithms like bubble sort, selection sort, insertion sort, merge sort, quick sort and heap sort.
2) It provides detailed explanations of how merge sort and quick sort algorithms work, including examples with diagrams showing the sorting process step-by-step.
3) Merge sort has a time complexity of O(n log n) as it recursively divides the array into halves and then merges the sorted halves, while quick sort selects a pivot element and partitions the array into elements less than and greater than the pivot in O(n) time on average.
sorting.pptx
This document provides information about sorting algorithms. It begins with an introduction to sorting, explaining why sorting is important and common sorting algorithms like merge sort, quicksort, heapsort, etc. It then discusses different types of sorting algorithms like comparison-based sorting and specialized sorting. The document proceeds to explain several specific sorting algorithms in detail, including bubble sort, selection sort, insertion sort, merge sort, and bitonic sort. It provides pseudocode for the algorithms and examples to illustrate how they work on sample data. The key details covered are the time complexity of common sorting algorithms and how different algorithms have tradeoffs in terms of speed and memory usage.
Algorithim lec1.pptx
The document discusses algorithms analysis and sorting algorithms. It introduces insertion sort and merge sort, and analyzes their time complexities. Insertion sort runs in O(n^2) time in the worst case, while merge sort runs in O(n log n) time in the worst case, which grows more slowly. Therefore, asymptotically merge sort performs better than insertion sort for large data sets. The document also covers asymptotic analysis, recurrences, and using recursion trees to solve recurrences.
Sorting and Hashing Algorithm full pdfs.
The document discusses sorting algorithms, including insertion sort and bubble sort. It provides descriptions of how each algorithm works, including pseudocode. Key points made include:
- Insertion sort works by inserting elements into the sorted portion of the array, maintaining the invariant that the sorted portion remains sorted.
- Bubble sort works by "bubbling up" the largest elements to the end through successive passes over the array, swapping adjacent out-of-order elements.
- Optimizations for both algorithms include detecting if the array is already sorted to stop early.
A practical Introduction to Machine(s) Learning
The data deluge we currently witnessing presents both opportunities and challenges. Never before have so many aspects of our world been so thoroughly quantified as now and never before has data been so plentiful. On the other hand, the complexity of the analyses required to extract useful information from these piles of data is also rapidly increasing rendering more traditional and simpler approaches simply unfeasible or unable to provide new insights.
In this tutorial we provide a practical introduction to some of the most important algorithms of machine learning that are relevant to the field of Complex Networks in general, with a particular emphasis on the analysis and modeling of empirical data. The goal is to provide the fundamental concepts necessary to make sense of the more sophisticated data analysis approaches that are currently appearing in the literature and to provide a field guide to the advantages an disadvantages of each algorithm.
In particular, we will cover unsupervised learning algorithms such as K-means, Expectation-Maximization, and supervised ones like Support Vector Machines, Neural Networks and Deep Learning. Participants are expected to have a basic understanding of calculus and linear algebra as well as working proficiency with the Python programming language.
Deep Learning and Design Thinking
The presentation is an introduction to AI (deep learning). The key to success with AI is “asking good questions.” The talk was given in "Seminar in Information Systems and Applications" at National Tsing Hua University in Taiwan. During this talk, we discussed what a good question is, how we use design thinking process to improve our question, and how can we “answer” the question by deep learning.
Lecture_5_Stack.pptx
The document discusses stacks and their implementation using arrays. It defines a stack as a collection of homogeneous elements that can have items inserted or removed from only one end, called the top. Stacks follow a last-in, first-out principle. The key operations are push, which inserts an item at the top, and pop, which removes an item from the top. The document presents an example of representing a stack as an array, using a top pointer and size variable. It also provides an example problem of performing various push and pop operations on a stack and describing the resulting state.
Chapter 12 - Heaps.ppt
Heaps are a type of tree structure that can be used to implement priority queues. Heaps allow for fast insertion and deletion operations in O(log n) time. They are usually implemented as arrays, where each node satisfies the heap property of being greater than or equal to the keys of its children. This makes heaps "weakly ordered" without a strong search mechanism. Removal of the maximum element is easy by removing the root, but requires trickling down the last element to maintain the heap ordering. Insertion works by trickling new elements up until they are below a larger parent node. Heapsort uses these heap operations to sort elements in O(n log n) time by building a heap and repeatedly removing
Basics in algorithms and data structure
The document discusses data structures and algorithms. It notes that good programmers focus on data structures and their relationships, while bad programmers focus on code. It then provides examples of different data structures like trees and binary search trees, and algorithms for searching, inserting, deleting, and traversing tree structures. Key aspects covered include the time complexity of different searching algorithms like sequential search and binary search, as well as how to implement operations like insertion and deletion on binary trees.
Daa final
Merge sort is a sorting algorithm that uses the divide and conquer technique. It divides the unsorted list into halves, recursively sorts the sub-lists, and then merges the sorted sub-lists into a single sorted list. The key steps are dividing, conquering by recursively sorting the sub-problems, and merging the sorted sub-lists. Merge sort has a time complexity of O(n log n) in all cases (best, average, worst) and requires additional storage space.
01 analysis-of-algorithms
- The document describes a course on algorithms and analysis of algorithms.
- It discusses insertion sort and merge sort, providing pseudocode and examples. Insertion sort runs in O(n^2) time in the worst case, while merge sort runs in O(n log n) time.
- Asymptotic analysis is introduced as a way to analyze algorithms by considering how their running time grows as the input size increases, ignoring lower order terms and machine-dependent constants.
Sorting Algorithms
The document discusses several sorting algorithms and their time complexities:
- Bubble sort, insertion sort, and selection sort have O(n^2) time complexity.
- Quicksort uses a divide-and-conquer approach and has O(n log n) time complexity on average but can be O(n^2) in the worst case.
- Heapsort uses a heap data structure and has O(n log n) time complexity.
Lec35
The document discusses various sorting algorithms including merge sort, quicksort, and insertion sort. Merge sort works by dividing the array into two halves, recursively sorting each half, and then merging the sorted halves together. Quicksort selects a pivot element and partitions the array into elements less than or greater than the pivot. Insertion sort iterates through the array and inserts each element into its sorted position.
Sortings .pptx
This document discusses various sorting algorithms and their time complexities. It covers common sorting algorithms like bubble sort, selection sort, insertion sort, which have O(N^2) time complexity and are slow for large data sets. More efficient algorithms like merge sort, quicksort, heapsort with O(N log N) time complexity are also discussed. Implementation details and examples are provided for selection sort, insertion sort, merge sort and quicksort algorithms.
Algorithm and Programming (Sorting)
This file contains explanation about sorting algorithm. This file was used in my Algorithm and Programming Class.
10.m way search tree
The document describes m-way search trees, B-trees, heaps, and their related operations. An m-way search tree is a tree where each node has at most m child nodes and keys are arranged in ascending order. B-trees are similar but ensure the number of child nodes falls in a range and all leaf nodes are at the same depth. Common operations like searching, insertion, and deletion are explained for each with examples. Heaps store data in a complete binary tree structure where a node's value is greater than its children's values.
Lecture 2d queues
This document discusses queue data structures and their implementation. A queue is a first-in, first-out (FIFO) data structure where elements are inserted at the rear and deleted from the front. Queues can be implemented using arrays or linked lists. With an array implementation, the front index remains fixed while the rear index moves to insert elements. To delete, the front index is incremented. Linked list implementations use head and tail pointers. Enqueue operations add to the tail and dequeue operations remove from the head. Common queue operations and applications are also covered.
Skiena algorithm 2007 lecture07 heapsort priority queues
The document summarizes key concepts about heapsort and priority queues. It begins by introducing heaps as a data structure that can be represented as a binary tree or implicitly as an array. Elements in a heap satisfy the heap property where a node is always less than or equal to its children. The document then discusses how to build a heap in O(n) time using the heapify algorithm, and how to perform insertion and deletion in O(log n) time by bubbling elements up or down the heap. Heaps enable priority queue operations and are used in heapsort, which runs in optimal O(n log n) time.
Similar to 04 - 15 Jan - Heap Sort (20)
Sorting in data structures and algorithms , it has all the necessary points t...
Sorting in data structures and algorithms , it has all the necessary points t...
Skiena algorithm 2007 lecture07 heapsort priority queues
Skiena algorithm 2007 lecture07 heapsort priority queues
More from Neeldhara Misra
Erdos Posa Theorem
The document discusses the benefits of exercise for mental health. Regular physical activity can help reduce anxiety and depression and improve mood and cognitive function. Exercise causes chemical changes in the brain that may help protect against mental illness and improve symptoms.
15 - 12 Feb - Stable Matchings
This document summarizes an algorithm lecture about stable matchings. It introduces the stable matching problem and Hall's marriage theorem. It then describes Gale-Shapley's stable matching algorithm, where men and women rank their preferences and men iteratively propose to the highest ranked remaining women. The algorithm is proven to always terminate with a stable matching in polynomial time.
07- 22 Jan - Divide and Conquer
The document summarizes the Master's Theorem for analyzing divide and conquer recurrences. It introduces three cases for the recurrence T(n) ≤ aT(n/b) + O(nd): (1) if a = bd, the solution is T(n) = O(ndlogn); (2) if a < bd, the solution is T(n) = O(nd); (3) if a > bd, the solution is T(n) = O(alogbn). Examples like binary search and merge sort are shown to illustrate the three cases.
10 - 29 Jan - Recursion Part 2
The document discusses algorithms for solving 3CNF formulas using recursion. It describes a recursive algorithm that picks a variable from a clause, and recursively checks if the formula is satisfiable with that variable set to 1 and then 0. This results in a recurrence relation of T(n) = T(n-1) + T(n-2) + T(n-3). The document also discusses using "clever base cases" like eliminating degree 0 and 1 vertices to improve the running time of algorithms on graphs.
02 - 04 Jan - Sorting (Continued)
The document discusses the CS 321 Algorithm Analysis and Design course. It covers announcements about homework, grading, and clarifications. Algorithm analysis is introduced, covering running time and correctness. Insertion sort is presented, including a loop invariant and examples. Best-case, average-case, and worst-case running times are defined. Asymptotics and big O notation are introduced. Merge sort is mentioned along with induction.
08 - 25 Jan - Divide and Conquer
This document discusses divide and conquer algorithms for multiplying integers and finding the kth smallest element. It describes how to multiply integers by dividing them into left and right halves, combining results. Finding the kth smallest element involves choosing a pivot, partitioning around it, and recursively searching halves until the kth element is found. Both algorithms take O(n log n) time by dividing the problem size by a constant factor at each step.
13 - 06 Feb - Dynamic Programming
The document summarizes content from a lecture on dynamic programming techniques, including the knapsack problem, shortest paths, and edit distance. It provides examples of using dynamic programming to solve the 0/1 knapsack problem by building up a 2D array from the bottom up where each entry stores the maximum value for items fitting in a knapsack of given size. It also explains calculating edit distance by building a 2D array where each entry stores the minimum edit operations to change one string to another.
00 - 30 Dec - Introduction
This document outlines the course details for CS 321 Algorithm Analysis and Design. It includes information on logistics like office hours and TAs, graded work like assignments and exams, starred problems, discussion policy, and an overview of design techniques, complexity issues, and key tools covered in the course. The document also provides pre-requisites and motivates the importance of algorithms through quotes about using both theory and practice to improve each other.
01 - 01 January - Sorting
This document discusses sorting algorithms that are covered in a CS 321 algorithms course. It introduces several sorting algorithms like counting sort, bubble sort, merge sort, quicksort, and insertion sort. For each algorithm, it provides the time complexity. It also mentions that merge sort runs in O(n log n) time due to having log n layers of recursion where each layer takes O(n) work. Quicksort's recursion tree can potentially be skewed, leading to O(n^2) performance in the worst case. References provided direct the reader to a video and website for learning more about sorting algorithms.
14 - 08 Feb - Dynamic Programming
This document discusses dynamic programming techniques for three problems: edit distance, longest increasing subsequence, and matrix chain multiplication. It provides examples of how to calculate the edit distance between two strings by finding the minimum cost of insertions, deletions, and replacements needed to convert one string to the other. It then explains how to find the longest increasing subsequence of a given array using dynamic programming by building up the solution bottom-up. Finally, it briefly mentions finding the most efficient way to multiply a chain of matrices using dynamic programming.
11 - 03 Feb - From Recursion to Dynamic Programming
This document discusses recursion and memoization. It introduces the Fibonacci numbers and the problem of tiling a corridor of length n. It shows the recursive definition of the number of tilings as C(n) = C(n-1) + C(n-2), with base cases C(1)=1 and C(2)=2. It notes that directly implementing this recursion leads to redundant computations. Memoization is proposed as a technique to store computed values in a table to avoid recomputing them, making the algorithm more efficient.
09 - 27 Jan - Recursion Part 1
The document discusses algorithms for solving satisfiability problems on conjunctive normal form (CNF) formulas. It first describes a trivial algorithm that tries all possible assignments, with a runtime of O(2^n*n^3). It then discusses using a recursive approach, but shows this results in an even worse runtime of O(3^n*n^3). Finally, it proposes a recursive algorithm that runs in O(1.8^n) by recursively trying assignments on subsets of variables.
04 - 15 Jan - Heap Sort
This document discusses heap sort and how to implement a min heap. It shows the steps of heap sort by organizing elements into a min heap where the first element is always the minimum. It explains that a min heap can support fast insertion and deletion of minimum elements in O(log n) time by maintaining the heap property that a node is larger than its children. The key aspects are using a complete binary tree structure represented in an array and algorithms for heapify, insert, and delete min that maintain the min heap ordering.
12 - 05 Feb - Dynamic Programming
The document discusses dynamic programming and its application to finding the independent set with the largest total weight on a path. It describes how dynamic programming can be used to solve this problem by breaking it down into subproblems and storing the solution to each subproblem in an array A, such that A[i] stores the maximum weight independent set for the subpath on the first i vertices. The value of each entry A[i] is computed recursively as the maximum of A[i-1] and A[i-2] + the weight of vertex i.
More from Neeldhara Misra (14)
11 - 03 Feb - From Recursion to Dynamic Programming
11 - 03 Feb - From Recursion to Dynamic Programming
Recently uploaded
How to Fix the Import Error in the Odoo 17
An import error occurs when a program fails to import a module or library, disrupting its execution. In languages like Python, this issue arises when the specified module cannot be found or accessed, hindering the program's functionality. Resolving import errors is crucial for maintaining smooth software operation and uninterrupted development processes.
Assessment and Planning in Educational technology.pptx
In an education system, it is understood that assessment is only for the students, but on the other hand, the Assessment of teachers is also an important aspect of the education system that ensures teachers are providing high-quality instruction to students. The assessment process can be used to provide feedback and support for professional development, to inform decisions about teacher retention or promotion, or to evaluate teacher effectiveness for accountability purposes.
Digital Artifact 1 - 10VCD Environments Unit
Digital Artifact 1 - 10VCD Environments Unit - NGV Pavilion Concept Design
Introduction to AI for Nonprofits with Tapp Network
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...Dr. Vinod Kumar Kanvaria
Exploiting Artificial Intelligence for Empowering Researchers and Faculty,
International FDP on Fundamentals of Research in Social Sciences
at Integral University, Lucknow, 06.06.2024
By Dr. Vinod Kumar KanvariaAzure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
A Strategic Approach: GenAI in Education
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
Advanced Java[Extra Concepts, Not Difficult].docx
This is part 2 of my Java Learning Journey. This contains Hashing, ArrayList, LinkedList, Date and Time Classes, Calendar Class and more.
Types of Herbal Cosmetics its standardization.
Physiology and chemistry of skin and pigmentation, hairs, scalp, lips and nail, Cleansing cream, Lotions, Face powders, Face packs, Lipsticks, Bath products, soaps and baby product,
Preparation and standardization of the following : Tonic, Bleaches, Dentifrices and Mouth washes & Tooth Pastes, Cosmetics for Nails.
The Diamonds of 2023-2024 in the IGRA collection
A review of the growth of the Israel Genealogy Research Association Database Collection for the last 12 months. Our collection is now passed the 3 million mark and still growing. See which archives have contributed the most. See the different types of records we have, and which years have had records added. You can also see what we have for the future.
South African Journal of Science: Writing with integrity workshop (2024)
South African Journal of Science: Writing with integrity workshop (2024)Academy of Science of South Africa
A workshop hosted by the South African Journal of Science aimed at postgraduate students and early career researchers with little or no experience in writing and publishing journal articles.The History of Stoke Newington Street Names
Presented at the Stoke Newington Literary Festival on 9th June 2024
www.StokeNewingtonHistory.com
ISO/IEC 27001, ISO/IEC 42001, and GDPR: Best Practices for Implementation and...
Denis is a dynamic and results-driven Chief Information Officer (CIO) with a distinguished career spanning information systems analysis and technical project management. With a proven track record of spearheading the design and delivery of cutting-edge Information Management solutions, he has consistently elevated business operations, streamlined reporting functions, and maximized process efficiency.
Certified as an ISO/IEC 27001: Information Security Management Systems (ISMS) Lead Implementer, Data Protection Officer, and Cyber Risks Analyst, Denis brings a heightened focus on data security, privacy, and cyber resilience to every endeavor.
His expertise extends across a diverse spectrum of reporting, database, and web development applications, underpinned by an exceptional grasp of data storage and virtualization technologies. His proficiency in application testing, database administration, and data cleansing ensures seamless execution of complex projects.
What sets Denis apart is his comprehensive understanding of Business and Systems Analysis technologies, honed through involvement in all phases of the Software Development Lifecycle (SDLC). From meticulous requirements gathering to precise analysis, innovative design, rigorous development, thorough testing, and successful implementation, he has consistently delivered exceptional results.
Throughout his career, he has taken on multifaceted roles, from leading technical project management teams to owning solutions that drive operational excellence. His conscientious and proactive approach is unwavering, whether he is working independently or collaboratively within a team. His ability to connect with colleagues on a personal level underscores his commitment to fostering a harmonious and productive workplace environment.
Date: May 29, 2024
Tags: Information Security, ISO/IEC 27001, ISO/IEC 42001, Artificial Intelligence, GDPR
-------------------------------------------------------------------------------
Find out more about ISO training and certification services
Training: ISO/IEC 27001 Information Security Management System - EN | PECB
ISO/IEC 42001 Artificial Intelligence Management System - EN | PECB
General Data Protection Regulation (GDPR) - Training Courses - EN | PECB
Webinars: https://pecb.com/webinars
Article: https://pecb.com/article
-------------------------------------------------------------------------------
For more information about PECB:
Website: https://pecb.com/
LinkedIn: https://www.linkedin.com/company/pecb/
Facebook: https://www.facebook.com/PECBInternational/
Slideshare: http://www.slideshare.net/PECBCERTIFICATION
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Let’s explore the intersection of technology and equity in the final session of our DEI series. Discover how AI tools, like ChatGPT, can be used to support and enhance your nonprofit's DEI initiatives. Participants will gain insights into practical AI applications and get tips for leveraging technology to advance their DEI goals.
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Chapter 4 - Islamic Financial Institutions in Malaysia.pptxMohd Adib Abd Muin, Senior Lecturer at Universiti Utara Malaysia
This slide is special for master students (MIBS & MIFB) in UUM. Also useful for readers who are interested in the topic of contemporary Islamic banking.
How to Build a Module in Odoo 17 Using the Scaffold Method
Odoo provides an option for creating a module by using a single line command. By using this command the user can make a whole structure of a module. It is very easy for a beginner to make a module. There is no need to make each file manually. This slide will show how to create a module using the scaffold method.
Recently uploaded (20)
Assessment and Planning in Educational technology.pptx
Assessment and Planning in Educational technology.pptx
Introduction to AI for Nonprofits with Tapp Network
Introduction to AI for Nonprofits with Tapp Network
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Azure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
South African Journal of Science: Writing with integrity workshop (2024)
South African Journal of Science: Writing with integrity workshop (2024)
ISO/IEC 27001, ISO/IEC 42001, and GDPR: Best Practices for Implementation and...
ISO/IEC 27001, ISO/IEC 42001, and GDPR: Best Practices for Implementation and...
Pride Month Slides 2024 David Douglas School District
Pride Month Slides 2024 David Douglas School District
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance.pptx
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
How to Build a Module in Odoo 17 Using the Scaffold Method
How to Build a Module in Odoo 17 Using the Scaffold Method
Digital Artefact 1 - Tiny Home Environmental Design
Digital Artefact 1 - Tiny Home Environmental Design
04 - 15 Jan - Heap Sort
- 1. CS 321. Algorithm Analysis & Design Lecture 4 Heap Sort
- 2. 4 9 2 1 8 5 6
- 3. 4 9 2 1 8 5 6
- 4. 4 9 2 1 8 5 6
- 5. 4 9 2 1 8 5 6
- 6. 4 9 21 8 5 6
- 7. 4 9 21 8 5 6
- 8. 4 9 21 8 5 6
- 9. 4 9 21 8 5 6
- 10. 4 9 21 8 5 6
- 11. 4 9 21 8 5 6
- 12. 4 9 21 8 5 6
- 13. 4 9 21 8 5 6
- 14. 4 9 21 85 6
- 15. 4 9 21 85 6
- 16. 4 921 85 6
- 17. 4 921 85 6 Can we speed up the find-min operations?
- 18. 4 9 21 8 5 6 Organize the elements so that finding minimum is “easy”.
- 19. 4 9 21 8 5 6 Organize the elements so that deleting the minimum element is “easy”.
- 20. Store a set of n distinct numbers. Inserting a new element and deleting the minimum element can be done in time proportional to (log n). GOAL
- 21. All jumbled up 4 9 2 1 8
- 22. All jumbled up 4 9 2 1 8 3
- 23. All jumbled up 4 9 2 1 8 3 6
- 24. All jumbled up 4 9 2 1 8 3 Insert: O(1) 6
- 25. All jumbled up 4 9 2 1 8 3 Insert: O(1) Delete-Min: O(n) 6
- 26. All sorted 9 8 6 3 1
- 27. All sorted 9 8 6 3
- 28. All sorted 9 8 6 3 Delete-Min: O(1)
- 29. All sorted 9 8 6 3 Delete-Min: O(1) 4
- 30. All sorted 9 8 6 3 Delete-Min: O(1) 47
- 31. All sorted 9 8 6 3 Insert: O(n) Delete-Min: O(1) 47
- 32. In-between? Invariant: The first element of the array is the minimum.
- 33. In-between? Invariant: The first element of the array is the minimum.
- 34. In-between? Invariant: The first element of the array is the minimum.
- 35. In-between? Invariant: The first element of the array is the minimum.
- 36. In-between? Invariant: The first element of the array is the minimum.
- 37. In-between? Invariant: The first element of the array is the minimum.
- 38. In-between? Invariant: The first element of the array is the minimum.
- 39. In-between? Invariant: The first element of the array is the minimum.
- 40. 4 9 21 8 5 6
- 41. 6 1 59 24 8 x is a child of y: x is larger than y.
- 42. 6 1 59 24 8
- 43. 6 1 59 24 8
- 44. 6 1 59 24 8
- 45. 61 5924 8
- 47. 61 5924 8 6 1 59 24 8 1 2 3 4 5 6 7 1 2 3 4 5 6 7
- 48. 61 5924 8 6 1 59 24 8 1 2 3 4 5 6 7 1 2 3 4 5 6 7 left-child(i) = 2i
- 49. 61 5924 8 6 1 4 1 2 4 1 2 3 4 5 6 7
- 50. 61 5924 8 6 1 4 1 2 4 1 2 3 4 5 6 7 left-child(i) = 2i
- 53. left-child(i) = 2i i+k 2i + 2k i 2i
- 68. Heapify