D422 ex-4-2 python
•Download as DOCX, PDF•
0 likes•90 views
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.
Report
Share
Report
Share
![Roll No D422
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
Paste Your Python Program ( Python Code):](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
D404 ex-4-2
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.
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.
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.
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.
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.
Recommended
D404 ex-4-2
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.
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.
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.
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.
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
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
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.
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.
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.
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.
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.
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.
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.
Stack
A stack is a last-in, first-out data structure where elements can only be inserted or removed from one end. Stacks follow the LIFO principle. The document discusses stacks and their use in evaluating arithmetic expressions. Expressions can be written in infix, prefix, or postfix notation, and converting an infix expression to postfix notation allows it to be evaluated using a stack, with operators and operands pushed and popped off the stack from left to right.
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.
Queue
The document discusses queues and their implementation and operations. It provides the names and roll numbers of group members working on a presentation about queues. It then defines a queue as a first-in first-out (FIFO) data structure where items can be inserted at one end and removed from the other. Various examples of queue applications are given. Implementation of queues using arrays is described, including tracking the front and rear indexes and how elements are added and removed. Pseudocode for queue insertion and removal algorithms is also provided.
Linear and binary search
The document discusses linear search and binary search algorithms.
Linear search is the simplest search algorithm that works by sequentially checking each element of a list to see if it matches the search item. It has linear time complexity of O(n) as it may need to traverse the entire list in the worst case.
Binary search works on sorted lists by comparing the search item to the middle element and recursively searching either the left or right half. It has logarithmic time complexity of O(log n) as it cuts the search space in half each step. Pseudocode and examples are provided to illustrate both algorithms.
Stack and queue -polish notations
This document describes algorithms for converting infix notation expressions to postfix and prefix notation using stacks. For postfix notation, operands are added to an expression string while operators are added to a stack based on precedence. For prefix notation, operands are added to a stack while operators are added to the beginning of an expression string. Both algorithms process expressions from left to right and handle parentheses.
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.
Stack and its operations
This document discusses stacks and their operations. It defines a stack as a linear data structure that follows LIFO (last-in, first-out) ordering. Elements are inserted and removed from one end only, called pushing and popping. Stacks have common real-world examples like decks of cards. They can be represented using arrays or linked lists. The core stack operations are push, which adds an element, and pop, which removes the top element. Additional operations check the stack status, like if it is full or empty. Pseudocode is provided for implementing push, pop, and status checks in both array-based and linked list-based stacks.
C# Method overloading
Overview:
Introduction to overloading.
Method overloading.
Example program for method overloading.
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.
Queue
A queue is a first-in, first-out (FIFO) data structure where items are inserted at one end called the rear and removed from the other end called the front. Common applications include printer queues, bank lines, and computer input/output operations. The document discusses different implementations of queues including physical, single-step append-serve, and circular models. It also covers priority queues where items have priorities and are served according to those priorities.
Slides
This document outlines a study on identifying classes in JavaScript code. It presents a technique called JSDeodorant that uses data flow analysis and function body analysis to identify class emulations. The approach was evaluated on several open source projects and found to have high precision and recall, outperforming an existing tool. An empirical study also found statistical differences in how classes are adapted across NodeJS, website, and library code. Future work could include identifying code smells and supporting class inheritance and modern JavaScript features.
presentation-225new
This document discusses skip lists, including:
- What a skip list is and how it is structured as multiple linked lists of increasing sparsity.
- The basic operations of searching, inserting, and deleting in skip lists and how they are performed by traversing the lists.
- Variables needed to implement a skip list class in Java.
- Examples showing the steps to insert and delete elements from a skip list through modifying pointers between nodes.
- Comparisons of the time complexities of basic operations between linked lists and skip lists.
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
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
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.
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.
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.
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.
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.
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.
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.
Stack
A stack is a last-in, first-out data structure where elements can only be inserted or removed from one end. Stacks follow the LIFO principle. The document discusses stacks and their use in evaluating arithmetic expressions. Expressions can be written in infix, prefix, or postfix notation, and converting an infix expression to postfix notation allows it to be evaluated using a stack, with operators and operands pushed and popped off the stack from left to right.
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.
Queue
The document discusses queues and their implementation and operations. It provides the names and roll numbers of group members working on a presentation about queues. It then defines a queue as a first-in first-out (FIFO) data structure where items can be inserted at one end and removed from the other. Various examples of queue applications are given. Implementation of queues using arrays is described, including tracking the front and rear indexes and how elements are added and removed. Pseudocode for queue insertion and removal algorithms is also provided.
Linear and binary search
The document discusses linear search and binary search algorithms.
Linear search is the simplest search algorithm that works by sequentially checking each element of a list to see if it matches the search item. It has linear time complexity of O(n) as it may need to traverse the entire list in the worst case.
Binary search works on sorted lists by comparing the search item to the middle element and recursively searching either the left or right half. It has logarithmic time complexity of O(log n) as it cuts the search space in half each step. Pseudocode and examples are provided to illustrate both algorithms.
Stack and queue -polish notations
This document describes algorithms for converting infix notation expressions to postfix and prefix notation using stacks. For postfix notation, operands are added to an expression string while operators are added to a stack based on precedence. For prefix notation, operands are added to a stack while operators are added to the beginning of an expression string. Both algorithms process expressions from left to right and handle parentheses.
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.
Stack and its operations
This document discusses stacks and their operations. It defines a stack as a linear data structure that follows LIFO (last-in, first-out) ordering. Elements are inserted and removed from one end only, called pushing and popping. Stacks have common real-world examples like decks of cards. They can be represented using arrays or linked lists. The core stack operations are push, which adds an element, and pop, which removes the top element. Additional operations check the stack status, like if it is full or empty. Pseudocode is provided for implementing push, pop, and status checks in both array-based and linked list-based stacks.
C# Method overloading
Overview:
Introduction to overloading.
Method overloading.
Example program for method overloading.
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.
Queue
A queue is a first-in, first-out (FIFO) data structure where items are inserted at one end called the rear and removed from the other end called the front. Common applications include printer queues, bank lines, and computer input/output operations. The document discusses different implementations of queues including physical, single-step append-serve, and circular models. It also covers priority queues where items have priorities and are served according to those priorities.
Slides
This document outlines a study on identifying classes in JavaScript code. It presents a technique called JSDeodorant that uses data flow analysis and function body analysis to identify class emulations. The approach was evaluated on several open source projects and found to have high precision and recall, outperforming an existing tool. An empirical study also found statistical differences in how classes are adapted across NodeJS, website, and library code. Future work could include identifying code smells and supporting class inheritance and modern JavaScript features.
presentation-225new
This document discusses skip lists, including:
- What a skip list is and how it is structured as multiple linked lists of increasing sparsity.
- The basic operations of searching, inserting, and deleting in skip lists and how they are performed by traversing the lists.
- Variables needed to implement a skip list class in Java.
- Examples showing the steps to insert and delete elements from a skip list through modifying pointers between nodes.
- Comparisons of the time complexities of basic operations between linked lists and skip lists.
What's hot (20)
Similar to D422 ex-4-2 python
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...
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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.
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.
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.
Exp 5-1 d-422
The document describes a Python program that uses linear search to find the position of a number in a list. It takes in a list of numbers as input, then prompts the user to enter a number to search for. It loops through the list, checks if each element is equal to the target number, and prints the index if found or a not found message if not. The program output shows it correctly finding a number in one list and not finding a number in another list.
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 .
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.
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.
Similar to D422 ex-4-2 python (20)
Revisiting a data structures in detail with linked list stack and queue
Revisiting a data structures in detail with linked list stack and queue
Stack and its operations, Queue and its operations
Stack and its operations, Queue and its operations
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
IEEE Aerospace and Electronic Systems Society as a Graduate Student Member
IEEE Aerospace and Electronic Systems Society as a Graduate Student Member
Electric vehicle and photovoltaic advanced roles in enhancing the financial p...
Climate change's impact on the planet forced the United Nations and governments to promote green energies and electric transportation. The deployments of photovoltaic (PV) and electric vehicle (EV) systems gained stronger momentum due to their numerous advantages over fossil fuel types. The advantages go beyond sustainability to reach financial support and stability. The work in this paper introduces the hybrid system between PV and EV to support industrial and commercial plants. This paper covers the theoretical framework of the proposed hybrid system including the required equation to complete the cost analysis when PV and EV are present. In addition, the proposed design diagram which sets the priorities and requirements of the system is presented. The proposed approach allows setup to advance their power stability, especially during power outages. The presented information supports researchers and plant owners to complete the necessary analysis while promoting the deployment of clean energy. The result of a case study that represents a dairy milk farmer supports the theoretical works and highlights its advanced benefits to existing plants. The short return on investment of the proposed approach supports the paper's novelty approach for the sustainable electrical system. In addition, the proposed system allows for an isolated power setup without the need for a transmission line which enhances the safety of the electrical network
A review on techniques and modelling methodologies used for checking electrom...
The proper function of the integrated circuit (IC) in an inhibiting electromagnetic environment has always been a serious concern throughout the decades of revolution in the world of electronics, from disjunct devices to today’s integrated circuit technology, where billions of transistors are combined on a single chip. The automotive industry and smart vehicles in particular, are confronting design issues such as being prone to electromagnetic interference (EMI). Electronic control devices calculate incorrect outputs because of EMI and sensors give misleading values which can prove fatal in case of automotives. In this paper, the authors have non exhaustively tried to review research work concerned with the investigation of EMI in ICs and prediction of this EMI using various modelling methodologies and measurement setups.
Recycled Concrete Aggregate in Construction Part III
Using recycled concrete aggregates (RCA) for pavements is crucial to achieving sustainability. Implementing RCA for new pavement can minimize carbon footprint, conserve natural resources, reduce harmful emissions, and lower life cycle costs. Compared to natural aggregate (NA), RCA pavement has fewer comprehensive studies and sustainability assessments.
22CYT12-Unit-V-E Waste and its Management.ppt
Introduction- e - waste – definition - sources of e-waste– hazardous substances in e-waste - effects of e-waste on environment and human health- need for e-waste management– e-waste handling rules - waste minimization techniques for managing e-waste – recycling of e-waste - disposal treatment methods of e- waste – mechanism of extraction of precious metal from leaching solution-global Scenario of E-waste – E-waste in India- case studies.
Advanced control scheme of doubly fed induction generator for wind turbine us...
This paper describes a speed control device for generating electrical energy on an electricity network based on the doubly fed induction generator (DFIG) used for wind power conversion systems. At first, a double-fed induction generator model was constructed. A control law is formulated to govern the flow of energy between the stator of a DFIG and the energy network using three types of controllers: proportional integral (PI), sliding mode controller (SMC) and second order sliding mode controller (SOSMC). Their different results in terms of power reference tracking, reaction to unexpected speed fluctuations, sensitivity to perturbations, and resilience against machine parameter alterations are compared. MATLAB/Simulink was used to conduct the simulations for the preceding study. Multiple simulations have shown very satisfying results, and the investigations demonstrate the efficacy and power-enhancing capabilities of the suggested control system.
6th International Conference on Machine Learning & Applications (CMLA 2024)
6th International Conference on Machine Learning & Applications (CMLA 2024) will provide an excellent international forum for sharing knowledge and results in theory, methodology and applications of on Machine Learning & Applications.
Embedded machine learning-based road conditions and driving behavior monitoring
Car accident rates have increased in recent years, resulting in losses in human lives, properties, and other financial costs. An embedded machine learning-based system is developed to address this critical issue. The system can monitor road conditions, detect driving patterns, and identify aggressive driving behaviors. The system is based on neural networks trained on a comprehensive dataset of driving events, driving styles, and road conditions. The system effectively detects potential risks and helps mitigate the frequency and impact of accidents. The primary goal is to ensure the safety of drivers and vehicles. Collecting data involved gathering information on three key road events: normal street and normal drive, speed bumps, circular yellow speed bumps, and three aggressive driving actions: sudden start, sudden stop, and sudden entry. The gathered data is processed and analyzed using a machine learning system designed for limited power and memory devices. The developed system resulted in 91.9% accuracy, 93.6% precision, and 92% recall. The achieved inference time on an Arduino Nano 33 BLE Sense with a 32-bit CPU running at 64 MHz is 34 ms and requires 2.6 kB peak RAM and 139.9 kB program flash memory, making it suitable for resource-constrained embedded systems.
DfMAy 2024 - key insights and contributions
We have compiled the most important slides from each speaker's presentation. This year’s compilation, available for free, captures the key insights and contributions shared during the DfMAy 2024 conference.
Literature Review Basics and Understanding Reference Management.pptx
Three-day training on academic research focuses on analytical tools at United Technical College, supported by the University Grant Commission, Nepal. 24-26 May 2024
CHINA’S GEO-ECONOMIC OUTREACH IN CENTRAL ASIAN COUNTRIES AND FUTURE PROSPECT
The rivalry between prominent international actors for dominance over Central Asia's hydrocarbon
reserves and the ancient silk trade route, along with China's diplomatic endeavours in the area, has been
referred to as the "New Great Game." This research centres on the power struggle, considering
geopolitical, geostrategic, and geoeconomic variables. Topics including trade, political hegemony, oil
politics, and conventional and nontraditional security are all explored and explained by the researcher.
Using Mackinder's Heartland, Spykman Rimland, and Hegemonic Stability theories, examines China's role
in Central Asia. This study adheres to the empirical epistemological method and has taken care of
objectivity. This study analyze primary and secondary research documents critically to elaborate role of
china’s geo economic outreach in central Asian countries and its future prospect. China is thriving in trade,
pipeline politics, and winning states, according to this study, thanks to important instruments like the
Shanghai Cooperation Organisation and the Belt and Road Economic Initiative. According to this study,
China is seeing significant success in commerce, pipeline politics, and gaining influence on other
governments. This success may be attributed to the effective utilisation of key tools such as the Shanghai
Cooperation Organisation and the Belt and Road Economic Initiative.
bank management system in java and mysql report1.pdf
truth is high but higher still is truth full living
Recently uploaded (20)
IEEE Aerospace and Electronic Systems Society as a Graduate Student Member
IEEE Aerospace and Electronic Systems Society as a Graduate Student Member
Electric vehicle and photovoltaic advanced roles in enhancing the financial p...
Electric vehicle and photovoltaic advanced roles in enhancing the financial p...
A review on techniques and modelling methodologies used for checking electrom...
A review on techniques and modelling methodologies used for checking electrom...
Recycled Concrete Aggregate in Construction Part III
Recycled Concrete Aggregate in Construction Part III
Advanced control scheme of doubly fed induction generator for wind turbine us...
Advanced control scheme of doubly fed induction generator for wind turbine us...
6th International Conference on Machine Learning & Applications (CMLA 2024)
6th International Conference on Machine Learning & Applications (CMLA 2024)
Embedded machine learning-based road conditions and driving behavior monitoring
Embedded machine learning-based road conditions and driving behavior monitoring
Literature Review Basics and Understanding Reference Management.pptx
Literature Review Basics and Understanding Reference Management.pptx
CHINA’S GEO-ECONOMIC OUTREACH IN CENTRAL ASIAN COUNTRIES AND FUTURE PROSPECT
CHINA’S GEO-ECONOMIC OUTREACH IN CENTRAL ASIAN COUNTRIES AND FUTURE PROSPECT
bank management system in java and mysql report1.pdf
bank management system in java and mysql report1.pdf
D422 ex-4-2 python
- 1. Name of Students Omkar Rane
- 2. Roll No D422 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 Paste Your Python Program ( Python Code):
- 3. 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]