Showing posts with label IT. Show all posts
Showing posts with label IT. Show all posts

Feb 27, 2013

Different Sorting Techniques


Binary Search
This is a very important algorithm you can apply at many different problem environments you never expect.
Understand the runtime complexity for the Binary Search and understand how to derive the complexity from algorithm. Note that it can be applied for only sorted lists. Learn how to apply Binary Search in a Rotated Sorted List by using recursion and how the algorithm complexity varies. Implement Binary Search using C for a list of strings. You should familiarize the terms in place sorting, stable sorting and also should understand which sorts come into these categories.
Insertion Sort
Understand the algorithm and derivation of algorithm analysis. Compare it with Card game in which we move the cards to the suitable position. Keep the example in mind and apply to similar problems. In Insertion sort, we sort the element set by consequently moving the current element to the appropriate position in an already sorted set.
QuickSort
QuickSort is a very important sorting technique. It uses divide and conquer technique. Divide the given set of elements into smaller sets recursively and apply comparison and swap. When comparison and swap is performed to formulated smaller sets, it results in the larger sorted set. Learn algorithm analysis. Learn how to find kth smallest element by modifying the Quicksort algorithm in O(nk) complexity. Find out mean of a set of elements in O(n) by modifying the above problem.
MergeSort
Mergesort is also a divide and conquer sorting technique. The concept is to merge two sorted list to obtain larger sorted set. By dividing the given array into smaller subset by recursion, smaller subsets are formed. Merging the subsets from lower level to higher level, we obtain sorted array. Learn algorithm analysis. Note that merge sort takes an extra array. Hence this is not an in place sorting. It has O(n) space complexity. You should practice problems related to merge sort. Eg. You are given two sorted arrays with size n and 2n. The second array contain n elements in the positions 0 to n-1. Now without using extra space, formulate the elements in 1st and 2nd array into 2nd array and return a sorted array of size 2n.
HeapSort
Heapsort is an interesting sorting technique. Heap is a tree in which parent node is always >= child nodes (called as max-heap) or parent node is always <= child nodes (called as min-heap). This is the basic property for a heap. Let us have an overview of how to create a heap and manage it. When we need to add an element into an existing heap, we add the element as root or to the rightmost bottom element in the heap. Then apply heapify operation. Heapify operation can be of two types: shiftup and shift down. When we add a new element to an existing heap as root element, we perform shift down operation. Shift down operation performs a traversal from root level to bottom level, at each level of traversal, it compares whether heap property is violated, if so it will perform swap between parent node and child node to obey the heap property. Hence the element we added as root will move to the accurate position when the traversal reaches the bottom level. If we add a new element to the bottom right element, we need to perform a shift up to position the element to the right position. We traverse from parent in the bottom level to the root, by checking the heap property at each level and swapping elements to meet the heap property, we get a balanced heap when traversal reaches the top element.
Heapsort makes use of these operations to obtain a sorted set. Let us assume we have a heap (1,n). the root element will be the highest value (max-heap). Hence it will be the last element in the sorted list. We swap the root and the last element. Now the heap property is lost. But the nth position of array has the correct element in the sorted list. So we exclude nth element and heapify the heap(1,n-1) by using shift down operation. Because the root element is the one breaking the heap balance. After doing heapify 2nd time, we get 2nd highest element as root element. Now swap root element with n-1 element. Hence n-1, nth elements are 2nd largest and largest elements. Now exclude the n-1 and nth element, heapify heap(1,n-2). Follow the procedure until the newly formed heap size become one. You will get a sorted list. Read the chapter Heaps from Programming Pearls (It will give you a wonderful insight). Practice the problems: Find kth largest element from a given unsorted array. Implement priority queues.

Jan 19, 2012

Architecture & Functional dig.of 8085


Architecture & Functional dig.of 8085.


The functional block diagram or architechture of 8085 Microprocessor is very important as it gives the complete details about a Microprocessor. Fig. shows the Block diagram of a Microprocessor.



8085 Bus Structure:
Address Bus:
  • The address bus is a group of 16 lines generally identified as A0 to A15.
  • The address bus is unidirectional: bits flow in one direction-from the MPU to peripheral devices.
  • The MPU uses the address bus to perform the first function: identifying a peripheral or a memory location.
Data Bus:
  • The data bus is a group of eight lines used for data flow.
  • These lines are bi-directional - data flow in both directions between the MPU and memory and peripheral devices.
  • The MPU uses the data bus to perform the second function: transferring binary information.
  • The eight data lines enable the MPU to manipulate 8-bit data ranging from 00 to FF (28 = 256 numbers).
  • The largest number that can appear on the data bus is 11111111.
Control Bus:
  • The control bus carries synchronization signals and providing timing signals.
  • The MPU generates specific control signals for every operation it performs. These signals are used to identify a device type with which the MPU wants to communicate.
Registers of 8085:
The 8085 have six general-purpose registers to store 8-bit data during program execution.
  • These registers are identified as B, C, D, E, H, and L.
  • They can be combined as register pairs-BC, DE, and HL-to perform some 16-bit operations.
Accumulator (A):
  • The accumulator is an 8-bit register that is part of the arithmetic/logic unit (ALU).
  • This register is used to store 8-bit data and to perform arithmetic and logical operations.
  • The result of an operation is stored in the accumulator.
Flags:
  • The ALU includes five flip-flops that are set or reset according to the result of an operation.
  • The microprocessor uses the flags for testing the data conditions.
  • They are Zero (Z), Carry (CY), Sign (S), Parity (P), and Auxiliary Carry (AC) flags. The most commonly used flags are Sign, Zero, and Carry.
The bit position for the flags in flag register is,
1.Sign Flag (S):
After execution of any arithmetic and logical operation, if D7 of the result is 1, the sign flag is set. Otherwise it is reset.
D7 is reserved for indicating the sign; the remaining is the magnitude of number.
If D7 is 1, the number will be viewed as negative number. If D7 is 0, the number will be viewed as positive number.
2.Zero Flag (z):
If the result of arithmetic and logical operation is zero, then zero flag is set otherwise it is reset.
3.Auxiliary Carry Flag (AC):
If D3 generates any carry when doing any arithmetic and logical operation, this flag is set.
Otherwise it is reset.
4.Parity Flag (P):
If the result of arithmetic and logical operation contains even number of 1's then this flag will be set and if it is odd number of 1's it will be reset.
5.Carry Flag (CY):
If any arithmetic and logical operation result any carry then carry flag is set otherwise it is reset.
Arithmetic and Logic Unit (ALU):
  • It is used to perform the arithmetic operations like addition, subtraction, multiplication, division, increment and decrement and logical operations like AND, OR and EX-OR.
  • It receives the data from accumulator and registers.
  • According to the result it set or reset the flags.
Program Counter (PC):
This 16-bit register sequencing the execution of instructions.
  • It is a memory pointer. Memory locations have 16-bit addresses, and that is why this is a 16-bit register.
  • The function of the program counter is to point to the memory address of the next instruction to be executed.
  • When an opcode is being fetched, the program counter is incremented by one to point to the next memory location.
Stack Pointer (Sp):
  • The stack pointer is also a 16-bit register used as a memory pointer.
  • It points to a memory location in R/W memory, called the stack.
  • The beginning of the stack is defined by loading a 16-bit address in the stack pointer (register).
·  Temporary Register: It is used to hold the data during the arithmetic and logical operations.
·  · Instruction Register: When an instruction is fetched from the memory, it is loaded in the instruction register.
·  · Instruction Decoder: It gets the instruction from the instruction register and decodes the instruction. It identifies the instruction to be performed.
·  · Serial I/O Control: It has two control signals named SID and SOD for serial data transmission.
Timing and Control unit:
  • It has three control signals ALE, RD (Active low) and WR (Active low) and three status signals IO/M(Active low), S0 and S1.
  • ALE is used for provide control signal to synchronize the components of microprocessor and timing for instruction to perform the operation.
  • RD (Active low) and WR (Active low) are used to indicate whether the operation is reading the data from memory or writing the data into memory respectively.
  • IO/M(Active low) is used to indicate whether the operation is belongs to the memory or peripherals.
  • If,
· 
Interrupt Control Unit:
It receives hardware interrupt signals and sends an acknowledgement for receiving the interrupt signal.

By : PVPSITIT 

Nov 28, 2011

Syllabus

The Syllabus for JNTUK R10 IT Department Has been Uploaded.
You can get the Download from either by clicking link below or by cvisiting downloads page by clicking below.
Donload file Downloads Page