Data Structures and Algorithms

Transcription

1 Data Structures and Algorithms

2 Circular buffer Circular buffer or ring buffer is a data structure that uses a single, fixed-size buffer like it is connected end-to-end. They are usually used for communication between two sequential processes e.g.: producer - places the information into the circular buffer consumer - takes the information out. It does not shift its elements when one element is consumed, while non-circular buffer does. Overwriting of data in ring buffer is sometimes needed, e.g., producer (e.g., an audio generator) needs to overwrite old data if the consumer (e.g., the sound card) is unable to momentarily keep up.

3 How circular buffer is managed? In general, a circular buffer could be described with: buffer (for data) in memory (dynamically allocated or statically allocated array) start of valid data (pointer or index) end of valid data (pointer or index) The buffer is set empty at the beginning of the communication The producer inserts bytes into the buffer The consumer extracts bytes from the buffer Insertions and extractions can occur in any order.

4 1. Buffer is EMPTY Circular buffer example front rear 2. Insert 1 1 front rear 3. Insert 2, 3, 4 and front rear

5 Circular buffer example 4. Extract 1, 2 and front rear 5. Insert 6, 7 and rear front 6a. Insert 9 => Buffer FULL. Case when REAR + 1 = FRONT. One slot is NOT USED rear front

6 Circular buffer example 6b. Insert 9 and 10 => Is buffer FULL or EMPTY? Additional variable is needed to COUNT data. If COUNT is used then this can be considered as a FULL buffer front rear 6c. Insert 9 and 10 => OVERFLOW. REAR should not pass FRONT. Both should be increased This data is ignored rear front 6d. Insert 9, 10 and 11 => OVERFLOW (case when COUNT is used) front rear

7 Keep One Slot Open This solution always keeps one slot unused. A full buffer has at most (size 1) slots. the buffer is empty if both pointers are pointing at the same location. the buffer is full if the end (rear) pointer, plus one, equals the start (front) pointer. The advantages are: Very simple and robust. Only two pointers/indices are needed The disadvantages are: One slot is left unused

8 Using a Fill Count The fill count is implemented as an additional variable which keeps the number of readable items in the buffer. This variable has to be increased if the write (end) pointer is moved, and to be decreased if the read (start) pointer is moved. In the situation if both pointers pointing at the same location, you consider the fill count to distinguish if the buffer is empty or full. The advantages are: Simple. Needs only one additional variable. The disadvantage is: Third variable needs to be tracked

9 Double Buffering Multiple buffering is the use of more than one buffer to hold a block of data, so that a "reader" will see a complete (though perhaps old) version of the data, rather than a partially-updated version of the data being created by a "writer" In computer graphics term double buffering names a technique used for drawing graphics to avoid flickering, tearing and other artifacts. In a software implementation of double buffering, all drawing operations are done in some region of RAM which is often called a "back buffer". When all drawing is completed, the whole region (or only the changed portion) is copied into the video RAM (the "front buffer") Double buffering necessarily requires: more RAM needed (for back buffer ) the more CPU time for the copy operation time waiting for monitor s vertical blank interval

10 Page flipping Sometimes called ping-pong buffering In this method instead of copying the data, both buffers are capable of being displayed (both are in Video RAM). At any time, one buffer is actively being displayed by the monitor, while the other, background buffer is being drawn. When drawing is complete, the roles of the two are switched. The page-flip is typically accomplished by modifying the value of a pointer to the beginning of the display data in the video memory. The page-flip is much faster than copying the data and can guarantee that tearing will not be seen as long as the pages are switched over during the monitor's vertical blank period when no video data is being drawn. The currently active and visible buffer is called the front buffer, while the background page is called the back buffer.

11 Not only in computer graphics When not used in computer graphics, the idea about using multiple buffers is that data is inserted into one buffer while data is extracted from another. Multiple buffers are used when the read and write operations are performed asynchronously, usually by two different processors, e.g. communication processor and CPU. For example: a communications processor/engine (USB, UART, etc.) receives data to buffer A, while CPU process data from buffer B. After buffer A is full, it is told to switch to buffer B and to receive data in it. a communications processor/engine (USB, UART, etc.) receives data to buffer B, while CPU process data from buffer A.

12 Linked List A linked list is a data structure in which: Successive nodes (elements) are connected by pointers Last node points to NULL. It can grow or shrink in size during execution of a program. It can be made just as long as required, free memory is a limit It does not waste memory space. Head

13 Linked List It is abstract data type because: It has defined functions for doing operation on the list, e.g. insert node, delete node etc. Details of how the list is implemented or how the functions are implemented are hidden and not important as long as they do what is specified Common linked lists operations are: Creating a list Destroying a list Inserting node Deleting node Keeping track of a linked list: Must know the pointer to the first node of the list (called start, head, etc.)

14 Types of list Several different types of linked lists are possible: singly-linked list last node points to NULL Head

15 Types of list circular linked list - The pointer from the last node in the list points back to the first node Head

16 Types of list Doubly linked list Pointers exist between adjacent nodes in both directions. The list can be traversed either forward or backward Usually two pointers are maintained to keep track of the list, head and tail. Head Tail

17 Array vs. Linked list Arrays are suitable for: Inserting/deleting node at the end. Randomly accessing any node (by index) Linked lists are suitable for: Inserting/deleting node anywhere in the list Applications where sequential access is required. In situations where the number of nodes cannot be predicted beforehand.

18 Creating the list Structure that represent list node should be defined typedef struct _node { /* put data fields here */ struct _node *next; /* points to the next node */ }node; Structure needed for storing data necessary for list handling should be created too struct list { node *head; /* points to the first node in the list */ node *tail; /* points to the last node in the list */ int count; /* represent number of nodes in the list */ }; For N nodes nodes following should be done: Allocate n nodes, one by one. Initialize the fields of the nodes. Modify the links of the nodes so that the chain is formed. Set head to point to the first node

19 How to traverse through the list? In order to traverse the list do the following: Start from head or tail (if exists) Follow the links Process the data of the nodes as they are traversed Stop when the next pointer points to NULL, if list is not circular

20 Inserting node Node to insert Node to insert

21 Inserting node in the list Following situations are possible: Inserting node at the beginning Head is made to point to the new node. New node points to the previously first element. Inserting node at the end, Last node now points to the new node. New node points to NULL. Inserting in the middle Previous node now points to the new node. New node points to the next node. NOTE: either unique value (key) is given the node in order to identify before which node new node should be inserted, or requested position of the new node in the list is used.

22 Deleting node Node to delete

23 Deleting node from the list Following situations are possible: Deleting node at the beginning Head is made to point to the next node. Deleting node at the end Node before last (deleted) node now points to NULL. Deleting node in the middle Previous node now points to the next node. NOTE: either unique value (key) is given or position of the new node is used in order to identify which node should be deleted.

24 Queue The queue is an abstract data structure. A physical analogy for a queue is a line at a bank. When you go to the bank, customers go to the rear (end) of the line and customers come off of the line (i.e., are serviced) from the front of the line. Common queue operations are: Enter (Add) - Places an object at the rear (tail) of the queue. Delete (Remove) - Removes an object from the front (head) of the queue and produces that object. IsEmpty - Reports whether the queue is empty or not.

25 Queue Queues produce a certain order in which content of the queue is used. Let's check that order by looking at a queue of letters... Lets start with the queue that has 3 letters in it. a b c front rear Now, Enter(queue, 'd')... a b c d front rear

26 Now, ch = Delete(queue)... Queue b c d a ch front rear Queue enforces a FIFO order to the use of its contents, i.e., the First thing In is the First thing Out (FIFO) order.

27 Queue Array Implementation Array of a fixed size is used, in this example size of 4 is used Number of elements in the queue is necessary to keep track of the queue. We'll start with a queue with 3 elements entered (added): a b c count where 'a' is at the front and 'c' is at the rear.

28 Enter a new element with: Enter(queue, 'd')... Queue Array Implementation a b c d count Remove an element with: ch = Delete(queue)... b c d count a ch

29 Queue Array Implementation Now there is a problem because the front of the queue is no longer at array position 0. One solution would be to move all the elements down one, giving: b c d count That is BAD SOLUTION because it is too expensive to move everything down every time we remove an element. Question: Can we use an additional piece of information to keep track of the front? Answer: Yes! We can use the index of the element at the front, giving: b c d front 3 count

30 Queue Array Implementation Enter another element with: Enter(queue, 'e')? Question: Where will we put 'e' since moving everything down is too expensive? Answer: Array will be used in circular fashion, so when the end of the array is hit, it is wrapped around. Now, with this choice for entering 'e', the fields look like: e b c d front 4 count Delete element: ch = Delete(queue)? e c d 2 3 b front count ch

31 Queue - Linked-List Implementation Here is an example singly-linked list that holds characters. a b c Beginning of the linked list will be the front of the queue and the end of the linked list will be rear of the queue. Initilly, pointer that points to the first value will be renamed to front a b c front

32 Queue - Linked-List Implementation Question: Will this representation be sufficient for adding and removing things from the queue? Answer: Yes, however, we see one inefficiency in that, to add something to a queue, that thing must go on the rear and the only way to get to the end is to traverse to the end of the list. To be more efficient track of the rear of the queue should be kept with a direct link. Then queue will look as follows: a b c front rear If queue is empty, front and rear should link to nothing.

33 Stack The stack is an abstract data structure. One way to describe how a stack data structure behaves is to look at a physical analogy, a stack of books...imagine we have 4 of them on the stack. Pulling out the 3 rd book from the top cannot be done directly because the stack might fall over. Instead, 3 rd book can be reached by taking books from the top of the pile, one by one. Common stack operations are: Push: Places an object on the top of the stack. Pop: Removes an object from the top of the stack IsEmpty: Reports whether the stack is empty or not.

34 Stack Stack produce a certain order in which content of the stack is used. Let's check that order by looking at a queue of letters... Lets start with stack which is empty: Put letter A with Push(stack, A): a top

35 Stack Again, another push operation, Push(stack, B), giving: b a top Now let's remove an item, ch = Pop(stack): a top b ch One more addition, Push(stack, C): c a One more removal, ch = Pop(stack): a top top c ch Stack enforces LIFO order to the use of its contents, i.e., the Last thing In is the First thing Out (LIFO) order.

36 Stack Array Implementation Array of a fixed size is used, in this example size of 4 is used Initially array has a and b in it: a b Question: Is array sufficient, or will we need to store more information concerning the stack? Answer: We need to keep track of the top of the stack

37 Stack Array Implementation Now we have a b top Since b is at the top of the stack, the value top stores the index of b in the array (i.e., 1). Push something on the stack with Push(stack, c'): a b c top Both, the contents and top are changed.

38 Stack Array Implementation Sequence of pops produce the following effects: ch = Pop(stack) a b ch = Pop(stack) a ch = Pop(stack) So, when the stack is empty top is top 0 top -1 top c ch b ch a ch

39 Stack Array Implementation Question: What happens if we apply the following set of operations? Push(stack, 'd') Push(stack, 'e') Push(stack, 'f') Push(stack, 'g') d e f g top ch and then try to add H with Push(stack, h')? Answer: There is no more space on the stack to store h Disadvantage of using an static array to implement a stack is limited size of the stack. That can be avoided by using dynamically allocated arrays

40 Stack Linked List Implementation When using linked list to implement a stack essentially any number of elements could be handled Here is what a linked list implementing a stack with 3 elements might look like: a b c Question: Where the top of the stack should be, at the beginning or end of the list? Answer: Top should be at the beginning Question: How to represent an empty stack? Answer: Top is NULL

41 Event-driven Finite State Machine (FSM) FSM is a behavior model composed of: finite number of states definitions of transitions between those states actions taken in particular states on particular events FSM cycle is as following: begins from one of the states (called a start state) executes actions upon the occurred event goes through transitions in response to events and current states ends up in required states

42 FSM It is probably easiest to understand state machines by examining the graphical depiction, known as a Finite State Diagram (FSD) or State Transition Diagram (STD), of a simple example. The Digital Lock FSM from example can be in one of the following states: NoneRight OneRight TwoRight Open The arrows between the state bubbles represent the transitions, labeled with the event that triggers that transition. The bubbles represent the states. While in a state, the FSM is waiting for an event to cause it to transition

43 FSM Best approach is to use nested IF/CASE structures in which FSM states are represented as different clauses/cases. Within each of those state clauses there is nested IF/CASE structure that handle the events that could occur while in that state. This combination of nested IF/CASE structures are wrapped inside a function that maintains a static local variable to track the current state of the machine. See example fsm.c