Please enable JavaScript.

Coggle requires JavaScript to display documents.

CHAPTER 3: STACKS, page 16, page 13, Dominic, Dominic (Page 21), Catherine…

- - - - ANOTHER DEFINATION
        
        A stack is a pointer to the “head” of the list where pushing and popping items happens, with perhaps a counter to keep track of the list’s size. The advantage of using a linked list over arrays is that it is possible to implement a stack that can grow or shrink as much as needed.
  - - - Declaring Stack
        typedef struct Tindan
        {
        int atas;
        int senarai [4];
        }Tindanan;
        Tindanan *t;
      - Creating Stack
        t-> atas= -1
      - Stacks in STL comes with template classes that are common in C++ data structures.
        eg;
        stack<int> st;
      - To create a stack, include <stack> header in our file code. Then, use to define std::stack:
        eg:
        include <iostream>
        
        include <stack>
        using namespace std;
  - - - Insert new item to an empty stack
        
        1.Create new node
        Sstack * pNew;
        pNew = new (nameofstack);
        
        2.Set new node created as first node in the stack
        pNew->next = head;
        
        3.Set head to new node created
        head = pNew;
  - - - EXAMPLE :
        
        Before : head > Data 1 > Data 4 > Data 8
        
        Pop ()
        
        After : head > Data 4 > Data 8
        
        Before : head > 45 > 60 > 32 >78 > 26 > 30
        
        Pop()
        
        head > 60 > 32 > 78 > 26 > 30
  - - - typedef struct Tindan
        {
        int data;
        Tindan *next;
        }Sstack;
        Sstack * head;
    - - head = NULL;
        
        When the head is NULL, the stack is empty
  - - - Stack is being created
      - Push(10)
      - Push(8)
      - Push(6)
      - Pop
  - - - head = NULL;
        When head is NULL; the stack is empty
  - - - add new item at top of the stack
    - - removes top item from stack
  - - - if(t->atas == -1) cout<<“Stack is Empty!” else
        return(0);
      - CHECK STACK FULL
        
        if(t->atas == 3)
        cout<<“Stack is Full!”
        else
        return(0);
- - - - Stack Underflow
        
        Underflow is a condition which occurs in a computer or similar device when a mathematical operation results in a number which is smaller than what the device is capable of storing. It is the opposite of overflow, which relates to a mathematical operation resulting in a number which is bigger than what the machine can store. Similar to overflow, underflow can cause significant errors.
        
        As stated in the comments: Stack underflow means having the stack pointer to point to an address below the beginning of the stack ("below" for architectures where the stack grows from low to high).
    - - The picture above is showing the pop operation.
    - - A stack is a list where all insertions and deletions occur at the same time. end, often known as the top
        
        Top
        
        The place for insertion and
        deletion data
        
        Bottom
        
        The first data will be place
        at the bottom of stack
    - - Underflow happen when we trying to delete data EMPTY STACK.
      - athirah (slide 13)
        
        EXAMPLE
    - - Step 1 − Checks if the stack is full.
      - Step 2 − If the stack is full, produces an error and exit.
      - Step 3 − If the stack is not full, increments top to point next empty space.
      - Step 4 − Adds data element to the stack location, where top is pointing.
      - Step 5 − Returns success.
      - If the linked list is used to implement the stack, then in step 3, we need to allocate space dynamically.
  - - - ANOTHER DEFINATION
        
        Stack is an abstract data type with a bounded (predefined) capacity. It is a simple data structure that allows adding and removing elements in a particular order.
        
        Every time an element is added, it goes on the top of the stack and the only element that can be removed is the element that is at the top of the stack, just like a pile of objects.
  - - - collection of data items in which only the most recently added item may be removed
      - . The latest added item is at the top
    - - Push - to insert data
      - Pop - to delete data
      - Top - allows adding and removing elements in a particular order
      - Underflow - we try to pop an item from the empty stack
      - Overflow - we try to push an item in the full stack
    - - LIFO - The last data into a stack is the first data
    - - Array
      - Linked List
  - - - PUSH ITEM INTO STACK
        cin>>data; t->atas++; t->senarai[t->atas] = data;
        POP ITEM FROM STACK
        t->atas--;
  - - - What is LIFO??
        
        LIFO or Last In, First Out.
        
        In this, the new element is inserted above the existing element, So that the newest element can be at the top and taken out first.
        
        LIFO CONCEPT
  - - - • The last element to be inserted into the
        stack will be the first to be removed.
        • Thus stacks are referred to as :
        Last In First Out (LIFO)