Please enable JavaScript.

Coggle requires JavaScript to display documents.

Kump 5 Joh, Syukri C1 - Coggle Diagram

- - - - Primitive data structure are the fundamentals of Data Structure
      - Especially know as a basic Data Strutures
      - Primitive data structures are defined by the programming languages, or we can say that it is built-in.
        
        For Example:
        
        Integer: This is used to represent a number without decimal point.
        
        Float and Double: This is used to represent a number with decimal point.
        
        Character : This is used to represent single character
        
        String: This is used to represent group of characters
        
        Boolean: This is used represent logical values either true or false
    - - Non-primitive data structures are the data structures that are created using the primitive data structures.
      - Non-Primitive Data Structure Is a bit Complicated as it is derived from Primitive Data Structure
      - For Example:
        
        Arrays : a collection of elements (values or variables), each identified by at least one array index or key
        
        Structure : a specialized format for organizing and storing data
        
        Union : a value that may have any of several representations or formats
        
        Linked List : a linear collection of data elements, called nodes, each pointing to the next node by means of a pointer
        
        Stacks : an ordered list of similar data type
        
        Queues : an abstract data structure, somewhat similar to Stacks
  - - - A static data structure is an organization or collection of data in memory that is fixed in size. This results in the maximum size needing to be known in advance, as memory cannot be reallocated at a later point. Arrays are a prominent example of a static data structure.
    - - Dynamic data structures are those whose organizational characteristics may change during their lifetime. The adaptability afforded by such structures, e.g. linked lists, is often at the expense of decreased efficiency in accessing elements of the structure.
  - - - A linear data structure is a structure in which the elements are stored sequentially, and the elements are connected to the previous and the next element.
      - For Example
        
        Stacks
        
        Linked List
        
        Ques
      - The elements are stored sequentially, so they can be traversed or accessed in a single run. The implementation of linear data structures is easier as the elements are sequentially organized in memory
    - - A non-linear data structure is the another type of data structure in which the data elements are not arranged in a contiguous manner.
      - Since arrangement is not sequential, so the data elements cannot be traversed or accessed in a single run
      - Example
        
        Tree
        
        Graph
- - - - Arrays can be declared in various ways in different languages. For illustration, let's take C array declaration.
        
        As per the below illustration, following are the important points to be considered
        
        Index starts with 0.
        
        Array length is 8 which means it can store 8 elements.
        
        Each element can be accessed via its index. For example, we can fetch an element at index 6 as 9
    - - Traverse - print all the array elements one by one
        
        Insertion - adds on element at the given index
        
        Deletion - deletes an element at the given index
        
        Search - searches an element using the given index of by the value
        
        Update - updates an element of at the given index
    - - We must know in advance that how many elements are to be stored in array.
      - The elements of array are stored in consecutive memory locations. So insertions and deletions are very difficult and time consuming
      - Array is static structure. It means that array is of fixed size. The memory which is allocated to array can not be increased or reduced
      - Since array is of fixed size, if we allocate more memory than requirement then the memory space will be wasted. And if we allocate less memory than requirement, then it will create problem.