title

Data Structures and Algorithms in Python for Beginners - 2023 | Great Learning

description

🔥1000+ Free Courses With Free Certificates: https://www.mygreatlearning.com/academy?ambassador_code=GLYT_DES_Top_SEP22&utm_source=GLYT&utm_campaign=GLYT_DES_Top_SEP22
Dear Learners Welcome to this video “Data Structures and Algorithms in Python”, where learners can begin with very basic topics like Introduction to Data Structures, Types of Data Structures like Array, Stack, Queue and linked list with introduction, examples, and Implementation using Python Programming language. Proceeding with concepts you can learn tree data structures like binary tree, binary search tree creation, traversal and implementation.
In the algorithm part, we start with finding the time and space complexity of algorithms. Searching and Sorting concepts like binary search, linear search, Insertion sort, and Quicksort with implementation using python programming language are also included. Towards the end of this course, you will learn and implement different programming approaches like the divide and conquer greedy method, and dynamic programming with examples like Merge sort, Minimum Spanning tree algorithm, and Towers of Hanoi concepts using Python Programming language. So let's start the video and learn more about Data Structures and Algorithms in Python.
🏁 Topics Covered:
00:00:00 Course Introduction
00:01:54 Agenda
00:04:47 Introduction to Data Structure
00:09:11 Inbuilt and User-Defined Data Structure in Python
00:39:28 Arrays Introduction
00:52:50 Arrays Implementation
01:06:40 Advantages and Disadvantages of Arrays
01:12:26 Stack
01:31:57 Advantages and Disadvantages of Stack
01:33:53 Queue introduction
01:38:22 Queue implementation
01:46:07 Advantages and Disadvantages of Queue
02:48:05 Linked list
04:09:55 Advantages and Disadvantages of Linked List
04:14:04 Binary tree introduction
04:17:20 Binary tree implementation
04:26:34 Advantages and Disadvantages of Binary Tree
04:28:05 Binary search tree introduction
04:31:26 Binary search tree implementation
04:43:47 Advantages and Disadvantages of Binary search Tree
04:45:16 Graphs introduction
04:49:46 Breadth-first search implementation
04:53:01 Depth-first search implementation
04:56:42 Hash tables introduction
05:01:31 Hashing implementation
05:04:54 Algorithms introduction and algorithmic analysis
05:22:38 Finding space and time complexity
05:32:57 Linear Search
05:35:52 Linear search implementation
05:38:27 Complexity analysis of Linear Search
05:41:59 Binary Search
05:55:31 Binary search implementation
05:58:22 Complexity analysis of Binary Search
06:01:34 Insertion sort
06:10:11 Insertion sort implementation
06:14:12 Complexity analysis of Insertion sort
06:22:38 Selection sort
06:33:14 Selection sort implementation
06:38:21 Complexity analysis of Selection sort
06:47:19 Quicksort
07:01:20 Quicksort implementation
07:06:32 Complexity analysis of Quicksort
07:12:08 Introduction to Divide and Conquer approach
07:15:06 Merge sort
07:27:10 merge sort implementation
07:30:33 Introduction to Greedy's approach
07:31:37 Prim's minimal Spanning Tree algorithm
07:38:07 Prim's minimal Spanning Tree algorithm implementation
07:42:05 Introduction to Dynamic Programming
07:43:31 Tower of Hanoi
07:46:35 Tower of Hanoi implementation
07:54:19 Summary
🔥Check Our Free Courses on with free certificate:
✔ Python Data Structures course: https://glacad.me/3qoBxYM
✔ Python for Data Science: https://www.mygreatlearning.com/academy/learn-for-free/courses/python-for-data-science3?ambassador_code=GLYT_DES_Middle_SEP22&utm_source=GLYT&utm_campaign=GLYT_DES_Middle_SEP22
⚡ About Great Learning Academy:
Visit Great Learning Academy to get access to 1000+ free courses with free certificate on Data Science, Data Analytics, Digital Marketing, Artificial Intelligence, Big Data, Cloud, Management, Cybersecurity, Software Development, and many more. These are supplemented with free projects, assignments, datasets, quizzes. You can earn a certificate of completion at the end of the course for free. https://www.mygreatlearning.com/acade
⚡ About Great Learning:
With more than 5.4 Million+ learners in 170+ countries, Great Learning, a part of the BYJU'S group, is a leading global edtech company for professional and higher education offering industry-relevant programs in the blended, classroom, and purely online modes across technology, data and business domains. These programs are developed in collaboration with the top institutions like Stanford Executive Education, MIT Professional Education, The University of Texas at Austin, NUS, IIT Madras, IIT Bombay & more.
SOCIAL MEDIA LINKS:
🔹 For more interesting tutorials, don't forget to subscribe to our channel: https://glacad.me/YTsubscribe
🔹 For more updates on courses and tips follow us on:
✅ Telegram: https://t.me/GreatLearningAcademy
✅ Facebook: https://www.facebook.com/GreatLearningOfficial/
✅ LinkedIn: https://www.linkedin.com/school/great-learning/mycompany/verification/
✅ Follow our Blog: https://glacad.me/GL_Blog

detail

{'title': 'Data Structures and Algorithms in Python for Beginners - 2023 | Great Learning', 'heatmap': [{'end': 3722.358, 'start': 3147.413, 'weight': 0.743}, {'end': 5442.937, 'start': 5148.479, 'weight': 0.868}, {'end': 6306.821, 'start': 6011.357, 'weight': 0.932}, {'end': 7161.189, 'start': 6585.261, 'weight': 0.729}, {'end': 16042.011, 'start': 15746.74, 'weight': 1}, {'end': 16892.981, 'start': 16604.858, 'weight': 0.848}, {'end': 17465.886, 'start': 17176.741, 'weight': 0.863}], 'summary': 'Course provides a beginner-friendly guide to data structures and algorithms in python, covering basic concepts, types of data structures, algorithms, and programming approaches. it includes in-depth explanations and demonstrations of various data structures such as linked lists, arrays, stack, queue, binary trees, graph, hash tables, and sorting algorithms like insertion sort, selection sort, quick sort, and merge sort. the course emphasizes practical python implementations, algorithm efficiency, time and space complexities, and real-life applications, making it a comprehensive learning resource for beginners in 2023.', 'chapters': [{'end': 1494.676, 'segs': [{'end': 52.233, 'src': 'embed', 'start': 21.033, 'weight': 0, 'content': [{'end': 29.76, 'text': 'Proceeding with concepts you can also learn regarding tree data structures like binary tree, binary search, tree creation,', 'start': 21.033, 'duration': 8.727}, {'end': 35.465, 'text': 'traversal and implementation, followed by graph and hash tables, are also taught.', 'start': 29.76, 'duration': 5.705}, {'end': 41.71, 'text': 'Coming to the algorithmic part, we start with finding time and space complexity of algorithms.', 'start': 36.065, 'duration': 5.645}, {'end': 52.233, 'text': 'Searching and sorting concepts like binary search, linear search, incision sort and quick sort, with implementation using Python programming language,', 'start': 42.31, 'duration': 9.923}], 'summary': 'Teaches tree data structures, graph, hash tables, and algorithmic concepts including time and space complexity, searching, and sorting using python.', 'duration': 31.2, 'max_score': 21.033, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c21033.jpg'}, {'end': 203.25, 'src': 'embed', 'start': 172.595, 'weight': 1, 'content': [{'end': 181.606, 'text': 'So Python is a very good interactive programming language which also has its inbuilt and own kind of data structures in it.', 'start': 172.595, 'duration': 9.011}, {'end': 187.207, 'text': "So we'll be learning that with a tad bit of implementation and with simple examples.", 'start': 181.646, 'duration': 5.561}, {'end': 192.868, 'text': 'So followed by will be starting data structures first then algorithms.', 'start': 187.687, 'duration': 5.181}, {'end': 203.25, 'text': 'So arrays will be the first element, which will be learning, and then followed by stack and queue, and again will be learning regarding linked list,', 'start': 193.188, 'duration': 10.062}], 'summary': 'Learning python data structures: arrays, stack, queue, linked list.', 'duration': 30.655, 'max_score': 172.595, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c172595.jpg'}, {'end': 550.289, 'src': 'embed', 'start': 525.22, 'weight': 2, 'content': [{'end': 532.803, 'text': "you'll see that the built-in data structures, of course, apart from the int float string and all those you'll see list, dictionary, tuple and set,", 'start': 525.22, 'duration': 7.583}, {'end': 534.884, 'text': 'and then take a look at user defined data structures.', 'start': 532.803, 'duration': 2.081}, {'end': 536.404, 'text': 'user user defined data structures.', 'start': 534.884, 'duration': 1.52}, {'end': 543.066, 'text': "i've given you four on the screen right now, but you can have any number of user defined data structures for that programming language right.", 'start': 536.404, 'duration': 6.662}, {'end': 550.289, 'text': 'for example, python itself has a lot more than four, but these four happen to be so so popular that you guys have to know about them.', 'start': 543.066, 'duration': 7.223}], 'summary': 'Python has popular built-in data structures like list, dictionary, tuple, and set, along with numerous user-defined structures.', 'duration': 25.069, 'max_score': 525.22, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c525220.jpg'}, {'end': 763.518, 'src': 'embed', 'start': 739.801, 'weight': 3, 'content': [{'end': 747.627, 'text': 'Of course, with respect to dictionaries, all these key value pairs can be added, accessed, modified and removed as and when you choose.', 'start': 739.801, 'duration': 7.826}, {'end': 751.289, 'text': "That's a huge advantage here, right? Now take a look at the example on your screen.", 'start': 747.647, 'duration': 3.642}, {'end': 753.711, 'text': 'In fact, here we have a dictionary which contains of two items.', 'start': 751.349, 'duration': 2.362}, {'end': 757.434, 'text': "When I say two items, I'm meaning two key value pairs.", 'start': 753.971, 'duration': 3.463}, {'end': 760.576, 'text': "The first item that we're talking about is basically an apple.", 'start': 758.074, 'duration': 2.502}, {'end': 763.518, 'text': 'but the key associated with respect to Apple is first.', 'start': 760.956, 'duration': 2.562}], 'summary': "Dictionaries allow easy manipulation of key-value pairs, with the example showcasing two key-value pairs - 'apple' with key 'first'.", 'duration': 23.717, 'max_score': 739.801, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c739801.jpg'}], 'start': 0.149, 'title': 'Python data structures & algorithms', 'summary': 'Provides a beginner-friendly course on data structures and algorithms in python, covering basic concepts, types of data structures, algorithms, and programming approaches. it also offers an overview of python data structures, including built-in and user-defined types, lists, dictionaries, and other data structures, emphasizing their functionalities and applications. additionally, it delves into user-defined data structures such as queues, trees, and graphs, highlighting their applications and providing insights into potential interview questions.', 'chapters': [{'end': 407.97, 'start': 0.149, 'title': 'Learn data structures & algorithms', 'summary': 'Introduces a beginner-friendly course on data structures and algorithms in python, covering basic concepts, types of data structures, algorithms, programming approaches, and implementation using python, catering to various domains like data science, artificial intelligence, machine learning, and web development.', 'duration': 407.821, 'highlights': ['Data structures and algorithms in Python is a starter-friendly course covering basic concepts, types of data structures, algorithms, and programming approaches. It introduces learners to the fundamental concepts in data structures and algorithms, providing a strong foundation for further learning.', 'The course includes examples and implementation using Python programming language. The practical examples and implementation using Python programming language enhance the learning experience and application of concepts.', 'The course covers various data structures such as array, stack, queue, linked list, tree, graph, and hash tables. It provides a comprehensive understanding of different data structures, catering to a wide range of applications.', 'Algorithmic concepts such as time and space complexity, searching and sorting techniques, and programming approaches like divide and conquer, greedy method, and dynamic programming are included. The course covers essential algorithmic concepts and programming approaches, enabling learners to analyze and solve complex problems efficiently.']}, {'end': 689.675, 'start': 408.151, 'title': 'Python data structures overview', 'summary': 'Provides an overview of data structures in python, including the types of data that can be stored, the distinction between built-in and user-defined data structures, and a detailed explanation of lists and dictionaries, highlighting their key features and functionalities.', 'duration': 281.524, 'highlights': ['Python has built-in data structures like lists, dictionaries, tuples, and sets, as well as user-defined data structures for more complex data processing needs. Python has built-in data structures like lists, dictionaries, tuples, and sets, as well as user-defined data structures for more complex data processing needs.', 'Lists in Python provide an array-like structure with indexed positions for every element, accommodating integers, floating point numbers, and string data types. Lists in Python provide an array-like structure with indexed positions for every element, accommodating integers, floating point numbers, and string data types.', 'Dictionaries in Python work similarly to searching for words in a physical dictionary, allowing quick access to elements based on index positions and key-value pairs. Dictionaries in Python work similarly to searching for words in a physical dictionary, allowing quick access to elements based on index positions and key-value pairs.']}, {'end': 1085.409, 'start': 689.675, 'title': 'Python data structures', 'summary': 'Discusses python data structures including dictionaries, tuples, sets, and user-defined data structures, emphasizing their functionalities, immutability, and usage in python, with a notable focus on the principles of stacks and sets.', 'duration': 395.734, 'highlights': ['Dictionaries allow adding, accessing, modifying, and removing key-value pairs as needed, providing a significant advantage. Dictionaries enable the addition, access, modification, and removal of key-value pairs, offering flexibility in data manipulation.', 'Tuples are similar to lists but are immutable, restricting the addition or removal of elements during execution. Tuples operate similarly to lists but are immutable, prohibiting the addition or removal of elements during execution.', 'Sets ensure unique elements and do not allow repeated elements, offering access only to the unique elements present. Sets guarantee uniqueness and exclude repeated elements, allowing access solely to the unique elements within the set.', 'User-defined data structures, such as stacks, operate on the principle of last in, first out (LIFO), enabling data addition, removal, and access. User-defined data structures, like stacks, follow the last in, first out (LIFO) principle, facilitating data addition, removal, and access.']}, {'end': 1494.676, 'start': 1085.929, 'title': 'User-defined data structures and their applications', 'summary': 'Covers the concepts of queue, tree, graph data structures, and their applications, emphasizing the principles of fifo for queue, parent-child relationships in trees, and the usage of nodes and edges in graph data structure, with a mention of facebook as an example, and a hint at potential interview questions.', 'duration': 408.747, 'highlights': ['The chapter covers the concepts of queue, tree, graph data structures, and their applications It discusses the implementation and usage of user-defined data structures such as queue, tree, and graph in Python, offering practical insights into their applications.', "Emphasizing the principles of FIFO for queue Explains the 'First in, First out' principle of queues, highlighting that whoever comes first in the queue gets priority, illustrating its real-life application and usage.", 'Parent-child relationships in trees Describes the concept of parent-child relationships in tree data structures, illustrating how nodes are connected and the importance of leaf nodes in computation.', "The usage of nodes and edges in graph data structure, with a mention of Facebook as an example Details the structure of a graph data structure, explaining the role of nodes and edges, and provides a real-world example of its application in Facebook's network.", 'A hint at potential interview questions Alerts the audience about potential interview questions related to the discussed data structures, emphasizing the importance of understanding the concepts for technical interviews.']}], 'duration': 1494.527, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c149.jpg', 'highlights': ['The course covers various data structures such as array, stack, queue, linked list, tree, graph, and hash tables, providing a comprehensive understanding of different data structures.', 'The practical examples and implementation using Python programming language enhance the learning experience and application of concepts.', 'Python has built-in data structures like lists, dictionaries, tuples, and sets, as well as user-defined data structures for more complex data processing needs.', 'Dictionaries enable the addition, access, modification, and removal of key-value pairs, offering flexibility in data manipulation.', 'The chapter covers the concepts of queue, tree, graph data structures, and their applications, offering practical insights into their applications.', 'The course covers essential algorithmic concepts and programming approaches, enabling learners to analyze and solve complex problems efficiently.']}, {'end': 3480.563, 'segs': [{'end': 1540.535, 'src': 'embed', 'start': 1514.217, 'weight': 0, 'content': [{'end': 1520.5, 'text': 'As in, we just saw how we can work with lists, how we can work with sets and all of those, right? We have a valid syntax to use that.', 'start': 1514.217, 'duration': 6.283}, {'end': 1526.725, 'text': 'But to implement linked list in terms of Python, you actually do not have it in the standard library.', 'start': 1521.04, 'duration': 5.685}, {'end': 1533.39, 'text': 'So you have to use functions, you have to use other lists, and you have to use manual logic to actually implement a linked list.', 'start': 1526.745, 'duration': 6.645}, {'end': 1535.191, 'text': 'First of all, what is a linked list?', 'start': 1533.71, 'duration': 1.481}, {'end': 1540.535, 'text': 'Well, a linked list is basically a connection of elements tied up in a chain structure.', 'start': 1535.552, 'duration': 4.983}], 'summary': 'Python does not have linked list in its standard library. linked list is a chain structure of elements.', 'duration': 26.318, 'max_score': 1514.217, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c1514217.jpg'}, {'end': 1565.643, 'src': 'embed', 'start': 1545.399, 'weight': 1, 'content': [{'end': 1555.391, 'text': 'A linked list is basically a sequence of elements that are connected to each other in a way where you can move around and access one or the other element as and when required.', 'start': 1545.399, 'duration': 9.992}, {'end': 1559.856, 'text': 'Now, if I have three elements that you can see on your screen, right? 5, 10 and 20.', 'start': 1555.892, 'duration': 3.964}, {'end': 1565.643, 'text': 'How do I even know that the location that holds the value 5 is able to talk to the value 10?', 'start': 1559.856, 'duration': 5.787}], 'summary': 'A linked list is a sequence of elements connected to access and move around, e.g., 5, 10, and 20.', 'duration': 20.244, 'max_score': 1545.399, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c1545399.jpg'}, {'end': 1745.857, 'src': 'embed', 'start': 1715.945, 'weight': 2, 'content': [{'end': 1718.788, 'text': 'So curious Jason tells us that tuples are immutable.', 'start': 1715.945, 'duration': 2.843}, {'end': 1722.79, 'text': 'Now, what does he mean when he states that tuples are immutable?', 'start': 1719.449, 'duration': 3.341}, {'end': 1729.392, 'text': "So, basically, when you go ahead and create a tuple, so let's say you add five elements inside one tuple.", 'start': 1723.19, 'duration': 6.202}, {'end': 1734.053, 'text': "Now, you can't change or modify the tuple which you have created.", 'start': 1729.912, 'duration': 4.141}, {'end': 1741.916, 'text': "So that would basically mean that let's say, if you have five elements, then you can't change the value of the second element or the third element,", 'start': 1734.534, 'duration': 7.382}, {'end': 1745.857, 'text': "or you can't add another element inside the tuple which you have already created.", 'start': 1741.916, 'duration': 3.941}], 'summary': 'Tuples are immutable, meaning the values and size cannot be changed after creation.', 'duration': 29.912, 'max_score': 1715.945, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c1715945.jpg'}, {'end': 1927.876, 'src': 'embed', 'start': 1900.721, 'weight': 3, 'content': [{'end': 1905.083, 'text': 'the only difference is lists are mutable while tuples are immutable.', 'start': 1900.721, 'duration': 4.362}, {'end': 1908.124, 'text': 'now, what do i mean when i say lists are mutable?', 'start': 1905.083, 'duration': 3.041}, {'end': 1912.086, 'text': 'so this means that lists can be changed once they are created.', 'start': 1908.124, 'duration': 3.962}, {'end': 1914.108, 'text': 'so there are five elements in a list.', 'start': 1912.086, 'duration': 2.022}, {'end': 1917.389, 'text': 'so the second element or the third element can be modified.', 'start': 1914.108, 'duration': 3.281}, {'end': 1922.372, 'text': "and again, since i've said that there are five elements, so another five elements can be added inside this list.", 'start': 1917.389, 'duration': 4.983}, {'end': 1927.876, 'text': 'so this is the basic difference between lists and tuples, and this is how you can create a list.', 'start': 1922.972, 'duration': 4.904}], 'summary': 'Lists are mutable, allowing modification and addition of elements, unlike tuples which are immutable.', 'duration': 27.155, 'max_score': 1900.721, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c1900721.jpg'}, {'end': 2109.924, 'src': 'embed', 'start': 2079.215, 'weight': 4, 'content': [{'end': 2082.078, 'text': "Now let's head on to the next data structure, which is a dictionary.", 'start': 2079.215, 'duration': 2.863}, {'end': 2088.485, 'text': 'So dictionary is actually quite different than a list and a tuple because it consists of key value pairs.', 'start': 2082.478, 'duration': 6.007}, {'end': 2094.13, 'text': 'And these are actually unordered collection of key value pairs, which are enclosed within curly braces.', 'start': 2088.725, 'duration': 5.405}, {'end': 2096.112, 'text': 'And again, dictionaries are mutable.', 'start': 2094.431, 'duration': 1.681}, {'end': 2098.215, 'text': 'So this is how you can create a dictionary.', 'start': 2096.473, 'duration': 1.742}, {'end': 2100.637, 'text': "So, you'll put in curly braces over here.", 'start': 2098.775, 'duration': 1.862}, {'end': 2101.878, 'text': "So, first you'll put in the key.", 'start': 2100.657, 'duration': 1.221}, {'end': 2106.041, 'text': "So, over here the key is apple and then you'll give in a colon and then you'll give in the value.", 'start': 2102.058, 'duration': 3.983}, {'end': 2109.924, 'text': 'So, for the key apple, the value is 10.', 'start': 2106.481, 'duration': 3.443}], 'summary': "Dictionaries are unordered key-value pairs enclosed in curly braces and are mutable. example: {'apple': 10}", 'duration': 30.709, 'max_score': 2079.215, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c2079215.jpg'}, {'end': 2270.734, 'src': 'embed', 'start': 2244.46, 'weight': 5, 'content': [{'end': 2248.662, 'text': 'And also another thing to be noted is sets do not allow duplicate values.', 'start': 2244.46, 'duration': 4.202}, {'end': 2253.405, 'text': "So let's say if you add a value 10, then you cannot add the same value again.", 'start': 2248.982, 'duration': 4.423}, {'end': 2257.227, 'text': 'So it will take the value only once, and this is how you can create a set.', 'start': 2253.465, 'duration': 3.762}, {'end': 2261.829, 'text': "So you'll have curly braces over here, and then you'll given all of the elements inside it.", 'start': 2257.707, 'duration': 4.122}, {'end': 2264.771, 'text': 'So let me create my final data structure over here.', 'start': 2262.45, 'duration': 2.321}, {'end': 2270.734, 'text': "So I'll type in one E and then I'll given a floating point value.", 'start': 2265.531, 'duration': 5.203}], 'summary': 'Sets do not allow duplicates; values are added only once.', 'duration': 26.274, 'max_score': 2244.46, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c2244460.jpg'}, {'end': 2349.892, 'src': 'embed', 'start': 2324.113, 'weight': 6, 'content': [{'end': 2329.255, 'text': "if i want to add more than one element at a single time, then we've got this update method.", 'start': 2324.113, 'duration': 5.142}, {'end': 2333.556, 'text': "so i'll type in s1.update, and i'll give it a list of values.", 'start': 2329.255, 'duration': 4.301}, {'end': 2340.299, 'text': "so i'll type in, let's say, sparta and then i'll type in 123.", 'start': 2333.556, 'duration': 6.743}, {'end': 2342.96, 'text': "then i'll give in, let's say, 3 plus 9j.", 'start': 2340.299, 'duration': 2.661}, {'end': 2348.131, 'text': 'Then let me print out S1, right?', 'start': 2345.709, 'duration': 2.422}, {'end': 2349.892, 'text': 'So all of these elements have been added.', 'start': 2348.271, 'duration': 1.621}], 'summary': "The update method allows adding multiple elements at once to a set, as demonstrated by adding 'sparta', 123, and 3+9j to set s1.", 'duration': 25.779, 'max_score': 2324.113, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c2324113.jpg'}, {'end': 2403.141, 'src': 'embed', 'start': 2373.911, 'weight': 7, 'content': [{'end': 2376.372, 'text': 'So what is an array? It is a linear data structure.', 'start': 2373.911, 'duration': 2.461}, {'end': 2381.714, 'text': 'That means elements will be stored in a linear fashion, right? Linear fashion.', 'start': 2376.692, 'duration': 5.022}, {'end': 2385.656, 'text': "Now, if you talk about array, let's take an example.", 'start': 2382.474, 'duration': 3.182}, {'end': 2390.437, 'text': "Now, let's consider that this is how you represent an array in the form of a row right?", 'start': 2385.676, 'duration': 4.761}, {'end': 2394.099, 'text': "And let's suppose it contains elements 1,, 2, 3, and 4, right?", 'start': 2390.958, 'duration': 3.141}, {'end': 2398.5, 'text': 'Now, with every memory location there will be some address, right?', 'start': 2394.979, 'duration': 3.521}, {'end': 2403.141, 'text': "So let's suppose these are the four elements right? 1, 2, 3, and 4..", 'start': 2398.761, 'duration': 4.38}], 'summary': 'An array is a linear data structure storing elements in a linear fashion with memory addresses, illustrated using an example of 1, 2, 3, 4.', 'duration': 29.23, 'max_score': 2373.911, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c2373911.jpg'}, {'end': 2697.678, 'src': 'embed', 'start': 2668.459, 'weight': 8, 'content': [{'end': 2674.204, 'text': 'Now, the data type or the type of data that you can store in this array will be homogeneous.', 'start': 2668.459, 'duration': 5.745}, {'end': 2678.808, 'text': 'That means you can only store similar elements, okay?', 'start': 2674.244, 'duration': 4.564}, {'end': 2686.416, 'text': 'so these are some facts, and this is how array works.', 'start': 2681.095, 'duration': 5.321}, {'end': 2687.556, 'text': 'and what are the addresses?', 'start': 2686.416, 'duration': 1.14}, {'end': 2688.917, 'text': 'what are the indexes?', 'start': 2687.556, 'duration': 1.361}, {'end': 2690.597, 'text': 'can you store different elements?', 'start': 2688.917, 'duration': 1.68}, {'end': 2694.618, 'text': 'no, you can only store similar elements in the array.', 'start': 2690.597, 'duration': 4.021}, {'end': 2697.678, 'text': "now let's talk about the applications of array.", 'start': 2694.618, 'duration': 3.06}], 'summary': 'Array stores homogeneous data, has indexes, and has specific applications.', 'duration': 29.219, 'max_score': 2668.459, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c2668459.jpg'}, {'end': 2764.983, 'src': 'embed', 'start': 2738.957, 'weight': 9, 'content': [{'end': 2743.443, 'text': 'So if you want to store your data in a linear fashion, you can use arrays, okay?', 'start': 2738.957, 'duration': 4.486}, {'end': 2751.735, 'text': 'Now, it is also suitable for the scenarios wherein you require frequent searching, right?', 'start': 2743.683, 'duration': 8.052}, {'end': 2757.538, 'text': 'If you want to search an element in an array, you can directly go and access these indexes one by one, right?', 'start': 2751.815, 'duration': 5.723}, {'end': 2759.639, 'text': 'So, in a linear fashion, you will access okay.', 'start': 2757.838, 'duration': 1.801}, {'end': 2761, 'text': "is this the element that you're looking for??", 'start': 2759.639, 'duration': 1.361}, {'end': 2761.22, 'text': 'No,', 'start': 2761.04, 'duration': 0.18}, {'end': 2763.122, 'text': "Is 20 the element that you're looking for? No.", 'start': 2761.3, 'duration': 1.822}, {'end': 2764.983, 'text': "Is 30 the element that you're looking for? No.", 'start': 2763.202, 'duration': 1.781}], 'summary': 'Arrays are suitable for linear data storage and frequent searching. example: searching for elements like 20 and 30.', 'duration': 26.026, 'max_score': 2738.957, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c2738957.jpg'}, {'end': 3182.548, 'src': 'embed', 'start': 3153.958, 'weight': 11, 'content': [{'end': 3156.46, 'text': "Now, let's suppose you are using three subscripts right?", 'start': 3153.958, 'duration': 2.502}, {'end': 3160.884, 'text': 'So similar to like this three, three and three, okay?', 'start': 3157.181, 'duration': 3.703}, {'end': 3162.885, 'text': 'So this time around, this is a 3D array.', 'start': 3161.124, 'duration': 1.761}, {'end': 3169.11, 'text': 'And similarly, you can have multidimensional array, right? And you just need to keep on adding the subscripts.', 'start': 3163.145, 'duration': 5.965}, {'end': 3172.854, 'text': "That's it, okay? Now we should learn regarding array implementation.", 'start': 3169.13, 'duration': 3.724}, {'end': 3175.858, 'text': 'We are solving three different problem statements here.', 'start': 3173.695, 'duration': 2.163}, {'end': 3178.923, 'text': 'The first one is we are creating one-dimensional array.', 'start': 3176.079, 'duration': 2.844}, {'end': 3182.548, 'text': 'It is very simple and people can understand it in very easy way.', 'start': 3178.963, 'duration': 3.585}], 'summary': 'Learning about 3d arrays and multidimensional arrays, with a focus on array implementation and solving three problem statements.', 'duration': 28.59, 'max_score': 3153.958, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c3153958.jpg'}, {'end': 3273.631, 'src': 'embed', 'start': 3246.263, 'weight': 10, 'content': [{'end': 3253.365, 'text': "So now we'll come to this IDE and we'll type one-dimensional array example,", 'start': 3246.263, 'duration': 7.102}, {'end': 3258.427, 'text': 'where you are including array size and you are asking the user what are the different inputs,', 'start': 3253.365, 'duration': 5.062}, {'end': 3262.848, 'text': 'and then we are presenting the same inputs received by the user on the output screen.', 'start': 3258.427, 'duration': 4.421}, {'end': 3267.37, 'text': "So to quickly save the time, I'm just putting up the code now.", 'start': 3263.169, 'duration': 4.201}, {'end': 3273.631, 'text': "So this is the Python code where we'll be using for one-dimensional array.", 'start': 3268.908, 'duration': 4.723}], 'summary': 'Python code for one-dimensional array input and output.', 'duration': 27.368, 'max_score': 3246.263, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c3246263.jpg'}, {'end': 3427.392, 'src': 'embed', 'start': 3400.171, 'weight': 12, 'content': [{'end': 3410.718, 'text': 'So we are going to create two dimensional integer array where you can insert row number and column number and it will fill up the elements inside the array accordingly.', 'start': 3400.171, 'duration': 10.547}, {'end': 3417.964, 'text': "so let's quickly switch on to the ide that's google collab and check out how does 2d array work in python.", 'start': 3410.718, 'duration': 7.246}, {'end': 3427.392, 'text': 'so here i have named this particular file as 2d array and you can name it whatever you want and m putting up the code here.', 'start': 3417.964, 'duration': 9.428}], 'summary': 'Creating a 2d integer array in python using google colab.', 'duration': 27.221, 'max_score': 3400.171, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c3400171.jpg'}], 'start': 1495.016, 'title': 'Python data structures', 'summary': 'Covers linked lists, data structures like tuples, lists, dictionaries, sets, arrays, and 2d arrays, with emphasis on their properties, differences, and implementations in python. it also explains the importance of linked lists, the immutability of tuples, the mutability of lists, and the properties of sets such as being unordered, unindexed, and not allowing duplicate values. additionally, it provides detailed explanations and code demonstrations for array implementation in python, suitable for applications requiring frequent searching.', 'chapters': [{'end': 1695.088, 'start': 1495.016, 'title': 'Linked lists in python', 'summary': "Covers the concept of linked lists, including its definition, implementation in python, and its importance, emphasizing that it is a crucial data structure used by professionals and is not a native support in python's standard library.", 'duration': 200.072, 'highlights': ['Linked list is a sequence of elements that are connected to each other, and its implementation in Python requires manual logic and use of functions, without native support in the standard library. Linked list is a sequence of elements that are connected to each other, and its implementation in Python requires manual logic and use of functions, without native support in the standard library.', 'Pointers are used in linked lists, serving as an addressing system to connect elements, and there are multiple types of linked lists such as single linked list, doubly linked list, and circular linked list. Pointers are used in linked lists, serving as an addressing system to connect elements, and there are multiple types of linked lists such as single linked list, doubly linked list, and circular linked list.', 'Linked lists are not super popular in Python due to the availability of other data structures, and the implementation of linked lists must be done manually, even though it is a crucial data structure used by professionals. Linked lists are not super popular in Python due to the availability of other data structures, and the implementation of linked lists must be done manually, even though it is a crucial data structure used by professionals.']}, {'end': 2222.155, 'start': 1695.308, 'title': 'Data structures and their properties', 'summary': 'Provides an overview of tuples, lists, and dictionaries, emphasizing their properties and differences, including immutability of tuples, mutability of lists, and the key-value pairs in dictionaries, with examples and code demonstrations.', 'duration': 526.847, 'highlights': ['Tuples are immutable, meaning the values within a tuple cannot be changed or modified once the tuple is created. Tuples are immutable and do not support item assignment or addition of new elements, making them a heterogeneous data structure.', 'Lists are mutable, allowing for modification of existing elements and addition of new elements after creation. Lists are mutable, enabling the modification of elements and addition of new elements, demonstrated through code examples.', 'Dictionaries consist of key-value pairs and are mutable, enabling the modification of values associated with keys. Dictionaries are unordered collections of key-value pairs enclosed within curly braces, allowing modification and access to keys and values, illustrated through practical examples.']}, {'end': 2738.676, 'start': 2223.216, 'title': 'Python data structures: set and array', 'summary': 'Covers the set data structure, emphasizing its properties such as being unordered, unindexed, and not allowing duplicate values. it then delves into the array data structure, detailing its linear storage of elements, contiguous memory allocation, and the requirement for storing homogeneous elements.', 'duration': 515.46, 'highlights': ['Sets do not allow duplicate values and are unordered and unindexed Sets in Python do not allow duplicate values, are unordered, and unindexed, making access to elements based on indexing impossible.', 'Demonstration of adding elements to a set and the use of update method to add multiple elements at once The demonstration showcases the addition of elements to a set, with the update method used to add multiple elements at once, exemplifying the behavior of sets in accepting only unique values.', 'Introduction to array as a linear data structure with elements stored in a contiguous fashion The introduction of arrays as a linear data structure emphasizes the storage of elements in a contiguous fashion, optimizing memory utilization and efficient access to elements.', 'Explanation of the need for storing homogeneous elements in an array The explanation emphasizes the requirement for storing homogeneous elements in an array, highlighting the limitation of an array to store only similar data types.']}, {'end': 3114.09, 'start': 2738.957, 'title': 'Arrays and 2d arrays', 'summary': 'Explains the concept of one-dimensional array and its initialization, followed by the concept of two-dimensional arrays, with detailed explanation and indexing method, suitable for applications requiring frequent searching.', 'duration': 375.133, 'highlights': ['The chapter explains the concept of two-dimensional arrays, with detailed explanation and indexing method, suitable for applications requiring frequent searching.', 'The concept of one-dimensional array and its initialization is detailed, including the representation and addressing of elements in a continuous memory location.', 'The chapter emphasizes the suitability of arrays for scenarios requiring frequent searching and accessing elements linearly.', 'The explanation includes the detailed process of accessing elements in an array for searching, exemplifying the linear fashion of access.']}, {'end': 3480.563, 'start': 3114.09, 'title': 'Array implementation in python', 'summary': 'Covers the implementation of one-dimensional and two-dimensional arrays in python, including creating, inserting, and displaying elements, as well as explaining the concept of multidimensional arrays, such as 2d and 3d arrays, and their applications.', 'duration': 366.473, 'highlights': ['The chapter covers the implementation of one-dimensional and two-dimensional arrays in Python, including creating, inserting, and displaying elements. It includes explaining the code for creating and inserting elements in a one-dimensional array and displaying the input and output.', 'Explaining the concept of multidimensional arrays, such as 2D and 3D arrays, and their applications. The chapter explains the concept of multidimensional arrays, including 2D and 3D arrays, and their various applications.', 'Describing the code for creating and inserting elements in a two-dimensional array, based on user input for row and column numbers. The transcript explains the code for creating and inserting elements in a two-dimensional array, taking user input for the number of rows and columns.']}], 'duration': 1985.547, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c1495016.jpg', 'highlights': ['Linked list is a sequence of elements connected manually in Python, without native support.', 'Pointers are used in linked lists, serving as an addressing system to connect elements.', 'Tuples are immutable, values cannot be changed or modified once created.', 'Lists are mutable, allowing modification of existing elements and addition of new elements.', 'Dictionaries consist of key-value pairs and are mutable, enabling modification of values.', 'Sets do not allow duplicate values, are unordered and unindexed.', 'Demonstration of adding elements to a set and the use of update method to add multiple elements at once.', 'Introduction to array as a linear data structure with elements stored in a contiguous fashion.', 'Explanation of the need for storing homogeneous elements in an array.', 'The chapter explains the concept of two-dimensional arrays, suitable for frequent searching.', 'The chapter covers the implementation of one-dimensional and two-dimensional arrays in Python.', 'Explaining the concept of multidimensional arrays, such as 2D and 3D arrays, and their applications.', 'Describing the code for creating and inserting elements in a two-dimensional array.']}, {'end': 5507.158, 'segs': [{'end': 3715.02, 'src': 'embed', 'start': 3680.869, 'weight': 3, 'content': [{'end': 3682.871, 'text': 'So, let us quickly see the output now.', 'start': 3680.869, 'duration': 2.002}, {'end': 3687.653, 'text': "So it is asking for array size, I'm giving three.", 'start': 3685.37, 'duration': 2.283}, {'end': 3693.1, 'text': "I'll enter, then entering all the three numbers what I want to give.", 'start': 3687.673, 'duration': 5.427}, {'end': 3701.512, 'text': "Okay, it will ask you which value to be deleted, right? I'm giving value five.", 'start': 3696.385, 'duration': 5.127}, {'end': 3706.157, 'text': 'So the new array is without 5 that is 4 and 6.', 'start': 3702.816, 'duration': 3.341}, {'end': 3715.02, 'text': "So this is how it will work and immediately I'll show you if you give any element which is out of the array bound how it will give you an error.", 'start': 3706.157, 'duration': 8.863}], 'summary': 'Demonstrating array manipulation with input and error handling.', 'duration': 34.151, 'max_score': 3680.869, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c3680869.jpg'}, {'end': 3901.814, 'src': 'embed', 'start': 3873.296, 'weight': 2, 'content': [{'end': 3878.64, 'text': 'So, this is a simple example to know how sorting will happen in Python.', 'start': 3873.296, 'duration': 5.344}, {'end': 3883.694, 'text': 'Now we shall see how do you search an element inside an array.', 'start': 3879.289, 'duration': 4.405}, {'end': 3886.838, 'text': "So here I'll try to put up occurrence as well.", 'start': 3884.015, 'duration': 2.823}, {'end': 3891.604, 'text': "So let's quickly search and see elements in an array in Python ID.", 'start': 3887.198, 'duration': 4.406}, {'end': 3901.814, 'text': 'Okay, so this is the code in order to search the element also find the occurrence of it, right? So here, this is the array set.', 'start': 3892.124, 'duration': 9.69}], 'summary': 'Demonstrating sorting and searching in python arrays.', 'duration': 28.518, 'max_score': 3873.296, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c3873296.jpg'}, {'end': 4040.524, 'src': 'embed', 'start': 4007.677, 'weight': 0, 'content': [{'end': 4012.141, 'text': 'So, it is easy for us to access any element with the help of this index.', 'start': 4007.677, 'duration': 4.464}, {'end': 4017.766, 'text': 'If you want to access the third element, you can directly go ahead and say ar in the 1D array.', 'start': 4012.501, 'duration': 5.265}, {'end': 4021.128, 'text': 'So, you can directly access elements with the help of indexing.', 'start': 4018.006, 'duration': 3.122}, {'end': 4024.071, 'text': 'Similarly, it is easy for us to iterate through it.', 'start': 4021.429, 'duration': 2.642}, {'end': 4030.276, 'text': 'With the help of one for loop, we can iterate through all the elements one by one that are there in the array.', 'start': 4024.511, 'duration': 5.765}, {'end': 4040.524, 'text': 'and similarly, if you want to do the sorting, we can go ahead and easily iterate through one, uh, these elements one by one and look for an element.', 'start': 4031.497, 'duration': 9.027}], 'summary': 'Access and iterate through elements in a 1d array using indexing and for loops.', 'duration': 32.847, 'max_score': 4007.677, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c4007677.jpg'}, {'end': 4193.859, 'src': 'embed', 'start': 4167.121, 'weight': 1, 'content': [{'end': 4171.203, 'text': 'so it is the replacement of multiple variables.', 'start': 4167.121, 'duration': 4.082}, {'end': 4174.327, 'text': 'so this is what it means.', 'start': 4171.203, 'duration': 3.124}, {'end': 4177.83, 'text': "now let's clear the screen and now let's talk about disadvantages.", 'start': 4174.327, 'duration': 3.503}, {'end': 4182.478, 'text': "there's one disadvantage that can be easily noticed is the size.", 'start': 4178.176, 'duration': 4.302}, {'end': 4189.279, 'text': "now, obviously, when you're talking about 1d array, right the size or any array, right the size is there right.", 'start': 4182.478, 'duration': 6.801}, {'end': 4192.06, 'text': 'so you, you cannot exceed the size.', 'start': 4189.279, 'duration': 2.781}, {'end': 4193.859, 'text': 'the elements cannot exceed this.', 'start': 4192.06, 'duration': 1.799}], 'summary': 'Discussing the disadvantages of array, one being its size limitation.', 'duration': 26.738, 'max_score': 4167.121, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c4167121.jpg'}, {'end': 4385.38, 'src': 'embed', 'start': 4359.96, 'weight': 4, 'content': [{'end': 4366.845, 'text': 'and at last, stack implementation can be done through list, through collections and through queue.', 'start': 4359.96, 'duration': 6.885}, {'end': 4369.567, 'text': 'we will discuss these ways in detail.', 'start': 4366.845, 'duration': 2.722}, {'end': 4371.489, 'text': "now let's see the concept of stack.", 'start': 4369.567, 'duration': 1.922}, {'end': 4372.71, 'text': 'now coming to the stack.', 'start': 4371.489, 'duration': 1.221}, {'end': 4376.793, 'text': 'stack is a linear data structure which follows last in first out order.', 'start': 4372.71, 'duration': 4.083}, {'end': 4385.38, 'text': 'that means the element which are inserted at last will be removed first, that is, before order, last in first out.', 'start': 4376.793, 'duration': 8.587}], 'summary': 'Stack implementation can be done through list, collections, and queue. it follows last in first out order.', 'duration': 25.42, 'max_score': 4359.96, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c4359960.jpg'}, {'end': 4717.237, 'src': 'embed', 'start': 4690.081, 'weight': 5, 'content': [{'end': 4693.203, 'text': 'So, empty function returns true for an empty stack.', 'start': 4690.081, 'duration': 3.122}, {'end': 4700.128, 'text': 'So, if this is a stack and if this stack is empty, then the empty function will return as true.', 'start': 4693.543, 'duration': 6.585}, {'end': 4707.113, 'text': 'Right? So, this was the basic idea about functions in stack and what will be the time complexity for each function.', 'start': 4700.629, 'duration': 6.484}, {'end': 4711.411, 'text': 'So, here the time complexity for each functions will be O of 1.', 'start': 4707.494, 'duration': 3.917}, {'end': 4713.553, 'text': 'for push, pop, size, stop and empty.', 'start': 4711.411, 'duration': 2.142}, {'end': 4717.237, 'text': 'So, for every function time complexity will be big of 1.', 'start': 4714.114, 'duration': 3.123}], 'summary': 'Functions in stack have o(1) time complexity for push, pop, size, top, and empty.', 'duration': 27.156, 'max_score': 4690.081, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c4690081.jpg'}, {'end': 4763.094, 'src': 'embed', 'start': 4732.491, 'weight': 6, 'content': [{'end': 4735.714, 'text': 'So, these are some ways from which we can implement stack in Python.', 'start': 4732.491, 'duration': 3.223}, {'end': 4738.089, 'text': "So, now let's see the implementation using list.", 'start': 4736.089, 'duration': 2}, {'end': 4742.27, 'text': 'So, in implementation using list, list in Python can be used as a stack.', 'start': 4738.369, 'duration': 3.901}, {'end': 4744.911, 'text': 'So, we can use list as a stack in Python.', 'start': 4742.63, 'duration': 2.281}, {'end': 4747.631, 'text': 'So, in Python, we are having append and pop function.', 'start': 4745.351, 'duration': 2.28}, {'end': 4749.751, 'text': "We don't have any push function in Python.", 'start': 4747.911, 'duration': 1.84}, {'end': 4755.672, 'text': 'So, if you want to insert the element, we need some function, right? So, we can use the append function which is used to insert the element.', 'start': 4749.791, 'duration': 5.881}, {'end': 4763.094, 'text': 'Now, coming to the pop function, yeah, we are having pop function in Python and pop removes the element in the lefo order.', 'start': 4755.972, 'duration': 7.122}], 'summary': 'Implementation of stack in python using list with append and pop functions.', 'duration': 30.603, 'max_score': 4732.491, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c4732491.jpg'}, {'end': 5442.937, 'src': 'heatmap', 'start': 5148.479, 'weight': 0.868, 'content': [{'end': 5160.129, 'text': "Let's suppose Z and once again, if I'm executing so, I will write here print stack and on execution, you can see that I'm getting XYZ.", 'start': 5148.479, 'duration': 11.65}, {'end': 5162.21, 'text': "Now let's perform pop operation.", 'start': 5160.569, 'duration': 1.641}, {'end': 5171.998, 'text': "So I'll write here stack dot pop and let me put inside this into the print function.", 'start': 5162.471, 'duration': 9.527}, {'end': 5179.188, 'text': "So as we know that if I'm writing here stack dot pop So, the last element which was inserted will remove first.", 'start': 5174.02, 'duration': 5.168}, {'end': 5180.609, 'text': 'So, Z will be removed here.', 'start': 5179.488, 'duration': 1.121}, {'end': 5184.231, 'text': 'So, you can see that Z has been removed.', 'start': 5181.489, 'duration': 2.742}, {'end': 5185.892, 'text': 'Now, if I am printing my stack.', 'start': 5184.411, 'duration': 1.481}, {'end': 5190.994, 'text': 'So, I am getting here only X and Y.', 'start': 5188.733, 'duration': 2.261}, {'end': 5193.115, 'text': 'So, you can see that List and Dequeue are the same.', 'start': 5190.994, 'duration': 2.121}, {'end': 5195.296, 'text': 'The only difference is that Dequeue is faster.', 'start': 5193.195, 'duration': 2.101}, {'end': 5199.038, 'text': 'Because the append and pop operations are faster in Dequeue.', 'start': 5195.656, 'duration': 3.382}, {'end': 5203.04, 'text': 'So, this was the basic idea about the stack implementation using Dequeue.', 'start': 5199.638, 'duration': 3.402}, {'end': 5205.574, 'text': "Now let's see the stack implementation using queue.", 'start': 5203.393, 'duration': 2.181}, {'end': 5211.276, 'text': 'So here in implementation using queue, queue module contains the lefo queue that means last in first out.', 'start': 5205.734, 'duration': 5.542}, {'end': 5216.518, 'text': 'So here basically what happens here it works same as the stack but it is having some additional functions.', 'start': 5211.576, 'duration': 4.942}, {'end': 5220.659, 'text': 'So it is having some additional functions and works same as a stack right.', 'start': 5216.938, 'duration': 3.721}, {'end': 5227.441, 'text': 'Now we have seen that in list as well as in dequeue we were using pop as well as append operation right.', 'start': 5221.179, 'duration': 6.262}, {'end': 5230.842, 'text': 'But here to insert the element we will be using put operation.', 'start': 5227.601, 'duration': 3.241}, {'end': 5235.853, 'text': "So if I'm writing here put of three, then that means it will insert 3 in my stack.", 'start': 5230.882, 'duration': 4.971}, {'end': 5238.035, 'text': "so similarly, if I'm writing here, get function.", 'start': 5235.853, 'duration': 2.182}, {'end': 5244.74, 'text': 'so it will remove the element and as I told you that it works same as the stack, so the last element will be removed first.', 'start': 5238.035, 'duration': 6.705}, {'end': 5248.222, 'text': 'here. now we are having some functions available in the queue module.', 'start': 5244.74, 'duration': 3.482}, {'end': 5249.943, 'text': 'so the first function that is get.', 'start': 5248.222, 'duration': 1.721}, {'end': 5253.566, 'text': 'so, as I already told you, in get function it is used to remove the element.', 'start': 5249.943, 'duration': 3.623}, {'end': 5255.527, 'text': 'now coming to the max size.', 'start': 5253.566, 'duration': 1.961}, {'end': 5259.99, 'text': 'so here max size means the number of maximum elements that are present in the queue.', 'start': 5255.527, 'duration': 4.463}, {'end': 5262.212, 'text': 'coming to the next function, we are having empty function.', 'start': 5259.99, 'duration': 2.222}, {'end': 5269.48, 'text': 'so if a queue is empty then it will return true or else in other case it will return false, next full.', 'start': 5262.637, 'duration': 6.843}, {'end': 5273.381, 'text': 'so whenever the queue is full it will give us true.', 'start': 5269.48, 'duration': 3.901}, {'end': 5279.344, 'text': 'similarly, put, i have already discussed about the put that if you are inserting any element, so you can write the put and suppose,', 'start': 5273.381, 'duration': 5.963}, {'end': 5283.646, 'text': 'if i am inserting here too, so it will insert two in a queue.', 'start': 5279.344, 'duration': 4.302}, {'end': 5285.086, 'text': 'now queue size.', 'start': 5283.646, 'duration': 1.44}, {'end': 5287.807, 'text': 'so queue size will give me the size of a queue.', 'start': 5285.086, 'duration': 2.721}, {'end': 5293.207, 'text': "so let's suppose that if you are having a three elements that are inserted in queue three, two, four.", 'start': 5287.807, 'duration': 5.4}, {'end': 5295.568, 'text': 'so what will be the size of the queue.', 'start': 5293.207, 'duration': 2.361}, {'end': 5296.888, 'text': 'queue size will be three.', 'start': 5295.568, 'duration': 1.32}, {'end': 5298.268, 'text': 'now coming to the logic.', 'start': 5296.888, 'duration': 1.38}, {'end': 5301.189, 'text': 'so how can i import leafo queue through the queue module?', 'start': 5298.268, 'duration': 2.921}, {'end': 5313.452, 'text': 'so i will write here from queue and then i will write here import and i will write here leafo and then i will write here queue.', 'start': 5301.189, 'duration': 12.263}, {'end': 5317.913, 'text': 'after that, as i told you that stack can be implemented through the queue module.', 'start': 5313.452, 'duration': 4.461}, {'end': 5322.648, 'text': 'so i will create a stack variable here and I will assign here lefoq.', 'start': 5317.913, 'duration': 4.735}, {'end': 5327.17, 'text': 'so I will write here lefoq.', 'start': 5322.648, 'duration': 4.522}, {'end': 5336.132, 'text': 'and now, if I am writing here stack.put, and if I am writing 2, so this means I am inserting the value 2 in stack.', 'start': 5327.17, 'duration': 8.962}, {'end': 5343.974, 'text': 'similarly, if I am writing here stack.get, so that means I am removing the value from the stack.', 'start': 5336.132, 'duration': 7.842}, {'end': 5345.355, 'text': 'so this is the basic idea.', 'start': 5343.974, 'duration': 1.381}, {'end': 5348.816, 'text': 'now we will see all these functions in the practical coding example.', 'start': 5345.355, 'duration': 3.461}, {'end': 5350.156, 'text': "so let's start with the coding part.", 'start': 5348.816, 'duration': 1.34}, {'end': 5363.755, 'text': 'I will write here comment and inside this comment I will write here implementation using queue.', 'start': 5350.612, 'duration': 13.143}, {'end': 5365.956, 'text': 'now, after this, what I have to do?', 'start': 5363.755, 'duration': 2.201}, {'end': 5368.897, 'text': 'I have to import lefoq from the queue module.', 'start': 5365.956, 'duration': 2.941}, {'end': 5369.837, 'text': 'so what I will write here?', 'start': 5368.897, 'duration': 0.94}, {'end': 5388.135, 'text': 'I will write from queue import lefoq and I will create a variable stack and I will write now leave for queue.', 'start': 5369.837, 'duration': 18.298}, {'end': 5396.221, 'text': 'so after creating stack variable, as I told you that if I want to insert the element in a queue, then I have to use the put function right.', 'start': 5388.135, 'duration': 8.086}, {'end': 5402.946, 'text': "so I will write here stack dot, put and I will insert here let's suppose 2.", 'start': 5396.221, 'duration': 6.725}, {'end': 5405.287, 'text': 'so you have seen that I have already inserted a 2 element.', 'start': 5402.946, 'duration': 2.341}, {'end': 5406.789, 'text': 'now let me insert some more element.', 'start': 5405.287, 'duration': 1.502}, {'end': 5416.296, 'text': 'so I will write stack dot, put and I will insert 3 here, and after this I will write stack.put4.', 'start': 5406.789, 'duration': 9.507}, {'end': 5418.578, 'text': 'so this is all about the put function right.', 'start': 5416.296, 'duration': 2.282}, {'end': 5420.72, 'text': 'so we have seen several functions in queue.', 'start': 5418.578, 'duration': 2.142}, {'end': 5422.001, 'text': 'so let me write here function.', 'start': 5420.72, 'duration': 1.281}, {'end': 5423.803, 'text': 'so here I will write print.', 'start': 5422.001, 'duration': 1.802}, {'end': 5430.248, 'text': 'and if I am writing here stack.queueSize.', 'start': 5423.803, 'duration': 6.445}, {'end': 5436.293, 'text': 'so as I told you that queue size will give you the number of elements that are present in the queue, and I have inserted 3 elements.', 'start': 5430.248, 'duration': 6.045}, {'end': 5438.874, 'text': 'so the queue size must come as 3.', 'start': 5436.293, 'duration': 2.581}, {'end': 5442.937, 'text': 'So on execution you can see that I am getting the queue size as 3..', 'start': 5438.874, 'duration': 4.063}], 'summary': 'Demonstration of implementing stack using dequeue and queue module, showcasing operations and functions with practical coding example.', 'duration': 294.458, 'max_score': 5148.479, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c5148479.jpg'}, {'end': 5227.441, 'src': 'embed', 'start': 5195.656, 'weight': 7, 'content': [{'end': 5199.038, 'text': 'Because the append and pop operations are faster in Dequeue.', 'start': 5195.656, 'duration': 3.382}, {'end': 5203.04, 'text': 'So, this was the basic idea about the stack implementation using Dequeue.', 'start': 5199.638, 'duration': 3.402}, {'end': 5205.574, 'text': "Now let's see the stack implementation using queue.", 'start': 5203.393, 'duration': 2.181}, {'end': 5211.276, 'text': 'So here in implementation using queue, queue module contains the lefo queue that means last in first out.', 'start': 5205.734, 'duration': 5.542}, {'end': 5216.518, 'text': 'So here basically what happens here it works same as the stack but it is having some additional functions.', 'start': 5211.576, 'duration': 4.942}, {'end': 5220.659, 'text': 'So it is having some additional functions and works same as a stack right.', 'start': 5216.938, 'duration': 3.721}, {'end': 5227.441, 'text': 'Now we have seen that in list as well as in dequeue we were using pop as well as append operation right.', 'start': 5221.179, 'duration': 6.262}], 'summary': 'Stack implementation using dequeue is faster for append and pop operations.', 'duration': 31.785, 'max_score': 5195.656, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c5195656.jpg'}], 'start': 3481.044, 'title': 'Array operations and stack data structure', 'summary': 'Includes two-dimensional array initialization and execution using a for loop, python 2d array operations such as search, sort, and delete, array operations in python including sorting and searching, and an introduction to stack data structure with its implementation using python list, emphasizing its real-life relevance and time complexity.', 'chapters': [{'end': 3552.983, 'start': 3481.044, 'title': 'Two-dimensional array initialization and execution', 'summary': 'Demonstrates the initialization and execution of a two-dimensional array using a for loop to print the elements one after the other, prompting user input for the number of rows and columns, resulting in a 2x3 array.', 'duration': 71.939, 'highlights': ['The chapter demonstrates the initialization and execution of a two-dimensional array using a for loop to print the elements one after the other. Illustrates the use of a for loop to print the elements one after the other.', 'Prompting user input for the number of rows and columns, resulting in a 2x3 array. Demonstrates user input to create a 2x3 array.']}, {'end': 3872.896, 'start': 3552.983, 'title': 'Python 2d array operations', 'summary': 'Explains how to implement search, sort, and delete operations on an array of integers in python, with a focus on deletion, followed by sorting in ascending order, showcasing the output and the code logic for the sorting algorithm.', 'duration': 319.913, 'highlights': ['The program demonstrates how to delete elements from an array of integers in Python, allowing users to input the array size and elements, and then specifying which element to delete, showcasing the logic of array manipulation and providing an example of successful and unsuccessful deletion. The program allows users to input the array size and elements, specifying which element to delete, and demonstrates the logic of array manipulation, providing examples of successful and unsuccessful deletion.', 'The chapter also covers sorting elements inside an array in Python, specifically showcasing the sorting of elements in ascending order through a code example, displaying the original and sorted array, and explaining the logic behind the sorting algorithm. The chapter covers sorting elements inside an array in Python, showcasing the sorting of elements in ascending order, displaying the original and sorted array, and explaining the logic behind the sorting algorithm.']}, {'end': 4338.272, 'start': 3873.296, 'title': 'Array operations in python', 'summary': 'Explores sorting, searching, and advantages and disadvantages of arrays in python, emphasizing the ease of iteration, sorting, and searching through arrays while highlighting the efficiency of arrays in replacing multiple variables and the limitations of fixed size, continuous memory allocation, and difficulty in insertion and deletion operations.', 'duration': 464.976, 'highlights': ['Arrays in Python facilitate easy iteration, sorting, and searching, with the ability to access elements via indexing and iterate through elements using a single for loop. The ease of accessing elements through indexing and iterating through all elements using a single for loop in arrays simplifies the iteration, sorting, and searching processes.', 'Arrays efficiently replace multiple variables, providing a more organized and scalable solution, as opposed to the inefficient method of using individual variables for each element. The use of arrays as a replacement for multiple variables offers a more organized and scalable solution, avoiding the inefficiency of using individual variables for each element.', 'The limitations of arrays in Python include fixed size, continuous memory allocation requirements, and difficulty in insertion and deletion operations, leading to potential memory wastage and complexity in modifying array elements. The drawbacks of arrays in Python encompass fixed size, continuous memory allocation requirements, and complexities in insertion and deletion operations, potentially resulting in memory wastage and element modification complexities.']}, {'end': 4831.449, 'start': 4338.572, 'title': 'Introduction to stack data structure', 'summary': 'Introduces the concept of a stack data structure, explaining its properties, functions, and implementation using python list, highlighting its relevance in real-life examples and time complexity of functions.', 'duration': 492.877, 'highlights': ['Stack follows last in first out order, with insertion and removal of elements done at one end. The stack follows the last in first out order, and the insertion and removal of elements are done at one end.', 'Explanation of push and pop functions, along with their usage for insertion and removal of elements from the stack. The push function is used for inserting elements into the stack, while the pop function is used for removing elements from the stack.', 'Real-life examples of stack, such as a pile of coins, DVDs, and books, demonstrating the last in first out property. Real-life examples, including a pile of coins, DVDs, and books, illustrate the last in first out property of a stack.', 'Introduction to functions associated with stack, including push, pop, size, top, and empty, with a time complexity of O(1) for each function. Functions associated with the stack, such as push, pop, size, top, and empty, have a time complexity of O(1) for each function.', 'Explanation of stack implementation using Python list, with the usage of append and pop functions for insertion and removal of elements. The implementation of a stack using Python lists involves using the append and pop functions for insertion and removal of elements.']}, {'end': 5507.158, 'start': 4831.629, 'title': 'Implementation of stack using list, deque, and queue', 'summary': 'Covers the practical implementation of stack using list, deque, and queue, demonstrating the append and pop operations, and highlighting the advantages of deque over list for faster operations.', 'duration': 675.529, 'highlights': ['The chapter demonstrates the practical implementation of stack using list, deque, and queue, emphasizing the append and pop operations for each implementation.', 'The advantages of using deque over list for implementing stack is highlighted, with a focus on the faster append and pop operations in deque compared to list.', 'The implementation of stack using queue is detailed, showcasing the put and get operations, and introducing additional functions such as queueSize, max size, empty, and full, along with practical coding examples.']}], 'duration': 2026.114, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c3481044.jpg', 'highlights': ['The ease of accessing elements through indexing and iterating through all elements using a single for loop in arrays simplifies the iteration, sorting, and searching processes.', 'The use of arrays as a replacement for multiple variables offers a more organized and scalable solution, avoiding the inefficiency of using individual variables for each element.', 'The chapter covers sorting elements inside an array in Python, showcasing the sorting of elements in ascending order, displaying the original and sorted array, and explaining the logic behind the sorting algorithm.', 'The program allows users to input the array size and elements, specifying which element to delete, and demonstrates the logic of array manipulation, providing examples of successful and unsuccessful deletion.', 'The stack follows the last in first out order, and the insertion and removal of elements are done at one end.', 'Functions associated with the stack, such as push, pop, size, top, and empty, have a time complexity of O(1) for each function.', 'The implementation of a stack using Python lists involves using the append and pop functions for insertion and removal of elements.', 'The advantages of using deque over list for implementing stack is highlighted, with a focus on the faster append and pop operations in deque compared to list.', 'The implementation of stack using queue is detailed, showcasing the put and get operations, and introducing additional functions such as queueSize, max size, empty, and full, along with practical coding examples.']}, {'end': 6266.477, 'segs': [{'end': 5613.663, 'src': 'embed', 'start': 5588.942, 'weight': 0, 'content': [{'end': 5595.668, 'text': 'so all the, since all the operations are performed in a constant amount of time, so these,', 'start': 5588.942, 'duration': 6.726}, {'end': 5600.532, 'text': 'the stack is used oftenly when you are doing competitive programming.', 'start': 5595.668, 'duration': 4.864}, {'end': 5602.414, 'text': 'now, what are the disadvantages?', 'start': 5600.532, 'duration': 1.882}, {'end': 5611.262, 'text': "since we are restricted right, there's a restriction that we can only add and remove elements from top of the stack.", 'start': 5602.414, 'duration': 8.848}, {'end': 5613.663, 'text': 'So this is one restriction that is there.', 'start': 5611.582, 'duration': 2.081}], 'summary': 'Stacks are useful in competitive programming due to constant time operations, but have restrictions on element manipulation.', 'duration': 24.721, 'max_score': 5588.942, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c5588942.jpg'}, {'end': 5799.447, 'src': 'embed', 'start': 5778.01, 'weight': 1, 'content': [{'end': 5787.357, 'text': 'advantage of these operations, these four operations, is that all of these operations are performed in a constant amount of time.', 'start': 5778.01, 'duration': 9.347}, {'end': 5792.581, 'text': 'that means the time complexity of performing these operations is before of one.', 'start': 5787.357, 'duration': 5.224}, {'end': 5799.447, 'text': 'so that is why, when you talk about competitive programming, q is most commonly used data structure.', 'start': 5792.581, 'duration': 6.866}], 'summary': 'Four operations in data structure have constant time complexity, making it commonly used in competitive programming.', 'duration': 21.437, 'max_score': 5778.01, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c5778010.jpg'}, {'end': 5850.123, 'src': 'embed', 'start': 5826.244, 'weight': 2, 'content': [{'end': 5833.166, 'text': 'In all these algorithms, queue is used for storing the data or the processes.', 'start': 5826.244, 'duration': 6.922}, {'end': 5840.917, 'text': "It's also used in maintaining playlists, like When you have a playlist, let's suppose you have 10 songs in a queue, right?", 'start': 5834.166, 'duration': 6.751}, {'end': 5846.981, 'text': 'And after one song, the next song, which is in the queue, will be played, and it goes on like this, right?', 'start': 5841.297, 'duration': 5.684}, {'end': 5850.123, 'text': 'So for maintaining a playlist again, a queue is used.', 'start': 5847.441, 'duration': 2.682}], 'summary': 'Queues are used for storing data, processes, and maintaining playlists, like playing songs in a queue.', 'duration': 23.879, 'max_score': 5826.244, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c5826244.jpg'}, {'end': 5921.782, 'src': 'embed', 'start': 5894.45, 'weight': 3, 'content': [{'end': 5899.454, 'text': 'and executes it and completes its execution and terminates the process.', 'start': 5894.45, 'duration': 5.004}, {'end': 5901.836, 'text': 'so it is also used in interrupt handling.', 'start': 5899.454, 'duration': 2.382}, {'end': 5909.879, 'text': "After learning what is Q in Python theoretically, let's know how to implement that into practicality.", 'start': 5902.637, 'duration': 7.242}, {'end': 5916.661, 'text': 'So Q will be having two different basic operations, that is NQ and DQ.', 'start': 5910.179, 'duration': 6.482}, {'end': 5921.782, 'text': 'So these things will be shown with a simple example in Python.', 'start': 5917.001, 'duration': 4.781}], 'summary': 'Python q implementation: nq and dq operations with a simple example', 'duration': 27.332, 'max_score': 5894.45, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c5894450.jpg'}, {'end': 6118.749, 'src': 'embed', 'start': 6091.206, 'weight': 4, 'content': [{'end': 6095.25, 'text': "Let's see one of the type of queue that is circular queue implementation.", 'start': 6091.206, 'duration': 4.044}, {'end': 6096.711, 'text': 'There are many types of queues,', 'start': 6095.39, 'duration': 1.321}, {'end': 6104.659, 'text': "but still I'm taking circular queue as an example and showing you the same operations of inserting and deleting elements from the queue.", 'start': 6096.711, 'duration': 7.948}, {'end': 6108.823, 'text': "So let's quickly hop into the Google Colab IDE and check out the program.", 'start': 6105.3, 'duration': 3.523}, {'end': 6112.567, 'text': 'How can we build a circular queue in Python?', 'start': 6109.183, 'duration': 3.384}, {'end': 6118.749, 'text': 'here is the program for circular queue and what are the different elements we have inside this program?', 'start': 6113.427, 'duration': 5.322}], 'summary': 'Demonstrating circular queue implementation in python.', 'duration': 27.543, 'max_score': 6091.206, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c6091206.jpg'}], 'start': 5507.719, 'title': 'Stack and queue data structures', 'summary': 'Covers the implementation of a stack using a queue, emphasizing advantages like lifo order and constant time operations, and the principles, operations, and applications of a queue including constant time complexity and practical python implementation.', 'chapters': [{'end': 5642.767, 'start': 5507.719, 'title': 'Stack implementation and advantages', 'summary': 'Discusses the implementation of a stack using a queue, highlighting its advantages such as maintaining data in lifo order and constant time operations, while also pointing out its limitations in terms of flexibility. it also briefly introduces the concept of a linear data structure, q.', 'duration': 135.048, 'highlights': ['Stack maintains data in LIFO order, allowing constant time operations, making it crucial for competitive programming. The stack maintains data in a LIFO order, and all operations such as push, pop, and isEmpty take a constant amount of time, making it crucial for efficient programming in competitive scenarios.', 'The restriction of only adding and removing elements from the top limits the flexibility of stack as a data structure. The stack is restricted in a way that only elements from the top can be added or removed, making it less flexible as a data structure.', 'Introduction to the concept of Q as a linear data structure. The transcript briefly introduces Q as a linear data structure where all elements are stored in a linear fashion.']}, {'end': 6266.477, 'start': 5644.347, 'title': 'Queue data structure: principles, operations, and applications', 'summary': 'Explains the principles and operations of a queue, including insertion and deletion, highlighting its constant time complexity, applications in scheduling algorithms and interrupt handling, and provides practical implementation in python.', 'duration': 622.13, 'highlights': ['Queue operations have a constant time complexity of O(1), making it a commonly used data structure in competitive programming. Constant time complexity of O(1), competitive programming usage', 'Queue is used in scheduling algorithms of the operating system, including first-in, first-out (FIFO) and round-robin, and in maintaining playlists, such as for playing songs sequentially. Usage in scheduling algorithms, FIFO, round-robin, maintaining playlists', 'Queue is employed in interrupt handling in operating systems, allowing processes to be stored and executed sequentially. Application in interrupt handling, sequential process execution', 'The practical implementation of a queue is demonstrated in Python, highlighting the enqueue (NQ) and dequeue (DQ) operations and their sequential behavior based on FIFO. Practical Python implementation, demonstration of enqueue and dequeue operations', 'The chapter also introduces the concept of circular queue and its implementation in Python, emphasizing the management of full and empty conditions for the queue. Introduction of circular queue, implementation in Python, management of full and empty conditions']}], 'duration': 758.758, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c5507719.jpg', 'highlights': ['Stack maintains data in LIFO order, allowing constant time operations, crucial for competitive programming.', 'Queue operations have a constant time complexity of O(1), making it a commonly used data structure in competitive programming.', 'Queue is used in scheduling algorithms of the operating system, including first-in, first-out (FIFO) and round-robin, and in maintaining playlists.', 'The practical implementation of a queue is demonstrated in Python, highlighting the enqueue (NQ) and dequeue (DQ) operations and their sequential behavior based on FIFO.', 'Introduction of circular queue, implementation in Python, management of full and empty conditions.']}, {'end': 9120.052, 'segs': [{'end': 6391.347, 'src': 'embed', 'start': 6362.65, 'weight': 1, 'content': [{'end': 6367.371, 'text': 'so this is the difference between the normal basic q and the circular q.', 'start': 6362.65, 'duration': 4.721}, {'end': 6370.711, 'text': "now let's talk about advantages and disadvantages of q first.", 'start': 6367.371, 'duration': 3.34}, {'end': 6372.612, 'text': 'we are talking about advantages.', 'start': 6370.711, 'duration': 1.901}, {'end': 6377.713, 'text': 'so it follows a principle of fifo, or the elements are stored in a fifo manner.', 'start': 6372.612, 'duration': 5.101}, {'end': 6382.501, 'text': "that means let's suppose this is a q And in this queue you have elements.", 'start': 6377.713, 'duration': 4.788}, {'end': 6391.347, 'text': 'So the deletion will take place from the front, right? And the insertion will take place from the rear side.', 'start': 6383.622, 'duration': 7.725}], 'summary': 'Comparison of normal basic q and circular q, discussing advantages of fifo principle.', 'duration': 28.697, 'max_score': 6362.65, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c6362650.jpg'}, {'end': 6467.312, 'src': 'embed', 'start': 6426.674, 'weight': 0, 'content': [{'end': 6434.367, 'text': 'this data structure is most commonly used because of these features that all the operations that are performed, like insertion, deletion, peak first,', 'start': 6426.674, 'duration': 7.693}, {'end': 6439.351, 'text': 'peak last, NQ, DQ all these operations are performed in a constant amount of time.', 'start': 6434.367, 'duration': 4.984}, {'end': 6442.074, 'text': "Now let's talk about disadvantages.", 'start': 6440.372, 'duration': 1.702}, {'end': 6453.884, 'text': 'Since we are only able to delete or insert from the front and the rear, that means deletion from front and insertion from the rear.', 'start': 6444.015, 'duration': 9.869}, {'end': 6458.729, 'text': 'so the restriction of insertion or any manipulation, right?', 'start': 6453.884, 'duration': 4.845}, {'end': 6461.49, 'text': 'We have a restriction over these right?', 'start': 6459.149, 'duration': 2.341}, {'end': 6463.09, 'text': 'What these operations?', 'start': 6461.65, 'duration': 1.44}, {'end': 6464.451, 'text': 'insertion and deletion.', 'start': 6463.09, 'duration': 1.361}, {'end': 6467.312, 'text': 'So this restriction is always there.', 'start': 6465.131, 'duration': 2.181}], 'summary': 'Data structure allows constant time operations for insertion, deletion, peak first, peak last, nq, dq, but with limitations on insertion and deletion.', 'duration': 40.638, 'max_score': 6426.674, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c6426674.jpg'}, {'end': 6550.196, 'src': 'embed', 'start': 6519.747, 'weight': 3, 'content': [{'end': 6524.711, 'text': 'so this pointer will contain the address of the next node, right.', 'start': 6519.747, 'duration': 4.964}, {'end': 6529.275, 'text': 'so as I told you, that linked list is a collection of nodes, so this is nothing but a single node.', 'start': 6524.711, 'duration': 4.564}, {'end': 6544.027, 'text': "so let's suppose, if I am having more than one node and if I am connecting them, then it will form a linked list.", 'start': 6529.275, 'duration': 14.752}, {'end': 6547.074, 'text': 'So we will see the linked list representation in the next slide.', 'start': 6544.372, 'duration': 2.702}, {'end': 6550.196, 'text': 'Now, so linked list is a linear data structure.', 'start': 6547.474, 'duration': 2.722}], 'summary': 'Linked list is a collection of nodes forming a linear data structure.', 'duration': 30.449, 'max_score': 6519.747, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c6519747.jpg'}, {'end': 7161.189, 'src': 'heatmap', 'start': 6585.261, 'weight': 0.729, 'content': [{'end': 6592.286, 'text': 'I will give the address of this as 2020 and I will give the address of entry node as 2030.', 'start': 6585.261, 'duration': 7.025}, {'end': 6593.467, 'text': 'So these are the addresses.', 'start': 6592.286, 'duration': 1.181}, {'end': 6597.249, 'text': 'So as I told you that each node will contain a data.', 'start': 6594.087, 'duration': 3.162}, {'end': 6599.09, 'text': 'So let me assign your data.', 'start': 6597.829, 'duration': 1.261}, {'end': 6603.134, 'text': "Let's suppose 10 is here and a reference Or you can say a pointer.", 'start': 6599.11, 'duration': 4.024}, {'end': 6608.136, 'text': 'So I told you about pointer that pointer will contain the address of the next node.', 'start': 6603.654, 'duration': 4.482}, {'end': 6612.579, 'text': 'So what is the address of next node? The address of next node is 2020.', 'start': 6608.477, 'duration': 4.102}, {'end': 6615.421, 'text': 'So I will write here 2020.', 'start': 6612.579, 'duration': 2.842}, {'end': 6620.864, 'text': 'So this pointer or this reference or you can say this link will contain the address of my next node.', 'start': 6615.421, 'duration': 5.443}, {'end': 6623.665, 'text': "And what's the address of my next node is 2020.", 'start': 6621.204, 'duration': 2.461}, {'end': 6625.707, 'text': 'Now again this will be a data.', 'start': 6623.665, 'duration': 2.042}, {'end': 6631.59, 'text': 'And this will be a reference of my end to node.', 'start': 6627.648, 'duration': 3.942}, {'end': 6638.11, 'text': 'So let me assign here data as 20 and what will be the reference? The reference will contain the address of the next node.', 'start': 6632.088, 'duration': 6.022}, {'end': 6640.21, 'text': 'So here it will be 20, 30.', 'start': 6638.37, 'duration': 1.84}, {'end': 6642.891, 'text': 'Now again, this N3 will also contain data.', 'start': 6640.21, 'duration': 2.681}, {'end': 6644.691, 'text': 'So I will assign here 30.', 'start': 6642.911, 'duration': 1.78}, {'end': 6647.792, 'text': 'So now you might have a question that what should be reference here?', 'start': 6644.691, 'duration': 3.101}, {'end': 6653.494, 'text': 'So now are you seeing any node after this N3 node?', 'start': 6650.213, 'duration': 3.281}, {'end': 6655.514, 'text': 'Do we have node N4 or N5??', 'start': 6653.774, 'duration': 1.74}, {'end': 6656.415, 'text': 'Not right.', 'start': 6655.754, 'duration': 0.661}, {'end': 6659.976, 'text': 'So this reference will be assigned to null.', 'start': 6656.755, 'duration': 3.221}, {'end': 6662.301, 'text': 'So I can write here 5.', 'start': 6660.356, 'duration': 1.945}, {'end': 6666.204, 'text': 'because there is no next node is present there right now.', 'start': 6662.301, 'duration': 3.903}, {'end': 6666.965, 'text': 'coming to head.', 'start': 6666.204, 'duration': 0.761}, {'end': 6667.766, 'text': 'what is head?', 'start': 6666.965, 'duration': 0.801}, {'end': 6670.688, 'text': 'so head will contain the address of my n1 node.', 'start': 6667.766, 'duration': 2.922}, {'end': 6673.11, 'text': 'that means 2010.', 'start': 6670.688, 'duration': 2.422}, {'end': 6676.913, 'text': 'right. so this is my linked list representation.', 'start': 6673.11, 'duration': 3.803}, {'end': 6679.456, 'text': 'now the question arises that why linked list?', 'start': 6676.913, 'duration': 2.543}, {'end': 6681.437, 'text': 'so now, why do we need linked list?', 'start': 6679.456, 'duration': 1.981}, {'end': 6686.221, 'text': 'because linked list is having more efficiency for performing the operations as compared to list.', 'start': 6681.437, 'duration': 4.784}, {'end': 6688.644, 'text': 'so what are the operations that we are performing?', 'start': 6686.221, 'duration': 2.423}, {'end': 6689.164, 'text': 'in linked list?', 'start': 6688.644, 'duration': 0.52}, {'end': 6693.969, 'text': 'we can perform the operations like insertion, deletion as well as traversal.', 'start': 6689.468, 'duration': 4.501}, {'end': 6697.21, 'text': 'So it is having more efficiency in performing the operation.', 'start': 6694.249, 'duration': 2.961}, {'end': 6705.452, 'text': 'So, moving to the next point, as I already told you that in linked list elements are stored randomly, whereas in list, or you can say in array,', 'start': 6697.61, 'duration': 7.842}, {'end': 6707.392, 'text': 'elements are stored at contiguous memory.', 'start': 6705.452, 'duration': 1.94}, {'end': 6714.354, 'text': 'Now moving next accessing the elements in linked list will be slower as compared to list.', 'start': 6708.212, 'duration': 6.142}, {'end': 6718.775, 'text': 'So if you want to access the element in linked list it will be slower as compared to list.', 'start': 6714.594, 'duration': 4.181}, {'end': 6723.459, 'text': "Why? I will tell you the reason now, let's see this slide linked list representation.", 'start': 6718.895, 'duration': 4.564}, {'end': 6725.639, 'text': 'So here this is my entry node, right?', 'start': 6723.779, 'duration': 1.86}, {'end': 6734.883, 'text': 'And if I want to access the data elements of this entry node, then I have to go from n1, n2 and n3.', 'start': 6726.06, 'duration': 8.823}, {'end': 6743.166, 'text': "then only I can access the elements, whereas in case of list we can access the element through indexing, but in linked list it's not possible.", 'start': 6734.883, 'duration': 8.283}, {'end': 6749.562, 'text': 'So you have to go traversely right? Here traversal means that you have to go through each node.', 'start': 6743.426, 'duration': 6.136}, {'end': 6756.908, 'text': 'So if you want to access the elements of N3 then you have to start with N1 then you will go to N2 then you can go to N3.', 'start': 6749.762, 'duration': 7.146}, {'end': 6761.672, 'text': "So that's why accessing the elements in linked list will be slower as compared to list.", 'start': 6757.088, 'duration': 4.584}, {'end': 6768.037, 'text': 'Now coming to the last point here in linked list utilization of memory will be more as compared to list.', 'start': 6762.092, 'duration': 5.945}, {'end': 6770.699, 'text': "So let's start with the singly linked list.", 'start': 6768.997, 'duration': 1.702}, {'end': 6776.163, 'text': 'So I have already showed you the representation of linked list which is same as the singly linked list.', 'start': 6771.319, 'duration': 4.844}, {'end': 6781.124, 'text': "So in singly linked list, I'm having here a data and reference in a node.", 'start': 6776.641, 'duration': 4.483}, {'end': 6784.287, 'text': "So let's suppose that this is my N1 node.", 'start': 6781.485, 'duration': 2.802}, {'end': 6787.75, 'text': 'This is my N2 node and this is my N3 node.', 'start': 6784.747, 'duration': 3.003}, {'end': 6791.572, 'text': 'So as I told you that each node will contain data as well as reference.', 'start': 6788.19, 'duration': 3.382}, {'end': 6793.474, 'text': 'So I will give here data.', 'start': 6792.173, 'duration': 1.301}, {'end': 6802, 'text': "Let's suppose 10 in node 2, I will give as 20 and here I will give as 30 and each node is having an address.", 'start': 6793.494, 'duration': 8.506}, {'end': 6806.775, 'text': "So let's suppose the address of this N1 node is 1000.", 'start': 6802.16, 'duration': 4.615}, {'end': 6811.216, 'text': "it's having 1100 and it's having 1200.", 'start': 6806.775, 'duration': 4.441}, {'end': 6816.897, 'text': 'so this reference, or you can say that link or pointer, this will contain the address of the next node.', 'start': 6811.216, 'duration': 5.681}, {'end': 6819.257, 'text': 'so this will contain 1100.', 'start': 6816.897, 'duration': 2.36}, {'end': 6823.878, 'text': 'similarly, my this reference or this link will contain the address of n3 node.', 'start': 6819.257, 'duration': 4.621}, {'end': 6830.239, 'text': "so i'll write here 1200 and here, after n3 node, do you see any node?", 'start': 6823.878, 'duration': 6.361}, {'end': 6831.679, 'text': 'we are not having any node.', 'start': 6830.239, 'duration': 1.44}, {'end': 6836.14, 'text': 'so here this link or this reference will null.', 'start': 6831.679, 'duration': 4.461}, {'end': 6838.489, 'text': 'now, Coming to here, what is head here?', 'start': 6836.14, 'duration': 2.349}, {'end': 6843.071, 'text': 'So head will contain the address of my first node, that is 1000..', 'start': 6838.87, 'duration': 4.201}, {'end': 6846.371, 'text': 'So, in singly linked list, the traversal is done only in one direction.', 'start': 6843.071, 'duration': 3.3}, {'end': 6850.592, 'text': 'So, what do you mean by traversal? Traversal means that you are going through each node.', 'start': 6846.912, 'duration': 3.68}, {'end': 6857.014, 'text': "So, let's suppose that if you want to go to the N3 node, first go to N1 then N2 then only you come to N3.", 'start': 6850.832, 'duration': 6.182}, {'end': 6858.674, 'text': "You can't directly jump to N3.", 'start': 6857.134, 'duration': 1.54}, {'end': 6861.675, 'text': 'You have to go through N1 and N2 then only you come to N3.', 'start': 6858.954, 'duration': 2.721}, {'end': 6865.076, 'text': "Now, let's see some operations in singly linked list.", 'start': 6862.315, 'duration': 2.761}, {'end': 6867.753, 'text': 'So we are having several operations in linked list.', 'start': 6865.731, 'duration': 2.022}, {'end': 6870.455, 'text': 'We are having insertion, deletion, traversal.', 'start': 6867.813, 'duration': 2.642}, {'end': 6877.26, 'text': 'So insertion as well as deletion can be done at beginning at any specified node as well as end.', 'start': 6870.835, 'duration': 6.425}, {'end': 6884.066, 'text': 'Now coming to the traversal, I have already told you that traversal means you have to go through each node.', 'start': 6878.381, 'duration': 5.685}, {'end': 6887.709, 'text': 'So going through each node of the linked list is a traversal.', 'start': 6884.927, 'duration': 2.782}, {'end': 6890.651, 'text': "Now let's see the pseudo code of singling linked list.", 'start': 6888.309, 'duration': 2.342}, {'end': 6899.36, 'text': 'So if you want to create a node in a singling linked list, then what should be the code here? So I will write first here class node.', 'start': 6891.212, 'duration': 8.148}, {'end': 6904.244, 'text': 'So here I have created a class whose name is node.', 'start': 6900.641, 'duration': 3.603}, {'end': 6910.709, 'text': "So this class node will also be having an object, right? I will create object later on but let's see.", 'start': 6904.905, 'duration': 5.804}, {'end': 6922.379, 'text': "Let's suppose this is my n1 node, as I told you that a node will contain data as well as reference, right?", 'start': 6912.991, 'duration': 9.388}, {'end': 6924.701, 'text': 'So instead of reference, I am writing here next.', 'start': 6922.899, 'duration': 1.802}, {'end': 6928.094, 'text': "I'm taking a small word here so that it will be easy for coding.", 'start': 6925.373, 'duration': 2.721}, {'end': 6930.854, 'text': 'Now so this is my node creation.', 'start': 6928.654, 'duration': 2.2}, {'end': 6932.755, 'text': 'Now what I will do here.', 'start': 6931.374, 'duration': 1.381}, {'end': 6938.096, 'text': 'So in this class node you have seen that I am creating an init method or you can say a constructor.', 'start': 6933.195, 'duration': 4.901}, {'end': 6943.837, 'text': 'So to create it first I will write a reserved word that is def and then I will write init method.', 'start': 6938.416, 'duration': 5.421}, {'end': 6952.519, 'text': 'So I will write first def and then underscore underscore init and then I will write underscore underscore.', 'start': 6944.257, 'duration': 8.262}, {'end': 6957.232, 'text': 'Then I will write self and then comma comma data.', 'start': 6952.839, 'duration': 4.393}, {'end': 6965.456, 'text': "So why I have written here self I will tell you later on and I've also passed data as a parameter here.", 'start': 6958.953, 'duration': 6.503}, {'end': 6971.18, 'text': 'So inside this I have written self dot data is equal to data and self dot reference is equal to none.', 'start': 6965.837, 'duration': 5.343}, {'end': 6975.062, 'text': 'So why I have written this because my node will contain data as well as reference.', 'start': 6971.54, 'duration': 3.522}, {'end': 6985.812, 'text': 'So I will write here in this method self dot data is equal to data and self dot reference i have written here next.', 'start': 6975.102, 'duration': 10.71}, {'end': 6989.894, 'text': 'so i will take here next is equal to none.', 'start': 6985.812, 'duration': 4.082}, {'end': 6994.555, 'text': "so when you are creating a node, let's say this is a node n1.", 'start': 6989.894, 'duration': 4.661}, {'end': 7001.537, 'text': 'so initially it will be having a data and because i am just creating a node as of now i am not linking this node.', 'start': 6994.555, 'duration': 6.982}, {'end': 7007.639, 'text': 'so the link, or you can say the reference, will be none right.', 'start': 7001.537, 'duration': 6.102}, {'end': 7009.079, 'text': 'so this is my initial node.', 'start': 7007.639, 'duration': 1.44}, {'end': 7014.001, 'text': 'i have written here self dot data is equal to data and self dot next is equal to none.', 'start': 7009.079, 'duration': 4.922}, {'end': 7018.211, 'text': 'right now this is a class whose name is node.', 'start': 7014.001, 'duration': 4.21}, {'end': 7019.251, 'text': 'I can create the object.', 'start': 7018.211, 'duration': 1.04}, {'end': 7020.452, 'text': 'so how to create an object?', 'start': 7019.251, 'duration': 1.201}, {'end': 7028.196, 'text': 'I will write here n1 and then I will write here class name, node, and inside this class I will pass the parameter 7.', 'start': 7020.452, 'duration': 7.744}, {'end': 7029.877, 'text': 'so here now what will happen?', 'start': 7028.196, 'duration': 1.681}, {'end': 7031.018, 'text': 'instead of self?', 'start': 7029.877, 'duration': 1.141}, {'end': 7032.419, 'text': 'my object will pass here.', 'start': 7031.018, 'duration': 1.401}, {'end': 7035.44, 'text': 'so my n1 will pass here instead of self.', 'start': 7032.419, 'duration': 3.021}, {'end': 7042.084, 'text': "so now it will be n1.data is equal to, and what's my data data is 7.", 'start': 7035.44, 'duration': 6.644}, {'end': 7045.444, 'text': 'now The next step we are having.', 'start': 7042.084, 'duration': 3.36}, {'end': 7047.325, 'text': 'the self.reference is equal to none, right.', 'start': 7045.444, 'duration': 1.881}, {'end': 7050.087, 'text': "Let's see here self.next is equal to none.", 'start': 7047.765, 'duration': 2.322}, {'end': 7057.111, 'text': 'So instead of self my n1 is there so n1 will be passed here and n1.next I will be having a none.', 'start': 7050.447, 'duration': 6.664}, {'end': 7060.794, 'text': 'So this is nothing but a creation of my node.', 'start': 7058.732, 'duration': 2.062}, {'end': 7066.877, 'text': 'Now, if you want to check, then we can write print function, and when you will write here node1 data inside a print function,', 'start': 7061.154, 'duration': 5.723}, {'end': 7068.999, 'text': 'you will see that you are getting the value as 7..', 'start': 7066.877, 'duration': 2.122}, {'end': 7073.822, 'text': 'Similarly if you are writing node1.reference inside a print method then you will be getting none.', 'start': 7068.999, 'duration': 4.823}, {'end': 7076.952, 'text': 'So now this is the idea about how to create a node.', 'start': 7074.471, 'duration': 2.481}, {'end': 7078.773, 'text': "Now let's see this into a coding.", 'start': 7077.212, 'duration': 1.561}, {'end': 7081.374, 'text': 'So I will be using here Jupyter Notebooks.', 'start': 7079.433, 'duration': 1.941}, {'end': 7087.137, 'text': 'So I will go on here new and then I will click on Python 3.', 'start': 7081.454, 'duration': 5.683}, {'end': 7090.559, 'text': 'And here you can see that I am getting a name untitled 21.', 'start': 7087.137, 'duration': 3.422}, {'end': 7091.299, 'text': 'Let me change it.', 'start': 7090.559, 'duration': 0.74}, {'end': 7092.84, 'text': 'I will write here linked list.', 'start': 7091.72, 'duration': 1.12}, {'end': 7097.202, 'text': 'Linked list.', 'start': 7096.082, 'duration': 1.12}, {'end': 7102.505, 'text': 'And I will write here Python.', 'start': 7101.504, 'duration': 1.001}, {'end': 7108.762, 'text': "now let's create a node.", 'start': 7106.061, 'duration': 2.701}, {'end': 7110.423, 'text': 'so i will comment it down.', 'start': 7108.762, 'duration': 1.661}, {'end': 7115.545, 'text': 'creating a node.', 'start': 7110.423, 'duration': 5.122}, {'end': 7125.888, 'text': 'so first i will create a class and i will give the name as node and inside this class node i will create my init method.', 'start': 7115.545, 'duration': 10.343}, {'end': 7131.09, 'text': 'so i will write here def, which is a reserved word, and then i will write here init.', 'start': 7125.888, 'duration': 5.202}, {'end': 7133.211, 'text': 'but before that i will write underscore underscore.', 'start': 7131.09, 'duration': 2.121}, {'end': 7141.976, 'text': 'then again I will write underscore underscore and then I will write here self comma data.', 'start': 7135.592, 'duration': 6.384}, {'end': 7143.817, 'text': 'so why I have written here self.', 'start': 7141.976, 'duration': 1.841}, {'end': 7148.741, 'text': 'so when I am creating a class object, that is n1, I have already showed you in the example.', 'start': 7143.817, 'duration': 4.924}, {'end': 7151.482, 'text': 'so instead of self, n1 is passed.', 'start': 7148.741, 'duration': 2.741}, {'end': 7161.189, 'text': 'so as we know that we can create a multiple object of a class, so if I am writing here n2 or n3, then instead of self I can pass n2 and n3 also.', 'start': 7151.482, 'duration': 9.707}], 'summary': 'Explanation of linked list representation and operations with examples and code in python.', 'duration': 575.928, 'max_score': 6585.261, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c6585261.jpg'}, {'end': 6743.166, 'src': 'embed', 'start': 6714.594, 'weight': 4, 'content': [{'end': 6718.775, 'text': 'So if you want to access the element in linked list it will be slower as compared to list.', 'start': 6714.594, 'duration': 4.181}, {'end': 6723.459, 'text': "Why? I will tell you the reason now, let's see this slide linked list representation.", 'start': 6718.895, 'duration': 4.564}, {'end': 6725.639, 'text': 'So here this is my entry node, right?', 'start': 6723.779, 'duration': 1.86}, {'end': 6734.883, 'text': 'And if I want to access the data elements of this entry node, then I have to go from n1, n2 and n3.', 'start': 6726.06, 'duration': 8.823}, {'end': 6743.166, 'text': "then only I can access the elements, whereas in case of list we can access the element through indexing, but in linked list it's not possible.", 'start': 6734.883, 'duration': 8.283}], 'summary': 'Accessing elements in linked list is slower compared to list due to traversal process.', 'duration': 28.572, 'max_score': 6714.594, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c6714594.jpg'}, {'end': 6784.287, 'src': 'embed', 'start': 6757.088, 'weight': 5, 'content': [{'end': 6761.672, 'text': "So that's why accessing the elements in linked list will be slower as compared to list.", 'start': 6757.088, 'duration': 4.584}, {'end': 6768.037, 'text': 'Now coming to the last point here in linked list utilization of memory will be more as compared to list.', 'start': 6762.092, 'duration': 5.945}, {'end': 6770.699, 'text': "So let's start with the singly linked list.", 'start': 6768.997, 'duration': 1.702}, {'end': 6776.163, 'text': 'So I have already showed you the representation of linked list which is same as the singly linked list.', 'start': 6771.319, 'duration': 4.844}, {'end': 6781.124, 'text': "So in singly linked list, I'm having here a data and reference in a node.", 'start': 6776.641, 'duration': 4.483}, {'end': 6784.287, 'text': "So let's suppose that this is my N1 node.", 'start': 6781.485, 'duration': 2.802}], 'summary': 'Accessing linked list elements is slower than list; linked list uses more memory.', 'duration': 27.199, 'max_score': 6757.088, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c6757088.jpg'}, {'end': 6922.379, 'src': 'embed', 'start': 6891.212, 'weight': 6, 'content': [{'end': 6899.36, 'text': 'So if you want to create a node in a singling linked list, then what should be the code here? So I will write first here class node.', 'start': 6891.212, 'duration': 8.148}, {'end': 6904.244, 'text': 'So here I have created a class whose name is node.', 'start': 6900.641, 'duration': 3.603}, {'end': 6910.709, 'text': "So this class node will also be having an object, right? I will create object later on but let's see.", 'start': 6904.905, 'duration': 5.804}, {'end': 6922.379, 'text': "Let's suppose this is my n1 node, as I told you that a node will contain data as well as reference, right?", 'start': 6912.991, 'duration': 9.388}], 'summary': 'Creating a node in a single linked list involves defining a class node with data and reference.', 'duration': 31.167, 'max_score': 6891.212, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c6891212.jpg'}, {'end': 7836.608, 'src': 'embed', 'start': 7795.148, 'weight': 7, 'content': [{'end': 7821.489, 'text': 'so I will write here if self.head is none, I write print singly linked list is empty and I give the another condition else.', 'start': 7795.148, 'duration': 26.341}, {'end': 7825.831, 'text': 'so the first condition was that if self.head is none, the linked list is empty.', 'start': 7821.489, 'duration': 4.342}, {'end': 7832.414, 'text': 'now coming to the next condition when my self.head is pointing to the first node, then only I can do the traversal right.', 'start': 7825.831, 'duration': 6.583}, {'end': 7836.608, 'text': 'So I will create a temporary variable where a is equal to self.head.', 'start': 7833.146, 'duration': 3.462}], 'summary': 'Code checks if linked list is empty and sets up traversal', 'duration': 41.46, 'max_score': 7795.148, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c7795148.jpg'}, {'end': 7925.424, 'src': 'embed', 'start': 7894.219, 'weight': 12, 'content': [{'end': 7898.1, 'text': 'so this is my main logic that I have written inside a traversal function.', 'start': 7894.219, 'duration': 3.881}, {'end': 7901.082, 'text': "Now let's see how to execute this program.", 'start': 7898.62, 'duration': 2.462}, {'end': 7902.523, 'text': 'So first I will create a node.', 'start': 7901.342, 'duration': 1.181}, {'end': 7907.346, 'text': 'So let me write here n1 is equal to node and let me insert the values 5.', 'start': 7902.863, 'duration': 4.483}, {'end': 7910.588, 'text': 'So I will create 4 nodes in this.', 'start': 7907.346, 'duration': 3.242}, {'end': 7913.95, 'text': 'So I will write here n2 is equal to node.', 'start': 7910.928, 'duration': 3.022}, {'end': 7925.424, 'text': 'I will give the data element value 10 here n2 node and n3 I will give the value as 15.', 'start': 7913.97, 'duration': 11.454}], 'summary': 'Logic written for creating and executing a program with 4 nodes and specific values.', 'duration': 31.205, 'max_score': 7894.219, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c7894219.jpg'}, {'end': 8595.686, 'src': 'embed', 'start': 8543.44, 'weight': 9, 'content': [{'end': 8546.823, 'text': 'now, after traversal, we will see the insertion in singly linked list.', 'start': 8543.44, 'duration': 3.383}, {'end': 8548.765, 'text': 'So insertion can be done in three ways.', 'start': 8547.165, 'duration': 1.6}, {'end': 8551.266, 'text': 'We can do the insertion at the beginning of the node.', 'start': 8549.045, 'duration': 2.221}, {'end': 8556.487, 'text': 'We can also do the insertion at the end of the node and we can do the insertion at a specified node.', 'start': 8551.666, 'duration': 4.821}, {'end': 8558.827, 'text': "Now let's see the insertion first at the beginning.", 'start': 8556.827, 'duration': 2}, {'end': 8562.788, 'text': 'So in the previous coding example, I was having four nodes.', 'start': 8559.227, 'duration': 3.561}, {'end': 8572.33, 'text': 'So let me write here the name of node N1, N2, N3 and N4.', 'start': 8563.648, 'duration': 8.682}, {'end': 8575.551, 'text': "And I've also shown you the traversal in linked list.", 'start': 8573.21, 'duration': 2.341}, {'end': 8587.404, 'text': 'So here I have assigned the data as 5, 10, 15 and 20 right, and this n1 was connected to n2.', 'start': 8575.911, 'duration': 11.493}, {'end': 8590.385, 'text': 'similarly, n2 was connected to n3, n3 to n4.', 'start': 8587.404, 'duration': 2.981}, {'end': 8594.446, 'text': 'so we have seen the traversal like this head was pointing to my n1 node right.', 'start': 8590.385, 'duration': 4.061}, {'end': 8595.686, 'text': 'so this is nothing but my link.', 'start': 8594.446, 'duration': 1.24}], 'summary': 'Insertion in singly linked list demonstrated with traversal and example data.', 'duration': 52.246, 'max_score': 8543.44, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c8543440.jpg'}], 'start': 6266.477, 'title': 'Data structures and operations', 'summary': 'Covers circular queue operations, highlighting advantages such as fifo principle and constant time operations, and disadvantages related to limitations in insertion and deletion operations. it also introduces linked list, explaining its structure, advantages, differences from arrays, and covers node creation, traversal, insertion, and logic of traversing a singly linked list with a demonstration resulting in the output of 5, 10, 15, 20.', 'chapters': [{'end': 6467.312, 'start': 6266.477, 'title': 'Circular queue operations', 'summary': 'Explains circular queue operations, highlighting the difference between normal and circular queues, advantages including fifo principle, constant time operations, and its common usage in competitive programming, and disadvantages related to limitations in insertion and deletion operations.', 'duration': 200.835, 'highlights': ['The circular queue differs from the basic queue as it forms a circular motion by connecting the front and rear, allowing for constant time operations such as insertion and deletion and enabling the storage of elements in a FIFO manner. The circular queue differentiates from the basic queue by forming a circular motion, connecting the front and rear, allowing for constant time operations including insertion and deletion, and enabling storage of elements in a FIFO manner.', 'Advantages of a circular queue include its adherence to the FIFO principle, constant time operations for insertion, deletion, peak first, peak last, enqueue, and dequeue, making it widely used in competitive programming. Advantages of a circular queue include its adherence to the FIFO principle, constant time operations for insertion, deletion, peak first, peak last, enqueue, and dequeue, making it widely used in competitive programming.', 'The restriction in circular queues lies in the limitation of insertion and deletion operations, as these operations are only allowed from the front and rear, leading to constraints in manipulation. The restriction in circular queues lies in the limitation of insertion and deletion operations, as these operations are only allowed from the front and rear, leading to constraints in manipulation.']}, {'end': 6890.651, 'start': 6467.572, 'title': 'Introduction to linked list', 'summary': 'Introduces the concept of linked list, explaining its structure as a collection of nodes with data and references, its advantages in performing operations such as insertion, deletion, and traversal, as well as its differences from arrays and lists, including its slower element access and higher memory utilization. it also covers singly linked list and its operations including insertion, deletion, and traversal.', 'duration': 423.079, 'highlights': ['Linked list is a collection of nodes containing data and references, allowing for more efficient operations like insertion, deletion, and traversal Linked list provides more efficient operations such as insertion, deletion, and traversal compared to arrays and lists.', 'Accessing elements in linked list is slower compared to lists due to the need for traversal through each node Accessing elements in a linked list is slower compared to lists as it requires traversal through each node rather than direct indexing.', 'Utilization of memory is higher in linked list as compared to lists Linked list utilizes more memory compared to lists.']}, {'end': 7852.457, 'start': 6891.212, 'title': 'Creating node and singly linked list', 'summary': 'Covers the creation of a node in a singly linked list, including the class and object creation, and discusses the traversal in a linked list using python, highlighting the logic and conditions for traversal.', 'duration': 961.245, 'highlights': ['Creation of a node in a singly linked list The chapter covers the creation of a node in a singly linked list, including the class and object creation, and discusses the logic for initializing a node with data and reference.', 'Logic and conditions for traversal in a linked list using Python The chapter explains the logic and conditions for traversal in a linked list, including handling empty linked lists, creating temporary variables, and using while loops to traverse through each node.']}, {'end': 8543.44, 'start': 7852.457, 'title': 'Linked list traversal logic', 'summary': 'Explains the logic of traversing a singly linked list and connecting nodes, with a demonstration of creating nodes, connecting them, and executing the traversal function, resulting in the output of 5, 10, 15, 20.', 'duration': 690.983, 'highlights': ['Creation of Nodes and Object Initialization The speaker demonstrates the creation of nodes (n1, n2, n3, n4) and the initialization of the singly linked list object, providing insight into the process of creating and linking nodes within the list.', 'Execution of Traversal Function The process of calling and executing the traversal function is explained, highlighting the traversal logic and the resulting output of 5, 10, 15, 20, providing a clear demonstration of the linked list traversal.', 'Explanation of Traversal Logic A detailed explanation of the traversal logic is provided, outlining the iterative process of traversing the linked list and printing the data values of the nodes, reinforcing the understanding of the traversal mechanism.']}, {'end': 9120.052, 'start': 8543.44, 'title': 'Singly linked list insertion', 'summary': 'Discusses the insertion of nodes in a singly linked list, covering insertion at the beginning and end, and includes a detailed explanation of the logic and code implementation, using an example with quantifiable data and traversal process.', 'duration': 576.612, 'highlights': ['The chapter discusses the insertion of nodes in a singly linked list, covering insertion at the beginning and end. This highlight provides the main topic of the chapter, emphasizing the focus on insertion methods in a singly linked list.', 'The detailed explanation of the logic and code implementation is provided, using an example with quantifiable data and traversal process. The detailed explanation of the logic and code implementation is emphasized, including the use of an example with quantifiable data and the traversal process to demonstrate the insertion methods.', 'The logic and code for inserting a node at the beginning of the linked list is thoroughly explained, including the step-by-step process and the actual code implementation. The logic and code for inserting a node at the beginning of the linked list is thoroughly explained, providing a step-by-step process and the actual code implementation.']}], 'duration': 2853.575, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c6266477.jpg', 'highlights': ['Advantages of a circular queue include its adherence to the FIFO principle, constant time operations for insertion, deletion, peak first, peak last, enqueue, and dequeue, making it widely used in competitive programming.', 'The circular queue differs from the basic queue as it forms a circular motion by connecting the front and rear, allowing for constant time operations such as insertion and deletion and enabling the storage of elements in a FIFO manner.', 'The restriction in circular queues lies in the limitation of insertion and deletion operations, as these operations are only allowed from the front and rear, leading to constraints in manipulation.', 'Linked list is a collection of nodes containing data and references, allowing for more efficient operations like insertion, deletion, and traversal.', 'Accessing elements in linked list is slower compared to lists due to the need for traversal through each node.', 'Utilization of memory is higher in linked list as compared to lists.', 'Creation of a node in a singly linked list, including the class and object creation, and discusses the logic for initializing a node with data and reference.', 'Logic and conditions for traversal in a linked list using Python, including handling empty linked lists, creating temporary variables, and using while loops to traverse through each node.', 'Creation of Nodes and Object Initialization, providing insight into the process of creating and linking nodes within the list.', 'Execution of Traversal Function, highlighting the traversal logic and the resulting output of 5, 10, 15, 20, providing a clear demonstration of the linked list traversal.', 'Explanation of Traversal Logic, outlining the iterative process of traversing the linked list and printing the data values of the nodes, reinforcing the understanding of the traversal mechanism.', 'The chapter discusses the insertion of nodes in a singly linked list, covering insertion at the beginning and end.', 'The detailed explanation of the logic and code implementation is emphasized, including the use of an example with quantifiable data and the traversal process to demonstrate the insertion methods.', 'The logic and code for inserting a node at the beginning of the linked list is thoroughly explained, providing a step-by-step process and the actual code implementation.']}, {'end': 10922.582, 'segs': [{'end': 9325.832, 'src': 'embed', 'start': 9293.193, 'weight': 4, 'content': [{'end': 9294.033, 'text': "So, I'll write here while.", 'start': 9293.193, 'duration': 0.84}, {'end': 9304.297, 'text': 'So, while a.next is not none, then a is equal to a.next.', 'start': 9294.633, 'duration': 9.664}, {'end': 9313.242, 'text': 'And now after this, I will simply assign a.next is equal to ne.', 'start': 9305.916, 'duration': 7.326}, {'end': 9323.29, 'text': "So this is the connection of my last node that is n4 node to ne, right? And here I've created this while loop so that I can go through each node.", 'start': 9313.842, 'duration': 9.448}, {'end': 9324.771, 'text': 'Now let me print out this.', 'start': 9323.73, 'duration': 1.041}, {'end': 9325.832, 'text': 'So what I will do now?', 'start': 9325.031, 'duration': 0.801}], 'summary': 'Traversing a linked list using a while loop to connect nodes.', 'duration': 32.639, 'max_score': 9293.193, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c9293193.jpg'}, {'end': 10128.62, 'src': 'embed', 'start': 10069.079, 'weight': 0, 'content': [{'end': 10069.999, 'text': 'So this is my logic.', 'start': 10069.079, 'duration': 0.92}, {'end': 10081.189, 'text': "Now, if I want to call this function, let me again copy and paste this what's the name of the function?", 'start': 10070.38, 'duration': 10.809}, {'end': 10085.712, 'text': 'insert at, insert at specified node?', 'start': 10081.189, 'duration': 4.523}, {'end': 10098.102, 'text': 'so i will write here insert at specified node and then i have given here position and then data.', 'start': 10085.712, 'duration': 12.39}, {'end': 10100.324, 'text': 'so i will here pass the position at three position.', 'start': 10098.102, 'duration': 2.222}, {'end': 10108.696, 'text': "I want to insert a node and let's say data is 7 and once again I'm calling it through SLL dot reversal.", 'start': 10101.414, 'duration': 7.282}, {'end': 10112.716, 'text': "So if I'm executing it, then you can see that I'm getting the output.", 'start': 10109.456, 'duration': 3.26}, {'end': 10116.437, 'text': 'So for getting the output in the next line, let me write here print.', 'start': 10113.176, 'duration': 3.261}, {'end': 10126.999, 'text': 'So you can clearly see in the output that at position 3 a new node has been inserted was data is 7.', 'start': 10121.518, 'duration': 5.481}, {'end': 10128.62, 'text': "So now let's understand the logic.", 'start': 10126.999, 'duration': 1.621}], 'summary': "A function 'insert at specified node' inserts data at position 3 and prints the output.", 'duration': 59.541, 'max_score': 10069.079, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c10069079.jpg'}, {'end': 10332.19, 'src': 'embed', 'start': 10299.147, 'weight': 3, 'content': [{'end': 10300.908, 'text': 'I have done the connection with n1 and n2.', 'start': 10299.147, 'duration': 1.761}, {'end': 10304.851, 'text': 'So this is the basic program of insertion in singly linked list.', 'start': 10301.128, 'duration': 3.723}, {'end': 10309.678, 'text': "So, now after seeing the insertion operation, now let's jump into the deletion operation.", 'start': 10305.936, 'duration': 3.742}, {'end': 10312.099, 'text': 'So, even deletion operation will be of three types.', 'start': 10309.998, 'duration': 2.101}, {'end': 10319.443, 'text': 'We will see the deletion at beginning, deletion at end and we can also delete a particular node at any specified position.', 'start': 10312.139, 'duration': 7.304}, {'end': 10321.444, 'text': "So, now let's see deletion at beginning.", 'start': 10319.803, 'duration': 1.641}, {'end': 10332.19, 'text': 'So, I was having a node here NB and then I was having N1 and at position 3, I have inserted a new node, right? NIB.', 'start': 10322.084, 'duration': 10.106}], 'summary': 'Basic singly linked list program with insertion and deletion operations.', 'duration': 33.043, 'max_score': 10299.147, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c10299147.jpg'}], 'start': 9120.632, 'title': 'Linked list operations', 'summary': 'Discusses creating a linked list with a while loop, insertion of nodes at various positions, and deletion at the beginning and end, with detailed explanations and coding examples.', 'chapters': [{'end': 9237.894, 'start': 9120.632, 'title': 'Creating linkedlist with while loop', 'summary': 'Discusses the process of creating a linked list using a while loop, explaining the need for a temporary variable and the logic behind the while loop, with a demonstration of how the process works through the example of adding nodes to the linked list.', 'duration': 117.262, 'highlights': ["Explaining the need for a temporary variable to maintain the fixed head value and demonstrate its usage in the while loop. Temporary variable 'a' used to maintain head value.", "Demonstrating the while loop logic for traversing the linked list and updating the 'a' value to the next node until the end is reached. Demonstration of the while loop for traversing the linked list.", "Illustrating the process of creating a link between the last node and a new node by setting 'a.next' to the new node 'any'. Demonstration of creating a link between the last node and a new node."]}, {'end': 9815.518, 'start': 9239.015, 'title': 'Linked list node insertion', 'summary': 'Covers the insertion of nodes at the end, beginning, and specified position in a linked list, with detailed explanations and examples of the traversal and logic involved.', 'duration': 576.503, 'highlights': ['The process of inserting a node at the end of a linked list involves creating a new node, traversing the list to reach the last node, and linking the new node to the last node, with a detailed explanation of the logic and traversal process.', 'The chapter also explains the insertion of a node at the beginning and at a specified position in the linked list, providing a thorough demonstration of the traversal and logic involved in these insertion processes.', 'Detailed examples and explanations are provided for the insertion of nodes at specific positions within the linked list, including the use of temporary variables and loops to navigate and insert nodes at the desired positions.']}, {'end': 10018.975, 'start': 9815.978, 'title': 'Inserting a node at specified position', 'summary': 'Explains the process of inserting a node at a specified position in a linked list, detailing the logic and coding example. it also covers the insertion at the beginning and end of the linked list.', 'duration': 202.997, 'highlights': ['The chapter explains the process of inserting a node at a specified position in a linked list inserting a node, specified position, linked list', 'It also covers the insertion at the beginning and end of the linked list insertion at beginning and end, linked list', 'The logic for traversing through each node is demonstrated using a temporary variable a and a loop traversing, temporary variable, loop']}, {'end': 10299.007, 'start': 10019.215, 'title': 'Inserting node at specified position in linked list', 'summary': 'Explains the logic and implementation of inserting a node at a specified position in a linked list, with a specific example of inserting a node at position 3 with data 7, showcasing the functionality and output of the insertion process.', 'duration': 279.792, 'highlights': ['The chapter explains the step-by-step process of inserting a node at a specified position in a linked list, showcasing the logic and implementation with a specific example of inserting a node at position 3 with data 7.', 'The transcript provides a detailed explanation of the logic behind connecting the newly inserted node at the specified position to the nodes before and after it in the linked list.', 'The speaker demonstrates the functionality and output of the insertion process, showcasing the successful insertion of a node at position 3 with data 7 in the linked list.']}, {'end': 10922.582, 'start': 10299.147, 'title': 'Sll deletion at beginning & end', 'summary': 'Covers the basic program for deletion at the beginning in a singly linked list, including the logic to shift the head and disconnect the link, as well as the logic for deletion at the end, involving traversing the list to disconnect the link from the last node.', 'duration': 623.435, 'highlights': ['The basic program for deletion at the beginning involves creating a temporary variable and shifting the head to the next node, then disconnecting the link from the initial node. Temporary variable creation, head shifting logic, link disconnection', 'The logic for deletion at the end includes traversing the list using two variables, disconnecting the link from the last node, and utilizing a while loop for traversal. Traversing the list, disconnecting link, while loop usage']}], 'duration': 1801.95, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c9120632.jpg', 'highlights': ['Detailed explanation of the logic and traversal process for inserting a node at the end of a linked list.', 'Thorough demonstration of the traversal and logic involved in inserting nodes at specific positions within the linked list.', 'Step-by-step process of inserting a node at a specified position in a linked list, including a specific example.', 'Basic program for deletion at the beginning and at the end of the linked list, including the logic and traversal process.', "Demonstration of the while loop logic for traversing the linked list and updating the 'a' value to the next node until the end is reached."]}, {'end': 13734.881, 'segs': [{'end': 10957.093, 'src': 'embed', 'start': 10927.165, 'weight': 9, 'content': [{'end': 10929.447, 'text': 'So here you can see that the last node has been deleted.', 'start': 10927.165, 'duration': 2.282}, {'end': 10935.53, 'text': 'So if you want to understand the logic for deletion and end, then follow the similar approach that I have showed you earlier here, right?', 'start': 10929.627, 'duration': 5.903}, {'end': 10940.153, 'text': 'So now we will see the deletion of a particular node at any specified position.', 'start': 10936.551, 'duration': 3.602}, {'end': 10947.198, 'text': 'So after deleting the node at beginning as well as end, we will see how to delete a node at a specified position.', 'start': 10941.734, 'duration': 5.464}, {'end': 10954.372, 'text': "So the singly link list that I'm having as of now looks like this.", 'start': 10947.771, 'duration': 6.601}, {'end': 10957.093, 'text': 'This is my N1.', 'start': 10955.913, 'duration': 1.18}], 'summary': 'Demonstrating deletion of nodes in a singly linked list.', 'duration': 29.928, 'max_score': 10927.165, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c10927165.jpg'}, {'end': 11160.208, 'src': 'embed', 'start': 11131.978, 'weight': 2, 'content': [{'end': 11134.159, 'text': "now let's see in the coding part.", 'start': 11131.978, 'duration': 2.181}, {'end': 11135.239, 'text': 'so let me create the function.', 'start': 11134.159, 'duration': 1.08}, {'end': 11141.621, 'text': 'i will write here def deletion at particular node.', 'start': 11135.239, 'duration': 6.382}, {'end': 11152.164, 'text': 'So I will give the function name here deletionAtParticularNode.', 'start': 11149.062, 'duration': 3.102}, {'end': 11155.746, 'text': 'So here I will give one more parameter other than self.', 'start': 11152.164, 'duration': 3.582}, {'end': 11160.208, 'text': 'I will give here position Because I want to delete a node at particular position.', 'start': 11155.746, 'duration': 4.462}], 'summary': "Creating a function 'deletionatparticularnode' to delete a node at a specific position.", 'duration': 28.23, 'max_score': 11131.978, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c11131978.jpg'}, {'end': 11278.321, 'src': 'embed', 'start': 11247.857, 'weight': 1, 'content': [{'end': 11249.898, 'text': "And let's suppose at position 3 I want to delete.", 'start': 11247.857, 'duration': 2.041}, {'end': 11253.62, 'text': 'So I will write here 3.', 'start': 11249.918, 'duration': 3.702}, {'end': 11255.741, 'text': 'So you will see the data element 10 will be removed from here.', 'start': 11253.62, 'duration': 2.121}, {'end': 11257.042, 'text': 'So now if I am running it.', 'start': 11256.161, 'duration': 0.881}, {'end': 11259.703, 'text': 'Again I have to write print.', 'start': 11258.742, 'duration': 0.961}, {'end': 11263.805, 'text': 'To get the output in the next line.', 'start': 11262.544, 'duration': 1.261}, {'end': 11271.278, 'text': "So if I'm running it you can see that the 10 data element has been removed because the node has been deleted.", 'start': 11266.636, 'duration': 4.642}, {'end': 11278.321, 'text': 'So we have seen here the insertion at beginning and at particular node same for the deletion and we have also seen the traversal.', 'start': 11271.598, 'duration': 6.723}], 'summary': 'Demonstrated deletion at position 3, successfully removed data element 10 from the node.', 'duration': 30.464, 'max_score': 11247.857, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c11247857.jpg'}, {'end': 11353.174, 'src': 'embed', 'start': 11326.854, 'weight': 3, 'content': [{'end': 11332.758, 'text': 'Now doubly linked list is a collection of nodes in which each node contains a data field and having two pointers.', 'start': 11326.854, 'duration': 5.904}, {'end': 11336.441, 'text': 'as I already explained you that we are having two pointers and data field.', 'start': 11332.758, 'duration': 3.683}, {'end': 11340.564, 'text': 'So one pointer is for previous node and other for the next node.', 'start': 11337.162, 'duration': 3.402}, {'end': 11348.691, 'text': 'Again, the difference between singly linked list and doubly linked list is that in singly linked list we can traverse only in the forward direction,', 'start': 11341.285, 'duration': 7.406}, {'end': 11353.174, 'text': 'whereas in doubly linked list we can traverse forward direction as well as backward direction.', 'start': 11348.691, 'duration': 4.483}], 'summary': 'Doubly linked list has nodes with two pointers, allowing traversal in both forward and backward directions.', 'duration': 26.32, 'max_score': 11326.854, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c11326854.jpg'}, {'end': 11515.239, 'src': 'embed', 'start': 11472.719, 'weight': 0, 'content': [{'end': 11478.921, 'text': 'So like singly linked list and doubly linked list also we are having three operations insertion deletion and traversal.', 'start': 11472.719, 'duration': 6.202}, {'end': 11482.982, 'text': 'So in insertion we are having beginning at a specified note at end.', 'start': 11479.221, 'duration': 3.761}, {'end': 11488.423, 'text': 'That means we can insert the node at beginning, at a specified node or at the end position.', 'start': 11483.202, 'duration': 5.221}, {'end': 11491.964, 'text': 'similarly, for the deletion also now coming to the traversal here.', 'start': 11488.423, 'duration': 3.541}, {'end': 11493.765, 'text': 'We can go to the forward direction.', 'start': 11492.265, 'duration': 1.5}, {'end': 11495.478, 'text': 'as well as backward direction.', 'start': 11494.136, 'duration': 1.342}, {'end': 11498.06, 'text': 'So we have already seen the logic of forward direction.', 'start': 11495.778, 'duration': 2.282}, {'end': 11500.843, 'text': 'So here I will explain you the logic of backward direction also.', 'start': 11498.361, 'duration': 2.482}, {'end': 11508.011, 'text': "Now, let's see the pseudo code of doubly linked list now coming to the pseudo code.", 'start': 11503.646, 'duration': 4.365}, {'end': 11509.653, 'text': 'The first thing is that you have to create a node.', 'start': 11508.051, 'duration': 1.602}, {'end': 11515.239, 'text': 'So how to create a node of doubly linked list so doubly linked list if I want to create a node.', 'start': 11510.173, 'duration': 5.066}], 'summary': 'Singly and doubly linked lists have 3 operations: insertion, deletion, and traversal. insertion can be at the beginning, specified node, or end. deletion and traversal can be done in forward and backward directions. pseudo code for creating a node in doubly linked list is explained.', 'duration': 42.52, 'max_score': 11472.719, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c11472719.jpg'}, {'end': 11622.166, 'src': 'embed', 'start': 11595.991, 'weight': 5, 'content': [{'end': 11603.296, 'text': 'so here I will create a class whose name is doubly linked list and then I will create a init method and then I will write self.head is equal to none.', 'start': 11595.991, 'duration': 7.305}, {'end': 11605.557, 'text': 'So that means my head is pointing to none.', 'start': 11603.456, 'duration': 2.101}, {'end': 11608.178, 'text': 'So my linked list is empty as of now.', 'start': 11605.937, 'duration': 2.241}, {'end': 11611.86, 'text': 'Now we will see the traversal operation in doubly linked list.', 'start': 11609.099, 'duration': 2.761}, {'end': 11617.563, 'text': 'So here this is the code for the forward traversal that we have already seen in the singly linked list.', 'start': 11612.521, 'duration': 5.042}, {'end': 11622.166, 'text': 'Right? So let me create the node of doubly linked list.', 'start': 11618.524, 'duration': 3.642}], 'summary': 'Creating a doubly linked list class and implementing forward traversal operation.', 'duration': 26.175, 'max_score': 11595.991, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c11595991.jpg'}, {'end': 12661.828, 'src': 'embed', 'start': 12632.914, 'weight': 8, 'content': [{'end': 12634.795, 'text': 'so we will see the insertion at beginning first.', 'start': 12632.914, 'duration': 1.881}, {'end': 12636.92, 'text': 'so this is my doubly linked list.', 'start': 12635.279, 'duration': 1.641}, {'end': 12642.281, 'text': 'so doubly linked list is having two pointers right.', 'start': 12636.92, 'duration': 5.361}, {'end': 12649.924, 'text': "so let's suppose that i'm having three nodes here n1, n2 and n3.", 'start': 12642.281, 'duration': 7.643}, {'end': 12654.346, 'text': 'so n1 next pointer will contain the address of n2 node.', 'start': 12649.924, 'duration': 4.422}, {'end': 12660.508, 'text': 'similarly, n2 previous pointer will contain the address of n1 node.', 'start': 12654.346, 'duration': 6.162}, {'end': 12661.828, 'text': 'the same goes for n2 and n3.', 'start': 12660.508, 'duration': 1.32}], 'summary': 'Demonstration of insertion in a doubly linked list with three nodes.', 'duration': 28.914, 'max_score': 12632.914, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c12632914.jpg'}], 'start': 10927.165, 'title': 'Doubly linked list operations', 'summary': 'Covers the concept of doubly linked list, including its representation, traversal, insertion, and deletion operations, with a focus on logic, coding, and examples, encompassing the creation, connection, and manipulation of nodes.', 'chapters': [{'end': 11271.278, 'start': 10927.165, 'title': 'Singly linked list node deletion', 'summary': 'Explains the process of deleting a node at a specified position in a singly linked list, demonstrating the logic and coding for the deletion, with a notable example of deleting a node at position 3 resulting in the removal of the data element 10.', 'duration': 344.113, 'highlights': ['The chapter explains the process of deleting a node at a specified position in a singly linked list, demonstrating the logic and coding for the deletion.', 'The example of deleting a node at position 3 resulting in the removal of the data element 10 serves as a notable demonstration of the deletion process.', "The detailed logic includes creating a function 'deletionAtParticularNode' with a parameter for the position of the node to be deleted, iterating through the list using a for loop, and updating the link references to achieve the deletion."]}, {'end': 11921.467, 'start': 11271.598, 'title': 'Doubly linked list: nodes, traversal, and operations', 'summary': 'Explains the concept of doubly linked list, including its representation, traversal in both directions, and operations such as insertion, deletion, and traversal, with a focus on the logic and code implementation.', 'duration': 649.869, 'highlights': ['Doubly linked list contains nodes with two pointers, allowing traversal in both forward and backward directions. Doubly linked list features nodes with two pointers, enabling traversal in both forward and backward directions, providing a clear distinction from singly linked lists.', 'Representation of doubly linked list nodes includes data and pointers to previous and next nodes. The representation of doubly linked list nodes involves containing a data field and two pointers, one for the previous node and the other for the next node, providing a clear illustration of the structure and functionality of the nodes.', 'Demonstrated the creation of nodes in a doubly linked list and explained their connections and traversal logic. The explanation includes the creation of nodes in a doubly linked list, the establishment of connections between nodes, and the logic of traversal, providing a comprehensive understanding of the construction and functionality of the list.', 'Detailed explanation of the forward traversal logic and code implementation in a doubly linked list. An in-depth explanation of the logic and code implementation for forward traversal in a doubly linked list, providing a clear understanding of the iterative process and data retrieval in the forward direction.', 'Thorough demonstration and explanation of the logic and code for backward traversal in a doubly linked list. The thorough demonstration and explanation of the logic and code for backward traversal in a doubly linked list, emphasizing the iterative process and data retrieval in the backward direction, enhancing the comprehension of traversal operations.']}, {'end': 12368.876, 'start': 11921.952, 'title': 'Doubly linked list logic and traversal', 'summary': 'Explains the logic of creating a doubly linked list, including the use of next and previous pointers, forward and backward traversal, and the process of creating and connecting nodes.', 'duration': 446.924, 'highlights': ["The logic of creating a doubly linked list involves using two pointers, 'next' and 'previous', and initializing the head pointer as 'none' to denote an empty list.", "The forward traversal in a doubly linked list is similar to that in a singly linked list, involving the traversal through each node using the 'next' pointer.", "The backward traversal in a doubly linked list involves traversing from the last node to the first node using the 'previous' pointer, and the process is demonstrated with the creation and connection of nodes such as N1, N2, N3, and N4.", "The process of creating and connecting nodes in a doubly linked list is explained, including assigning data values and pointing 'next' and 'previous' pointers for each node, as well as initializing the head of the list."]}, {'end': 12964.259, 'start': 12368.876, 'title': 'Doubly linked list traversal and insertion', 'summary': 'Demonstrates the creation of nodes in a doubly linked list, forward and backward traversal, and insertion at the beginning, providing insights into the logic of traversal and node insertion at the start in a doubly linked list.', 'duration': 595.383, 'highlights': ["Nodes creation and linking The speaker explains the process of creating a new node (N2) and linking it with the previous node (N1) by setting N2's 'previous' pointer to N1 and N1's 'next' pointer to N2.", 'Backward traversal logic The detailed explanation of backward traversal logic in a doubly linked list is provided, showcasing the process of iterating through nodes from the last to the first, effectively displaying the data in reverse order.', "Insertion at the beginning The process of inserting a new node at the beginning of a doubly linked list is illustrated, involving the creation of a new node and the adjustment of 'previous' and 'next' pointers to establish the link with the existing head node."]}, {'end': 13734.881, 'start': 12964.259, 'title': 'Doubly linked list insertion', 'summary': 'Covers the basic logic and coding example for insertion at the beginning, end, and at a specified node in a doubly linked list, demonstrating the creation of nodes and connection between nodes, with an example of inserting a node at position 3.', 'duration': 770.622, 'highlights': ['The chapter covers the basic logic and coding example for insertion at the beginning, end, and at a specified node in a doubly linked list It provides an overview of the key topics covered in the chapter, including insertion at the beginning, end, and at a specified node in a doubly linked list.', 'demonstrating the creation of nodes and connection between nodes The transcript details the process of creating nodes and establishing connections between nodes in a doubly linked list, illustrating the fundamental operations involved in insertion.', 'example of inserting a node at position 3 It includes an example of inserting a node at a specified position (position 3) in a doubly linked list, demonstrating the practical application of the insertion logic.']}], 'duration': 2807.716, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c10927165.jpg', 'highlights': ['The chapter covers the basic logic and coding example for insertion at the beginning, end, and at a specified node in a doubly linked list', 'The example of deleting a node at position 3 resulting in the removal of the data element 10 serves as a notable demonstration of the deletion process', "The detailed logic includes creating a function 'deletionAtParticularNode' with a parameter for the position of the node to be deleted, iterating through the list using a for loop, and updating the link references to achieve the deletion", 'Representation of doubly linked list nodes includes data and pointers to previous and next nodes', "The process of creating and connecting nodes in a doubly linked list is explained, including assigning data values and pointing 'next' and 'previous' pointers for each node, as well as initializing the head of the list", "The logic of creating a doubly linked list involves using two pointers, 'next' and 'previous', and initializing the head pointer as 'none' to denote an empty list", 'The thorough demonstration and explanation of the logic and code for backward traversal in a doubly linked list, emphasizing the iterative process and data retrieval in the backward direction, enhancing the comprehension of traversal operations', 'The detailed explanation of backward traversal logic in a doubly linked list is provided, showcasing the process of iterating through nodes from the last to the first, effectively displaying the data in reverse order', "The process of inserting a new node at the beginning of a doubly linked list is illustrated, involving the creation of a new node and the adjustment of 'previous' and 'next' pointers to establish the link with the existing head node", 'The chapter explains the process of deleting a node at a specified position in a singly linked list, demonstrating the logic and coding for the deletion']}, {'end': 15064.288, 'segs': [{'end': 13788.516, 'src': 'embed', 'start': 13734.881, 'weight': 0, 'content': [{'end': 13741.285, 'text': "so let's suppose that if I want to insert a node at any specified position, so before that I have to traverse through each node right.", 'start': 13734.881, 'duration': 6.404}, {'end': 13744.447, 'text': "so this is the logic that I've used using for loop.", 'start': 13741.285, 'duration': 3.162}, {'end': 13745.768, 'text': 'so after that, what I will do here?', 'start': 13744.447, 'duration': 1.321}, {'end': 13752.048, 'text': 'I will write here an IV dot previous is equal to a.', 'start': 13745.768, 'duration': 6.28}, {'end': 13753.109, 'text': 'So why I am writing this?', 'start': 13752.048, 'duration': 1.061}, {'end': 13765.318, 'text': 'because I want a link connection between the nodes and after writing this I will write here nib.next is equal to a.next.', 'start': 13753.109, 'duration': 12.209}, {'end': 13773.024, 'text': 'then I will write here a.next.previous is equal to nib.', 'start': 13765.318, 'duration': 7.706}, {'end': 13776.247, 'text': 'Since this is a doubly linked list.', 'start': 13774.866, 'duration': 1.381}, {'end': 13781.732, 'text': 'so we have to connect the previous pointer also and next pointer also.', 'start': 13776.247, 'duration': 5.485}, {'end': 13786.755, 'text': 'now i will write after this a dot next is equal to n i b.', 'start': 13781.732, 'duration': 5.023}, {'end': 13788.516, 'text': 'so this is my connection.', 'start': 13786.755, 'duration': 1.761}], 'summary': 'Inserting a node at a specified position in a doubly linked list using a for loop and connecting previous and next pointers.', 'duration': 53.635, 'max_score': 13734.881, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c13734881.jpg'}, {'end': 14020.63, 'src': 'embed', 'start': 13990.041, 'weight': 2, 'content': [{'end': 13996.002, 'text': 'So once the link has been disconnected so you can see that this is the deletion of a N1 node that is deletion at the beginning.', 'start': 13990.041, 'duration': 5.961}, {'end': 13997.823, 'text': 'And here this is my head position.', 'start': 13996.263, 'duration': 1.56}, {'end': 14001.664, 'text': 'This is my N2 node and this is pointing to none.', 'start': 13998.143, 'duration': 3.521}, {'end': 14006.505, 'text': 'Right So this is the basic logic of deletion at the beginning.', 'start': 14003.824, 'duration': 2.681}, {'end': 14008.165, 'text': "Now let's see it into the coding part.", 'start': 14006.665, 'duration': 1.5}, {'end': 14011.845, 'text': "So now let's start with the deletion at the beginning.", 'start': 14009.264, 'duration': 2.581}, {'end': 14020.63, 'text': "So I'll write here def and then I will write here deletion at beginning.", 'start': 14012.066, 'duration': 8.564}], 'summary': 'Deletion of n1 node at the beginning demonstrated, followed by coding explanation.', 'duration': 30.589, 'max_score': 13990.041, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c13990041.jpg'}, {'end': 15015.736, 'src': 'embed', 'start': 14988.241, 'weight': 3, 'content': [{'end': 14992.843, 'text': 'So the same goes for the singly circular linked list as well as for doubly circular linked list.', 'start': 14988.241, 'duration': 4.602}, {'end': 14995.404, 'text': 'Right So this was all about circular linked list.', 'start': 14993.123, 'duration': 2.281}, {'end': 14999.825, 'text': "Now let's talk about the advantages and disadvantages of linked list.", 'start': 14996.184, 'duration': 3.641}, {'end': 15001.826, 'text': "First let's talk about the advantages.", 'start': 15000.125, 'duration': 1.701}, {'end': 15012.135, 'text': 'So obviously as compared to array, right? When we talked about arrays, they were fixed in size, right? We need to specify the size in the subscript.', 'start': 15002.213, 'duration': 9.922}, {'end': 15015.736, 'text': 'So fixed in size, which is not in the case of arrays.', 'start': 15012.555, 'duration': 3.181}], 'summary': 'Discussed advantages of linked list over arrays, specifically regarding size flexibility.', 'duration': 27.495, 'max_score': 14988.241, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c14988241.jpg'}], 'start': 13734.881, 'title': 'Linked list operations', 'summary': 'Covers the process of inserting and deleting nodes at specified positions in a doubly linked list, emphasizing pointer manipulation and logic implementation. it also discusses circular linked lists and their advantages, highlighting efficient memory allocation and dynamic sizing.', 'chapters': [{'end': 13788.516, 'start': 13734.881, 'title': 'Inserting node in doubly linked list', 'summary': 'Explains the process of inserting a node at a specified position in a doubly linked list using a for loop and the logic of connecting the previous and next pointers, ensuring proper link connections between the nodes.', 'duration': 53.635, 'highlights': ['The process involves traversing through each node using a for loop to insert a node at a specified position.', "The logic includes connecting the previous and next pointers by writing 'IV dot previous = a' and 'nib.next = a.next', followed by 'a.next.previous = nib' and 'a.next = nib'.", 'It is emphasized that in a doubly linked list, both the previous and next pointers need to be connected to ensure proper link connections between the nodes.']}, {'end': 14399.51, 'start': 13788.516, 'title': 'Doubly linked list operations', 'summary': 'Covers the logic and coding for insertion and deletion at specified nodes in a doubly linked list, with an emphasis on disconnecting links and pointer manipulation. it includes the insertion of a node at a specified position and the deletion of nodes at the beginning and end of the list.', 'duration': 610.994, 'highlights': ['The logic and coding for insertion and deletion at specified nodes in a doubly linked list are covered. ', 'The chapter emphasizes disconnecting links and pointer manipulation during insertion and deletion at specified nodes. ', 'The process of inserting a node at a specified position in a doubly linked list is explained, with an example of inserting a value of 7 at position 3. Example of inserting a value of 7 at position 3', 'The logic for deletion at the beginning of a doubly linked list is discussed, involving the reassignment of head and disconnection of links. ', 'The coding for deletion at the beginning involves the reassignment of head, disconnecting links between nodes, and executing forward and backward traversal to display the changes. ', 'The process of deleting the last node in a doubly linked list is explained, incorporating a loop for traversal, two variables for tracking, and the disconnection of links to delete the node. Incorporation of loop for traversal and disconnection of links', 'The coding for deletion at the end involves the use of variables for tracking, a while loop for traversal, and the disconnection of links to delete the last node. ']}, {'end': 14739.025, 'start': 14399.91, 'title': 'Deletion in a doubly linked list', 'summary': 'Explores the logic behind deletion at the end, resulting in the removal of a data element and a backward traversal, as well as the process for deleting a specified node at a particular position using python, detailing the use of pointers and loops for this purpose.', 'duration': 339.115, 'highlights': ['The logic for deletion at end involves removing the last node, resulting in the deletion of a data element and a backward traversal to display the remaining data values.', "The explanation of deleting a specified node at a particular position involves utilizing pointers 'a' and 'b' to iterate through the list and reassigning the next and previous pointers to remove the desired node, demonstrating the use of loops and Python indexing for this process."]}, {'end': 15064.288, 'start': 14739.025, 'title': 'Linked list operations and advantages', 'summary': 'Covers the logic of deletion in a doubly linked list, the concept of circular linked list, its types, operations, and advantages of linked list including efficient memory allocation and dynamic size.', 'duration': 325.263, 'highlights': ['The logic of deletion in a doubly linked list is explained, and an example of deleting a node at position three is demonstrated resulting in a new doubly linked list with data elements 5, 7, 15, and 20. Demonstrates the logic of deletion in a doubly linked list, showcasing the deletion of a node at position three resulting in a new doubly linked list with data elements 5, 7, 15, and 20.', 'The concept of circular linked list and its types, including singly circular linked list and doubly circular linked list, are discussed along with the operations of insertion, deletion, and traversal for both types. Explains the concept of circular linked list and its types, discussing the operations of insertion, deletion, and traversal for both singly circular linked list and doubly circular linked list.', 'The advantages of linked list over arrays are highlighted, emphasizing the dynamic nature and efficient memory allocation based on application requirements, leading to no memory wastage. Emphasizes the advantages of linked list over arrays, highlighting the dynamic nature and efficient memory allocation based on application requirements, resulting in no memory wastage.']}], 'duration': 1329.407, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c13734881.jpg', 'highlights': ["The logic includes connecting the previous and next pointers by writing 'IV dot previous = a' and 'nib.next = a.next', followed by 'a.next.previous = nib' and 'a.next = nib'.", 'The process involves traversing through each node using a for loop to insert a node at a specified position.', 'The logic for deletion at the beginning of a doubly linked list is discussed, involving the reassignment of head and disconnection of links.', 'The advantages of linked list over arrays are highlighted, emphasizing the dynamic nature and efficient memory allocation based on application requirements, leading to no memory wastage.']}, {'end': 16798.623, 'segs': [{'end': 15506.645, 'src': 'embed', 'start': 15473.104, 'weight': 2, 'content': [{'end': 15477.851, 'text': 'so Let me give you a brief explanation over this.', 'start': 15473.104, 'duration': 4.747}, {'end': 15481.313, 'text': "First, we'll start with what is binary tree.", 'start': 15478.771, 'duration': 2.542}, {'end': 15486.816, 'text': "I'm taking a simple example, nothing related to coding or anything, just a simple example.", 'start': 15481.793, 'duration': 5.023}, {'end': 15494.14, 'text': 'So binary tree in the sense, it should have at least one node and two different nodes.', 'start': 15487.396, 'duration': 6.744}, {'end': 15495.16, 'text': 'sub nodes.', 'start': 15494.5, 'duration': 0.66}, {'end': 15498.122, 'text': 'i call it as left and right sides, right.', 'start': 15495.16, 'duration': 2.962}, {'end': 15506.645, 'text': "it should have one data item, i'm putting it to one here, and it should also have left child and it should have the right child.", 'start': 15498.122, 'duration': 8.523}], 'summary': 'Explanation of binary tree: 1 data item, left and right child nodes', 'duration': 33.541, 'max_score': 15473.104, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c15473104.jpg'}, {'end': 16042.011, 'src': 'heatmap', 'start': 15746.74, 'weight': 1, 'content': [{'end': 15750.283, 'text': "so what i'm writing it's two here and four next.", 'start': 15746.74, 'duration': 3.543}, {'end': 15752.925, 'text': 'then you have to visit right side.', 'start': 15750.283, 'duration': 2.642}, {'end': 15756.609, 'text': 'so at right side you have three.', 'start': 15752.925, 'duration': 3.684}, {'end': 15762.454, 'text': 'so this is how pre-order traversal will work in binary tree so quickly.', 'start': 15756.609, 'duration': 5.845}, {'end': 15766.358, 'text': 'we shall see the last one, that is, post order.', 'start': 15762.454, 'duration': 3.904}, {'end': 15768.141, 'text': 'right Post order.', 'start': 15766.358, 'duration': 1.783}, {'end': 15768.921, 'text': 'as per the rules.', 'start': 15768.141, 'duration': 0.78}, {'end': 15769.702, 'text': 'what does it say??', 'start': 15768.921, 'duration': 0.781}, {'end': 15773.503, 'text': 'We have to go towards the left first, then right and then root at the last.', 'start': 15769.722, 'duration': 3.781}, {'end': 15779.425, 'text': 'So, writing down a simple diagram again here for avoiding the confusion.', 'start': 15774.023, 'duration': 5.402}, {'end': 15783.026, 'text': '4, this is 3.', 'start': 15780.925, 'duration': 2.101}, {'end': 15784.166, 'text': 'So, we are doing that.', 'start': 15783.026, 'duration': 1.14}, {'end': 15788.608, 'text': 'Left side, what do you have now? We have 4.', 'start': 15785.027, 'duration': 3.581}, {'end': 15799.304, 'text': 'Again, continuing, you have towards the right side, 3.', 'start': 15788.608, 'duration': 10.696}, {'end': 15801.131, 'text': 'Right after having three.', 'start': 15799.304, 'duration': 1.827}, {'end': 15802.537, 'text': 'what do you have?', 'start': 15801.636, 'duration': 0.901}, {'end': 15804.258, 'text': 'you have to go to root.', 'start': 15802.537, 'duration': 1.721}, {'end': 15806.219, 'text': 'so what does it say?', 'start': 15804.258, 'duration': 1.961}, {'end': 15808.961, 'text': 'you have to first complete whatever there in the left.', 'start': 15806.219, 'duration': 2.742}, {'end': 15810.422, 'text': 'so what we have left out here?', 'start': 15808.961, 'duration': 1.461}, {'end': 15813.104, 'text': 'we have left the 2, because it is also on the left side.', 'start': 15810.422, 'duration': 2.682}, {'end': 15814.304, 'text': 'so what we will do here?', 'start': 15813.104, 'duration': 1.2}, {'end': 15824.351, 'text': 'right, we will try to put up this 2 here, finish it off, that is 4, 2, 3, and then you have to go to 1, so first, what did I do?', 'start': 15814.304, 'duration': 10.047}, {'end': 15833.837, 'text': 'I went to the left part that is 4, so after that you have 2 and then you have to go to right and then root.', 'start': 15824.351, 'duration': 9.486}, {'end': 15835.438, 'text': 'so this is the root.', 'start': 15833.837, 'duration': 1.601}, {'end': 15839.76, 'text': "we can't go there until unless we finish towards the right side, towards the right side.", 'start': 15835.438, 'duration': 4.322}, {'end': 15842.422, 'text': 'we had three and then we went to root back.', 'start': 15839.76, 'duration': 2.662}, {'end': 15847.485, 'text': 'so that makes four, two, three, one as a post order.', 'start': 15842.422, 'duration': 5.063}, {'end': 15849.406, 'text': 'hope this was a clear for you.', 'start': 15847.485, 'duration': 1.921}, {'end': 15855.609, 'text': "and now let's quickly hop into the coding part and check out the same elements, the same functions.", 'start': 15849.406, 'duration': 6.203}, {'end': 15856.65, 'text': 'how does that work?', 'start': 15855.609, 'duration': 1.041}, {'end': 15862.212, 'text': "so what is happening here is the same example i've taken in a coding format.", 'start': 15857.628, 'duration': 4.584}, {'end': 15869.498, 'text': "that is where i'm taking the four different nodes, that is, one, two, three, four and applying all the three functions we have, that is, in order,", 'start': 15862.212, 'duration': 7.286}, {'end': 15875.323, 'text': 'post-order and pre-order with the same way of working, but in a coding manner.', 'start': 15869.498, 'duration': 5.825}, {'end': 15876.484, 'text': 'so what has happened here?', 'start': 15875.323, 'duration': 1.161}, {'end': 15881.088, 'text': 'the first, if you could see, they have put up a class that is node right.', 'start': 15876.484, 'duration': 4.604}, {'end': 15887.076, 'text': 'so after creating a class node we have to initialize the values values.', 'start': 15881.088, 'duration': 5.988}, {'end': 15890.021, 'text': 'val is nothing but root right and left.', 'start': 15887.076, 'duration': 2.945}, {'end': 15896.209, 'text': 'so we have to have one single root node and we have to have left and right for the same root.', 'start': 15890.021, 'duration': 6.188}, {'end': 15905.273, 'text': "so then we'll create some functions for traversing towards preorder, traversal towards inorder, traversal towards postorder.", 'start': 15896.69, 'duration': 8.583}, {'end': 15911.275, 'text': 'to make it clear and precise enough, i have kept related name to the functions and classes here.', 'start': 15905.273, 'duration': 6.002}, {'end': 15917.038, 'text': "so what happens here is we'll be using the functions called preorder, postorder and inorder.", 'start': 15911.275, 'duration': 5.763}, {'end': 15921.421, 'text': 'so First it will visit the nodes accordingly, as I told you.', 'start': 15917.038, 'duration': 4.383}, {'end': 15928.347, 'text': 'So first for pre-order it will go to root left right, and for in-order it will go for left, root right,', 'start': 15921.841, 'duration': 6.506}, {'end': 15932.57, 'text': 'and again for post-order it will go for left right and root.', 'start': 15928.347, 'duration': 4.223}, {'end': 15936.374, 'text': "So let's check out how does this program work in a manner.", 'start': 15932.951, 'duration': 3.423}, {'end': 15940.299, 'text': "So here you could see I've used the left and right accordingly.", 'start': 15937.074, 'duration': 3.225}, {'end': 15944.466, 'text': "So as per the rules I've told you that has been used here as well.", 'start': 15940.319, 'duration': 4.147}, {'end': 15949.194, 'text': 'So let me quickly run the program for you and check out what is the output we get.', 'start': 15944.907, 'duration': 4.287}, {'end': 15957.138, 'text': 'right. if you could see here pre-order.', 'start': 15954.136, 'duration': 3.002}, {'end': 15959.78, 'text': 'we got it as 1, 2, 4, 3.', 'start': 15957.138, 'duration': 2.642}, {'end': 15968.487, 'text': 'the reason is because it is going from root, left and right, and for in order we are going with left, root and right.', 'start': 15959.78, 'duration': 8.707}, {'end': 15974.93, 'text': 'so left side we had 4, 2 and again 1 was the root node and 3 was at the right.', 'start': 15968.487, 'duration': 6.443}, {'end': 15976.731, 'text': 'so left root and right.', 'start': 15974.93, 'duration': 1.801}, {'end': 15982.874, 'text': 'if you go for post order traversal, then it will start from left, right and root.', 'start': 15976.731, 'duration': 6.143}, {'end': 15986.696, 'text': 'so leftmost was 4, 2 and it went to right.', 'start': 15982.874, 'duration': 3.822}, {'end': 15989.197, 'text': 'right side was 3 and root is 1.', 'start': 15986.696, 'duration': 2.501}, {'end': 15993.779, 'text': 'so this is how the traversal will work in binary tree in python.', 'start': 15989.197, 'duration': 4.582}, {'end': 15997.962, 'text': "Now let's talk about advantages and disadvantages of binary tree.", 'start': 15994.44, 'duration': 3.522}, {'end': 16002.624, 'text': 'If you talk about advantages, we can represent data with some relationship, right?', 'start': 15998.322, 'duration': 4.302}, {'end': 16006.745, 'text': 'So this is the root node or this is the parent node and this is the child node.', 'start': 16002.904, 'duration': 3.841}, {'end': 16010.127, 'text': 'So that relationship, parent-child relationship is always there.', 'start': 16007.045, 'duration': 3.082}, {'end': 16017.53, 'text': 'And while you are inserting or searching an element or node in a binary tree,', 'start': 16010.587, 'duration': 6.943}, {'end': 16022.132, 'text': 'it is much more efficient as compared to other data structures which we have seen.', 'start': 16017.53, 'duration': 4.602}, {'end': 16029.382, 'text': 'now, if you talk about disadvantage, if you want to sort this binary tree, it is much more difficult.', 'start': 16023.377, 'duration': 6.005}, {'end': 16031.263, 'text': 'right, because we can.', 'start': 16029.382, 'duration': 1.881}, {'end': 16042.011, 'text': 'obviously we can either go on the left side this can be a tree that means this is a left skew tree or this can be the scenario when we have all the elements on the right side of the node.', 'start': 16031.263, 'duration': 10.748}], 'summary': 'Explanation and coding of pre-order, in-order, and post-order traversal in a binary tree, followed by discussion of advantages and disadvantages of binary tree.', 'duration': 295.271, 'max_score': 15746.74, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c15746740.jpg'}, {'end': 15932.57, 'src': 'embed', 'start': 15905.273, 'weight': 0, 'content': [{'end': 15911.275, 'text': 'to make it clear and precise enough, i have kept related name to the functions and classes here.', 'start': 15905.273, 'duration': 6.002}, {'end': 15917.038, 'text': "so what happens here is we'll be using the functions called preorder, postorder and inorder.", 'start': 15911.275, 'duration': 5.763}, {'end': 15921.421, 'text': 'so First it will visit the nodes accordingly, as I told you.', 'start': 15917.038, 'duration': 4.383}, {'end': 15928.347, 'text': 'So first for pre-order it will go to root left right, and for in-order it will go for left, root right,', 'start': 15921.841, 'duration': 6.506}, {'end': 15932.57, 'text': 'and again for post-order it will go for left right and root.', 'start': 15928.347, 'duration': 4.223}], 'summary': 'Functions preorder, postorder, and inorder are used to visit nodes in specific orders.', 'duration': 27.297, 'max_score': 15905.273, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c15905273.jpg'}, {'end': 16313.946, 'src': 'embed', 'start': 16285.487, 'weight': 3, 'content': [{'end': 16287.929, 'text': 'After learning what is binary search tree right?', 'start': 16285.487, 'duration': 2.442}, {'end': 16292.752, 'text': 'We have to implement that particular topic here in Python on Google Colab.', 'start': 16287.969, 'duration': 4.783}, {'end': 16298.416, 'text': "So before that, let's understand what are the different function you'll see in binary search tree.", 'start': 16292.952, 'duration': 5.464}, {'end': 16302.979, 'text': 'So it is very basic function that is insert, search and delete.', 'start': 16298.716, 'duration': 4.263}, {'end': 16309.843, 'text': 'So, before going to these functions, I need to let you know that how do you draw a binary search tree?', 'start': 16303.299, 'duration': 6.544}, {'end': 16313.946, 'text': 'You have a specific condition to be followed in order to have a binary search tree.', 'start': 16309.863, 'duration': 4.083}], 'summary': 'Implement binary search tree functions in python on google colab, including insert, search, and delete.', 'duration': 28.459, 'max_score': 16285.487, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c16285487.jpg'}, {'end': 16364.469, 'src': 'embed', 'start': 16334.657, 'weight': 4, 'content': [{'end': 16341.069, 'text': "So I'll just give you a simple example of a binary search tree keeping these conditions in point.", 'start': 16334.657, 'duration': 6.412}, {'end': 16351.502, 'text': 'The first condition I told you is the root node should be taken into consideration, whatever the root node is.', 'start': 16341.59, 'duration': 9.912}, {'end': 16356.605, 'text': 'for example, the root node is 10, okay, anything below 10.', 'start': 16351.502, 'duration': 5.103}, {'end': 16364.469, 'text': 'it should come towards the left side of the root node, anything about 10, 11, 12, 13 and so on.', 'start': 16356.605, 'duration': 7.864}], 'summary': 'Binary search tree organizes nodes based on their values, e.g., nodes less than the root go to the left, those greater go to the right.', 'duration': 29.812, 'max_score': 16334.657, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c16334657.jpg'}], 'start': 15064.608, 'title': 'Binary trees and binary search trees', 'summary': 'Covers the advantages and disadvantages of linked lists, introduces binary trees, discusses variations like bst, avl, and red-black trees, and emphasizes practical implementation in python for traversal. it also delves into the efficiency of binary search trees and demonstrates operations like searching, insertion, and deletion with python implementation.', 'chapters': [{'end': 15372.739, 'start': 15064.608, 'title': 'Linked list and binary tree overview', 'summary': 'Discusses the advantages and disadvantages of linked lists, emphasizing efficient memory usage, ease of insertion and deletion, but also highlighting the limitations of losing the head node and lack of random access. it then introduces binary trees as a hierarchical data structure with at most two children for each node, presenting common traversals like pre-order, post-order, and in-order. it also mentions the applications of these data structures.', 'duration': 308.131, 'highlights': ['Linked List Advantages and Disadvantages It highlights the efficient memory usage, ease of insertion and deletion, but also emphasizes the limitations of losing the head node and lack of random access.', 'Introduction to Binary Trees It introduces binary trees as a hierarchical data structure with at most two children for each node, presenting common traversals like pre-order, post-order, and in-order.', 'Traversal Methods for Binary Trees It explains common traversal methods for binary trees, such as pre-order, post-order, and in-order, providing a brief overview of their functionality.']}, {'end': 15986.696, 'start': 15373.519, 'title': 'Binary tree basics & traversal', 'summary': 'Discusses the basics of binary trees, including variations like bst, avl, and red-black trees, followed by a practical implementation in python for in-order, pre-order, and post-order traversal, with a focus on left, root, and right node visit sequence.', 'duration': 613.177, 'highlights': ['The chapter discusses the basics of binary trees, including variations like BST, AVL, and red-black trees. The chapter introduces the basics of binary trees, discussing variations like BST, AVL, and red-black trees.', 'Practical implementation in Python for in-order, pre-order, and post-order traversal, with a focus on left, root, and right node visit sequence. The chapter delves into a practical implementation of in-order, pre-order, and post-order traversal in Python, emphasizing the sequence of left, root, and right node visitation.', 'Explanation of in-order, pre-order, and post-order traversal rules and application in the context of a simple binary tree example. The chapter provides a detailed explanation of in-order, pre-order, and post-order traversal rules and their application using a simple binary tree example.', 'Demonstration of the implementation in Python for in-order, pre-order, and post-order traversal. The chapter demonstrates the practical implementation of in-order, pre-order, and post-order traversal in Python.', 'Introduction to the file hierarchy system as an analogy to hierarchical data structures in binary trees. The chapter introduces the file hierarchy system as an analogy to hierarchical data structures in binary trees.']}, {'end': 16437.836, 'start': 15986.696, 'title': 'Binary tree and binary search tree', 'summary': 'Discusses the traversal in a binary tree, advantages and disadvantages of binary tree, additional restrictions and efficiency of binary search tree, and the application and implementation of binary search tree in python, emphasizing the insertion, search, and delete functions.', 'duration': 451.14, 'highlights': ['The chapter discusses the application and implementation of binary search tree in Python, emphasizing the insertion, search, and delete functions It explains the application of binary search tree for storing sorted hierarchical data and the suitable scenarios for its usage, along with the implementation of insertion, search, and delete functions in Python.', 'The chapter discusses the traversal in a binary tree and the advantages and disadvantages of binary tree It explains the traversal process in a binary tree and highlights the advantages of representing data with parent-child relationships and the efficiency of inserting and searching elements, while also addressing the difficulty in sorting and lack of flexibility.', 'The chapter explains the additional restrictions and efficiency of binary search tree over binary tree It explains the additional restrictions of a binary search tree, such as the constraints on the placement of elements in relation to the root node, and emphasizes the efficiency of insertion, search, and deletion in comparison to a binary tree.']}, {'end': 16798.623, 'start': 16437.836, 'title': 'Binary search tree operations', 'summary': 'Discusses the operations of searching, insertion, and deletion in a binary search tree, outlining the pseudocode and the conditions for each operation, and also mentioning the three cases for deletion, with a demonstration of implementing the operations in python on google colab.', 'duration': 360.787, 'highlights': ['The chapter discusses the operations of searching, insertion, and deletion in a binary search tree, outlining the pseudocode and the conditions for each operation.', 'It explains the conditions for searching in a binary search tree, including handling cases when the root node is null, when the input number is equal to the root, and when the number is less than or greater than the root.', 'The chapter outlines the conditions for insertion in a binary search tree, including handling cases when the node is null and when the input data is less than or greater than the node value.', 'It details the three cases to be considered for deletion in a binary search tree, including directly deleting the node, replacing the node with its child, and following the in-order traversal to determine replacement and deletion.', 'The chapter concludes with a demonstration of implementing binary search tree operations in Python on Google Colab, initializing a class and considering three different elements for implementation.']}], 'duration': 1734.015, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c15064608.jpg', 'highlights': ['Practical implementation in Python for in-order, pre-order, and post-order traversal, emphasizing the sequence of left, root, and right node visitation.', 'Demonstration of the implementation in Python for in-order, pre-order, and post-order traversal.', 'Introduction to Binary Trees as a hierarchical data structure with at most two children for each node, presenting common traversals like pre-order, post-order, and in-order.', 'The chapter discusses the application and implementation of binary search tree in Python, emphasizing the insertion, search, and delete functions.', 'The chapter outlines the conditions for insertion in a binary search tree, including handling cases when the node is null and when the input data is less than or greater than the node value.']}, {'end': 17800.777, 'segs': [{'end': 17054.268, 'src': 'embed', 'start': 17008.276, 'weight': 0, 'content': [{'end': 17016.78, 'text': "so we'll replace with the help of in order method or what is the flow of, in order that is left root and correct.", 'start': 17008.276, 'duration': 8.504}, {'end': 17023.602, 'text': 'so, considering this factor, it will give you the deletion process and replacement for that particular deleted node as well.', 'start': 17016.78, 'duration': 6.822}, {'end': 17026.583, 'text': "so that's about binary search tree.", 'start': 17023.602, 'duration': 2.981}, {'end': 17030.444, 'text': "now let's talk about advantages and disadvantages of binary tree.", 'start': 17026.583, 'duration': 3.861}, {'end': 17034.749, 'text': 'if you talk about advantages, We can represent data with some relationship right?', 'start': 17030.444, 'duration': 4.305}, {'end': 17038.853, 'text': 'So this is the root node or this is the parent node and this is the child node.', 'start': 17035.03, 'duration': 3.823}, {'end': 17042.256, 'text': 'So that relationship, parent-child relationship is always there.', 'start': 17039.154, 'duration': 3.102}, {'end': 17049.643, 'text': 'And while you are inserting or searching an element or node in a binary tree,', 'start': 17042.697, 'duration': 6.946}, {'end': 17054.268, 'text': 'it is much more efficient as compared to other data structures which we have seen.', 'start': 17049.643, 'duration': 4.625}], 'summary': 'Binary search tree offers efficient insertion and search with clear parent-child relationships. it outperforms other data structures in terms of efficiency.', 'duration': 45.992, 'max_score': 17008.276, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c17008276.jpg'}, {'end': 17112.166, 'src': 'embed', 'start': 17078.785, 'weight': 4, 'content': [{'end': 17082.719, 'text': 'so sorting is difficult and it is not much more much flexible.', 'start': 17078.785, 'duration': 3.934}, {'end': 17089.744, 'text': 'right, if you talk about this binary tree, we always have either the two children or one children or no children.', 'start': 17082.719, 'duration': 7.025}, {'end': 17093.827, 'text': 'there is no flexibility in terms of how you want to store it.', 'start': 17089.744, 'duration': 4.083}, {'end': 17097.73, 'text': 'can we store another node on the with this root node?', 'start': 17093.827, 'duration': 3.903}, {'end': 17104.256, 'text': "no, that is not the case, right, and we don't follow any restrictions like okay, we always find this node.", 'start': 17097.73, 'duration': 6.526}, {'end': 17112.166, 'text': 'that is, if this is in root node, we always find a element which is less than this node on the left side or on the right side, that is,', 'start': 17104.256, 'duration': 7.91}], 'summary': 'Binary trees provide limited flexibility with two, one, or no children, and follow restrictions on node placement.', 'duration': 33.381, 'max_score': 17078.785, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c17078785.jpg'}, {'end': 17167.939, 'src': 'embed', 'start': 17144.093, 'weight': 3, 'content': [{'end': 17154.036, 'text': 'so vertices will be represented with the help of V, capital V or small v, and edges will be represented with the help of capital E or small e,', 'start': 17144.093, 'duration': 9.943}, {'end': 17156.356, 'text': 'and it will always define the relationship.', 'start': 17154.036, 'duration': 2.32}, {'end': 17162.198, 'text': 'we will be having certain connections between the edges or the vertices or the node to node connections.', 'start': 17156.356, 'duration': 5.842}, {'end': 17167.939, 'text': 'so There are different types of graphs for different types of projects or computer science concepts.', 'start': 17162.198, 'duration': 5.741}], 'summary': 'Graphs are represented by vertices and edges, defining relationships and connections between nodes, used for various projects and computer science concepts.', 'duration': 23.846, 'max_score': 17144.093, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c17144093.jpg'}, {'end': 17465.886, 'src': 'heatmap', 'start': 17176.741, 'weight': 0.863, 'content': [{'end': 17185.323, 'text': "So I'll write down a simple graph which is having certain connections.", 'start': 17176.741, 'duration': 8.582}, {'end': 17207.358, 'text': 'right. so here what you can consider vertices are a, b, d and c.', 'start': 17193.675, 'duration': 13.683}, {'end': 17210.639, 'text': 'so whatever the nodes you have, those are the vertices.', 'start': 17207.358, 'duration': 3.281}, {'end': 17211.959, 'text': 'how do you count the edges?', 'start': 17210.639, 'duration': 1.32}, {'end': 17214.379, 'text': 'so here i have just connected it together.', 'start': 17211.959, 'duration': 2.42}, {'end': 17217.06, 'text': 'so it is forming a loop kind of element.', 'start': 17214.379, 'duration': 2.681}, {'end': 17223.145, 'text': 'so if you consider some other graph also, you can have a clarity on edges.', 'start': 17217.06, 'duration': 6.085}, {'end': 17225.067, 'text': 'right, I am cutting down this.', 'start': 17223.145, 'duration': 1.922}, {'end': 17231.332, 'text': 'so if you want to know what is an edge, so edge forms between A and B.', 'start': 17225.067, 'duration': 6.265}, {'end': 17235.67, 'text': 'again, you have an edge from a and d right.', 'start': 17231.332, 'duration': 4.338}, {'end': 17238.672, 'text': 'if you want to implement that in this graph as well,', 'start': 17235.67, 'duration': 3.002}, {'end': 17247.718, 'text': 'you can take it as a to b as one edge and b to c as one more edge and c to d as another edge right.', 'start': 17238.672, 'duration': 9.046}, {'end': 17252.641, 'text': 'so edges are calculated between the connection between the two different vertices.', 'start': 17247.718, 'duration': 4.923}, {'end': 17259.485, 'text': "this is the basic introduction towards the graph data structure and we'll be seeing implementation in python as well.", 'start': 17252.641, 'duration': 6.844}, {'end': 17268.472, 'text': 'So there is a graph class and you have to have a constructor in order to know the edges, in order to store the vertices,', 'start': 17260.686, 'duration': 7.786}, {'end': 17271.033, 'text': 'and you have to store the graph weight as well.', 'start': 17268.472, 'duration': 2.561}, {'end': 17276.477, 'text': 'So we have to allocate certain memory in the format of list in Python for that.', 'start': 17271.534, 'duration': 4.943}, {'end': 17279.86, 'text': 'And then we are adding edges to the directed graph.', 'start': 17276.998, 'duration': 2.862}, {'end': 17282.181, 'text': 'So I told you there are different types of graphs.', 'start': 17280.14, 'duration': 2.041}, {'end': 17285.404, 'text': 'It is directed weighted graphs and it is graph in loop.', 'start': 17282.241, 'duration': 3.163}, {'end': 17289.787, 'text': "So everything will be considered, but here I'm considering for directed graph.", 'start': 17285.424, 'duration': 4.363}, {'end': 17296.052, 'text': 'and then you have the edges where you have sources and destination.', 'start': 17290.427, 'duration': 5.625}, {'end': 17300.655, 'text': 'that is if it is a and b, a is a source and b is a destination.', 'start': 17296.052, 'duration': 4.603}, {'end': 17302.597, 'text': 'so that is how edges are calculated.', 'start': 17300.655, 'duration': 1.942}, {'end': 17305.379, 'text': 'it is a combination of two different vertices.', 'start': 17302.597, 'duration': 2.782}, {'end': 17310.183, 'text': 'so then you have a function in order to print the list.', 'start': 17305.379, 'duration': 4.804}, {'end': 17315.768, 'text': 'whatever the list is there in graph we cannot draw as it is as we draw to understand the graph.', 'start': 17310.183, 'duration': 5.585}, {'end': 17325.214, 'text': 'but we have to put that in a sequential order or in the form of list so that particular representation is taken care with the help of print graph function.', 'start': 17315.768, 'duration': 9.446}, {'end': 17328.116, 'text': 'and then we have the input.', 'start': 17325.214, 'duration': 2.902}, {'end': 17330.157, 'text': 'so input is already given here.', 'start': 17328.116, 'duration': 2.041}, {'end': 17332.698, 'text': 'so the edges is being directed.', 'start': 17330.157, 'duration': 2.541}, {'end': 17339.502, 'text': 'so 0 to 1, 1 to 2 and 2 to 0, 2 to 1, 3 to 2 and 4 to 5 and 5 to 4.', 'start': 17332.698, 'duration': 6.804}, {'end': 17341.284, 'text': 'so the edges are being connected.', 'start': 17339.502, 'duration': 1.782}, {'end': 17344.605, 'text': 'it has been directed from which vertex to another vertex.', 'start': 17341.284, 'duration': 3.321}, {'end': 17347.967, 'text': 'it has been told here with the help of edges.', 'start': 17344.605, 'duration': 3.362}, {'end': 17350.028, 'text': 'and then what are the different vertices we have?', 'start': 17347.967, 'duration': 2.061}, {'end': 17352.249, 'text': 'we have the labeling from 0 to 5.', 'start': 17350.028, 'duration': 2.221}, {'end': 17354.91, 'text': 'that means we have 6 different vertices.', 'start': 17352.249, 'duration': 2.661}, {'end': 17357.27, 'text': 'and then we have to construct the graph.', 'start': 17354.91, 'duration': 2.36}, {'end': 17358.491, 'text': 'how do you construct a graph?', 'start': 17357.27, 'duration': 1.221}, {'end': 17366.414, 'text': 'with the help of this particular statement that is, graph is combination of edges and the number of vertices we have,', 'start': 17358.491, 'duration': 7.923}, {'end': 17370.957, 'text': 'and we are finally printing the graph And it goes like this', 'start': 17366.414, 'duration': 4.543}, {'end': 17377.985, 'text': 'So first it will go from 0 to 1 and then 1 to 2, 2 to again 0, again 3 to 2, 4 to 5, 5 to 4.', 'start': 17371.057, 'duration': 6.928}, {'end': 17381.609, 'text': 'You have one more extension here that is 2 to 1.', 'start': 17377.985, 'duration': 3.624}, {'end': 17385.693, 'text': 'So this is how the graph looks like in Python.', 'start': 17381.609, 'duration': 4.084}, {'end': 17394.701, 'text': "after knowing what is breadth first search right, we'll implement that particular bfs algorithm in python as well.", 'start': 17386.494, 'duration': 8.207}, {'end': 17399.105, 'text': "so before that, let's quickly see what is this algorithm all about.", 'start': 17394.701, 'duration': 4.404}, {'end': 17407.472, 'text': 'in general, breadth first search will always traverse the nodes, which is from level 1 to level 2 to level 3..', 'start': 17399.105, 'duration': 8.367}, {'end': 17410.014, 'text': 'it will not leave any single level.', 'start': 17407.472, 'duration': 2.542}, {'end': 17420.221, 'text': 'so, for example, if you have a node right, a root node followed by sub nodes, so you will traverse level wise, not node wise.', 'start': 17410.014, 'duration': 10.207}, {'end': 17428.466, 'text': 'so, for example, say you have 10 here and you have 8, 9.', 'start': 17420.221, 'duration': 8.245}, {'end': 17430.487, 'text': 'this is level 1.', 'start': 17428.466, 'duration': 2.021}, {'end': 17433.85, 'text': 'sometimes it is also called as level 0 as well.', 'start': 17430.487, 'duration': 3.363}, {'end': 17437.652, 'text': 'right, again, you have one more level 11.', 'start': 17433.85, 'duration': 3.802}, {'end': 17440.313, 'text': 'this is 12.', 'start': 17437.652, 'duration': 2.661}, {'end': 17445.311, 'text': 'again here this is 13 and this is 14.', 'start': 17440.313, 'duration': 4.998}, {'end': 17449.414, 'text': 'right, you have this graph and it goes level wise.', 'start': 17445.311, 'duration': 4.103}, {'end': 17450.375, 'text': 'this is level 2.', 'start': 17449.414, 'duration': 0.961}, {'end': 17451.716, 'text': 'or it can also be level 1.', 'start': 17450.375, 'duration': 1.341}, {'end': 17453.737, 'text': 'if you start with 0, it comes with 1.', 'start': 17451.716, 'duration': 2.021}, {'end': 17456.679, 'text': 'if you start with 1, it will go to 2.', 'start': 17453.737, 'duration': 2.942}, {'end': 17465.886, 'text': 'so first it will start with 10, it will finish 8, it will finish 9 again, it will come back to 11 and then 12.', 'start': 17456.679, 'duration': 9.207}], 'summary': 'Introduction to graph data structure and its implementation in python, covering edges, vertices, and breadth first search algorithm.', 'duration': 289.145, 'max_score': 17176.741, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c17176741.jpg'}, {'end': 17285.404, 'src': 'embed', 'start': 17260.686, 'weight': 5, 'content': [{'end': 17268.472, 'text': 'So there is a graph class and you have to have a constructor in order to know the edges, in order to store the vertices,', 'start': 17260.686, 'duration': 7.786}, {'end': 17271.033, 'text': 'and you have to store the graph weight as well.', 'start': 17268.472, 'duration': 2.561}, {'end': 17276.477, 'text': 'So we have to allocate certain memory in the format of list in Python for that.', 'start': 17271.534, 'duration': 4.943}, {'end': 17279.86, 'text': 'And then we are adding edges to the directed graph.', 'start': 17276.998, 'duration': 2.862}, {'end': 17282.181, 'text': 'So I told you there are different types of graphs.', 'start': 17280.14, 'duration': 2.041}, {'end': 17285.404, 'text': 'It is directed weighted graphs and it is graph in loop.', 'start': 17282.241, 'duration': 3.163}], 'summary': 'Graph class stores edges, vertices, and weights. adding edges to directed weighted and looped graphs.', 'duration': 24.718, 'max_score': 17260.686, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c17260686.jpg'}, {'end': 17410.014, 'src': 'embed', 'start': 17381.609, 'weight': 1, 'content': [{'end': 17385.693, 'text': 'So this is how the graph looks like in Python.', 'start': 17381.609, 'duration': 4.084}, {'end': 17394.701, 'text': "after knowing what is breadth first search right, we'll implement that particular bfs algorithm in python as well.", 'start': 17386.494, 'duration': 8.207}, {'end': 17399.105, 'text': "so before that, let's quickly see what is this algorithm all about.", 'start': 17394.701, 'duration': 4.404}, {'end': 17407.472, 'text': 'in general, breadth first search will always traverse the nodes, which is from level 1 to level 2 to level 3..', 'start': 17399.105, 'duration': 8.367}, {'end': 17410.014, 'text': 'it will not leave any single level.', 'start': 17407.472, 'duration': 2.542}], 'summary': 'Implementing breadth first search algorithm in python to traverse nodes from level 1 to level 3.', 'duration': 28.405, 'max_score': 17381.609, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c17381609.jpg'}, {'end': 17616.027, 'src': 'embed', 'start': 17588.045, 'weight': 6, 'content': [{'end': 17593.991, 'text': "so let's quickly see what is depth first search before implementing the same right.", 'start': 17588.045, 'duration': 5.946}, {'end': 17601.077, 'text': 'so this algorithm will always travels between nodes towards the depth of the tree.', 'start': 17593.991, 'duration': 7.086}, {'end': 17603.019, 'text': 'that means first node.', 'start': 17601.077, 'duration': 1.942}, {'end': 17610.664, 'text': 'if it is having two, three and four levels, first it will complete the levels according to the depth.', 'start': 17603.019, 'duration': 7.645}, {'end': 17616.027, 'text': 'wise, it will not go towards horizontal manner, it will just work in the vertical manner.', 'start': 17610.664, 'duration': 5.363}], 'summary': 'Depth first search algorithm explores tree depth-wise, not horizontally.', 'duration': 27.982, 'max_score': 17588.045, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c17588045.jpg'}], 'start': 16798.623, 'title': 'Binary trees and graph data structure', 'summary': 'Covers binary tree operations, such as insertion and deletion, using the in-order method, and discusses the efficiency and sorting challenges. it also introduces the graph data structure, emphasizing the implementation in python and different graph types, along with traversal algorithms like breadth-first search and depth-first search.', 'chapters': [{'end': 17118.537, 'start': 16798.623, 'title': 'Binary tree operations and properties', 'summary': 'Covers the operations of inserting, deleting, and traversing a binary tree using the in order method, highlighting the advantages and disadvantages of binary trees, with a focus on efficiency and sorting challenges.', 'duration': 319.914, 'highlights': ['Binary tree operations The chapter focuses on the operations of inserting, deleting, and traversing a binary tree using the in order method, emphasizing the rules and conditions for each operation.', 'Efficiency of binary tree operations Efficiency in inserting or searching an element or node in a binary tree is highlighted as being much more efficient compared to other data structures, emphasizing the advantage of binary trees.', 'Sorting challenges and inflexibility The difficulty in sorting binary trees and their lack of flexibility, with a focus on the limitations of storing nodes and the absence of flexibility in node placement, are highlighted as disadvantages of binary trees.']}, {'end': 17305.379, 'start': 17118.857, 'title': 'Introduction to graph data structure', 'summary': 'Introduces the concept of graph data structure, defining vertices and edges and explaining their relationship, with a focus on implementation in python and different types of graphs, including directed weighted graphs.', 'duration': 186.522, 'highlights': ['Graph is a collection of vertices and edges, with different types of graphs for different projects or computer science concepts. The graph is a collection of vertices and edges, with different types of graphs for various projects or computer science concepts.', 'Vertices are represented as V or v, edges as E or e, and they define the relationship and connections between nodes. Vertices are represented as V or v, edges as E or e, and they define the relationship and connections between nodes.', 'Introduction to graph data structure and its implementation in Python, including the use of a graph class and the allocation of memory for storing vertices and graph weight. Introduction to graph data structure and its implementation in Python, including the use of a graph class and the allocation of memory for storing vertices and graph weight.']}, {'end': 17800.777, 'start': 17305.379, 'title': 'Graph traversal algorithms in python', 'summary': 'Introduces and explains the concepts of breadth first search and depth first search algorithms in python, emphasizing their traversal strategies and sequential node visits in graph representation.', 'duration': 495.398, 'highlights': ['The chapter introduces breadth first search and depth first search algorithms in Python The chapter introduces the concepts of breadth first search and depth first search algorithms in Python, providing an overview of the two traversal strategies.', 'Breadth first search traverses nodes level-wise and does not leave any single level Breadth first search algorithm traverses nodes level-wise, ensuring that each level is visited before moving to the next, providing a clear strategy for graph traversal.', 'Depth first search algorithm works by traveling between nodes towards the depth of the tree or graph The depth first search algorithm focuses on traveling in a vertical manner, prioritizing the depth of the tree or graph over horizontal traversal, emphasizing its distinct approach to graph traversal.']}], 'duration': 1002.154, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c16798623.jpg', 'highlights': ['Efficiency in inserting or searching an element or node in a binary tree is highlighted as being much more efficient compared to other data structures, emphasizing the advantage of binary trees.', 'The chapter introduces breadth first search and depth first search algorithms in Python, providing an overview of the two traversal strategies.', 'Binary tree operations The chapter focuses on the operations of inserting, deleting, and traversing a binary tree using the in order method, emphasizing the rules and conditions for each operation.', 'Graph is a collection of vertices and edges, with different types of graphs for different projects or computer science concepts.', 'Sorting challenges and inflexibility The difficulty in sorting binary trees and their lack of flexibility, with a focus on the limitations of storing nodes and the absence of flexibility in node placement, are highlighted as disadvantages of binary trees.', 'Introduction to graph data structure and its implementation in Python, including the use of a graph class and the allocation of memory for storing vertices and graph weight.', 'Breadth first search traverses nodes level-wise and does not leave any single level Breadth first search algorithm traverses nodes level-wise, ensuring that each level is visited before moving to the next, providing a clear strategy for graph traversal.', 'Depth first search algorithm works by traveling between nodes towards the depth of the tree or graph The depth first search algorithm focuses on traveling in a vertical manner, prioritizing the depth of the tree or graph over horizontal traversal, emphasizing its distinct approach to graph traversal.']}, {'end': 19929.137, 'segs': [{'end': 17829.435, 'src': 'embed', 'start': 17800.777, 'weight': 0, 'content': [{'end': 17804.96, 'text': 'first, search in python, hash tables is our next concept.', 'start': 17800.777, 'duration': 4.183}, {'end': 17807.408, 'text': 'So what is hash table?', 'start': 17805.467, 'duration': 1.941}, {'end': 17810.509, 'text': "Before learning that, let's see what is hashing.", 'start': 17807.528, 'duration': 2.981}, {'end': 17819.092, 'text': 'So hashing plays a very important role generally in order to compress data, in order to have encrypted.', 'start': 17810.889, 'duration': 8.203}, {'end': 17821.293, 'text': "It's not exact encryption.", 'start': 17819.432, 'duration': 1.861}, {'end': 17824.994, 'text': 'It is just changing the values into its relevant keys.', 'start': 17821.433, 'duration': 3.561}, {'end': 17827.535, 'text': 'OK, so cryptology we see.', 'start': 17825.234, 'duration': 2.301}, {'end': 17829.435, 'text': 'So that is also there.', 'start': 17828.015, 'duration': 1.42}], 'summary': 'Introduction to hash tables and hashing in python for data compression and encryption.', 'duration': 28.658, 'max_score': 17800.777, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c17800777.jpg'}, {'end': 17930.392, 'src': 'embed', 'start': 17899.55, 'weight': 2, 'content': [{'end': 17907.372, 'text': 'people will recognize in case if they want to do any communication or it is necessary for any documentation.', 'start': 17899.55, 'duration': 7.822}, {'end': 17909.473, 'text': 'so they use employee id.', 'start': 17907.372, 'duration': 2.101}, {'end': 17917.455, 'text': 'so employee id acts as a real-time example for keying, and this is a hashing technique.', 'start': 17909.473, 'duration': 7.982}, {'end': 17927.691, 'text': 'for example, the first person, sham r, is assigned with the employee id to, so anywhere anytime, if they ask for employee to,', 'start': 17917.455, 'duration': 10.236}, {'end': 17930.392, 'text': 'that is always sham are right.', 'start': 17927.691, 'duration': 2.701}], 'summary': 'Employee id is used for communication and documentation, acting as a real-time example for keying and employing hashing technique.', 'duration': 30.842, 'max_score': 17899.55, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c17899550.jpg'}, {'end': 18235.097, 'src': 'embed', 'start': 18206.53, 'weight': 1, 'content': [{'end': 18213.993, 'text': 'so this is how you implement hashing function with the help of particular mathematical formula.', 'start': 18206.53, 'duration': 7.463}, {'end': 18216.726, 'text': 'So this is the table which is formed.', 'start': 18215.005, 'duration': 1.721}, {'end': 18223.67, 'text': "Let's implement this particular example in Python programming with the same concept.", 'start': 18217.887, 'duration': 5.783}, {'end': 18224.671, 'text': "It's very simple.", 'start': 18223.85, 'duration': 0.821}, {'end': 18226.952, 'text': "Let's quickly switch on to the IDE now.", 'start': 18225.051, 'duration': 1.901}, {'end': 18231.415, 'text': 'Here you can find this particular program.', 'start': 18227.933, 'duration': 3.482}, {'end': 18235.097, 'text': 'Whatever I thought as an example is put up into a program.', 'start': 18231.735, 'duration': 3.362}], 'summary': 'Implement hashing function using a mathematical formula in python with a simple example.', 'duration': 28.567, 'max_score': 18206.53, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c18206530.jpg'}, {'end': 18435.783, 'src': 'embed', 'start': 18408.82, 'weight': 3, 'content': [{'end': 18412.641, 'text': 'This is, again, a step by step approach to solve a particular problem.', 'start': 18408.82, 'duration': 3.821}, {'end': 18417.843, 'text': 'It helps us identify which algorithm is optimal.', 'start': 18413.202, 'duration': 4.641}, {'end': 18421.925, 'text': 'OK, this is the analysis part of algorithm right here.', 'start': 18417.944, 'duration': 3.981}, {'end': 18424.186, 'text': "Let's suppose I told you to swap.", 'start': 18422.505, 'duration': 1.681}, {'end': 18429.048, 'text': 'It helps us to understand the trade off between time and space complexity.', 'start': 18424.706, 'duration': 4.342}, {'end': 18435.783, 'text': 'Right So there should be always, you should be able to understand the difference between time complexity and space complexity.', 'start': 18429.288, 'duration': 6.495}], 'summary': 'Step-by-step approach to identify optimal algorithms, analyzing time and space complexity trade-offs.', 'duration': 26.963, 'max_score': 18408.82, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c18408820.jpg'}, {'end': 18685.244, 'src': 'embed', 'start': 18657.563, 'weight': 4, 'content': [{'end': 18662.544, 'text': 'And you always deduce your time and space complexities based on worst case.', 'start': 18657.563, 'duration': 4.981}, {'end': 18669.206, 'text': 'It is computed because the analysis as it dictates the maximum resource requirements.', 'start': 18662.885, 'duration': 6.321}, {'end': 18677.129, 'text': 'So worst case helps us to find what are the maximum resources that this is going to take.', 'start': 18669.546, 'duration': 7.583}, {'end': 18682.01, 'text': 'So we keep track of those things and we allocate resources in such manner.', 'start': 18677.409, 'duration': 4.601}, {'end': 18685.244, 'text': 'So we always talk about worst case.', 'start': 18682.642, 'duration': 2.602}], 'summary': 'Deduce time and space complexities based on worst case for resource allocation.', 'duration': 27.681, 'max_score': 18657.563, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c18657563.jpg'}, {'end': 19025.593, 'src': 'embed', 'start': 18995.908, 'weight': 9, 'content': [{'end': 19003.711, 'text': 'That means you are multiplying big O of n, that is for the nested one, okay, into big O of log n.', 'start': 18995.908, 'duration': 7.803}, {'end': 19004.772, 'text': 'So you are multiplying it.', 'start': 19003.711, 'duration': 1.061}, {'end': 19011.654, 'text': 'Whenever you have a situation wherein you have a for loop inside a for loop, therein you will multiply the time complexities.', 'start': 19005.172, 'duration': 6.482}, {'end': 19016.336, 'text': 'Now you have a for loop outside and then you have this nested for loop.', 'start': 19012.295, 'duration': 4.041}, {'end': 19025.593, 'text': 'For this nested for loop, you have n into log n, right? And for this, you have what? Big O of N.', 'start': 19016.676, 'duration': 8.917}], 'summary': 'Nested for loops multiply time complexities, e.g. o(n * log n).', 'duration': 29.685, 'max_score': 18995.908, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c18995908.jpg'}, {'end': 19102.74, 'src': 'embed', 'start': 19060.09, 'weight': 5, 'content': [{'end': 19069.174, 'text': "As soon as our input is increased, these terms will be neglected and they will not be that much significant while you're allocating resources.", 'start': 19060.09, 'duration': 9.084}, {'end': 19078.06, 'text': 'Now, what about the space complexity? It determines the total space to be allocated in order to solve a particular problem.', 'start': 19070.834, 'duration': 7.226}, {'end': 19086.688, 'text': 'Now, whenever you are using any extra space in the algorithm while you are implementing it, that is termed to be as space complexity.', 'start': 19078.521, 'duration': 8.167}, {'end': 19094.715, 'text': 'It can be in the form of arrays that extra array that you have used to solve a problem, or an extra linked list that you have used to solve a problem,', 'start': 19087.008, 'duration': 7.707}, {'end': 19096.697, 'text': 'or a stack or a queue.', 'start': 19094.715, 'duration': 1.982}, {'end': 19100.057, 'text': 'right?. It involves memory of the computer, right?', 'start': 19096.697, 'duration': 3.36}, {'end': 19102.74, 'text': "You're involving memory right?", 'start': 19100.758, 'duration': 1.982}], 'summary': 'Increasing input neglects terms; space complexity involves extra space in algorithms.', 'duration': 42.65, 'max_score': 19060.09, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c19060090.jpg'}, {'end': 19407.418, 'src': 'embed', 'start': 19382.833, 'weight': 7, 'content': [{'end': 19388.254, 'text': 'you know concepts which we use, like, for example, conditional loops, conditional statements.', 'start': 19382.833, 'duration': 5.421}, {'end': 19391.955, 'text': 'then you know looping constructs, so nested loops.', 'start': 19388.254, 'duration': 3.701}, {'end': 19395.356, 'text': 'so how does you know time complexity is found?', 'start': 19391.955, 'duration': 3.401}, {'end': 19402.357, 'text': 'or in this cases, and also the space complex like, what is the total space being taken while executing that particular code?', 'start': 19395.356, 'duration': 7.001}, {'end': 19404.237, 'text': 'you know space when I talk about.', 'start': 19402.357, 'duration': 1.88}, {'end': 19407.418, 'text': 'you know how many variable at a time resides in memory.', 'start': 19404.237, 'duration': 3.181}], 'summary': 'Discussion on time and space complexity in coding, including nested loops and memory usage.', 'duration': 24.585, 'max_score': 19382.833, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c19382833.jpg'}, {'end': 19551.698, 'src': 'embed', 'start': 19525.181, 'weight': 8, 'content': [{'end': 19530.222, 'text': 'Because every time, no matter how much is the input, every time that same two variables occupies the space.', 'start': 19525.181, 'duration': 5.041}, {'end': 19533.265, 'text': 'So space here complexity will be O of 1.', 'start': 19530.523, 'duration': 2.742}, {'end': 19537.428, 'text': 'But time complexity will be for one element this for loop will run only one time.', 'start': 19533.265, 'duration': 4.163}, {'end': 19540.85, 'text': 'So time complexity will be also one unit of time it is going to take.', 'start': 19538.148, 'duration': 2.702}, {'end': 19544.173, 'text': 'For two elements this for loop will run two times.', 'start': 19541.271, 'duration': 2.902}, {'end': 19548.436, 'text': 'Similarly for n elements this for loop is going to run n times.', 'start': 19545.253, 'duration': 3.183}, {'end': 19551.698, 'text': 'So this statement will be executed how many times? n times.', 'start': 19548.756, 'duration': 2.942}], 'summary': 'Time complexity is o(n) and space complexity is o(1) for the given code.', 'duration': 26.517, 'max_score': 19525.181, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c19525181.jpg'}, {'end': 19735.336, 'src': 'embed', 'start': 19710.696, 'weight': 10, 'content': [{'end': 19717.001, 'text': 'suppose the time complexity of this is o of n and time complexity of this is o of n square,', 'start': 19710.696, 'duration': 6.305}, {'end': 19719.723, 'text': 'which will be the final time complexity out of this complete.', 'start': 19717.001, 'duration': 2.722}, {'end': 19722.005, 'text': 'if else loop.', 'start': 19719.723, 'duration': 2.282}, {'end': 19732.053, 'text': 'final time complexity will be whichever part of either if or else whichever part has less time complexity which is taking less time to execute.', 'start': 19722.005, 'duration': 10.048}, {'end': 19735.336, 'text': 'if this is taking n times to execute, this is taking n square times to execute.', 'start': 19732.053, 'duration': 3.283}], 'summary': 'The final time complexity is o(n) due to the if-else loop.', 'duration': 24.64, 'max_score': 19710.696, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c19710696.jpg'}, {'end': 19884.638, 'src': 'embed', 'start': 19853.596, 'weight': 11, 'content': [{'end': 19858.057, 'text': 'Okay Then there is this do I loop which also takes the time complexity of O of n.', 'start': 19853.596, 'duration': 4.461}, {'end': 19862.358, 'text': 'Okay Then there is this a is equal a plus plus statement which takes constant time.', 'start': 19858.057, 'duration': 4.301}, {'end': 19866.44, 'text': 'Okay Then in this case what will be the final time complexity.', 'start': 19863.279, 'duration': 3.161}, {'end': 19874.642, 'text': 'So the final time complexity is going to be the summation of all that is 1 plus n plus n plus 1.', 'start': 19867.12, 'duration': 7.522}, {'end': 19878.043, 'text': 'Okay, And this will be your.', 'start': 19874.642, 'duration': 3.401}, {'end': 19884.638, 'text': "So, constants are always removed because it doesn't play much role, because constant is going to be always taking constant time.", 'start': 19878.874, 'duration': 5.764}], 'summary': 'The final time complexity is the summation of 1 plus n plus n plus 1, resulting in o(n).', 'duration': 31.042, 'max_score': 19853.596, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c19853596.jpg'}], 'start': 17800.777, 'title': 'Hash tables, hashing, and algorithm efficiency', 'summary': "Introduces hash tables in python, emphasizes hashing's role in data compression, encryption, and database indexing, explains employee ids as unique identifiers, discusses algorithm analysis, efficiency, time and space complexities, and provides examples for optimal algorithm selection and determining time and space complexity.", 'chapters': [{'end': 17850.716, 'start': 17800.777, 'title': 'Hash tables in python', 'summary': 'Introduces the concept of hash tables in python, highlighting its role in data compression, encryption, and database indexing, emphasizing the function of hashing as a black box that provides hash values as output.', 'duration': 49.939, 'highlights': ['Hashing plays a crucial role in data compression and encryption, serving as a black box that provides hash values as output.', 'Hash tables are used for database indexing and can be implemented in Python.', 'Hashing is described as a black box that takes a key as input and provides hash values as output.']}, {'end': 18285.289, 'start': 17851.076, 'title': 'Understanding hashing and hash tables', 'summary': 'Discusses the importance of employee ids as unique identifiers in an organization, explaining the concept of hashing and demonstrating its implementation through a mathematical formula and python programming, with a focus on minimalistic collision and hash table structure.', 'duration': 434.213, 'highlights': ['Employee ID as a unique identifier Employee ID is emphasized as the unique identifier for individuals in an organization, ensuring no repetition and providing a one-way function for communication and documentation.', 'Importance of hashing and hash function The concept of hashing and hash function is explained, highlighting its role in generating unique hash keys for values and the use of a mathematical formula (h of k = k1 modulo m) for hash function.', 'Implementation of hashing in Python programming The demonstration of implementing hashing technique through Python programming, utilizing a hash function to determine the storage location of values in a hash table with a focus on minimalistic collision.']}, {'end': 18564.463, 'start': 18285.289, 'title': 'Algorithm analysis and efficiency', 'summary': 'Discusses the concept of algorithms, algorithm analysis, and efficiency, emphasizing the importance of language-independent and efficient approaches, and the trade-offs between time and space complexity, with examples of best, worst, and average case scenarios.', 'duration': 279.174, 'highlights': ['The chapter explains the concept of algorithms as a step-by-step approach to solving a problem, emphasizing the importance of providing a precise and language-independent solution. An algorithm is defined as a step-by-step approach to solve a particular problem, emphasizing the need for a precise and language-independent solution.', 'It discusses the importance of efficiency in algorithms, presenting different approaches for swapping two numbers and emphasizing the need for non-technical understanding. Efficiency in algorithms is highlighted through examples of different approaches for swapping two numbers, emphasizing the need for non-technical understanding.', 'The chapter introduces algorithm analysis, emphasizing its role in identifying optimal algorithms and understanding the trade-offs between time and space complexity. Algorithm analysis is introduced as a tool to identify optimal algorithms and understand the trade-offs between time and space complexity.', 'It provides examples of best, worst, and average case scenarios to illustrate the impact of different approaches on time complexity in algorithmic analysis. Examples of best, worst, and average case scenarios are provided to illustrate the impact of different approaches on time complexity in algorithmic analysis.']}, {'end': 19165.165, 'start': 18564.463, 'title': 'Time and space complexity in algorithms', 'summary': 'Discusses the importance of worst-case analysis in determining time and space complexities, highlighting how it influences resource allocation. it emphasizes the impact of input size on time complexity, showcasing examples of linear and binary search. additionally, it explains the concept of space complexity and its role in optimal algorithm selection.', 'duration': 600.702, 'highlights': ['The importance of worst-case analysis in determining time and space complexities The worst-case scenario dictates the maximum resource requirements, influencing resource allocation and aiding in determining the time and space complexities.', 'Impact of input size on time complexity with examples of linear and binary search As the input size grows, the time complexity becomes substantial, highlighting the trade-off between time and space. Binary search works faster than linear search due to its time complexity.', 'Explanation of space complexity and its role in optimal algorithm selection Space complexity involves using extra memory in algorithms and is critical in optimal algorithm selection, emphasizing the preference for minimal space usage.']}, {'end': 19929.137, 'start': 19165.165, 'title': 'Time and space complexity in algorithms', 'summary': 'Discusses the calculation of time and space complexity in algorithms using examples of different constructs such as loops, conditional statements, and sequential statements, demonstrating how to determine the time and space complexity of the code for given inputs.', 'duration': 763.972, 'highlights': ['The time and space complexity of algorithms can be determined using different constructs like loops, conditional statements, and sequential statements. The chapter explains how to calculate time and space complexity using examples of constructs like loops, conditional statements, and sequential statements.', "The time complexity of a for loop is O(n), where 'n' is the number of input elements, and the space complexity is O(1) as it requires constant space regardless of the input size. The time complexity of a for loop is O(n) and the space complexity is O(1) as it requires constant space regardless of the input size.", 'The time complexity of nested loops is O(n^2), calculated by multiplying the iterations of the outer loop with the iterations of the inner loop, and the space complexity remains O(1) as it requires constant space. The time complexity of nested loops is O(n^2), calculated by multiplying the iterations of the outer loop with the iterations of the inner loop, and the space complexity remains O(1) as it requires constant space.', 'The time complexity of the if-else loop is determined by the part with the higher time complexity, and the overall time complexity is O(n) if the if part has a time complexity of O(n) and the else part has a time complexity of O(n^2). The time complexity of the if-else loop is determined by the part with the higher time complexity, and the overall time complexity is O(n) if the if part has a time complexity of O(n) and the else part has a time complexity of O(n^2).', 'The time complexity of sequential statements is calculated by summing the time complexities of individual statements, and the constants are eliminated from the total time complexity. The time complexity of sequential statements is calculated by summing the time complexities of individual statements, and the constants are eliminated from the total time complexity.']}], 'duration': 2128.36, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c17800777.jpg', 'highlights': ['Hashing plays a crucial role in data compression and encryption, serving as a black box that provides hash values as output.', 'Hash tables are used for database indexing and can be implemented in Python.', 'Employee ID is emphasized as the unique identifier for individuals in an organization, ensuring no repetition and providing a one-way function for communication and documentation.', 'The chapter introduces algorithm analysis, emphasizing its role in identifying optimal algorithms and understanding the trade-offs between time and space complexity.', 'The worst-case scenario dictates the maximum resource requirements, influencing resource allocation and aiding in determining the time and space complexities.', 'As the input size grows, the time complexity becomes substantial, highlighting the trade-off between time and space.', 'Space complexity involves using extra memory in algorithms and is critical in optimal algorithm selection, emphasizing the preference for minimal space usage.', 'The chapter explains how to calculate time and space complexity using examples of constructs like loops, conditional statements, and sequential statements.', 'The time complexity of a for loop is O(n) and the space complexity is O(1) as it requires constant space regardless of the input size.', 'The time complexity of nested loops is O(n^2), calculated by multiplying the iterations of the outer loop with the iterations of the inner loop, and the space complexity remains O(1) as it requires constant space.', 'The time complexity of the if-else loop is determined by the part with the higher time complexity, and the overall time complexity is O(n) if the if part has a time complexity of O(n) and the else part has a time complexity of O(n^2).', 'The time complexity of sequential statements is calculated by summing the time complexities of individual statements, and the constants are eliminated from the total time complexity.']}, {'end': 21120.55, 'segs': [{'end': 20021.303, 'src': 'embed', 'start': 19952.855, 'weight': 0, 'content': [{'end': 19957.317, 'text': 'Simply by just looking at the code, you can make out what is the time complexity for that given code.', 'start': 19952.855, 'duration': 4.462}, {'end': 19964.76, 'text': 'There are other methods also like master theorem, which is properly used for finding the time and space complexity,', 'start': 19958.918, 'duration': 5.842}, {'end': 19967.292, 'text': "but that's the time taking procedure.", 'start': 19964.76, 'duration': 2.532}, {'end': 19970.453, 'text': "it's for a full you know process or steps that you have to follow,", 'start': 19967.292, 'duration': 3.161}, {'end': 19977.775, 'text': 'but these tips and tricks will help you quickly find out or verify the time and space complexity of your given code.', 'start': 19970.453, 'duration': 7.322}, {'end': 19986.317, 'text': "now let's talk about searching algorithms, and the first searching algorithm that we are going to talk about is linear search algorithm.", 'start': 19977.775, 'duration': 8.542}, {'end': 19988.057, 'text': 'so what is linear search?', 'start': 19986.317, 'duration': 1.74}, {'end': 19992.35, 'text': 'It helps us to search an element in a linear data structure.', 'start': 19988.809, 'duration': 3.541}, {'end': 19997.873, 'text': "Now let's talk about one example wherein we will be searching some element inside the array.", 'start': 19992.651, 'duration': 5.222}, {'end': 20006.38, 'text': "So let's suppose this is an array and the elements are 10, 20, 30, 40 and 50.", 'start': 19998.373, 'duration': 8.007}, {'end': 20011.421, 'text': "Now, if we're trying to search an element that is 50 inside this array,", 'start': 20006.38, 'duration': 5.041}, {'end': 20018.743, 'text': 'how linear search works is that it checks each and every element that is to be searched right?', 'start': 20011.421, 'duration': 7.322}, {'end': 20021.303, 'text': 'That is there in the element array right?', 'start': 20019.223, 'duration': 2.08}], 'summary': 'The transcript discusses time and space complexity analysis and explains the linear search algorithm.', 'duration': 68.448, 'max_score': 19952.855, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c19952855.jpg'}, {'end': 20366.64, 'src': 'embed', 'start': 20340.962, 'weight': 3, 'content': [{'end': 20348.745, 'text': "So this is the best case time, complexity where the element that you're trying to find is the first element that you search right?", 'start': 20340.962, 'duration': 7.783}, {'end': 20352.426, 'text': "In this case, you're looking for 10 and 10 is the first element.", 'start': 20348.805, 'duration': 3.621}, {'end': 20354.034, 'text': 'So, this is your best case.', 'start': 20352.773, 'duration': 1.261}, {'end': 20359.456, 'text': 'Now, what about the average case and the worst case?', 'start': 20354.774, 'duration': 4.682}, {'end': 20366.64, 'text': "Now, let's suppose average case is that you were looking for an element which is at the middle point right?", 'start': 20359.796, 'duration': 6.844}], 'summary': 'Best case: finding first element. average case: middle point search.', 'duration': 25.678, 'max_score': 20340.962, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c20340962.jpg'}, {'end': 20593.203, 'src': 'embed', 'start': 20565.482, 'weight': 4, 'content': [{'end': 20577.386, 'text': 'Now, binary search is much more efficient and it is used on a sorted array or it can be used on an array wherein some order is maintained.', 'start': 20565.482, 'duration': 11.904}, {'end': 20582.576, 'text': 'Because, based on that order, we will divide our array right?', 'start': 20577.793, 'duration': 4.783}, {'end': 20591.402, 'text': 'It is a searching algorithm which follows the divide and conquer strategy right?', 'start': 20582.916, 'duration': 8.486}, {'end': 20593.203, 'text': "Let's suppose this is our array.", 'start': 20591.742, 'duration': 1.461}], 'summary': 'Binary search is an efficient algorithm used on sorted arrays, following the divide and conquer strategy.', 'duration': 27.721, 'max_score': 20565.482, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c20565482.jpg'}], 'start': 19929.977, 'title': 'Search algorithm complexity', 'summary': 'Covers time and space complexity calculation for code, linear search in python with best, average, and worst case time complexities, and compares the efficiency of linear and binary search algorithms.', 'chapters': [{'end': 20091.394, 'start': 19929.977, 'title': 'Time and space complexity calculation', 'summary': 'Covers the calculation of time and space complexity for any given code, including tips and tricks for quick verification. it also explains the linear search algorithm and its basic working principle, using an example to demonstrate how it searches for an element in a linear data structure.', 'duration': 161.417, 'highlights': ['Explanation of Time and Space Complexity Calculation The chapter provides insights into the calculation of time and space complexity for any given code, including tips and tricks for quick verification.', 'Introduction to Linear Search Algorithm The chapter introduces the linear search algorithm and explains its basic working principle, demonstrating how it searches for an element in a linear data structure.', 'Demonstration of Linear Search Example An example is used to demonstrate the working of the linear search algorithm, showcasing how it searches for a specific element in a linear data structure.']}, {'end': 20391.338, 'start': 20091.674, 'title': 'Linear search in python', 'summary': 'Discusses the implementation of linear search in python, demonstrating its operation through a sequential search of an array, and explaining the best, average, and worst case time complexities.', 'duration': 299.664, 'highlights': ['Linear search involves searching one single element throughout an array in a sequential manner, with 5 different elements in the array. The linear search involves sequentially searching one single element in an array and in this case, there are 5 different elements in the array.', 'The best case time complexity for linear search occurs when the element being searched is the first element in the array, requiring only one single unit operation. The best case time complexity occurs when the element being searched is the first element in the array, requiring only one single unit operation.', 'The average case time complexity for linear search occurs when searching for an element located around the middle of the array. The average case time complexity occurs when searching for an element located around the middle of the array.', 'The worst case time complexity for linear search is when the searched element is not found in the array, requiring a complete sequential comparison of all elements. The worst case time complexity occurs when the searched element is not found in the array, requiring a complete sequential comparison of all elements.']}, {'end': 21120.55, 'start': 20391.338, 'title': 'Binary search complexity', 'summary': 'Explains the time and space complexity of linear search and binary search, comparing their efficiency and algorithmic approach, as well as detailing the iterative and recursive approaches of the binary search algorithm.', 'duration': 729.212, 'highlights': ['Binary search has a worst case time complexity of O(n), iterating through the entire array when the element being searched is not found. The worst case time complexity of binary search is O(n) when the search element is not found, leading to the iteration of the entire array.', 'Space complexity of linear search is constant, not utilizing any auxiliary memory for searching elements within the given array. Linear search has a constant space complexity as it does not require any extra memory, auxiliary memory, or additional space to search for elements within the given array.', 'Binary search algorithm follows the divide and conquer strategy, efficiently neglecting half of the array in each iteration. Binary search algorithm efficiently follows the divide and conquer strategy, reducing the search space by neglecting half of the array in each iteration, thus leading to a more efficient search.']}], 'duration': 1190.573, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c19929977.jpg', 'highlights': ['The chapter provides insights into the calculation of time and space complexity for any given code, including tips and tricks for quick verification.', 'The chapter introduces the linear search algorithm and explains its basic working principle, demonstrating how it searches for an element in a linear data structure.', 'An example is used to demonstrate the working of the linear search algorithm, showcasing how it searches for a specific element in a linear data structure.', 'The worst case time complexity occurs when the searched element is not found in the array, requiring a complete sequential comparison of all elements.', 'Binary search algorithm efficiently follows the divide and conquer strategy, reducing the search space by neglecting half of the array in each iteration, thus leading to a more efficient search.']}, {'end': 22595.761, 'segs': [{'end': 21142.763, 'src': 'embed', 'start': 21120.65, 'weight': 4, 'content': [{'end': 21129.836, 'text': 'Okay, Even if you might be thinking we are not using any extra space, but whenever recursion is there an extra space, that is in the form of stack,', 'start': 21120.65, 'duration': 9.186}, {'end': 21131.236, 'text': 'that stack is maintained.', 'start': 21129.836, 'duration': 1.4}, {'end': 21137.72, 'text': "So you need to keep this thing in mind while you are playing around with space complexity at the time when you're using recursion.", 'start': 21131.316, 'duration': 6.404}, {'end': 21142.763, 'text': "So now with that being said, let's clear our screen and let's see how recursion is called here.", 'start': 21138.54, 'duration': 4.223}], 'summary': 'Recursion introduces extra space in the form of stack', 'duration': 22.113, 'max_score': 21120.65, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c21120650.jpg'}, {'end': 21240.762, 'src': 'embed', 'start': 21211.803, 'weight': 5, 'content': [{'end': 21218.708, 'text': "pause. okay, so this is how your binary search works when you're using recursion.", 'start': 21211.803, 'duration': 6.905}, {'end': 21223.291, 'text': "so now let's try to understand binary search and let's see its demonstration.", 'start': 21218.708, 'duration': 4.583}, {'end': 21231.116, 'text': 'okay, so we are looking for 20 and this is our array right 10, 11, 16, 20 and 23.', 'start': 21223.291, 'duration': 7.825}, {'end': 21236.179, 'text': 'now this array is sorted right, so we can apply binary search.', 'start': 21231.116, 'duration': 5.063}, {'end': 21240.762, 'text': 'okay, since we can neglect some part of the array based on some conditions.', 'start': 21236.179, 'duration': 4.583}], 'summary': 'Demonstration of binary search for finding 20 in a sorted array.', 'duration': 28.959, 'max_score': 21211.803, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c21211803.jpg'}, {'end': 21368.87, 'src': 'embed', 'start': 21338.899, 'weight': 9, 'content': [{'end': 21344.221, 'text': 'so the binary search has four different elements in important.', 'start': 21338.899, 'duration': 5.322}, {'end': 21345.641, 'text': 'the first one is array.', 'start': 21344.221, 'duration': 1.42}, {'end': 21350.923, 'text': 'the second one is which is the element to search for, which is stored in x and low and high.', 'start': 21345.641, 'duration': 5.282}, {'end': 21357.425, 'text': 'Why? because every array, in order to have the binary search, will be divided into two parts.', 'start': 21351.483, 'duration': 5.942}, {'end': 21360.006, 'text': 'right, it will go accordingly.', 'start': 21357.425, 'duration': 2.581}, {'end': 21368.87, 'text': 'if the key that means whatever the element you are searching is matching the middle element, it will exit the binary search immediately.', 'start': 21360.006, 'duration': 8.864}], 'summary': 'Binary search involves array, element, low, and high, with immediate exit if key matches middle element.', 'duration': 29.971, 'max_score': 21338.899, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c21338899.jpg'}, {'end': 21660.369, 'src': 'embed', 'start': 21630.896, 'weight': 2, 'content': [{'end': 21637.323, 'text': 'So the worst case time complexity of binary search is log n, and same goes for the average case,', 'start': 21630.896, 'duration': 6.427}, {'end': 21646.311, 'text': 'wherein it will be somewhere around log n divided by 2, neglecting log n divided by 2, neglecting the constant terms, it will be again,', 'start': 21637.323, 'duration': 8.988}, {'end': 21649.173, 'text': 'or it boils down to big o of log n.', 'start': 21646.311, 'duration': 2.862}, {'end': 21654.118, 'text': "okay now, let's talk about space complexity of binary search.", 'start': 21649.173, 'duration': 4.945}, {'end': 21660.369, 'text': 'now, when you talk about space complexity, right, we only think of auxiliary memories.', 'start': 21654.118, 'duration': 6.251}], 'summary': 'Binary search has a worst case time complexity of log n and average case of log n/2, leading to a big o of log n. the space complexity is determined by auxiliary memory.', 'duration': 29.473, 'max_score': 21630.896, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c21630896.jpg'}, {'end': 21827.505, 'src': 'embed', 'start': 21801.671, 'weight': 6, 'content': [{'end': 21806.142, 'text': "okay?. In this brute force algorithm, what happens that, let's suppose.", 'start': 21801.671, 'duration': 4.471}, {'end': 21807.442, 'text': 'let me give you an example, right?', 'start': 21806.142, 'duration': 1.3}, {'end': 21810.382, 'text': 'Obviously, we can sort with the help of this insertion sort algorithm.', 'start': 21807.542, 'duration': 2.84}, {'end': 21816.564, 'text': "You can obviously sort either in ascending or in descending order, right? Let's take one example.", 'start': 21810.562, 'duration': 6.002}, {'end': 21819.044, 'text': 'We all know about the card game right?', 'start': 21816.784, 'duration': 2.26}, {'end': 21822.044, 'text': 'Wherein you have a bunch of cards right?', 'start': 21819.444, 'duration': 2.6}, {'end': 21824.765, 'text': 'Suppose you have a single card that is in your hand right?', 'start': 21822.064, 'duration': 2.701}, {'end': 21827.505, 'text': 'And you have a bunch of cards available on the table.', 'start': 21825.125, 'duration': 2.38}], 'summary': 'Discusses insertion sort algorithm for sorting cards.', 'duration': 25.834, 'max_score': 21801.671, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c21801671.jpg'}, {'end': 21978.341, 'src': 'embed', 'start': 21932.054, 'weight': 7, 'content': [{'end': 21938.219, 'text': 'Now this is one simple scenario wherein you can apply what insertion sort right?', 'start': 21932.054, 'duration': 6.165}, {'end': 21945.324, 'text': 'This is the most simpler way one can explain or one can understand you this insertion sort algorithm.', 'start': 21938.459, 'duration': 6.865}, {'end': 21947.237, 'text': 'Now it is simple, right?', 'start': 21945.776, 'duration': 1.461}, {'end': 21954.04, 'text': 'Now you start picking these elements and you keep sorting them, and at the end, when all of these elements are exhausted,', 'start': 21947.577, 'duration': 6.463}, {'end': 21956.281, 'text': 'you will get your sorted array.', 'start': 21954.04, 'duration': 2.241}, {'end': 21959.703, 'text': "Now let's try to understand insertion sort algorithm.", 'start': 21956.681, 'duration': 3.022}, {'end': 21961.844, 'text': 'So, in this algorithm, what happens?', 'start': 21960.143, 'duration': 1.701}, {'end': 21964.545, 'text': 'obviously, now we know that we will have two parts right?', 'start': 21961.844, 'duration': 2.701}, {'end': 21968.387, 'text': 'One is the sorted part and another is the unsorted part, right?', 'start': 21964.925, 'duration': 3.462}, {'end': 21976.559, 'text': "Obviously, the one element that is present in your hat, or the element or the card that is in your hat, and there's only one element there, right?", 'start': 21969.594, 'duration': 6.965}, {'end': 21978.341, 'text': 'The one element in your hat.', 'start': 21976.819, 'duration': 1.522}], 'summary': 'Insertion sort algorithm creates sorted and unsorted parts, sorting elements to obtain the final array.', 'duration': 46.287, 'max_score': 21932.054, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c21932054.jpg'}, {'end': 22266.131, 'src': 'embed', 'start': 22211.693, 'weight': 1, 'content': [{'end': 22217.418, 'text': "after learning what is incision sort, let's quickly implement the same in python language.", 'start': 22211.693, 'duration': 5.725}, {'end': 22222.683, 'text': "so i'm using google collab, whether it is easy for everybody to access google collab.", 'start': 22217.418, 'duration': 5.265}, {'end': 22224.024, 'text': 'so need not install anything.', 'start': 22222.683, 'duration': 1.341}, {'end': 22226.266, 'text': "it's right available in the online.", 'start': 22224.024, 'duration': 2.242}, {'end': 22231.23, 'text': "so let's quickly switch to that google collab ide for python.", 'start': 22226.266, 'duration': 4.964}, {'end': 22238.036, 'text': 'so here you can find incision sort, the name for the file in python extension.', 'start': 22231.23, 'duration': 6.806}, {'end': 22243.396, 'text': 'so with that we already have this particular program which is easy for me to explain to you.', 'start': 22238.036, 'duration': 5.36}, {'end': 22245.577, 'text': 'So here.', 'start': 22243.936, 'duration': 1.641}, {'end': 22249.88, 'text': 'so we are considering a function called incision sort right?', 'start': 22245.577, 'duration': 4.303}, {'end': 22259.366, 'text': 'So the function is called whenever the data has been passed in order to sort the elements inside the data in ascending order right?', 'start': 22250.28, 'duration': 9.086}, {'end': 22266.131, 'text': 'So in order to do that we have to write a proper function accordingly, as incision sort will work.', 'start': 22259.887, 'duration': 6.244}], 'summary': 'Implementing incision sort in python using google colab for easy access and execution, aiming to sort data in ascending order.', 'duration': 54.438, 'max_score': 22211.693, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c22211693.jpg'}, {'end': 22509.772, 'src': 'embed', 'start': 22482.424, 'weight': 0, 'content': [{'end': 22487.107, 'text': 'so in that case the time complexity, the worst case, will be order of n squares.', 'start': 22482.424, 'duration': 4.683}, {'end': 22495.06, 'text': 'because we have two nested loops, that is, one is for loop and inside that for loop we have that, we have that y loop right.', 'start': 22487.107, 'duration': 7.953}, {'end': 22504.087, 'text': 'so this is the in the worst case and it happens also in the average case where some part or the sorted part is already there and it is,', 'start': 22495.06, 'duration': 9.027}, {'end': 22509.772, 'text': "let's suppose we have 5, 4, 5, 6, 7, 8 and then we have the unsorted part.", 'start': 22504.087, 'duration': 5.685}], 'summary': 'Worst case time complexity is o(n^2), with nested loops for sorting algorithm.', 'duration': 27.348, 'max_score': 22482.424, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c22482424.jpg'}], 'start': 21120.65, 'title': 'Understanding recursion, binary search, and insertion sort', 'summary': 'Explores the space complexity of recursion and demonstrates binary search, explaining its time and space complexity, and illustrates the insertion sort algorithm, emphasizing its efficiency with a time complexity of o(n^2) in the worst case.', 'chapters': [{'end': 21284.773, 'start': 21120.65, 'title': 'Understanding recursion and binary search', 'summary': 'Explains the space complexity of recursion and demonstrates the process of binary search using a sorted array, detailing the iteration and condition checks involved.', 'duration': 164.123, 'highlights': ['The chapter emphasizes the additional space, in the form of a stack, consumed by recursion, prompting consideration of space complexity, especially when using recursion.', 'The process of binary search is demonstrated with an array of 10, 20, 30, 40, and 50, showcasing the identification of the middle index, comparison of the target value, and the iteration process, providing a clear understanding of the binary search algorithm.']}, {'end': 21707.81, 'start': 21284.773, 'title': 'Binary search and its complexity', 'summary': 'Explains the concept of binary search, its implementation in python, and the time and space complexity involved, with the best case time complexity being constant and the worst and average case time complexity being log n, and the space complexity being constant.', 'duration': 423.037, 'highlights': ['Binary search has a best case time complexity of constant time. In the best case scenario, when the middle index is at the location of the element being searched, the binary search algorithm takes a constant amount of time to find the element.', 'The worst and average case time complexity of binary search is log n. The worst and average case time complexity of binary search is log n, as demonstrated by the example of finding the element in three steps and the logarithmic calculation of log 8 to the base 2 resulting in 3.', 'The space complexity of binary search is constant. Since no extra memory is used in the implementation, the space complexity of binary search is constant, denoted by big o of 1.', 'Explanation of binary search implementation in Python. The chapter explains the implementation of binary search in Python using an array, element to search for, and low and high variables for dividing the array into subarrays and searching for the key element accordingly.']}, {'end': 22211.058, 'start': 21708.55, 'title': 'Insertion sort algorithm', 'summary': 'Explains the insertion sort algorithm, a brute force sorting algorithm, that sorts a given set of elements in ascending order by iteratively comparing and swapping elements, resulting in a sorted array.', 'duration': 502.508, 'highlights': ['The insertion sort algorithm is a brute force sorting algorithm that sorts a given set of elements in ascending order by iteratively comparing and swapping elements. It is the simplest, easiest, and a brute force sorting algorithm, sorting a given set of elements in ascending order by iteratively comparing and swapping elements.', 'The algorithm works by maintaining two parts: the sorted part and the unsorted part, and iteratively compares and sorts the elements until the entire array is sorted. The algorithm maintains two parts: the sorted part and the unsorted part, and iteratively compares and sorts the elements until the entire array is sorted.', 'The chapter provides a step-by-step explanation and example of how the insertion sort algorithm sorts a given array of elements in ascending order. The chapter provides a step-by-step explanation and example of how the insertion sort algorithm sorts a given array of elements in ascending order.']}, {'end': 22595.761, 'start': 22211.693, 'title': 'Implementing incision sort in python', 'summary': 'Explains the implementation of incision sort in python using google colab, demonstrating the sorting process, its time complexity in best, average, and worst cases, with the worst case having a time complexity of o(n^2) and the best case having a time complexity of o(n), emphasizing the efficiency of the algorithm.', 'duration': 384.068, 'highlights': ['The worst case time complexity of incision sort is O(n^2), with two nested loops for sorting, and the average case time complexity is O(n^2) as well, considering partially sorted elements. In the worst case, all elements are in reverse order, leading to O(n^2) time complexity with two nested loops. Additionally, the average case also has O(n^2) complexity when some elements are already sorted.', 'The best case time complexity of incision sort is O(n), as the elements are already sorted, resulting in a more efficient sorting process. In the best case scenario where the elements are already sorted, the time complexity is O(n), as the while loop checking for element comparisons is only executed once per iteration.', 'The implementation of incision sort in Python using Google Colab is demonstrated, showcasing the sorting process and the ease of accessing and executing the code. The chapter demonstrates the implementation of incision sort in Python using Google Colab, highlighting the ease of access and execution of the code.']}], 'duration': 1475.111, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c21120650.jpg', 'highlights': ['The worst case time complexity of incision sort is O(n^2), with two nested loops for sorting, and the average case time complexity is O(n^2) as well, considering partially sorted elements.', 'The best case time complexity of incision sort is O(n), as the elements are already sorted, resulting in a more efficient sorting process.', 'The worst and average case time complexity of binary search is log n.', 'The space complexity of binary search is constant.', 'The chapter emphasizes the additional space, in the form of a stack, consumed by recursion, prompting consideration of space complexity, especially when using recursion.', 'The process of binary search is demonstrated with an array of 10, 20, 30, 40, and 50, showcasing the identification of the middle index, comparison of the target value, and the iteration process, providing a clear understanding of the binary search algorithm.', 'The insertion sort algorithm is a brute force sorting algorithm that sorts a given set of elements in ascending order by iteratively comparing and swapping elements.', 'The algorithm works by maintaining two parts: the sorted part and the unsorted part, and iteratively compares and sorts the elements until the entire array is sorted.', 'The chapter provides a step-by-step explanation and example of how the insertion sort algorithm sorts a given array of elements in ascending order.', 'The chapter explains the implementation of binary search in Python using an array, element to search for, and low and high variables for dividing the array into subarrays and searching for the key element accordingly.', 'The implementation of incision sort in Python using Google Colab is demonstrated, showcasing the sorting process and the ease of accessing and executing the code.']}, {'end': 24489.021, 'segs': [{'end': 22625.909, 'src': 'embed', 'start': 22596.021, 'weight': 0, 'content': [{'end': 22606.605, 'text': 'So, that is for the reason that the whole time complexity in the best case will be O and not O in the best case.', 'start': 22596.021, 'duration': 10.584}, {'end': 22610.32, 'text': "Okay Now, let's talk about insertion sort space complexity.", 'start': 22606.745, 'duration': 3.575}, {'end': 22618.445, 'text': 'If you have observed, in algorithms and in implementation we never talked about any auxiliary memory, right?', 'start': 22611.16, 'duration': 7.285}, {'end': 22625.909, 'text': 'We were not using any extra space, either in the form of array, linked list, stack queue or anything right?', 'start': 22618.785, 'duration': 7.124}], 'summary': 'Insertion sort has o(1) space complexity, no extra space used.', 'duration': 29.888, 'max_score': 22596.021, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c22596021.jpg'}, {'end': 22814.49, 'src': 'embed', 'start': 22781.788, 'weight': 1, 'content': [{'end': 22785.629, 'text': 'whenever you are trying to implement insertion, sort, it is stable.', 'start': 22781.788, 'duration': 3.841}, {'end': 22790.031, 'text': 'That means the relative positions of both these ones will be intact.', 'start': 22785.689, 'duration': 4.342}, {'end': 22796.413, 'text': 'Okay So if someone asks you if insertion sort is stable or not, you will say yes.', 'start': 22790.251, 'duration': 6.162}, {'end': 22803.576, 'text': 'Why? Because the relative positions of the numbers that are repeated remains intact.', 'start': 22796.633, 'duration': 6.943}, {'end': 22806.397, 'text': 'Now, what about this in place or out place??', 'start': 22803.976, 'duration': 2.421}, {'end': 22814.49, 'text': "Since we are not using any auxiliary memory right, we didn't use any stack, queue, linked list or array.", 'start': 22807.364, 'duration': 7.126}], 'summary': 'Insertion sort is stable, maintaining relative positions of repeated numbers. it is also in-place, not using auxiliary memory.', 'duration': 32.702, 'max_score': 22781.788, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c22781788.jpg'}, {'end': 23662.825, 'src': 'embed', 'start': 23634.455, 'weight': 2, 'content': [{'end': 23637.596, 'text': 'any element which is found which is lesser than the minimum element.', 'start': 23634.455, 'duration': 3.141}, {'end': 23645.759, 'text': 'then we swap the places of and the values of minimum with the found element right.', 'start': 23638.137, 'duration': 7.622}, {'end': 23651.021, 'text': 'so we always consider the array should have the first place, should have the smallest value.', 'start': 23645.759, 'duration': 5.262}, {'end': 23654.562, 'text': 'so this is how generally selection sort will work right.', 'start': 23651.021, 'duration': 3.541}, {'end': 23662.825, 'text': "so after doing this process, one swap in order to continue the iteration, we'll always put min value plus one.", 'start': 23654.562, 'duration': 8.263}], 'summary': 'Selection sort ensures the array starts with smallest value, making one swap per iteration.', 'duration': 28.37, 'max_score': 23634.455, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c23634455.jpg'}, {'end': 24027.528, 'src': 'embed', 'start': 23995.187, 'weight': 4, 'content': [{'end': 23996.988, 'text': "okay, so it doesn't matter.", 'start': 23995.187, 'duration': 1.801}, {'end': 23998.829, 'text': 'so average case type.', 'start': 23996.988, 'duration': 1.841}, {'end': 24002.731, 'text': 'if you talk about every time complexity, it will also be n square.', 'start': 23998.829, 'duration': 3.902}, {'end': 24013.036, 'text': 'but what happens if our array is still sorted right or if our array, that is, the array given, is already in sorted format?', 'start': 24002.731, 'duration': 10.305}, {'end': 24014.857, 'text': 'will there be?', 'start': 24013.036, 'duration': 1.821}, {'end': 24021.561, 'text': 'if we modify our bubble sort, we can get this down to b of n, but this is not the case in selection sort.', 'start': 24014.857, 'duration': 6.704}, {'end': 24027.528, 'text': 'Still, we will be comparing in the outer loop from 0 to n minus 1 or size minus 1,', 'start': 24022.142, 'duration': 5.386}], 'summary': 'Bubble sort can be optimized to o(n) if array is sorted.', 'duration': 32.341, 'max_score': 23995.187, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c23995187.jpg'}], 'start': 22596.021, 'title': 'Sorting algorithms analysis', 'summary': 'Delves into the complexity and implementation of insertion sort, stable and in-place sorting, selection sort algorithm, its implementation in python, and time and space complexity analysis, including o(n^2) time complexity and o(1) space complexity.', 'chapters': [{'end': 22709.485, 'start': 22596.021, 'title': 'Insertion sort complexity analysis', 'summary': 'Explains the time complexity of insertion sort as o, the space complexity as constant, and the number of comparisons and swaps required in worst and average case scenarios.', 'duration': 113.464, 'highlights': ['The time complexity of insertion sort in the best case is O and not O in the best case, indicating the efficiency of the algorithm.', 'The space complexity of insertion sort is Bico of 1, representing a constant amount of space used.', 'In the worst case scenario, the number of comparisons required in insertion sort is N square by 2, while in the average case scenario, it is N square by 4, twice as much as the worst case.', 'The number of swaps required in insertion sort is n square by 4 in the worst case and n square by 8 in the average case, indicating the performance of the algorithm in different scenarios.']}, {'end': 22968.265, 'start': 22709.485, 'title': 'Stable and in-place sorting', 'summary': 'Discusses the stability and in-place nature of insertion sort, explaining that it is a stable and in-place algorithm, and introduces the concept of nearly sorted arrays or k-sorted arrays, where elements are not at their original positions, requiring a maximum of three swaps or comparisons to reach their original positions.', 'duration': 258.78, 'highlights': ['Insertion sort is a stable algorithm, preserving the relative positions of elements, making it stable. Insertion sort maintains the relative positions of elements, making it a stable algorithm, demonstrated with the example of an array containing repeated elements.', 'Insertion sort is an in-place algorithm as it does not use any auxiliary memory, preserving the original array. Insertion sort is in-place as it does not use any additional memory, ensuring that the sorting is done within the original array without requiring extra space.', 'Introduction of nearly sorted arrays or k-sorted arrays, where elements may require a maximum of three swaps or comparisons to reach their original positions. The concept of nearly sorted arrays or k-sorted arrays is introduced, explaining that elements may require a maximum of three swaps or comparisons to reach their original positions, demonstrating the concept with examples.']}, {'end': 23612.428, 'start': 22968.908, 'title': 'Selection sort algorithm', 'summary': 'Discusses the selection sort algorithm, a comparison-based sorting algorithm that iterates through the array to find the minimum index and places it at the appropriate position, ultimately reducing the number of swaps and demonstrating its implementation in python on google colab.', 'duration': 643.52, 'highlights': ['Selection sort is a comparison-based sorting algorithm that iterates through the array to find the minimum index and places it at the appropriate position, ultimately reducing the number of swaps. The selection sort algorithm focuses on finding the minimum index and placing it at the appropriate position, reducing the number of swaps compared to other sorting algorithms.', "The algorithm's objective is to find the minimum index in each iteration and place it at the appropriate position. In each iteration, the algorithm aims to find the minimum index and position it correctly within the array.", 'The demonstration includes an example with an input array of 23, 10, 16, 11, and 20, showcasing the step-by-step process of finding the minimum index and swapping the elements. The example with the input array of 23, 10, 16, 11, and 20 illustrates the step-by-step process of finding the minimum index and swapping the elements to achieve the sorted array.', 'The chapter transitions to the implementation of selection sort in Python on Google Colab, providing a brief overview of the process. The chapter concludes with a transition to the implementation of selection sort in Python on Google Colab, offering a brief overview of the process for the audience.']}, {'end': 23904.801, 'start': 23612.428, 'title': 'Selection sort in python', 'summary': "Explains the implementation of selection sort in python, using a variable 'min' to find the minimum element in an array, then comparing and swapping the elements to sort the array in ascending or descending order, with a demonstration of the sorted array and a mention of its time complexity.", 'duration': 292.373, 'highlights': ["Selection sort is implemented using a variable 'min' to find the minimum element in the array and compare it with other elements, followed by swapping to ensure the array is sorted in ascending or descending order. The implementation of selection sort involves using a variable 'min' to find the minimum element in the array and then comparing it with other elements, followed by swapping to ensure the array is sorted in ascending or descending order.", 'Demonstration of sorting in ascending order using selection sort with the given data, resulting in the sorted array of -20, 12, 19, 20, and 45. A demonstration of sorting in ascending order using selection sort with the given data, resulting in the sorted array of -20, 12, 19, 20, and 45.', 'Illustration of changing the condition to sort in descending order and showcasing the resulting sorted array in descending order. Illustration of changing the condition to sort in descending order and showcasing the resulting sorted array in descending order.', 'Explanation of the time complexity of selection sort, providing insight into the efficiency of the sorting algorithm. Explanation of the time complexity of selection sort, providing insight into the efficiency of the sorting algorithm.']}, {'end': 24489.021, 'start': 23905.202, 'title': 'Selection sort time and space complexity', 'summary': "Explains the time and space complexity of selection sort. it highlights that the worst case and average case time complexity is o(n^2), regardless of the array's sortedness. the space complexity is constant at o(1). it also discusses the stability and in-place nature of the algorithm.", 'duration': 583.819, 'highlights': ["The worst case and average case time complexity of selection sort is O(n^2), regardless of the array's sortedness. In worst and average cases, the time complexity remains O(n^2), as the nested loops iterate over the entire array.", "The space complexity of selection sort is constant at O(1) because it does not use any auxiliary memory. Selection sort's space complexity remains constant at O(1) as it operates within the provided array without using additional memory.", 'Selection sort is an unstable algorithm, but it can be made stable by modifying the algorithm. The inherent instability of selection sort can be addressed through algorithm modification to achieve stability.', 'Selection sort is an in-place algorithm as it does not use any extra memory or space. Due to its operation without extra memory, selection sort is considered an in-place algorithm.']}], 'duration': 1893, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c22596021.jpg', 'highlights': ['The time complexity of insertion sort in the best case is O and not O in the best case, indicating the efficiency of the algorithm.', 'Insertion sort is a stable algorithm, preserving the relative positions of elements, making it stable.', 'Selection sort is a comparison-based sorting algorithm that iterates through the array to find the minimum index and places it at the appropriate position, ultimately reducing the number of swaps.', "Selection sort is implemented using a variable 'min' to find the minimum element in the array and compare it with other elements, followed by swapping to ensure the array is sorted in ascending or descending order.", "The worst case and average case time complexity of selection sort is O(n^2), regardless of the array's sortedness."]}, {'end': 25903.001, 'segs': [{'end': 24517.688, 'src': 'embed', 'start': 24489.282, 'weight': 1, 'content': [{'end': 24492.963, 'text': 'So in this tutorial, we are going to understand quick sort algorithm.', 'start': 24489.282, 'duration': 3.681}, {'end': 24496.164, 'text': 'It is one of the most widely used algorithm.', 'start': 24493.383, 'duration': 2.781}, {'end': 24499.945, 'text': 'It follows a paradigm of divide and conquer.', 'start': 24496.604, 'duration': 3.341}, {'end': 24509.367, 'text': 'What do you mean by divide and conquer? Basically, we will be dividing our array in such a way that every time we will be dividing.', 'start': 24500.485, 'duration': 8.882}, {'end': 24512.348, 'text': "Let's suppose this is an array and now we will be dividing into two.", 'start': 24509.547, 'duration': 2.801}, {'end': 24514.769, 'text': "Then further we'll divide it into two.", 'start': 24513.068, 'duration': 1.701}, {'end': 24517.688, 'text': 'Then further, we will divide it into two and so on.', 'start': 24515.267, 'duration': 2.421}], 'summary': 'Understanding quick sort algorithm, a widely used divide-and-conquer paradigm.', 'duration': 28.406, 'max_score': 24489.282, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c24489282.jpg'}, {'end': 24625.255, 'src': 'embed', 'start': 24576.592, 'weight': 0, 'content': [{'end': 24587.701, 'text': 'after that iteration is over and all the elements that are less than this pivot are on the left hand side and all the elements that are greater than will be on the right hand side.', 'start': 24576.592, 'duration': 11.109}, {'end': 24590.587, 'text': 'now then we will be choosing another pivot.', 'start': 24587.701, 'duration': 2.886}, {'end': 24596.571, 'text': "Now, what are those pivots? We'll see in the algorithm more extensively how we can choose that pivot.", 'start': 24590.687, 'duration': 5.884}, {'end': 24601.254, 'text': "Now, let's suppose we chose this pivot and this pivot is here.", 'start': 24597.011, 'duration': 4.243}, {'end': 24608.158, 'text': 'And after the second iteration, what happens? This pivot, this will be our next pivot and this will be our next pivot.', 'start': 24601.614, 'duration': 6.544}, {'end': 24609.699, 'text': 'Now we will be having two pivots.', 'start': 24608.358, 'duration': 1.341}, {'end': 24616.463, 'text': 'So this is how we induce that we are implementing divide and conquer approach.', 'start': 24609.999, 'duration': 6.464}, {'end': 24625.255, 'text': 'okay?. With each step, our problem gets reduced to two, which leads to quick sorting algorithm.', 'start': 24616.463, 'duration': 8.792}], 'summary': 'Iterative pivot selection reduces problem to two, leading to quick sorting algorithm.', 'duration': 48.663, 'max_score': 24576.592, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c24576592.jpg'}, {'end': 24854.497, 'src': 'embed', 'start': 24820.816, 'weight': 5, 'content': [{'end': 24822.077, 'text': 'this will be our pivot.', 'start': 24820.816, 'duration': 1.261}, {'end': 24823.378, 'text': 'okay, what happens?', 'start': 24822.077, 'duration': 1.301}, {'end': 24825.379, 'text': 'this pivot index maintains that order.', 'start': 24823.378, 'duration': 2.001}, {'end': 24827.902, 'text': 'okay, from this index, from this index,', 'start': 24825.379, 'duration': 2.523}, {'end': 24834.547, 'text': 'everything on the left hand side is less than the pivot and everything on the right hand side is greater than the pivot.', 'start': 24827.902, 'duration': 6.645}, {'end': 24841.533, 'text': 'so we will see when we we will see an example and therein i will show you how this pivot index is very important.', 'start': 24834.547, 'duration': 6.986}, {'end': 24843.114, 'text': 'okay, now what we will do?', 'start': 24841.533, 'duration': 1.581}, {'end': 24846.031, 'text': 'Obviously, at start, it is at this position.', 'start': 24843.689, 'duration': 2.342}, {'end': 24854.497, 'text': 'That means we have no such scenario wherein we have some elements that are less than pivot and we have some elements that are greater than pivot.', 'start': 24846.071, 'duration': 8.426}], 'summary': 'Pivot index maintains order, separates left and right elements.', 'duration': 33.681, 'max_score': 24820.816, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c24820816.jpg'}, {'end': 25065.667, 'src': 'embed', 'start': 25042.729, 'weight': 6, 'content': [{'end': 25052.294, 'text': 'Because you see, if you observe carefully that we were sending pivot index minus one, that is without five, all the elements on the left hand side,', 'start': 25042.729, 'duration': 9.565}, {'end': 25056.983, 'text': 'and plus one, that means without this index, all the elements on the right hand side.', 'start': 25052.294, 'duration': 4.689}, {'end': 25059.664, 'text': 'okay, this is how partition works.', 'start': 25056.983, 'duration': 2.681}, {'end': 25061.965, 'text': 'now you might be confused a little bit.', 'start': 25059.664, 'duration': 2.301}, {'end': 25065.667, 'text': "now let's try to demonstrate this with the help of example.", 'start': 25061.965, 'duration': 3.702}], 'summary': 'Explanation of pivot index and partitioning in algorithm demonstration.', 'duration': 22.938, 'max_score': 25042.729, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c25042729.jpg'}, {'end': 25315.511, 'src': 'embed', 'start': 25287.578, 'weight': 7, 'content': [{'end': 25292.115, 'text': "One of the IDE mean to say, And then we'll implement that particular program there.", 'start': 25287.578, 'duration': 4.537}, {'end': 25295.677, 'text': "So let's quickly hop into the IDE now.", 'start': 25292.635, 'duration': 3.042}, {'end': 25300, 'text': 'So here is the program for quicksort in Python.', 'start': 25296.538, 'duration': 3.462}, {'end': 25303.263, 'text': "So let's understand how this program works right?", 'start': 25300.341, 'duration': 2.922}, {'end': 25306.845, 'text': 'The first part we need partition to be made right?', 'start': 25303.743, 'duration': 3.102}, {'end': 25315.511, 'text': 'Any array in quicksort to be broken into two halves and we will start sorting in that particular different pieces.', 'start': 25307.065, 'duration': 8.446}], 'summary': 'The transcript discusses implementing a quicksort program in python, involving partitioning an array into two halves for sorting.', 'duration': 27.933, 'max_score': 25287.578, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c25287578.jpg'}, {'end': 25479.106, 'src': 'embed', 'start': 25445.849, 'weight': 11, 'content': [{'end': 25449.251, 'text': 'so partitioning is done accordingly.', 'start': 25445.849, 'duration': 3.402}, {'end': 25453.293, 'text': 'so this is a recursive call which we follow for quick sort.', 'start': 25449.251, 'duration': 4.042}, {'end': 25460.957, 'text': "right. we'll be having again array low pi minus one pi is pivot minus one.", 'start': 25453.293, 'duration': 7.664}, {'end': 25466.577, 'text': 'so Again, for the right of the period we have a recursive call function which is declared here', 'start': 25460.957, 'duration': 5.62}, {'end': 25472.121, 'text': 'Once all these things are done, we have to give data in order to sort something right?', 'start': 25467.157, 'duration': 4.964}, {'end': 25479.106, 'text': 'We are here presently concentrating on sorting the array which is given in the ascending order right?', 'start': 25472.461, 'duration': 6.645}], 'summary': 'Recursive quick sort algorithm implemented for sorting arrays.', 'duration': 33.257, 'max_score': 25445.849, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c25445849.jpg'}, {'end': 25644.518, 'src': 'embed', 'start': 25614.644, 'weight': 8, 'content': [{'end': 25619.605, 'text': 'and then quick sort problem divides it into the factor by the factor of two right.', 'start': 25614.644, 'duration': 4.961}, {'end': 25622.206, 'text': 'every time we are dividing it by two.', 'start': 25619.605, 'duration': 2.601}, {'end': 25632.055, 'text': 'so the entire process, or the time complexity of quick sort in best case and in average case takes order of n time.', 'start': 25622.206, 'duration': 9.849}, {'end': 25634.695, 'text': 'that is O.', 'start': 25632.055, 'duration': 2.64}, {'end': 25639.156, 'text': 'and same thing happens when we are talking about the average case as well.', 'start': 25634.695, 'duration': 4.461}, {'end': 25642.677, 'text': 'but why this is n square in worst case?', 'start': 25639.156, 'duration': 3.521}, {'end': 25644.518, 'text': 'that is the question right.', 'start': 25642.677, 'duration': 1.841}], 'summary': 'Quick sort has time complexity of o(n) in best and average case, but becomes o(n^2) in worst case.', 'duration': 29.874, 'max_score': 25614.644, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c25614644.jpg'}, {'end': 25781.624, 'src': 'embed', 'start': 25755.282, 'weight': 10, 'content': [{'end': 25761.186, 'text': 'But for calling this function, that is the Quicksort function, we are using recursion right?', 'start': 25755.282, 'duration': 5.904}, {'end': 25764.028, 'text': 'We are calling this Quicksort again and again right?', 'start': 25761.226, 'duration': 2.802}, {'end': 25765.509, 'text': 'Two Quicksort calls are there.', 'start': 25764.068, 'duration': 1.441}, {'end': 25776.461, 'text': 'For maintaining the call stack, we require order of n space, That is, the time complexity will be O when we are using this approach.', 'start': 25765.889, 'duration': 10.572}, {'end': 25781.624, 'text': 'And in the worst case, this will be the scenario that all the elements will be on the call stack.', 'start': 25776.701, 'duration': 4.923}], 'summary': 'The quicksort function uses recursion, requiring o(n) space for maintaining the call stack, with a worst-case scenario of all elements on the call stack.', 'duration': 26.342, 'max_score': 25755.282, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c25755282.jpg'}, {'end': 25903.001, 'src': 'embed', 'start': 25880.314, 'weight': 9, 'content': [{'end': 25888.201, 'text': 'we are not using any extra space explicitly in the form of array or linked list or stack, or even queue.', 'start': 25880.314, 'duration': 7.887}, {'end': 25890.744, 'text': "we're not using any extra memory.", 'start': 25888.201, 'duration': 2.543}, {'end': 25895.496, 'text': 'This algorithm Quicksort algorithm,', 'start': 25893.394, 'duration': 2.102}, {'end': 25903.001, 'text': 'although we are maintaining a call stack wherein we are maintaining a call stack and we have a space complexity of O.', 'start': 25895.496, 'duration': 7.505}], 'summary': 'Quicksort algorithm used with o space complexity', 'duration': 22.687, 'max_score': 25880.314, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c25880314.jpg'}], 'start': 24489.282, 'title': 'Quick sort algorithm', 'summary': 'Explains the quick sort algorithm, its implementation in python, recursive sorting process, and time complexity analysis, emphasizing its efficiency and in-place nature.', 'chapters': [{'end': 24663.969, 'start': 24489.282, 'title': 'Understanding quick sort algorithm', 'summary': 'Explains the quick sort algorithm, a widely used divide and conquer approach, employing recursive calls and pivot elements to efficiently sort arrays.', 'duration': 174.687, 'highlights': ['The quick sort algorithm follows a divide and conquer paradigm, recursively dividing the array into two subarrays, leading to efficient sorting.', "The algorithm involves choosing pivot elements and rearranging the elements in such a way that all elements less than the pivot are on the left and all elements greater than the pivot are on the right, achieving the original pivot's position in the array.", 'The tutorial emphasizes the implementation of quick sort using recursion and highlights the reduction of the problem into subarrays with each step, leading to an efficient sorting algorithm.']}, {'end': 25019.994, 'start': 24663.969, 'title': 'Quick sort algorithm explanation', 'summary': "Explains the quick sort algorithm, detailing the partition method and the recursive sorting process, with a focus on the pivot index and its role, emphasizing the importance of the algorithm's efficiency.", 'duration': 356.025, 'highlights': ['The chapter explains the Quick Sort algorithm, detailing the partition method and the recursive sorting process. Quick Sort algorithm explanation, focus on partition method and recursive sorting process', 'Emphasizes the importance of the pivot index in maintaining order during the partition process. Importance of pivot index in maintaining order during partition', 'Illustrates the iterative process of the partition method, showcasing the swapping of elements based on their relation to the pivot. Illustration of iterative partition process, swapping of elements based on relation to pivot']}, {'end': 25315.511, 'start': 25019.994, 'title': 'Quick sort algorithm explanation and implementation in python', 'summary': 'Explains the quick sort algorithm and its implementation in python, demonstrating the partitioning process with an example array, leading to sorting the entire array after two iterations.', 'duration': 295.517, 'highlights': ['The quick sort algorithm is explained, demonstrating the partitioning process with an example array. The explanation details the process of partitioning an example array using the quick sort algorithm, showcasing the steps involved in the partitioning process.', 'The entire array is sorted after two iterations of the quick sort algorithm. The chapter illustrates that the entire array is sorted after two iterations of the quick sort algorithm, highlighting the efficiency and effectiveness of the algorithm.', "The implementation of the quick sort algorithm in Python is demonstrated using a Python IDE, Google Colab. The chapter demonstrates the implementation of the quick sort algorithm in Python using a Python IDE, Google Colab, providing a practical understanding of the algorithm's application."]}, {'end': 25903.001, 'start': 25316.052, 'title': 'Understanding quicksort algorithm', 'summary': 'Explains the quicksort algorithm, including its partitioning process, recursive calls, time complexity analysis, space complexity, stability, and in-place nature, and concludes with a demonstration of the algorithm in python and its time and space complexity.', 'duration': 586.949, 'highlights': ['Partitioning process in Quicksort algorithm The partitioning process involves positioning the pivot element at the rightmost of the array, using a pointer to traverse the elements, and swapping elements based on their relationship with the pivot, enabling the recursive call for quicksort.', 'Time complexity of Quicksort algorithm The time complexity in the best and average case is O(nlogn) due to the division of elements by two, while in the worst case, it becomes O(n^2) when picking the smallest or largest element as the pivot, leading to extra iterations and swapping.', 'Space complexity of Quicksort algorithm Although Quicksort does not use explicit auxiliary memory but relies on recursion, the space complexity is O(n) in the average case, and in the worst case, it can be reduced to O(logn) by modifying the approach of maintaining the call stack.', 'Stability of Quicksort algorithm Quicksort algorithm is considered unstable as it does not maintain the relative positions of equal elements from the unsorted array in the sorted array, although it can be modified to achieve stability.', 'In-place nature of Quicksort algorithm Quicksort algorithm is in-place, as it does not use any additional auxiliary memory explicitly, maintaining a call stack for recursion, resulting in an average space complexity of O(logn).']}], 'duration': 1413.719, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c24489282.jpg', 'highlights': ['The entire array is sorted after two iterations of the quick sort algorithm. The chapter illustrates that the entire array is sorted after two iterations of the quick sort algorithm, highlighting the efficiency and effectiveness of the algorithm.', 'The quick sort algorithm follows a divide and conquer paradigm, recursively dividing the array into two subarrays, leading to efficient sorting.', "The algorithm involves choosing pivot elements and rearranging the elements in such a way that all elements less than the pivot are on the left and all elements greater than the pivot are on the right, achieving the original pivot's position in the array.", 'The tutorial emphasizes the implementation of quick sort using recursion and highlights the reduction of the problem into subarrays with each step, leading to an efficient sorting algorithm.', 'The chapter explains the Quick Sort algorithm, detailing the partition method and the recursive sorting process. Quick Sort algorithm explanation, focus on partition method and recursive sorting process', 'Emphasizes the importance of the pivot index in maintaining order during the partition process. Importance of pivot index in maintaining order during partition', 'Illustrates the iterative process of the partition method, showcasing the swapping of elements based on their relation to the pivot. Illustration of iterative partition process, swapping of elements based on relation to pivot', "The implementation of the quick sort algorithm in Python is demonstrated using a Python IDE, Google Colab. The chapter demonstrates the implementation of the quick sort algorithm in Python using a Python IDE, Google Colab, providing a practical understanding of the algorithm's application.", 'Time complexity of Quicksort algorithm The time complexity in the best and average case is O(nlogn) due to the division of elements by two, while in the worst case, it becomes O(n^2) when picking the smallest or largest element as the pivot, leading to extra iterations and swapping.', 'In-place nature of Quicksort algorithm Quicksort algorithm is in-place, as it does not use any additional auxiliary memory explicitly, maintaining a call stack for recursion, resulting in an average space complexity of O(logn).', 'Space complexity of Quicksort algorithm Although Quicksort does not use explicit auxiliary memory but relies on recursion, the space complexity is O(n) in the average case, and in the worst case, it can be reduced to O(logn) by modifying the approach of maintaining the call stack.', 'Partitioning process in Quicksort algorithm The partitioning process involves positioning the pivot element at the rightmost of the array, using a pointer to traverse the elements, and swapping elements based on their relationship with the pivot, enabling the recursive call for quicksort.']}, {'end': 27021.062, 'segs': [{'end': 25957.566, 'src': 'embed', 'start': 25933.144, 'weight': 0, 'content': [{'end': 25941.269, 'text': 'so every complex program can be divided into sub programs and solved to make it more simple and precise enough.', 'start': 25933.144, 'duration': 8.125}, {'end': 25944.531, 'text': "so let's quickly see what is divide and conquer approach.", 'start': 25941.269, 'duration': 3.262}, {'end': 25950.975, 'text': 'so, as the name suggests, divide and conquer any complex program, for example right,', 'start': 25944.531, 'duration': 6.444}, {'end': 25957.566, 'text': "I'm writing complex program which is having so many applications in that.", 'start': 25951.505, 'duration': 6.061}], 'summary': 'Divide and conquer approach simplifies complex programs into sub programs for precision.', 'duration': 24.422, 'max_score': 25933.144, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c25933144.jpg'}, {'end': 26207.579, 'src': 'embed', 'start': 26166.917, 'weight': 1, 'content': [{'end': 26170.558, 'text': 'So, in this particular tutorial, we are going to talk about merge sort.', 'start': 26166.917, 'duration': 3.641}, {'end': 26174.48, 'text': 'So merge sort is a classical sorting algorithm.', 'start': 26170.819, 'duration': 3.661}, {'end': 26183.415, 'text': 'In this sorting, Every time your problem is divided into sub problems, so that your problem set is reduced,', 'start': 26174.96, 'duration': 8.455}, {'end': 26186.038, 'text': 'and then you will be focusing on that sub problem.', 'start': 26183.415, 'duration': 2.623}, {'end': 26194.027, 'text': "Similarly, every time when you're dividing your sub problems, you will keep on dividing it unless and until there is only one element left right?", 'start': 26186.278, 'duration': 7.749}, {'end': 26199.094, 'text': 'If you compare it with simpler sorting algorithms like bubble is there insertion?', 'start': 26194.591, 'duration': 4.503}, {'end': 26200.155, 'text': 'is there selection?', 'start': 26199.094, 'duration': 1.061}, {'end': 26201.175, 'text': 'is there quake?', 'start': 26200.155, 'duration': 1.02}, {'end': 26201.515, 'text': 'is there?', 'start': 26201.175, 'duration': 0.34}, {'end': 26207.579, 'text': 'When you talk about its time complexity as compared to these algorithms, this is very much efficient.', 'start': 26202.096, 'duration': 5.483}], 'summary': 'The tutorial focuses on merge sort, a classical sorting algorithm, which is more efficient than simpler sorting algorithms like bubble, insertion, selection, and quake.', 'duration': 40.662, 'max_score': 26166.917, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c26166917.jpg'}, {'end': 26854.737, 'src': 'embed', 'start': 26823.253, 'weight': 3, 'content': [{'end': 26825.634, 'text': 'either the left or the right, are sorted.', 'start': 26823.253, 'duration': 2.381}, {'end': 26830.036, 'text': 'okay, so this is how you execute your merge function.', 'start': 26825.634, 'duration': 4.402}, {'end': 26834.888, 'text': 'so here is the program for merge sort in python.', 'start': 26830.686, 'duration': 4.202}, {'end': 26836.769, 'text': 'so how does this merge sort work?', 'start': 26834.888, 'duration': 1.881}, {'end': 26841.051, 'text': 'generally, one single array will be broken into two different pieces.', 'start': 26836.769, 'duration': 4.282}, {'end': 26846.133, 'text': 'again, those two different sub arrays will be broken into sub sub arrays.', 'start': 26841.051, 'duration': 5.082}, {'end': 26854.737, 'text': 'so after that, whatever the answers we get at the last will be combined together in order to finish the sorting of that particular array.', 'start': 26846.133, 'duration': 8.604}], 'summary': 'Merge sort algorithm splits and merges arrays to sort efficiently.', 'duration': 31.484, 'max_score': 26823.253, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c26823253.jpg'}], 'start': 25903.001, 'title': 'Divide and conquer approach and merge sort algorithm', 'summary': 'Discusses the concept, advantages, and applications of the divide and conquer approach in programming, particularly its role in sorting algorithms like merge sort and quicksort. it also explains the merge sort algorithm, its time complexity, efficiency, and process of dividing, conquering, and combining subproblems to sort the original array. additionally, it delves into the process of implementing merge sort in python with step-by-step explanation, program code, and example output.', 'chapters': [{'end': 26166.417, 'start': 25903.001, 'title': 'Divide and conquer approach', 'summary': 'Discusses the divide and conquer approach to programming, explaining its concept, advantages, applications, and its role in sorting algorithms like merge sort and quicksort.', 'duration': 263.416, 'highlights': ['The chapter discusses the divide and conquer approach to programming, explaining its concept, advantages, applications, and its role in sorting algorithms like merge sort and quicksort. The chapter gives a detailed explanation of the divide and conquer approach, its advantages, and applications, as well as its relevance in sorting algorithms like merge sort and quicksort.', 'The divide and conquer approach simplifies problem-solving by dividing complex programs into sub-programs, making it easy to understand and less time-consuming. The divide and conquer approach simplifies problem-solving by breaking down complex programs into sub-programs, making it easier to understand and reducing time consumption.', 'The divide and conquer approach is commonly used in data structures, especially in algorithms like merge sort, quick sort, and binary search. The divide and conquer approach is frequently applied in data structures, particularly in algorithms such as merge sort, quick sort, and binary search.']}, {'end': 26593.818, 'start': 26166.917, 'title': 'Understanding merge sort algorithm', 'summary': 'Explains the merge sort algorithm, a classical sorting method, which follows the paradigm of divide and conquer, discussing the time complexity and efficiency compared to other sorting algorithms, and detailing the process of dividing, conquering, and combining subproblems to sort the original array, along with a demonstration of the algorithm.', 'duration': 426.901, 'highlights': ['Merge sort algorithm follows the paradigm of divide and conquer, providing better time complexity as compared to simpler sorting algorithms like bubble, insertion, selection, and quake. Merge sort offers improved time complexity compared to other sorting algorithms such as bubble, insertion, selection, and quake.', 'The algorithm follows a process of dividing the original problem into subproblems, conquering them, and then combining them, ultimately resulting in a sorted array. The merge sort algorithm involves dividing the problem into subproblems, conquering and combining them to produce a sorted array.', "The demonstration of the algorithm includes the iterative process of dividing the array into subarrays, illustrating the recursive nature of the algorithm's implementation. The demonstration of the merge sort algorithm includes an iterative process of dividing the array into subarrays, showcasing the recursive nature of its implementation.", 'The merge function in the algorithm involves creating left and right sub-arrays, deducing their lengths, and initializing them for the merging process. The merge function in the merge sort algorithm includes creating left and right sub-arrays, determining their lengths, and initializing them for the merging process.']}, {'end': 27021.062, 'start': 26593.818, 'title': 'Merge sort in python', 'summary': 'Explains the process of implementing merge sort in python, where a single array is divided into subarrays, sorted, and then merged to obtain the final sorted array, as demonstrated through a step-by-step explanation, program code, and example output.', 'duration': 427.244, 'highlights': ['The chapter explains the process of implementing merge sort in Python, where a single array is divided into subarrays, sorted, and then merged to obtain the final sorted array. It provides a detailed explanation of the merge sort algorithm and its implementation in Python, emphasizing the division of a single array into subarrays, sorting the subarrays, and merging them to obtain the final sorted array.', "The step-by-step demonstration and explanation include the use of iterators i, j, and k to manage the left array, right array, and original array, the comparison of elements, and the insertion process. The demonstration includes the use of iterators i, j, and k to manage the left array, right array, and original array, as well as the comparison of elements and the insertion process, providing a clear understanding of the algorithm's execution.", 'The program code for merge sort in Python is presented, illustrating the process of dividing the array, sorting its halves, and merging the sorted subarrays to obtain the final result. The program code for merge sort in Python demonstrates the process of dividing the array, sorting its halves, and merging the sorted subarrays to obtain the final result, providing a practical implementation of the algorithm.']}], 'duration': 1118.061, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c25903001.jpg', 'highlights': ['The divide and conquer approach simplifies problem-solving by breaking down complex programs into sub-programs, making it easier to understand and reducing time consumption.', 'Merge sort offers improved time complexity compared to other sorting algorithms such as bubble, insertion, selection, and quake.', 'The demonstration of the merge sort algorithm includes an iterative process of dividing the array into subarrays, showcasing the recursive nature of its implementation.', 'It provides a detailed explanation of the merge sort algorithm and its implementation in Python, emphasizing the division of a single array into subarrays, sorting the subarrays, and merging them to obtain the final sorted array.']}, {'end': 28621.353, 'segs': [{'end': 27048.728, 'src': 'embed', 'start': 27021.062, 'weight': 5, 'content': [{'end': 27023.723, 'text': 'so this is the sorted array which we get.', 'start': 27021.062, 'duration': 2.661}, {'end': 27031.244, 'text': "so here we could see we don't have a sorted array, but here it is sorted in ascending order, that is smallest to the highest.", 'start': 27023.723, 'duration': 7.521}, {'end': 27033.424, 'text': 'so this is all about the merge sort.', 'start': 27031.244, 'duration': 2.18}, {'end': 27038.265, 'text': "now let's quickly check out what is greedy approach in programming right.", 'start': 27033.424, 'duration': 4.841}, {'end': 27046.607, 'text': 'so greedy approach is nothing but a simple solution for the problem which will give you exact, correct solution.', 'start': 27038.265, 'duration': 8.342}, {'end': 27048.728, 'text': 'it is a step-by-step approach.', 'start': 27046.607, 'duration': 2.121}], 'summary': 'The transcript discusses sorted arrays, merge sort, and the greedy approach in programming.', 'duration': 27.666, 'max_score': 27021.062, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c27021062.jpg'}, {'end': 27224.395, 'src': 'embed', 'start': 27190.903, 'weight': 2, 'content': [{'end': 27199.467, 'text': 'if you calculate the sum of the edges is always minimum, then we let that particular tree known as minimal spanning tree.', 'start': 27190.903, 'duration': 8.564}, {'end': 27205.95, 'text': "So, this is a brief introduction towards Prim's minimal spanning tree algorithm.", 'start': 27199.927, 'duration': 6.023}, {'end': 27210.312, 'text': 'So let me quickly see with an example.', 'start': 27206.41, 'duration': 3.902}, {'end': 27213.754, 'text': 'let you know how does this work right?', 'start': 27210.312, 'duration': 3.442}, {'end': 27218.032, 'text': 'Now, this particular example is a spanning tree.', 'start': 27214.254, 'duration': 3.778}, {'end': 27224.395, 'text': 'it is not having anything mentioned minimum or maximum.', 'start': 27218.032, 'duration': 6.363}], 'summary': "Introduction to prim's minimal spanning tree algorithm.", 'duration': 33.492, 'max_score': 27190.903, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c27190903.jpg'}, {'end': 27535.161, 'src': 'embed', 'start': 27480.21, 'weight': 3, 'content': [{'end': 27482.911, 'text': "so let's implement and check out on google collab.", 'start': 27480.21, 'duration': 2.701}, {'end': 27486.614, 'text': 'how does this prims spanning tree will work?', 'start': 27482.911, 'duration': 3.703}, {'end': 27494.219, 'text': 'so here is an ide that is google collab, where we have prims algorithm program in python.', 'start': 27486.614, 'duration': 7.605}, {'end': 27497.641, 'text': "so let's understand how this program flow works.", 'start': 27494.219, 'duration': 3.422}, {'end': 27502.164, 'text': "So first we'll be considering the infinity term.", 'start': 27498.482, 'duration': 3.682}, {'end': 27511.308, 'text': 'So we are mentioning infinity to so many 9 together in order to have as many as combinations as possible.', 'start': 27502.544, 'duration': 8.764}, {'end': 27514.87, 'text': 'So next we are considering the number of vertices for the graphs.', 'start': 27511.888, 'duration': 2.982}, {'end': 27517.771, 'text': 'So we have 5 vertices for the graph.', 'start': 27515.31, 'duration': 2.461}, {'end': 27522.393, 'text': 'So v is always indicating the vertices of the graph.', 'start': 27518.331, 'duration': 4.062}, {'end': 27524.634, 'text': 'So number of vertices is 5.', 'start': 27522.413, 'duration': 2.221}, {'end': 27532.299, 'text': "after that we'll always form an adjacency matrix of rows versus column 2d, that is, rows versus columns 5.", 'start': 27524.634, 'duration': 7.665}, {'end': 27535.161, 'text': 'cross frame matrix will be present.', 'start': 27532.299, 'duration': 2.862}], 'summary': 'Implementing prims spanning tree in python using google colab with 5 vertices.', 'duration': 54.951, 'max_score': 27480.21, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c27480210.jpg'}, {'end': 28008.949, 'src': 'embed', 'start': 27979.585, 'weight': 4, 'content': [{'end': 27982.965, 'text': 'Say, for example, you have a smaller disk that is disk 1 here.', 'start': 27979.585, 'duration': 3.38}, {'end': 27986.066, 'text': "You can't put a larger disk on the smaller disk.", 'start': 27983.245, 'duration': 2.821}, {'end': 27991.727, 'text': 'So, this is a second rule for this particular problem statement.', 'start': 27986.566, 'duration': 5.161}, {'end': 27997.468, 'text': "So, considering all this, let's see how do we implement tower of Hanai problem.", 'start': 27992.007, 'duration': 5.461}, {'end': 28000.429, 'text': "Let's quickly hop into the IDE now.", 'start': 27997.768, 'duration': 2.661}, {'end': 28003.085, 'text': 'Here we are on the IDE.', 'start': 28001.624, 'duration': 1.461}, {'end': 28008.949, 'text': "So let's quickly check out what a source, named as what is auxiliary, is nothing but temporary,", 'start': 28003.485, 'duration': 5.464}], 'summary': 'Tower of hanoi problem involves moving disks between pegs.', 'duration': 29.364, 'max_score': 27979.585, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c27979585.jpg'}, {'end': 28503.918, 'src': 'embed', 'start': 28473.068, 'weight': 0, 'content': [{'end': 28481.174, 'text': 'Then we learned different data structures, that is array, how to create an array, what is an array, how to implement in Python programming.', 'start': 28473.068, 'duration': 8.106}, {'end': 28488.7, 'text': 'Then followed by queue, stack, linked list, and concepts, methods, and implementation as well.', 'start': 28481.775, 'duration': 6.925}, {'end': 28492.783, 'text': 'After that, we learned regarding tree data structure.', 'start': 28489.84, 'duration': 2.943}, {'end': 28503.918, 'text': 'So tree data structure had binary tree, binary search tree, And we also learned how to create traverse and then implement the same in Python.', 'start': 28493.203, 'duration': 10.715}], 'summary': 'Learned array, queue, stack, linked list, and tree data structures with python implementation.', 'duration': 30.85, 'max_score': 28473.068, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c28473068.jpg'}, {'end': 28576.096, 'src': 'embed', 'start': 28550.575, 'weight': 1, 'content': [{'end': 28557.441, 'text': 'then at the last we learned regarding different programming approaches we could follow in order to solve the problem.', 'start': 28550.575, 'duration': 6.866}, {'end': 28563.967, 'text': 'So we started with divide and conquer, followed by greedy, then dynamic approach, right?', 'start': 28557.802, 'duration': 6.165}, {'end': 28571.112, 'text': 'So all these approaches were taught with examples like merge, sort, prims, minimum spanning tree,', 'start': 28564.287, 'duration': 6.825}, {'end': 28576.096, 'text': 'and then we were taught with the beautiful example of Tower of Hanoi.', 'start': 28571.112, 'duration': 4.984}], 'summary': 'Covered programming approaches: divide and conquer, greedy, dynamic. illustrated with merge sort, prims, tower of hanoi.', 'duration': 25.521, 'max_score': 28550.575, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c28550575.jpg'}], 'start': 27021.062, 'title': 'Graph algorithms and tower of hanoi in python', 'summary': "Covers merge sort, greedy approach, and prim's minimal spanning tree algorithm, along with the implementation of graph vertices, minimal spanning tree, and dynamic programming. additionally, it explains the tower of hanoi problem and its python implementation, emphasizing the number of moves required to transfer the disks.", 'chapters': [{'end': 27075.142, 'start': 27021.062, 'title': 'Merge sort and greedy approach', 'summary': 'Discusses merge sort, showcasing a sorted array in ascending order, followed by an explanation of the greedy approach in programming, emphasizing its step-by-step efficiency and quick solution benefits.', 'duration': 54.08, 'highlights': ['The chapter discusses merge sort, showcasing a sorted array in ascending order, followed by an explanation of the greedy approach in programming, emphasizing its step-by-step efficiency and quick solution benefits.']}, {'end': 27511.308, 'start': 27075.142, 'title': "Prim's minimal spanning tree", 'summary': "Introduces prim's minimal spanning tree algorithm, explaining the concepts of spanning tree, minimal spanning tree, and demonstrates its implementation through an example, illustrating the process of finding the minimal spanning tree with detailed steps.", 'duration': 436.166, 'highlights': ["Prim's minimal spanning tree algorithm is introduced, explaining the concept of spanning tree and minimal spanning tree. The algorithm is introduced, defining the concepts of spanning tree and minimal spanning tree, emphasizing the minimal value for edges to form the tree.", 'Demonstration of finding a minimal spanning tree through a detailed example, illustrating the process step by step. The example demonstrates the process of finding the minimal spanning tree, emphasizing the selection of minimal edge values and traversal through the nodes to form the minimal spanning tree.', "Introduction to implementing Prim's spanning tree algorithm in Python through a programming code in Google Colab. The introduction to implementing Prim's algorithm in Python through a programming code in Google Colab is provided, emphasizing the practical implementation of the algorithm."]}, {'end': 28003.085, 'start': 27511.888, 'title': 'Graph vertices and minimal spanning tree', 'summary': 'Discusses the formation of a graph with 5 vertices, creation of an adjacency matrix, selection of vertices, tracking of edges, and traversal techniques for minimal spanning tree as well as an introduction to dynamic programming and its applications, including tower of hanoi problem.', 'duration': 491.197, 'highlights': ['The chapter discusses the formation of a graph with 5 vertices and the creation of an adjacency matrix. It mentions the use of 5 vertices to form the graph and the creation of an adjacency matrix to represent the graph.', 'Introduction to minimal spanning tree traversal techniques and the process of selecting and tracking vertices and edges. It explains the process of tracking selected vertices and setting the number of edges to zero, and the traversal techniques for minimal spanning tree.', 'Overview of dynamic programming and its recursive approach to problem-solving, as well as applications including Tower of Hanoi problem. It provides an introduction to dynamic programming, its recursive approach to problem-solving, and its applications, such as the Tower of Hanoi problem.']}, {'end': 28621.353, 'start': 28003.485, 'title': 'Tower of hanoi in python', 'summary': 'Explains the tower of hanoi problem, which involves moving disks between three pegs (x, y, z) and implementing the solution in python. the program demonstrates the execution of the tower of hanoi problem and explains the number of moves required to transfer the disks, with a detailed explanation of the concepts covered in the video.', 'duration': 617.868, 'highlights': ['The Tower of Hanoi problem involves moving disks between three pegs (X, Y, Z) and implementing the solution in Python. The chapter explains the Tower of Hanoi problem, which involves moving disks between three pegs (X, Y, Z) and implementing the solution in Python.', 'The program demonstrates the execution of the Tower of Hanoi problem and explains the number of moves required to transfer the disks. The program demonstrates the execution of the Tower of Hanoi problem and explains the number of moves required to transfer the disks.', 'The chapter covers various concepts in data structures and algorithms in Python, including array, queue, stack, linked list, tree data structure, graph data structure, hashing, algorithm analysis, searching and sorting algorithms, programming approaches, and the Tower of Hanoi problem. The chapter covers various concepts in data structures and algorithms in Python, including array, queue, stack, linked list, tree data structure, graph data structure, hashing, algorithm analysis, searching and sorting algorithms, programming approaches, and the Tower of Hanoi problem.']}], 'duration': 1600.291, 'thumbnail': 'https://coursnap.oss-ap-southeast-1.aliyuncs.com/video-capture/MLqHDsBOC4c/pics/MLqHDsBOC4c27021062.jpg', 'highlights': ['The chapter covers various concepts in data structures and algorithms in Python, including array, queue, stack, linked list, tree data structure, graph data structure, hashing, algorithm analysis, searching and sorting algorithms, programming approaches, and the Tower of Hanoi problem.', 'Introduction to dynamic programming, its recursive approach to problem-solving, and its applications, such as the Tower of Hanoi problem.', 'Demonstration of finding a minimal spanning tree through a detailed example, illustrating the process step by step.', "Introduction to implementing Prim's spanning tree algorithm in Python through a programming code in Google Colab.", 'The program demonstrates the execution of the Tower of Hanoi problem and explains the number of moves required to transfer the disks.', 'The chapter discusses merge sort, showcasing a sorted array in ascending order, followed by an explanation of the greedy approach in programming, emphasizing its step-by-step efficiency and quick solution benefits.', 'The chapter discusses the formation of a graph with 5 vertices and the creation of an adjacency matrix.', "Prim's minimal spanning tree algorithm is introduced, explaining the concept of spanning tree and minimal spanning tree."]}], 'highlights': ['The course covers various data structures such as array, stack, queue, linked list, tree, graph, and hash tables, providing a comprehensive understanding of different data structures.', 'The practical examples and implementation using Python programming language enhance the learning experience and application of concepts.', 'Python has built-in data structures like lists, dictionaries, tuples, and sets, as well as user-defined data structures for more complex data processing needs.', 'The chapter covers sorting elements inside an array in Python, showcasing the sorting of elements in ascending order, displaying the original and sorted array, and explaining the logic behind the sorting algorithm.', 'The stack follows the last in first out order, and the insertion and removal of elements are done at one end.', 'The advantages of using deque over list for implementing stack is highlighted, with a focus on the faster append and pop operations in deque compared to list.', 'Queue operations have a constant time complexity of O(1), making it a commonly used data structure in competitive programming.', 'Advantages of a circular queue include its adherence to the FIFO principle, constant time operations for insertion, deletion, peak first, peak last, enqueue, and dequeue, making it widely used in competitive programming.', 'Linked list is a collection of nodes containing data and references, allowing for more efficient operations like insertion, deletion, and traversal.', 'The chapter covers the basic logic and coding example for insertion at the beginning, end, and at a specified node in a doubly linked list.', 'Introduction to Binary Trees as a hierarchical data structure with at most two children for each node, presenting common traversals like pre-order, post-order, and in-order.', 'The chapter introduces breadth first search and depth first search algorithms in Python, providing an overview of the two traversal strategies.', 'Hashing plays a crucial role in data compression and encryption, serving as a black box that provides hash values as output.', 'The chapter provides insights into the calculation of time and space complexity for any given code, including tips and tricks for quick verification.', 'The worst case time complexity occurs when the searched element is not found in the array, requiring a complete sequential comparison of all elements.', 'The quick sort algorithm follows a divide and conquer paradigm, recursively dividing the array into two subarrays, leading to efficient sorting.', 'Merge sort offers improved time complexity compared to other sorting algorithms such as bubble, insertion, selection, and quake.', 'The chapter covers various concepts in data structures and algorithms in Python, including array, queue, stack, linked list, tree data structure, graph data structure, hashing, algorithm analysis, searching and sorting algorithms, programming approaches, and the Tower of Hanoi problem.']}