Skip to main content
UploadLanguage (EN)Support
BusinessMobileSocial MediaMarketingTechnologyArt & PhotosCareerDesignEducationPresentations & Public SpeakingGovernment & NonprofitHealthcareInternetLawLeadership & ManagementAutomotiveEngineeringSoftwareRecruiting & HRRetailSalesServicesScienceSmall Business & EntrepreneurshipFoodEnvironmentEconomy & FinanceData & AnalyticsInvestor RelationsSportsSpiritualNews & PoliticsTravelSelf ImprovementReal EstateEntertainment & HumorHealth & MedicineDevices & HardwareLifestyle
AK
Uploaded byAkhtarzeb Khan
PPTX, PDF108 views

Lecture 01

This document provides an overview of data structures and algorithms. It discusses that a data structure organizes data to enable efficient computation and supports certain operations. Data structures can be static or dynamic depending on whether their size is fixed or variable. The choice of data structure and algorithm impacts efficiency in terms of time and space usage. Non-primitive data structures like linked lists, stacks, and trees are built using primitive data types. Algorithms must be unambiguous, have defined inputs/outputs, and terminate after a finite number of steps. The time and space complexity of an algorithm determines its efficiency.

Software◦
Download to read offline
DATA STRUCTURES AND ALGORITHMS Lecture 1
Data Structures ■ A data structure is a way to organize data to enable efficient computation over that data ■ A data structure supports certain operations, each with a: – Meaning: what does the operation do/return – Performance: how efficient is the operation ■ Examples: – List with operations insert and delete – Stack with operations push and pop
Organizing Data ■ Any organization for a collection of records that can be easily searched, processed in any order, or modified. ■ The choice of data structure and algorithm can make the difference between a program running in a few seconds or many days.
Efficiency ■ A solution is said to be efficient if it solves the problem within its resource constraints. – Time – Space ■ The cost of a solution is the amount of resources that the solution consumes
Need for Data Structure ■ Data Search − Consider an inventory of 1 million(106) items of a store. If the application is to search an item, it has to search an item in 1 million(106) items every time slowing down the search. As data grows, search will become slower. ■ Processor Speed − Processor speed although being very high, falls limited if the data grows to billion records. ■ Multiple Requests − As thousands of users can search data simultaneously on a web server, even the fast server fails while searching the data.
Data Structures ■ The domain of data structures studies how we can store and access data. ■ A data structure can be: – Static: the size of the data structure is fixed. Such data structures are suitable if it is known that a fixed number of elements need to be stored. – Dynamic: the size of the data structure can grow or shrink as needed by the number of elements.
Classification of Data Structure ■ Data structure are normally divided into two broad categories: – Primitive Data Structure – Non-Primitive Data Structure
Primitive Data Structure Primitive Data Structure Integer Float Character Pointer
Primitive Data Structure ■ Primitive data structures are the fundamental data types which are supported by a programming language. ■ Some basic data types are integer, real, character, float. ■ The terms ‘data type’, ‘basic data type’, and ‘primitive data type’ are often used interchangeably
Non-Primitive Data Structure Non-Primitive Data Structure Linear Data Structures Non-Linear Data Structures Arrays Linked Lists Stacks Queues Trees Graphs Hash Tables
Non-Primitive Data Structure ■ Non-primitive data structures are those data structures which are created using primitive data structures. ■ Examples of such data structures include linked lists, stacks, trees, and graphs. ■ Non-primitive data structures can further be classified into two categories: linear and non-linear data structures.
Non-Primitive Data Structure ■ Linear: In Linear data structure, values are arrange in a linear or sequential order. – Array: Fixed-size – Linked-list: Variable-size – Stack: Add to top and remove from top – Queue: Add to back and remove from front – Priority queue: Add anywhere, remove the highest priority
Non-Primitive Data Structure ■ Non-Linear: The data values in this structure are not arranged in sequential order. – Hash tables: Unordered lists which use a ‘hash function’ to insert and search – Tree: Data is organized in branches. – Graph: A more general branching structure, with less strict connection conditions than for a tree
Data Types ■ A data type is a set of values and a set of operations on those values. For example: ■ int – set of values are integer numbers from a given interval – possible operations: add, subtract, multiply, etc. ■ boolean – set of values: true, false – possible operations: negation, and, or, xor, etc.
Data Types ■ String – ”abc”, ”text”, etc. – possible operations: get the length, get a character from a position, get a substring, etc. ■ etc.
Abstract Data Types ■ An Abstract Data Type (ADT) is a data type having the following two properties: – the objects from the domain of the ADT are specified independently of their representation – the operations of the ADT are specified independently of their implementation
Abstract Data Types - Domain ■ The domain of an ADT describes what elements belong to this ADT. ■ If the domain is finite, we can simply enumerate them. ■ If the domain is not finite, we will use a rule that describes the elements belonging to the ADT.
Abstract Data Types - Interface ■ After specifying the domain of an ADT, we need to specify its operations. ■ The set of all operations for an ADT is called its interface. ■ The interface of an ADT contains the signature of the operations, together with their input data, results, preconditions and post conditions (but no detail regarding the implementation of the method). ■ When talking about ADT we focus on the WHAT (it is, it does), not on the HOW.
ADT - Example ■ Consider the Date ADT (made of three numbers: year, month and day) – Elements belonging to this ADT are all the valid dates (year is positive, maybe less than 3000, month is between 1 and 12, day is between 1 and maximum number of possible days for the month)
ADT - Example ■ One possible operation for the Data ADT could be: difference(Date d1, Date d2) – Descr: computed the difference in number of days between two dates – Pre: d1 and d2 have to be valid Dates, d1 ≤ d2 – Post: difference ← d, d is a natural number and represents the number of days between d1 and d2. – Throws: and exception if d1 is greater than d2
ADT - Example ■ This information specifies everything we need to use the Date ADT, even if we know nothing about how it is represented or how the operation difference is implemented.
Why Abstract Data Types? ■ There are several different Abstract Data Types, so choosing the most suitable one is an important step during application design. ■ When choosing the suitable ADT we are not interested in the implementation details of the ADT. ■ Most high-level programming languages usually provide implementations for different Abstract Data Types. – In order to be able to use the right ADT for a specific problem, we need to know their domain and interface.
Why Abstract Data Types? ■ Why do we need to implement our own Abstract Data Types if they are already implemented in most programming languages? – Implementing these ADT will help us understand better how they work (we cannot use them, if we do not know what they are doing)
Why Abstract Data Types? – To learn to create, implement and use ADT for situations when: ■ we work in a programming language where they are not readily implemented. ■ we need an ADT which is not part of the standard ones, but might be similar to them.
Advantages of working with ADTs ■ Abstraction is defined as the separation between the specification of an object (its domain and interface) and its implementation. ■ Encapsulation - abstraction provides a promise that any implementation of an ADT will belong to its domain and will respect its interface. And this is all that is needed to use an ADT.
Advantages of working with ADTs ■ Localization of change - any code that uses an ADT is still valid if the ADT changes (because no matter how it changes, it still has to respect the domain and interface). ■ Flexibility - an ADT can be implemented in different ways, but all these implementation have the same interface. Switching from one implementation to another can be done with minimal changes in the code.
Advantages of working with ADTs ■ Consider again our example with the Date ADT: – Assume you used variables of type Date and the difference operation in your code. – If the implementation of the Date changes, these changes will not affect your code, because even if the representation changes and even if the implementation of the operations changes, they still have to respect the interface (the signature and behavior of the difference operation is still the same).
Advantages of working with ADTs – If a new implementation for the Date will appear and you want to switch to that implementation, it can be done with minimal modifications in your code
Algorithm ■ Algorithm is a step by step procedure, which defines a set of instructions to be executed in certain order to get the desired output. ■ Algorithms are generally created independent of underlying languages
Algorithm ■ From data structure point of view, following are some important categories of algorithms : – Search − Algorithm to search an item in a data structure. – Sort − Algorithm to sort items in certain order – Insert − Algorithm to insert item in a data structure – Update − Algorithm to update an existing item in a data structure – Delete − Algorithm to delete an existing item from a data structure
Characteristics of an Algorithm ■ Unambiguous − Algorithm should be clear and unambiguous. Each of its steps or phases, and their input/outputs should be clear and must lead to only one meaning. ■ Input − An algorithm should have 0 or more well defined inputs. ■ Output − An algorithm should have 1 or more well defined outputs, and should match the desired output.
Characteristics of an Algorithm ■ Finiteness − Algorithms must terminate after a finite number of steps. ■ Feasibility − Should be feasible with the available resources. ■ Independent − An algorithm should have step-by-step directions which should be independent of any programming code.
How to write an algorithm? ■ There are no well-defined standards for writing algorithms. Rather, it is problem and resource dependent. – Algorithms are never written to support a particular programming code. – As we know that all programming languages share basic code constructs like loops (do, for, while), flow- control (if-else), etc. These common constructs can be used to write an algorithm.
Algorithm Complexity ■ Time and space used by the Algorithm determines the efficiency of an algorithm. ■ Time Factor − The time is measured by counting the number of key operations such as comparisons in sorting algorithm ■ Space Factor − The space is measured by counting the maximum memory space required by the algorithm.