1 / 14

Understanding Random Access vs Sequential Access in Dynamic Data Storage

This module explores the differences between random access and sequential access in dynamic data storage, emphasizing the significance of data-driven programming. Topics include the static vs dynamic allocation of data structures, with practical examples such as handling registration lists for students. The course covers structures and enumerations for managing registration statuses and conflicts, highlighting the complexities of efficient data access and manipulation. We will analyze various solution implementations and assess their performance implications.

trygg
Download Presentation

Understanding Random Access vs Sequential Access in Dynamic Data Storage

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Today’s Agenda Lists Random Access vs. Sequential Access Sundar B. BITS, Pilani.

  2. Course Agenda Modules • Approach – Personal Programming Process  • Data-Driven Programming  • Dynamic Data Storage Sundar B. BITS, Pilani.

  3. Dynamic Data Storage • Lists – • Random Access vs. Sequential Access • Storage - • Static Allocation vs Dynamic Allocation • Applications – Access Restricted Lists: • Stacks and Queues • Files Sundar B. BITS, Pilani.

  4. Example Consider Registration Day: Registration is just over. Dean asks you to produce 3 lists: Students who were not allowed to register Students who registered successfully. Students who had (time table) conflicts Sundar B. BITS, Pilani.

  5. Example - Types Assume the following types: typedef struct { ID i; Year y; char name[NAME_LEN]; } Student; typedef enum { DENY=1; SUCC=2; CON=3; } RegStatus; typedef enum { LEC=1; COMPRE=2; DTC=3; } Conflict; typedef unsigned int Code; Sundar B. BITS, Pilani.

  6. union { Code courses[NUM_COURSES]; String regRest; Conflict con; } rd; Example - Types typedef struct { Student st; RegStatus rs; } RegInfo; typedef RegInfo RegList[MAX]; Sundar B. BITS, Pilani.

  7. unsigned int ks =0, kd=0; kc=0; unsigned int j; for (j = 0; j < size; j++) { } if (rl[j].rs == DEN) den[kd++] = rl[j]; else if (rl[j].rs == SUC) suc[ks++] = rl[j]; else conf[kc++] = rl[j]; Example - Implementation void regCats(RegList rl, unsigned int size, RegList suc, RegList den, RegList con) { } Sundar B. BITS, Pilani.

  8. Example – Issues? • What should the size of suc, den, and con be? • Each must be of size len : total 3 * len • But the total size cannot be more than len Sundar B. BITS, Pilani.

  9. Example – Second Solution • Use cursors: • Each element specifies position of next element in the list. • Declare new type: typedef struct { RegInfo ri; int next; } Element; Sundar B. BITS, Pilani.

  10. unsigned int ks =0, kd=1; kc=2, j; for (j = 0; j < size; j++) { } res[ks].next = res[kd].next = res[kc].next = -1; if (rl[j].rs == DEN) { res[kd].next = j+3; kd = j+3; res[kd].ri = rl[j]; } else if (rl[j].rs == SUC) { res[ks].next = j+3; ks = j+3; res[ks].ri = rl[j]; } else { res[kc].next = j+3; kc = j+3; res[kc].ri = rl[j]; } Example – Implementation 2 void regCats(RegList rl[], unsigned int size, Element res[]) { }

  11. Example – Analysis of Solution 2 • Array size passed: (len + 3)*sizeof(Element) which is same as (len+3) * (sizeof(RegInfo) + sizeof(int)) Compare this with (3*len) * (sizeof(RegInfo)) in the earlier implementation. Sundar B. BITS, Pilani.

  12. But “what is the solution?” • Elements of a list are not “randomly accessible” any more. • We have a created a “sequentially accessible” list • If you need element at position k then you need to step through elements in positions 0 to k-1 first. Sundar B. BITS, Pilani.

  13. ri next ri next ri next Structure of the (sequential access) list This is the logical structure. Physically each ri and next are just stored in adjacent positions in the array. Sundar B. BITS, Pilani.

  14. Is this a good representation? • (As usual) judge by the operations • Accessing the kth element – O(k) time (bad) • Inserting an element (ordered list): • Find the right element: create space for one element but no shifting required. • Still O(k) time (as opposed to O(n) time) - not much improvement. (Why not?) • Deleting an element: • Similar to insertion: no shifting! • What is the primary use? • Space Savings Sundar B. BITS, Pilani.

More Related