lecture_4

Sorting and Searching

• Importance of Searching: Basic operation to check if an element is stored within a data structure.

• Sorting: Arranging items in non-decreasing order, which can enhance search efficiency (e.g. binary search).

Classic Sorting Algorithms

• Introduction of classic sorting algorithms

• Overview of three algorithms: Insertion Sort, Selection Sort, Bubble Sort

• Focus on Insertion Sort during the lecture, with other two for home review.

Insertion Sort

• Concept: If the first i numbers are sorted, the i+1th number can be inserted into the sorted section.

• Example: Given an unsorted array, start with a sorted section and insert elements until the entire array is sorted.

• Each iteration enlarges the sorted zone.

• Time Complexity: Worst case is (O(n^2)) due to nested iterations.

• Insertion Process: Inserting involves comparing the new element with elements in the sorted section from the back to find the appropriate position.

Other Sorting Algorithms

• Selection Sort: Another classic example discussed in a sentence; students encouraged to explore its visualizations.

• Bubble Sort: Simple but inefficient; also discussed briefly.

• Time Complexity of All Three: (O(n^2)) in worst cases.

Introduction to Data Structures

• First Data Structure: List

• Definition: A collection of items stored in a linear shape.

• Abstract Data Type (ADT): A list as an implementation within Python; considerations of what data is stored and what operations are supported.

List vs. Array

• List: Stores items with relative position, allowing easy adjustment of size.

• Array: Requires consecutive memory and fixed size, making insertion and resizing more complex.

• Pros and Cons variation noted for arrays (constant time access) vs lists (dynamic length).

Array List Introduction

• Rediscovered Array List: A type of list utilizing an array structure internally.

• Contains:

  • Array: Actual storage of items.

  • Size Attribute: Tracks number of items stored.

• Empty Structure Creation: Noted instantiation method using constructor:

  • Default length can be set or chosen by the user.

Array List Operations

• Constructor Method: Defines how to set up an initial empty structure and size is set to zero.

• Size: Returns the number of items in the list with a time complexity of (O(1)).

• Check if Empty: Uses size to quickly return if the list is empty, also (O(1)).

Searching in Array List

• Contains and Index Operations: Check if an item is in the list and return its index. Both are linear searches for unsorted lists, thus (O(n)).

Popping Items

• Pop Last Item: Removes last item; quick operation with constant time use of size.

• Pop By Index: Requires shifting elements if an item is removed from a non-final position, leading to a time complexity of (O(n)).

Remove Item

• Find the index of the item and then use the pop function; worst case complexity is the same as pop operations (linear time).

Concluding Thoughts

• Reinforcement that these operations can be constructed and analyzed for complexity, crucial for understanding performance in data structures.