Explore
For Enterprise
Join for Free
Log In

University of Pennsylvania
Earn an Ivy League CS Master’s designed for non-CS majors
Applications for Penn’s online Master of Computer and Information Technology degree are now open.
HEC Paris
MSc in Entrepreneurship and Innovation
Get an MSIE from a top business school. Apply by Feb 17 to get 2,000 EUR off.

Explore todo o Coursera

Navegar
Os melhores cursos
For Enterprise
Entrar
Inscreva-se gratuitamente

Path Compression

Loading...

estrutura de dadosestrutura de dados

Universidade da Califórnia, San Diego

4.7 (2,468 classificações) | 100K alunos inscritos

Curso 2 de 6 no Estruturas de dados e algoritmos Programa de cursos integrados

Cadastre-se gratuitamente

A good algorithm usually comes together with a set of good data structures that allow the algorithm to manipulate the data efficiently. In this course, we consider the common data structures that are used in various computational problems. You will learn how these data structures are implemented in different programming languages and will practice implementing them in our programming assignments. This will help you to understand what is going on inside a particular built-in implementation of a data structure and what to expect from it. You will also learn typical use cases for these data structures. A few examples of questions that we are going to cover in this class are the following: 1. What is a good strategy of resizing a dynamic array? 2. How priority queues are implemented in C++, Java, and Python? 3. How to implement a hash table so that the amortized running time of all operations is O(1) on average? 4. What are good strategies to keep a binary tree balanced? You will also learn how services like Dropbox manage to upload some large files instantly and to save a lot of storage space! Do you have technical problems? Write to us: coursera@hse.ru

Visualizar o programa do curso

Habilidades que você aprenderá

Binary Search Tree, Priority Queue, Hash Table, Stack (Abstract Data Type), List

Avaliações

4.7 (2,468 classificações)

5 stars
1,820 ratings
4 stars
521 ratings
3 stars
88 ratings
2 stars
15 ratings
1 star
24 ratings

AS

Sep 19, 2019

The best data structures course that I have taken!\n\nThe complex topics are made simpler at the expense of teaching style that allowed me to make it applicable in a real world situations.

AS

Nov 23, 2019

The lectures and the reading material were great. The assignments are challenging and require thought before attempting. The forums were really useful when I got stuck with the assignments

Na lição

Priority Queues and Disjoint Sets

We start this module by considering priority queues which are used to efficiently schedule jobs, either in the context of a computer operating system or in real life, to sort huge files, which is the most important building block for any Big Data processing algorithm, and to efficiently compute shortest paths in graphs, which is a topic we will cover in our next course. For this reason, priority queues have built-in implementations in many programming languages, including C++, Java, and Python. We will see that these implementations are based on a beautiful idea of storing a complete binary tree in an array that allows to implement all priority queue methods in just few lines of code. We will then switch to disjoint sets data structure that is used, for example, in dynamic graph connectivity and image processing. We will see again how simple and natural ideas lead to an implementation that is both easy to code and very efficient. By completing this module, you will be able to implement both these data structures efficiently from scratch.

Trees for Disjoint Sets7:54

Union by Rank9:41

Path Compression6:07

Analysis (Optional)18:17

Ministrado por

Alexander S. Kulikov
Visiting Professor
Michael Levin
Lecturer
Daniel M Kane
Assistant Professor
Neil Rhodes
Adjunct Faculty

Experimente o curso Gratuito

Transcrição

To build our Y intuition involves a second characteristic for the disjoint at the destruction. Let's again consider the example shown here on the slide. Assume that we call find of six. This will traverse the following path from six to the root of this tree. So let's know that in this case we find the root of three that contains element six, but we also find the root of the tree that contains element 12 and contains element three. In general, by reversing this path we find the root for all the elements on this path. So, why lose this information? Let's just store it somehow. And one way to do this, for example, is to re-attach all these notes directly to the root, we can do this as follows. Now as you can see the parent of element 12 for example is five, and also the parent of element six is also five. We've just attached them directly to the root. And this can not only save us space in the future. Save us time, I'm sorry, in the future. For future calls of find operation. So this heuristic is called path compression. Implementing this heuristic I mean path compression heuristic, don't sound to be surprisingly simple. It is actually only three lines of code. Here we do the following. We first check whether i is equal to parent of i. If it is equal, if it is the root, then we will just return the result. If i is not the root, if i is not the root, we do the following. We call find recursively for the parent of the node i. This is done here. So we call find for the parent of the node i. It will return the root of the correspondent three. And then we set parent of i to be equal to the returned root. That is, we attach the node number i directly to the root. And we do this recursively for all the elements on this pass. Finally we return the new parent of i, which is now just the root of the corresponding tree. Before stating an upper bound on the running time of operations of our current implementations, we need to introduce the so-called iterated logarithm function, which is also denoted by log star of n. So by definition, iterated logarithm of n is the number of times the binary logarithm should be applied to n before we get a number which is at most one. Let me illustrate this with an example so n equal to one is a binary logarithm of n is equal to zero. We do not need to apply binary logarithm to get a number which is at most one, because n is already almost one in this case. For n equal to two, we need to apply binary logarithm once to get the number which is at most one. Mainly, if we apply binary algorithm to two we just get the number one. Okay for n equals to three and four, the binary algorithm is equal to two and so on. And for example, for the numbers shown here, two to the sixth, 5536 If we apply binary logarithm once, then just by definition of binary logarithm we get this number, just 65536, which is two to 16, okay? So if we apply the binary logarithm once again we get 16, 16 is two to the four. If we apply the binary logarithm once again we get four. If we apply, again, we get two, and if we apply it finally once again, we get one. And at this point, we stop. So we applied the binary logarithm five times to get a number which is at most one, which ensures that for this number, two to the 65536 the log star is equal to five, okay? So, and this shows that for any practical value of n, the binary log, the log star function is, at most, five. Because this number is extremely huge. We will never see any value of m which is greater than this number in practical value. We will never get an input, a sequence that consists of so many elements. So theoretically speaking, the lock star function is not bound. It is not constant. So there are extremely huge numbers for which lock star is equal to ten or twenty or 100 and so on. However, for all practical values of n, log star of n is at most five. We're now ready to state an upper bound. Assume that we used both union by rank heuristic and past compression heuristic, and assume that we make m operations with our data structure, of which m are calls to the MakeSet does a MakeSet operation. Namely, we have n object, and we make m operations with them. Then the total running time of all these calls is O(mlog*n). Put it otherwise, the amortized running time of a single operation is O(log*n). And recalls it for all practical values of n, log star of n is at most five. Which means that we have a constant average time for a single operation for all practical values of n. So once again, log star theoretically speaking, log star function is not bound, however it is at most five for all practical values of n which makes our data structure very efficient in practice. We will prove this upper bound in the next video.

Explore nosso catálogo

Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.

O Coursera proporciona acesso universal à melhor educação do mundo, fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.

© 2020 Coursera Inc. Todos os direitos reservados.

Baixar no Google Play

Coursera
Sobre
Liderança
Carreiras
Lista de cursos
Certificados
Certificados MasterTrack™
Notas
For Enterprise
For Government
For Campus

Comunidade
Learners
Partners
Developers
Beta Testers
Translators

Conectar
Blog
Facebook
LinkedIn
Twitter
Instagram
YouTube
Tech Blog

Mais
Termos
Privacidade
Ajuda
Acessibilidade
Imprensa
Contato
Diretório
Afiliados