D404 ex-4-2
•Download as DOCX, PDF•
0 likes•25 views
This document contains an algorithm and Python program to perform selection sort on a list of integers. The algorithm has 14 steps that take an input list, find the maximum value in each pass, swap it with the end element, and repeat until the list is sorted. The Python program defines a selectionsort function, takes user input for the number of elements and values, calls the function to sort the initial list, and prints the sorted output. It runs the program twice with different input lists and displays the expected sorted output both times.
Report
Share
Report
Share
![Name of Students KAUSTUBH ARUN WANKHADE
Roll No D404
Batch D1
Experiment No EX-4-2
Title of Experiment List outthe givencharactersin ascendingorder(use SelectionSort)
Write An Algorithm:
STEP I:START
STEP II: Take an empty list
STEP III: Take input of no of elements in list
STEP IV:Initializing loop for no
STEP V:Taking input of elements in list
STEP VI: Appending values to list
STEP VII:Display given list
STEP VIII:Defining a function selectionsort
STEP IX: Initializing outer For loop (len(alist)-1,0,-1)
STEP X: Defining position of maximum
STEP XI:Initializing inner loop for 1 to fillslot+1
STEP XII:Check condition if alist [location]>alist[positionofmax]
Then swap
STEP XIII: Display Sorted list of given elements
STEP XIV:STOP](https://image.slidesharecdn.com/d404-ex-4-2-170514084603/85/D404-ex-4-2-1-320.jpg)
![Paste Your Python Program ( Python Code):
def selectionsort(alist):
for fillslot in range (len(alist)-1,0,-1): #Initializing outer For loop
positionofmax=0 #Defining position of maximum
for location in range(1,fillslot+1): #Initializing inner For loop
if alist [location]>alist[positionofmax]: #Checking condition
positionofmax=location #Defining Position of maximum as loaction
temp = alist[fillslot]
alist[fillslot]=alist[positionofmax]
alist[positionofmax]=temp
alist=[] #Taking an empty list
no=raw_input("Enter no of elements") #Taking no of elements in list
no=int(no)
for i in range(no): #Initializing for loop
list=raw_input("Enter the elements") #Assigning values to list
list=int(list)
alist.append(list) #Append values to list
print"Given list is",alist #Display given list
selectionsort(alist)
print("Sorted list is"),alist #Display Sorted list
Paste Your Program OUTPUT :
Given list is [989, 22, 787]
Sorted list is [22, 787, 989]
Given list is [698, 78, 3, 659, 550]
Sorted list is [3, 78, 550, 659, 698]](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
D422 ex-4-2 python
The document describes an algorithm to perform selection sort on a list of numbers. It defines the selection sort function that takes a list as a parameter. The function uses nested for loops to find the maximum element in the list and swap it with the current element being considered. The Python code implements this by taking user input to build a list, calling the selection sort function, and printing the original and sorted lists. It provides examples of sorting lists of different lengths.
D404 ex-4-1-3-1
The document contains an algorithm and Python program to sort a list of integers in ascending order using bubble sort.
The algorithm takes in a list as input, calculates its length, then has two nested for loops to compare adjacent elements and swap them if out of order.
The Python program implements this by taking in a number of elements, appending them to a list, sorting the list using the bubble sort algorithm, and outputting the sorted list.
D404 ex-5-2 (1)-1
1. The student wrote a Python program to implement binary search on a list.
2. The program takes user input to generate a list, sorts the list, then takes a target number to search for.
3. It uses a while loop to repeatedly check if the target is equal to the midpoint of the current search range, and updates the range based on the comparison, printing the index if found or a message if not found.
D404 ex-5-1-1
The document contains the algorithm and Python code to perform a linear search on a list to find the position of a given number.
The algorithm takes user input to create a list, accepts a number to search for, then loops through the list and checks if each element is equal to the number. If found, it prints the index position. If not found after fully looping, it prints that the number is not in the list.
The Python code implements this by taking input to build a list, accepting a search number, looping through the list with an if/else statement to check for a match and print the output. It runs correctly for numbers found and not found in the lists.
Queue-Data Structure
The document describes different types of queues as data structures. A queue is a first-in, first-out (FIFO) data structure where elements are added to the rear and removed from the front. The document discusses linear (simple) queues, circular queues, double-ended queues, and priority queues. It provides algorithms and examples for insert and delete operations on each type of queue.
Lect 17-18 Zaheer Abbas
A queue is a first-in, first-out (FIFO) data structure where elements are added to the rear of the queue and removed from the front of the queue. Common queue operations include enqueue to add an element, dequeue to remove an element, and functions to access the front and rear of the queue. Queues can be implemented using arrays or linked lists, with pointers or indexes to track the front and rear of the queue. The document provides examples of these operations and overflow/underflow conditions that can occur.
2.1 STACK & QUEUE ADTS
This document discusses data structures stacks and queues. It provides definitions and examples of stacks and queues. Stacks follow LIFO (last in first out) and are useful for undo sequences and function calls. Queues follow FIFO (first in first out) and are useful for things like printer queues. The document discusses implementations of stacks and queues using arrays and linked lists. It provides pseudocode for common stack and queue operations like push, pop, enqueue, dequeue.
Formal methods Project Report for the support of slides uploaded
A complete report for the beginners to handle the HOL and many theorem provers and the development strategy.
Recommended
D422 ex-4-2 python
The document describes an algorithm to perform selection sort on a list of numbers. It defines the selection sort function that takes a list as a parameter. The function uses nested for loops to find the maximum element in the list and swap it with the current element being considered. The Python code implements this by taking user input to build a list, calling the selection sort function, and printing the original and sorted lists. It provides examples of sorting lists of different lengths.
D404 ex-4-1-3-1
The document contains an algorithm and Python program to sort a list of integers in ascending order using bubble sort.
The algorithm takes in a list as input, calculates its length, then has two nested for loops to compare adjacent elements and swap them if out of order.
The Python program implements this by taking in a number of elements, appending them to a list, sorting the list using the bubble sort algorithm, and outputting the sorted list.
D404 ex-5-2 (1)-1
1. The student wrote a Python program to implement binary search on a list.
2. The program takes user input to generate a list, sorts the list, then takes a target number to search for.
3. It uses a while loop to repeatedly check if the target is equal to the midpoint of the current search range, and updates the range based on the comparison, printing the index if found or a message if not found.
D404 ex-5-1-1
The document contains the algorithm and Python code to perform a linear search on a list to find the position of a given number.
The algorithm takes user input to create a list, accepts a number to search for, then loops through the list and checks if each element is equal to the number. If found, it prints the index position. If not found after fully looping, it prints that the number is not in the list.
The Python code implements this by taking input to build a list, accepting a search number, looping through the list with an if/else statement to check for a match and print the output. It runs correctly for numbers found and not found in the lists.
Queue-Data Structure
The document describes different types of queues as data structures. A queue is a first-in, first-out (FIFO) data structure where elements are added to the rear and removed from the front. The document discusses linear (simple) queues, circular queues, double-ended queues, and priority queues. It provides algorithms and examples for insert and delete operations on each type of queue.
Lect 17-18 Zaheer Abbas
A queue is a first-in, first-out (FIFO) data structure where elements are added to the rear of the queue and removed from the front of the queue. Common queue operations include enqueue to add an element, dequeue to remove an element, and functions to access the front and rear of the queue. Queues can be implemented using arrays or linked lists, with pointers or indexes to track the front and rear of the queue. The document provides examples of these operations and overflow/underflow conditions that can occur.
2.1 STACK & QUEUE ADTS
This document discusses data structures stacks and queues. It provides definitions and examples of stacks and queues. Stacks follow LIFO (last in first out) and are useful for undo sequences and function calls. Queues follow FIFO (first in first out) and are useful for things like printer queues. The document discusses implementations of stacks and queues using arrays and linked lists. It provides pseudocode for common stack and queue operations like push, pop, enqueue, dequeue.
Formal methods Project Report for the support of slides uploaded
A complete report for the beginners to handle the HOL and many theorem provers and the development strategy.
Project of data structure
The document discusses various applications of stacks including:
1) Reversing strings by pushing characters onto a stack and popping them off in reverse order.
2) Calculator operations using postfix notation and a stack.
3) Recursive functions using a stack to store previous function calls and variables.
4) Determining if a word is a palindrome by pushing characters onto a stack and comparing to the popped off characters.
Code examples are provided for reversing strings, recursive summation, and determining palindromes using stacks.
Stack
A stack is a Last In, First Out (LIFO) data structure where items added last are removed first. When an item is added to a stack, it is placed on the "top" of the stack, and when an item is removed it is taken from the top. Items are removed from the stack in the reverse order that they were inserted. The two main operations on a stack are PUSH, which adds an item to the top, and POP, which removes and returns the top item.
Data structure
This document provides an overview of different data structures including linked lists, stacks, queues, and priority queues. It describes linked lists as a linear data structure composed of nodes with data and address fields. It discusses different types of linked lists such as singly linked lists, circular singly linked lists, and doubly linked lists. It also describes how to perform operations like insertion and deletion on singly linked lists. The document further explains stacks, queues, and priority queues, describing their representations and basic operations.
Queue as data_structure
The document discusses different types of queues, including their definitions, properties, and implementations. It defines a queue as a linear data structure with two ends - one for adding elements and one for removing them, following a FIFO (first-in, first-out) approach. Key points covered include common queue operations like insertion and removal; circular queues which wrap elements around to avoid overflow; priority queues which order elements by priority; and deques which allow additions and removals from both ends.
Queue
A queue is a first-in first-out (FIFO) data structure where elements are inserted at the rear end and deleted from the front end. It maintains two pointers - a front pointer pointing to the front element and a rear pointer pointing to the rear element. New elements are added by incrementing the rear pointer and elements are removed by incrementing the front pointer. Common queue operations include enqueue() to add an element, dequeue() to remove an element, peek() to access the front element without removing it, and functions to check if the queue is full or empty.
Exp 4-1 d422-1
This document contains a student's experiment on bubble sorting integers in ascending order. It includes the student's name, experiment number, title, pseudocode for the bubble sort algorithm using a list, the Python code implementing the algorithm, and sample output showing the list of integers sorted in ascending order.
Data Structure (Queue)
Queue is a first-in first-out (FIFO) data structure where elements can only be added to the rear of the queue and removed from the front of the queue. It has two pointers - a front pointer pointing to the front element and a rear pointer pointing to the rear element. Queues can be implemented using arrays or linked lists. Common queue operations include initialization, checking if empty/full, enqueue to add an element, and dequeue to remove an element. The document then describes how these operations work for queues implemented using arrays, linked lists, and circular arrays. It concludes by providing exercises to implement specific queue tasks.
Team 6
This document discusses deque, or double-ended queue, which is an abstract data type that allows elements to be added or removed from either end. It describes two types of deques - input-restricted and output-restricted - and common operations like push, pop, and isEmpty. Examples are given of using a deque for palindrome checking, A-Steal job scheduling, and undo-redo operations in software.
Priority queues
Describes basic understanding of priority queues, their applications, methods, implementation with sorted/unsorted list, sorting applications with insertion sort and selection sort with their running times.
Queue
A queue is a linear data structure where insertion is done at one end called the rear and deletion is done at the other end called the front. There are different types of queues including simple, circular, deque, and priority queues. A priority queue allows insertion and removal of items from any position based on priority. Common queue operations are insertion, deletion, and examples of queue usage include lines at registers and traffic signals.
Applications of stack
The document discusses applications of stacks, including reversing strings and lists, Polish notation for mathematical expressions, converting between infix, prefix and postfix notations, evaluating postfix and prefix expressions, recursion, and the Tower of Hanoi problem. Recursion involves defining a function in terms of itself, with a stopping condition. Stacks can be used to remove recursion by saving local variables at each step.
My lectures circular queue
This document discusses queues and priority queues. It defines a queue as a first-in first-out (FIFO) linear data structure with elements added to the rear and removed from the front. Circular queues are introduced to address the limitation of linear queues filling up. Priority queues are also covered, with elements ordered by priority and the highest or lowest priority element always at the front. Implementation of priority queues using heaps is explained, with insertion and deletion operations having time complexity of O(log n).
Queue
Queue is a linear data structure where elements are inserted at one end called the rear and deleted from the other end called the front. It follows the FIFO (first in, first out) principle. Queues can be implemented using arrays or linked lists. In an array implementation, elements are inserted at the rear and deleted from the front. In a linked list implementation, nodes are added to the rear and removed from the front using front and rear pointers. There are different types of queues including circular queues, double-ended queues, and priority queues.
Detalied information of queue
The document discusses different types of queues, including simple queues, circular queues, priority queues, and deques. It provides details on how each type of queue is implemented and how elements are inserted and removed. Simple queues use an array and only allow insertion at the rear and removal at the front. Circular queues also use an array but allow wrapping around to the beginning so the queue never fills. Priority queues order elements by priority when inserting and removing. Deques allow insertion and removal from both the front and rear.
Stack & queue
Stacks are data structures that follow LIFO (last in, first out) ordering. Elements can only be added to or removed from one end, called the top. Stacks are used to maintain information between main programs and subroutines. Elements are pushed onto the stack by decrementing the stack pointer and storing the element, and popped off by incrementing the stack pointer after retrieving the element. Operations must check that the stack is not empty before popping or full before pushing to prevent errors.
Odersky week1 notes
This document discusses function types in Scala, including defining functions as objects or classes that extend function types. It provides examples of defining a factorial function recursively and using function types, as well as discussing recursion patterns like base cases and inductive steps. It also briefly mentions fold operations like foldLeft and foldRight, and using for comprehensions as a substitute for map/flatMap/filter operations.
Circular queue
A circular queue is a fixed size data structure that follows FIFO (first in, first out) principles. Elements are added to the rear of the queue and removed from the front. When the rear reaches the end, it wraps around to the beginning so the queue space is used efficiently. Common circular queue operations include enqueue to add an element, dequeue to remove an element, and display to output all elements.
Type hints Python 3
The document discusses type hints in Python 3, which allow specifying the types of function parameters and return values to enable type checking without changing runtime behavior. It provides examples of basic type hints like int and str, generic types like List and Dict, Callable for functions, NamedTuple for named tuples, overloading functions based on type, and using dataclasses to define classes from annotated fields. While type hints do not affect runtime, they allow catching errors earlier during development and improve code readability, refactoring safety, and documentation.
Queue Data Structure
Queue is an abstract data structure, somewhat similar to Stacks. Unlike stacks, a queue is open at both its ends. One end is always used to insert data (enqueue) and the other is used to remove data (dequeue). Queue follows First-In-First-Out methodology, i.e., the data item stored first will be accessed first.
Queues
The document discusses queues and their implementation using linked lists and arrays. It defines a queue as a first-in, first-out (FIFO) data structure where elements are inserted at the rear and deleted from the front. Operations on queues include enqueue, which inserts an element at the rear, and dequeue, which removes an element from the front and returns it. The document provides pseudocode for implementing queues using linked lists with a front and rear pointer and using arrays with front and rear indices.
Stack.pptx
The document discusses stacks and their implementation. It defines stacks as ordered collections where insertions and deletions occur at one end. Common stack operations like push and pop are described. Stacks can be implemented using arrays or linked lists. Various stack applications are mentioned like checking balanced symbols.
Stack Operation In Data Structure
well prepared and detailed description of stack in data structure.
Also cover the topic of Infix, prefix and post fix notation...
More Related Content
What's hot
Project of data structure
The document discusses various applications of stacks including:
1) Reversing strings by pushing characters onto a stack and popping them off in reverse order.
2) Calculator operations using postfix notation and a stack.
3) Recursive functions using a stack to store previous function calls and variables.
4) Determining if a word is a palindrome by pushing characters onto a stack and comparing to the popped off characters.
Code examples are provided for reversing strings, recursive summation, and determining palindromes using stacks.
Stack
A stack is a Last In, First Out (LIFO) data structure where items added last are removed first. When an item is added to a stack, it is placed on the "top" of the stack, and when an item is removed it is taken from the top. Items are removed from the stack in the reverse order that they were inserted. The two main operations on a stack are PUSH, which adds an item to the top, and POP, which removes and returns the top item.
Data structure
This document provides an overview of different data structures including linked lists, stacks, queues, and priority queues. It describes linked lists as a linear data structure composed of nodes with data and address fields. It discusses different types of linked lists such as singly linked lists, circular singly linked lists, and doubly linked lists. It also describes how to perform operations like insertion and deletion on singly linked lists. The document further explains stacks, queues, and priority queues, describing their representations and basic operations.
Queue as data_structure
The document discusses different types of queues, including their definitions, properties, and implementations. It defines a queue as a linear data structure with two ends - one for adding elements and one for removing them, following a FIFO (first-in, first-out) approach. Key points covered include common queue operations like insertion and removal; circular queues which wrap elements around to avoid overflow; priority queues which order elements by priority; and deques which allow additions and removals from both ends.
Queue
A queue is a first-in first-out (FIFO) data structure where elements are inserted at the rear end and deleted from the front end. It maintains two pointers - a front pointer pointing to the front element and a rear pointer pointing to the rear element. New elements are added by incrementing the rear pointer and elements are removed by incrementing the front pointer. Common queue operations include enqueue() to add an element, dequeue() to remove an element, peek() to access the front element without removing it, and functions to check if the queue is full or empty.
Exp 4-1 d422-1
This document contains a student's experiment on bubble sorting integers in ascending order. It includes the student's name, experiment number, title, pseudocode for the bubble sort algorithm using a list, the Python code implementing the algorithm, and sample output showing the list of integers sorted in ascending order.
Data Structure (Queue)
Queue is a first-in first-out (FIFO) data structure where elements can only be added to the rear of the queue and removed from the front of the queue. It has two pointers - a front pointer pointing to the front element and a rear pointer pointing to the rear element. Queues can be implemented using arrays or linked lists. Common queue operations include initialization, checking if empty/full, enqueue to add an element, and dequeue to remove an element. The document then describes how these operations work for queues implemented using arrays, linked lists, and circular arrays. It concludes by providing exercises to implement specific queue tasks.
Team 6
This document discusses deque, or double-ended queue, which is an abstract data type that allows elements to be added or removed from either end. It describes two types of deques - input-restricted and output-restricted - and common operations like push, pop, and isEmpty. Examples are given of using a deque for palindrome checking, A-Steal job scheduling, and undo-redo operations in software.
Priority queues
Describes basic understanding of priority queues, their applications, methods, implementation with sorted/unsorted list, sorting applications with insertion sort and selection sort with their running times.
Queue
A queue is a linear data structure where insertion is done at one end called the rear and deletion is done at the other end called the front. There are different types of queues including simple, circular, deque, and priority queues. A priority queue allows insertion and removal of items from any position based on priority. Common queue operations are insertion, deletion, and examples of queue usage include lines at registers and traffic signals.
Applications of stack
The document discusses applications of stacks, including reversing strings and lists, Polish notation for mathematical expressions, converting between infix, prefix and postfix notations, evaluating postfix and prefix expressions, recursion, and the Tower of Hanoi problem. Recursion involves defining a function in terms of itself, with a stopping condition. Stacks can be used to remove recursion by saving local variables at each step.
My lectures circular queue
This document discusses queues and priority queues. It defines a queue as a first-in first-out (FIFO) linear data structure with elements added to the rear and removed from the front. Circular queues are introduced to address the limitation of linear queues filling up. Priority queues are also covered, with elements ordered by priority and the highest or lowest priority element always at the front. Implementation of priority queues using heaps is explained, with insertion and deletion operations having time complexity of O(log n).
Queue
Queue is a linear data structure where elements are inserted at one end called the rear and deleted from the other end called the front. It follows the FIFO (first in, first out) principle. Queues can be implemented using arrays or linked lists. In an array implementation, elements are inserted at the rear and deleted from the front. In a linked list implementation, nodes are added to the rear and removed from the front using front and rear pointers. There are different types of queues including circular queues, double-ended queues, and priority queues.
Detalied information of queue
The document discusses different types of queues, including simple queues, circular queues, priority queues, and deques. It provides details on how each type of queue is implemented and how elements are inserted and removed. Simple queues use an array and only allow insertion at the rear and removal at the front. Circular queues also use an array but allow wrapping around to the beginning so the queue never fills. Priority queues order elements by priority when inserting and removing. Deques allow insertion and removal from both the front and rear.
Stack & queue
Stacks are data structures that follow LIFO (last in, first out) ordering. Elements can only be added to or removed from one end, called the top. Stacks are used to maintain information between main programs and subroutines. Elements are pushed onto the stack by decrementing the stack pointer and storing the element, and popped off by incrementing the stack pointer after retrieving the element. Operations must check that the stack is not empty before popping or full before pushing to prevent errors.
Odersky week1 notes
This document discusses function types in Scala, including defining functions as objects or classes that extend function types. It provides examples of defining a factorial function recursively and using function types, as well as discussing recursion patterns like base cases and inductive steps. It also briefly mentions fold operations like foldLeft and foldRight, and using for comprehensions as a substitute for map/flatMap/filter operations.
Circular queue
A circular queue is a fixed size data structure that follows FIFO (first in, first out) principles. Elements are added to the rear of the queue and removed from the front. When the rear reaches the end, it wraps around to the beginning so the queue space is used efficiently. Common circular queue operations include enqueue to add an element, dequeue to remove an element, and display to output all elements.
Type hints Python 3
The document discusses type hints in Python 3, which allow specifying the types of function parameters and return values to enable type checking without changing runtime behavior. It provides examples of basic type hints like int and str, generic types like List and Dict, Callable for functions, NamedTuple for named tuples, overloading functions based on type, and using dataclasses to define classes from annotated fields. While type hints do not affect runtime, they allow catching errors earlier during development and improve code readability, refactoring safety, and documentation.
Queue Data Structure
Queue is an abstract data structure, somewhat similar to Stacks. Unlike stacks, a queue is open at both its ends. One end is always used to insert data (enqueue) and the other is used to remove data (dequeue). Queue follows First-In-First-Out methodology, i.e., the data item stored first will be accessed first.
Queues
The document discusses queues and their implementation using linked lists and arrays. It defines a queue as a first-in, first-out (FIFO) data structure where elements are inserted at the rear and deleted from the front. Operations on queues include enqueue, which inserts an element at the rear, and dequeue, which removes an element from the front and returns it. The document provides pseudocode for implementing queues using linked lists with a front and rear pointer and using arrays with front and rear indices.
What's hot (20)
Similar to D404 ex-4-2
Stack.pptx
The document discusses stacks and their implementation. It defines stacks as ordered collections where insertions and deletions occur at one end. Common stack operations like push and pop are described. Stacks can be implemented using arrays or linked lists. Various stack applications are mentioned like checking balanced symbols.
Stack Operation In Data Structure
well prepared and detailed description of stack in data structure.
Also cover the topic of Infix, prefix and post fix notation...
Bca ii dfs u-2 linklist,stack,queue
The document discusses different data structures including stacks, queues, linked lists, and their implementations. It defines stacks as LIFO structures that allow push and pop operations. Queues are FIFO structures that allow enqueue and dequeue operations. Linked lists store data in nodes that link to the next node, allowing flexible sizes. Stacks and queues can be implemented using arrays or linked lists, with special handling needed at the ends. Priority queues allow deletion based on priority rather than order. Circular linked lists connect the last node to the first to allow continuous traversal.
Bsc cs ii dfs u-2 linklist,stack,queue
The document discusses different data structures including stacks, queues, linked lists, and their implementations. It defines stacks as LIFO structures that can add and remove items from one end only. Queues are FIFO structures that add to one end and remove from the other. Linked lists store data in nodes that point to the next node. Stacks, queues and linked lists can all be implemented using arrays or by linking nodes. Priority queues and deques are also discussed.
Stack
Stack is a linear data structure that follows the LIFO (Last In First Out) principle. Elements are inserted and removed from the top of the stack. Stack can be implemented using arrays or linked lists. Common stack operations are push, which adds an element to the top, and pop, which removes an element from the top.
Data Structures: Stacks (Part 1)
The document describes stacks and queues. Stacks are linear lists that only allow insertions and deletions at one end, following the LIFO principle. Queues are linear lists that only allow insertions at one end and deletions at the other, following the FIFO principle. Common applications of stacks include expression evaluation and recursion, while queues are often used for task scheduling and message buffering.
Stacks in c++
The document discusses stacks in C++. It defines a stack as a data structure that follows LIFO (Last In First Out) principle where the last element added is the first to be removed. Stacks can be implemented using arrays or linked lists. The key operations on a stack are push which adds an element and pop which removes an element. Example applications of stacks include function call stacks, converting infix to postfix notation, and reversing arrays.
STACK1.pptx
The document discusses stacks and queues as abstract data types. It describes stacks as last-in, first-out (LIFO) data structures that can be implemented using arrays or linked lists. Elements are inserted and removed from one end, called the top. Similarly, queues are first-in, first-out (FIFO) structures where elements are inserted at the rear and removed from the front. Common operations for both include push/enqueue, pop/dequeue, isEmpty, and isFull. Example code demonstrates implementing stacks and queues in C using arrays and linked lists. Applications are given such as undo functions, method call stacks, and waiting lists.
Stack and Queue.pptx university exam preparation
Queues and stacks are dynamic while arrays are static. So when we require dynamic memory we use queue or stack over arrays. Stacks and queues are used over arrays when sequential access is required. To efficiently remove any data from the start (queue) or the end (stack) of a data structure
Mca ii dfs u-3 linklist,stack,queue
The document defines and describes stacks, queues, and linked lists. It defines a stack as a LIFO data structure that allows push and pop operations. A queue is defined as a FIFO data structure that allows enqueue and dequeue operations. Linked lists are collections of nodes that contain data and a pointer to the next node. The document discusses implementations of stacks, queues, and linked lists using arrays and linked nodes. It also covers priority queues, deques, and circular linked lists.
Stack data structure
The document discusses stacks and their implementation and operations. It defines a stack as a linear data structure that follows the LIFO principle. Stacks can be implemented using arrays or linked lists. The two main operations on a stack are push and pop. Push adds an element to the top of the stack, while pop removes an element from the top. The document provides examples of these operations and discusses applications of stacks such as converting infix to postfix notation.
Revisiting a data structures in detail with linked list stack and queue
This document discusses various data structures including arrays, stacks, queues, and linked lists. It provides code examples for creating and manipulating each type of data structure. Specifically, it shows code for inserting and deleting elements from arrays and linked lists. It also includes algorithms and code for common stack and queue operations like push, pop, enqueue, and dequeue. The document provides a detailed overview of linear and non-linear data structures.
stack presentation
The document introduces stacks and discusses their implementation and applications. It defines a stack as a data structure that follows LIFO order, where elements can only be added and removed from one end. Stacks have two main implementations - using arrays and linked lists. Common applications of stacks include undo/redo in editors, browser history, and evaluating postfix expressions.
A Prelude of Purity: Scaling Back ZIO
Some parts of our applications don't need to be asynchronous or interact with the outside world: it's enough that they are stateful, possibly with the ability to handle failure, context, and logging. Although you can use ZIO 2 or monad transformers for this task, both come with drawbacks. In this presentation, Jorge Vásquez will introduce you to ZPure, a data type from ZIO Prelude, which lets you scale back on the power of ZIO 2, but with the same high-performance, type-inference, and ergonomics you expect from ZIO 2 libraries.
9 python data structure-2
This document discusses linear data structures like stacks and queues. It defines them as ordered data collections where items are added and removed from specific ends. Stacks follow LIFO while queues follow FIFO. The key operations for stacks are push and pop, while queues use enqueue and dequeue. Python implementations are shown using lists. Functions are created to add, remove, and display items for both stacks and queues.
Data structure lab manual
The document describes implementing a queue using an array. It provides algorithms for enQueue() and deQueue() operations. EnQueue() inserts elements at the rear by incrementing rear and checking for full. DeQueue() deletes elements from the front by incrementing front and checking for empty. The queue uses front and rear pointers to manage insertion and deletion of elements based on FIFO principle using an underlying fixed-size array.
Write a Java Class to Implement a Generic Linked ListYour list mus.pdf
Write a Java Class to Implement a Generic Linked List
Your list must be implemented as a singly-linked list of generic nodes, where each Node object
has two instance variables: an object of the “type variable” class, and a pointer to the next node
on the list.
Your class will contain separate methods to handle each of the operations read from a data file
(see II., below)
Your class will also override toString() to return the objects on the list in the order in which they
occur.
Write a Test Class for Your LinkedList Class
Your main method will read list operation instructions from a data file, until end-of-file and call
the appropriate LinkedList method to execute each one.
After each operation is executed, print out the operation and the updated list.
The data file to be used is on the class web site and the operations are:
APPEND X - Append object X to the end of the list
ADD N X - Insert object X as the new Nth element in the list, increasing the size of the list by 1
E.g. Suppose the list is:
head -> 1 -> 2 -> 3 -> 4->null
After ADD 3 7 it would be:
head -> 1 -> 2 -> 7 -> 3 -> 4->null
DELETE N – Remove the Nth object from the list
SWAP M N - Interchange the positions of the Mth and Nth
objects on the list
For credit, the two nodes must actually \"trade places\" in the list, and not merely swap their data
values
REVERSE - Reverse the order of the objects on the list
This must be done by reversing the order of the nodes themselves, rather than by swapping the
data stored
To get credit for your reverse() method, it must use either one of these 2 algorithms:
For each node on the list except the current “head”
node, delete the node and insert it as the new head
Use your swap() method
6. CLEAR – Clear the list (make it empty)
No credit will be given for programs that use any additional data structures – either from the Java
API or programmer defined -, other than your own LinkedList class
txt file:
Solution
//Java Program to Implement Singly Linked List
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/* Class Node */
class Nodes
{
protected Object data;
protected Nodes next;
/* Constructor */
public Nodes()
{
next = null;
data = null;
}
/* Constructor */
public Nodes(Object d,Nodes n)
{
data = d;
next = n;
}
/* Function to set link to next Node */
public void setLink(Nodes n)
{
next = n;
}
/* Function to set data to current Node */
public void setData(Object d)
{
data = d;
}
/* Function to get link to next node */
public Nodes getLink()
{
return next;
}
/* Function to get data from current Node */
public Object getData()
{
return data;
}
}
/* Class linkedList */
class linkList
{
protected Nodes start;
protected Nodes end ;
public int size ;
/* Constructor */
public linkList()
{
start = null;
end = null;
size = 0;
}
/* Function to check if list is empty */
public boolean isEmpty()
{
return start == null;
}
/* Function to get size of list */
public int getSize()
{
return .
Lab Manual-OOP.pdf
The document discusses implementing linked lists in C++. It describes singly linked lists and doubly linked lists. For singly linked lists, it explains how to traverse the list, insert nodes, and delete nodes. For doubly linked lists, it notes the additional previous pointer and advantages like ability to traverse backward. The lab tasks involve creating Node and LinkedList classes to implement insertion at the beginning and end of a singly linked list, and comparing singly and doubly linked lists.
STACK ( LIFO STRUCTURE) - Data Structure
Stack which is known as LIFO structure.Which is type of the Linear data structure and it is Non-Primitive data structure.
Definition:Non primitive data structure are not a basic data structure and depends on other primitive data structure (Integer,float etc).
Non primitive data structure can't be operated by machine level instruction directly.
Similar to D404 ex-4-2 (20)
Stack and its operations, Queue and its operations
Stack and its operations, Queue and its operations
Revisiting a data structures in detail with linked list stack and queue
Revisiting a data structures in detail with linked list stack and queue
Write a Java Class to Implement a Generic Linked ListYour list mus.pdf
Write a Java Class to Implement a Generic Linked ListYour list mus.pdf
More from Omkar Rane
Enabling SSL Elasticsearch on server
This document provides steps to enable SSL/HTTPS for an Elasticsearch server. It involves generating certificates, configuring Elasticsearch, and enabling TLS for both transport and HTTP layers. The process includes generating a CA certificate, creating node certificates signed by the CA, editing the Elasticsearch configuration file, and restarting Elasticsearch to enable HTTPS.
Anti lock braking (ABS) Model based Design in MATLAB-Simulink
This document describes the modeling and simulation of an anti-lock braking system (ABS) using Simulink. It includes models of vehicle dynamics, wheel dynamics, and a simplified ABS controller. The vehicle model accounts for mass, friction forces, and acceleration. The wheel model includes torque from braking and friction. Simulation results show wheel slip and stopping distance with and without the ABS controller engaged. The ABS system helps maintain optimal slip to minimize stopping distance.
Autosar fundamental
The document discusses Autosar's layered architecture and communication capabilities. It describes the layered architecture with basic software, runtime environment and application layers. The runtime environment implements a virtual function bus to allow software components to communicate within and across ECUs. Communication can be intra-ECU, inter-ECU, or inter-partition. The runtime environment uses services like AUTOSAR COM and IOC to enable different types of communication.
Stress Management
The document discusses stress, its causes and effects, and strategies for managing stress. It defines stress as the body's response to any physical or mental demand, which can be triggered by events or thoughts that make one feel frustrated, angry or nervous. Both moderate and excessive stress can impact one's physical and emotional health negatively. While stress is a normal experience, anxiety involves worrying and affects one's lifestyle longer term. The document recommends stress management techniques like relaxation exercises, physical activity, meditation and counseling to improve physical, emotional and cognitive functioning.
Bootloaders (U-Boot)
This document discusses bootloaders for embedded systems. It defines a bootloader as the first code executed after a system powers on or resets that is responsible for loading the operating system kernel. The document then describes the tasks of a bootloader like initializing hardware, loading binaries from storage, and providing a shell. It outlines the booting process differences between desktops and embedded systems. Finally, it focuses on the universal bootloader U-Boot, describing its directory structure, configuration, building process, and commands.
Concept of Diversity & Fading (wireless communication)
This document discusses concepts related to fading and diversity in wireless communication systems. It introduces fading as signal variations caused by multipath interference from multiple signal propagation paths. It describes two types of fading: large-scale fading due to path loss and shadowing, and small-scale fading which includes fast fading due to mobility and slow fading due to shadowing. It also discusses different diversity techniques that can be used to combat fading, including space, polarization, frequency and time diversity.
Tata Motors GDC .LTD Internship
The document describes several projects completed as part of a semester-long internship at Tata Motors. The projects include:
1. Developing a vendor chatbot using Rasa and Telegram APIs to provide invoice information to users. NLP techniques were used to extract intent and entities.
2. Creating a dashboard using HTML, CSS, and Flask for employee health monitoring.
3. Building a system to automatically add new employee data from Excel files to an AWS RDS database to then be viewed on a dashboard.
4. Deploying projects to AWS EC2 and RDS instances.
5. Working on a contract lifecycle management dashboard for Tata Motors using various technologies.
Machine Learning Model for M.S admissions
The document describes building a machine learning model to predict admissions for a Master's program. It loads student data, preprocesses it by imputing missing values, splits it into training and test sets, trains several models and evaluates their accuracy via cross-validation. Logistic regression achieved the best results with 77.5% accuracy. The trained logistic regression model is used to make predictions on new student data.
Timer 0 programming on LPC 1768
The document defines a function called DelayMs that uses Timer0 to create delays in milliseconds. It initializes Timer0 to increment every 12,000 clock cycles, which at a clock speed of 12MHz equals 1ms. The main function blinks an LED by turning it on for 500ms, then off for 500ms in a continuous loop using the DelayMs function.
ADC (Analog to Digital conversion) using LPC 1768
This document contains code for an interfacing diagram that converts analog to digital values and displays the output in hexadecimal on an LCD screen. The code configures the ADC and UART ports, performs an analog to digital conversion on an input voltage, converts the output to hexadecimal, and transmits the values over UART. It also contains calculations for the step size of the ADC based on the reference voltage and bits. An observation table shows theoretical and measured output values for different input voltages.
PWM based motor speed control using LPC 1768
This code configures the LPC1768 microcontroller's PWM peripheral to generate a pulse width modulated signal on pin PWM1.5. It initializes the PWM timer and match registers, enables the PWM output, and then uses a for loop to incrementally change the duty cycle of the PWM signal from 10% to 100% over 10 steps, pausing 1 second between each step. This allows the user to see the PWM output change frequency smoothly over time.
UART interfacing on LPC1768 (Cortex M3 micro controller)
This code configures the UART0 port on an LPC1768 microcontroller to communicate at 9600 baud. It sets the pin configuration for transmit and receive, enables the FIFO and clears flags. It then configures the baud rate divisor, character length, parity and stop bits. The code enters a loop to continuously read incoming serial data and echo it back on the transmit line.
LED Blinking logic on LPC1768
This document provides an interfacing diagram and code for an LPC1768 microcontroller to toggle a set of GPIO pins. The code uses PINSEL4 and FIO2DIR registers to configure pins P0.2 to P0.7 as GPIO outputs. It then uses a for loop to toggle all the pins high and low by setting and clearing the FIO2SET and FIO2CLR registers respectively.
CAN interfacing on LPC1768 (ARM Cortex M3 based Micro controller)
The document describes code for initializing and transmitting messages over a CAN bus on an LPC1768 microcontroller, including initializing the CAN controller, setting an acceptance filter to define which message IDs will be received, and sending a test message over CAN1 while monitoring reception on CAN2. Functions are defined for CAN initialization, setting the acceptance filter, and transmitting messages with given IDs and data over CAN1.
Vlisi Course project presentation:Keypad Scanner
This document describes a keypad scanner project implemented on an FPGA board. It includes the truth table and equations for scanning the keys of a 3x4 keypad to drive 4 LEDs. The Verilog code implements this design using logic gates and assigns statements. The code was submitted by 3 students for their VLSI design course, overseen by instructor Dr. Dipti Sakhare. References on Verilog, digital design, and the FPGA board used are also listed.
VlSI course project report : Keypad Scanner
This project report describes the design, simulation, and implementation of a keypad scanner on an FPGA board. A Verilog code was written using a dataflow modeling style to scan a 3x4 keypad and output a 5-bit binary number corresponding to the pressed key. The code was simulated using Xilinx Vivado software. Finally, the design was implemented on a Digilent Nexys ddr FPGA board and tested successfully.
LPC 1768 A study on Real Time clock features
The document discusses the real-time clock (RTC) and backup registers for the LPC176x/5x microcontroller. It describes the RTC oscillator, clock control register, time counter registers, consolidated time registers, and steps for using the RTC including initializing, setting date and time, and reading date and time. Potential applications mentioned include a digital clock, timer controller, and data logging systems.
Nexys4ddr rm FPGA board Datasheet
This document provides an overview and reference manual for the Nexys4 DDR FPGA board. It describes the board's features such as the Artix-7 FPGA, memory resources, ports, and peripherals. It also provides details on power supplies, FPGA configuration options, and migrating designs from the original Nexys4 board. The manual is intended to help users understand and utilize the capabilities of the Nexys4 DDR board.
Linear Regression (Machine Learning)
The document discusses linear regression for predicting salary based on years of experience. It introduces gradient descent for linear regression, which iteratively updates the slope and intercept parameters (θ1 and θ2) to minimize cost and improve predictions. Gradient descent takes steps in the direction of the steepest descent down the cost function landscape. The learning rate determines step sizes and must be optimized for accurate predictions within a reasonable time.
transmission gate based design for 2:1 Multiplexer in micro-wind
A 2:1 multiplexer uses a transmission gate to select between two input signals and output the selected signal. The transmission gate is controlled by a select signal, where a high select chooses input A and a low select chooses input B. The multiplexer uses the select signal to pass either input A or B to the output without affecting the logic levels of the selected signal.
More from Omkar Rane (20)
Anti lock braking (ABS) Model based Design in MATLAB-Simulink
Anti lock braking (ABS) Model based Design in MATLAB-Simulink
Concept of Diversity & Fading (wireless communication)
Concept of Diversity & Fading (wireless communication)
UART interfacing on LPC1768 (Cortex M3 micro controller)
UART interfacing on LPC1768 (Cortex M3 micro controller)
CAN interfacing on LPC1768 (ARM Cortex M3 based Micro controller)
CAN interfacing on LPC1768 (ARM Cortex M3 based Micro controller)
transmission gate based design for 2:1 Multiplexer in micro-wind
transmission gate based design for 2:1 Multiplexer in micro-wind
Recently uploaded
RAT: Retrieval Augmented Thoughts Elicit Context-Aware Reasoning in Long-Hori...
RAT: Retrieval Augmented Thoughts Elicit Context-Aware Reasoning in Long-Horizon Generation
[JPP-1] - (JEE 3.0) - Kinematics 1D - 14th May..pdf
Kinematics 11th jpp- 01. ( Solved ) unacademy namo kaul on 14th may...
Modelagem de um CSTR com reação endotermica.pdf
Modelagem em função de transferencia. CSTR não-linear.
DEEP LEARNING FOR SMART GRID INTRUSION DETECTION: A HYBRID CNN-LSTM-BASED MODEL
As digital technology becomes more deeply embedded in power systems, protecting the communication
networks of Smart Grids (SG) has emerged as a critical concern. Distributed Network Protocol 3 (DNP3)
represents a multi-tiered application layer protocol extensively utilized in Supervisory Control and Data
Acquisition (SCADA)-based smart grids to facilitate real-time data gathering and control functionalities.
Robust Intrusion Detection Systems (IDS) are necessary for early threat detection and mitigation because
of the interconnection of these networks, which makes them vulnerable to a variety of cyberattacks. To
solve this issue, this paper develops a hybrid Deep Learning (DL) model specifically designed for intrusion
detection in smart grids. The proposed approach is a combination of the Convolutional Neural Network
(CNN) and the Long-Short-Term Memory algorithms (LSTM). We employed a recent intrusion detection
dataset (DNP3), which focuses on unauthorized commands and Denial of Service (DoS) cyberattacks, to
train and test our model. The results of our experiments show that our CNN-LSTM method is much better
at finding smart grid intrusions than other deep learning algorithms used for classification. In addition,
our proposed approach improves accuracy, precision, recall, and F1 score, achieving a high detection
accuracy rate of 99.50%.
New techniques for characterising damage in rock slopes.pdf
rock mass characterization and New techniques for characterising damage in rock slopes
Understanding Inductive Bias in Machine Learning
This presentation explores the concept of inductive bias in machine learning. It explains how algorithms come with built-in assumptions and preferences that guide the learning process. You'll learn about the different types of inductive bias and how they can impact the performance and generalizability of machine learning models.
The presentation also covers the positive and negative aspects of inductive bias, along with strategies for mitigating potential drawbacks. We'll explore examples of how bias manifests in algorithms like neural networks and decision trees.
By understanding inductive bias, you can gain valuable insights into how machine learning models work and make informed decisions when building and deploying them.
5214-1693458878915-Unit 6 2023 to 2024 academic year assignment (AutoRecovere...
Bigdata of technology
IEEE Aerospace and Electronic Systems Society as a Graduate Student Member
IEEE Aerospace and Electronic Systems Society as a Graduate Student Member
Iron and Steel Technology Roadmap - Towards more sustainable steelmaking.pdf
Iron and Steel Technology towards Sustainable Steelmaking
Recently uploaded (20)
RAT: Retrieval Augmented Thoughts Elicit Context-Aware Reasoning in Long-Hori...
RAT: Retrieval Augmented Thoughts Elicit Context-Aware Reasoning in Long-Hori...
[JPP-1] - (JEE 3.0) - Kinematics 1D - 14th May..pdf
[JPP-1] - (JEE 3.0) - Kinematics 1D - 14th May..pdf
DEEP LEARNING FOR SMART GRID INTRUSION DETECTION: A HYBRID CNN-LSTM-BASED MODEL
DEEP LEARNING FOR SMART GRID INTRUSION DETECTION: A HYBRID CNN-LSTM-BASED MODEL
New techniques for characterising damage in rock slopes.pdf
New techniques for characterising damage in rock slopes.pdf
2. Operations Strategy in a Global Environment.ppt
2. Operations Strategy in a Global Environment.ppt
ML Based Model for NIDS MSc Updated Presentation.v2.pptx
ML Based Model for NIDS MSc Updated Presentation.v2.pptx
5214-1693458878915-Unit 6 2023 to 2024 academic year assignment (AutoRecovere...
5214-1693458878915-Unit 6 2023 to 2024 academic year assignment (AutoRecovere...
Generative AI leverages algorithms to create various forms of content
Generative AI leverages algorithms to create various forms of content
IEEE Aerospace and Electronic Systems Society as a Graduate Student Member
IEEE Aerospace and Electronic Systems Society as a Graduate Student Member
Iron and Steel Technology Roadmap - Towards more sustainable steelmaking.pdf
Iron and Steel Technology Roadmap - Towards more sustainable steelmaking.pdf
D404 ex-4-2
- 1. Name of Students KAUSTUBH ARUN WANKHADE Roll No D404 Batch D1 Experiment No EX-4-2 Title of Experiment List outthe givencharactersin ascendingorder(use SelectionSort) Write An Algorithm: STEP I:START STEP II: Take an empty list STEP III: Take input of no of elements in list STEP IV:Initializing loop for no STEP V:Taking input of elements in list STEP VI: Appending values to list STEP VII:Display given list STEP VIII:Defining a function selectionsort STEP IX: Initializing outer For loop (len(alist)-1,0,-1) STEP X: Defining position of maximum STEP XI:Initializing inner loop for 1 to fillslot+1 STEP XII:Check condition if alist [location]>alist[positionofmax] Then swap STEP XIII: Display Sorted list of given elements STEP XIV:STOP
- 2. Paste Your Python Program ( Python Code): def selectionsort(alist): for fillslot in range (len(alist)-1,0,-1): #Initializing outer For loop positionofmax=0 #Defining position of maximum for location in range(1,fillslot+1): #Initializing inner For loop if alist [location]>alist[positionofmax]: #Checking condition positionofmax=location #Defining Position of maximum as loaction temp = alist[fillslot] alist[fillslot]=alist[positionofmax] alist[positionofmax]=temp alist=[] #Taking an empty list no=raw_input("Enter no of elements") #Taking no of elements in list no=int(no) for i in range(no): #Initializing for loop list=raw_input("Enter the elements") #Assigning values to list list=int(list) alist.append(list) #Append values to list print"Given list is",alist #Display given list selectionsort(alist) print("Sorted list is"),alist #Display Sorted list Paste Your Program OUTPUT : Given list is [989, 22, 787] Sorted list is [22, 787, 989] Given list is [698, 78, 3, 659, 550] Sorted list is [3, 78, 550, 659, 698]