ಸ್ಟಾಕ್ನ ಮಧ್ಯದ ಅಂಶವನ್ನು ಅಳಿಸಿ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್
ಪುನರಾವರ್ತನೆ ಸ್ಟಾಕ್

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ

ಡೇಟಾ ರಚನೆ (ಸ್ಟಾಕ್) ನೀಡಲಾಗಿದೆ. ಸ್ಟಾಕ್ನ ಮೂಲ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿರ್ದಿಷ್ಟ ಸ್ಟಾಕ್ನ ಮಧ್ಯದ ಅಂಶವನ್ನು ಅಳಿಸಲು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯಿರಿ -

  • push () - ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸಲು.
  • ಪಾಪ್ () - ಸ್ಟ್ಯಾಕ್‌ನಿಂದ ಮೇಲಿನ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕಲು / ಅಳಿಸಲು.
  • ಖಾಲಿ () - ಸ್ಟಾಕ್‌ನ ಗಾತ್ರವು 0 ಕ್ಕಿಂತ ಹೆಚ್ಚಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂದು ಪರಿಶೀಲಿಸಲು.

ನವೀಕರಿಸಿದ ಸ್ಟ್ಯಾಕ್ ಅನ್ನು ಮುದ್ರಿಸಿ ಅಂದರೆ ಮಧ್ಯದಲ್ಲಿ ಅಂಶವನ್ನು ಅಳಿಸಿದ ನಂತರ ಸ್ಟಾಕ್. ಬೇರೆ ಯಾವುದೇ ಡೇಟಾ ರಚನೆಯ ಬಳಕೆಯನ್ನು ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ.

ಸ್ಟಾಕ್ನ ಮಧ್ಯದ ಅಂಶವನ್ನು ಅಳಿಸಿ

ಉದಾಹರಣೆ

1 2 3 4 5
1 2 4 5
10 20 30 40 50 60
10 20 40 50 60

ಕ್ರಮಾವಳಿ

  1. ಪ್ರಾರಂಭಿಸಿ a ಸ್ಟಾಕ್ ಡೇಟಾ ರಚನೆ ಮತ್ತು ಅದರಲ್ಲಿರುವ ಅಂಶಗಳನ್ನು ತಳ್ಳಿರಿ.
  2. ಕಾರ್ಯವನ್ನು ರಚಿಸಿ deleteMiddle ಅದು ಸ್ಟಾಕ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಅದರ ಗಾತ್ರ ಮತ್ತು ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕವನ್ನು ಅದರ ನಿಯತಾಂಕಗಳಂತೆ ಪ್ರತಿನಿಧಿಸುವ ವೇರಿಯೇಬಲ್. ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕ ವೇರಿಯೇಬಲ್ನ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು 0 ಎಂದು ಹೊಂದಿಸಿ.
  3. ಸ್ಟಾಕ್ ಖಾಲಿಯಾಗಿದೆಯೇ ಅಥವಾ ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕ ವೇರಿಯೇಬಲ್ ಸ್ಟ್ಯಾಕ್‌ನ ಗಾತ್ರಕ್ಕೆ ಸಮನಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ, ಹಿಂತಿರುಗಿ.
  4. ವೇರಿಯಬಲ್ ರಚಿಸಿ x ಮತ್ತು ಅದರಲ್ಲಿ ಸ್ಟ್ಯಾಕ್‌ನ ಮೇಲ್ಭಾಗವನ್ನು ಸಂಗ್ರಹಿಸಿ. ಸ್ಟಾಕ್ನ ಮೇಲ್ಭಾಗದಲ್ಲಿರುವ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕಿ / ಅಳಿಸಿ.
  5. ಕಾರ್ಯಚಟುವಟಿಕೆಗೆ ಪುನರಾವರ್ತಿತ ಕರೆಯನ್ನು ಸ್ಟಾಕ್, ಸ್ಟಾಕ್‌ನ ಗಾತ್ರ ಮತ್ತು ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕ ವೇರಿಯೇಬಲ್ + 1 ರ ನಿಯತಾಂಕಗಳಂತೆ ಮಾಡಿ.
  6. ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕ ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವು ಸ್ಟಾಕ್ ಗಾತ್ರದ ಅರ್ಧದಷ್ಟು ಸಮನಾಗಿಲ್ಲವೇ ಎಂದು ಪರಿಶೀಲಿಸಿ, ಅಂದರೆ ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕ ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವು ಸ್ಟಾಕ್ನ ಮಧ್ಯ ಸೂಚ್ಯಂಕಕ್ಕೆ ಸಮನಾಗಿರದಿದ್ದರೆ, ವೇರಿಯೇಬಲ್ x ಅನ್ನು ಸ್ಟಾಕ್ನಲ್ಲಿ ಹಿಂದಕ್ಕೆ ತಳ್ಳಿರಿ.
  7. ಅದರ ನಂತರ, ಸ್ಟ್ಯಾಕ್‌ನ ಗಾತ್ರ 0 ಕ್ಕೆ ಸಮನಾಗಿರದಿದ್ದಾಗ ಸಂಚರಿಸಿ. ವೇರಿಯೇಬಲ್ p ಅನ್ನು ರಚಿಸಿ ಮತ್ತು ಅದರಲ್ಲಿ ಸ್ಟ್ಯಾಕ್‌ನ ಮೇಲ್ಭಾಗವನ್ನು ಸಂಗ್ರಹಿಸಿ, ಸ್ಟಾಕ್‌ನ ಮೇಲ್ಭಾಗವನ್ನು ಪಾಪ್ ಮಾಡಿ ಮತ್ತು ಎಲ್ಲಾ ಪುನರಾವರ್ತನೆಗಳಿಗಾಗಿ ವೇರಿಯಬಲ್ p ಅನ್ನು ಮುದ್ರಿಸಿ.

ಇದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಏಕೆಂದರೆ ನಾವು ವೇರಿಯೇಬಲ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಿರುವ ಸ್ಟಾಕ್ನ ಮೇಲ್ಭಾಗವನ್ನು ಉಳಿಸಿಕೊಳ್ಳಲು ನಾವು ಪುನರಾವರ್ತನೆಯ ಸಹಾಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತಿದ್ದೇವೆ x ಸಂಗ್ರಹಿಸಲು. ನಾವು ಮೂಲ ಸ್ಟ್ಯಾಕ್‌ನಿಂದ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತಲೇ ಇರುತ್ತೇವೆ ಮತ್ತು ವೇರಿಯೇಬಲ್ ಒಳಗೆ ಸಂಗ್ರಹಿಸುತ್ತಲೇ ಇರುತ್ತೇವೆ ಇದು ತಾತ್ಕಾಲಿಕ ಸ್ಟ್ಯಾಕ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಪ್ರಸ್ತುತ = n / 2 ನ ಮೌಲ್ಯವನ್ನು ಹೊರತುಪಡಿಸಿ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ನಾವು ಮೂಲ ಸ್ಟ್ಯಾಕ್‌ಗೆ ಮರು ಸೇರಿಸುತ್ತೇವೆ.

ಕೋಡ್

ಸಿ ++ ಪ್ರೋಗ್ರಾಂ ಸ್ಟ್ಯಾಕ್‌ನ ಮಧ್ಯದ ಅಂಶವನ್ನು ಅಳಿಸಲು

#include<iostream>
#include<stack> 
using namespace std; 

void deleteMiddle(stack<char> &s, int n, int current=0){ 
    if(s.empty() || current == n){ 
        return; 
    }
    int x = s.top(); 
    s.pop();
    
    deleteMiddle(s, n, current+1); 
    
    if(current != n/2){ 
        s.push(x); 
    }
}

int main(){ 
    stack<char> st; 
    
    st.push('5'); 
    st.push('4'); 
    st.push('3'); 
    st.push('2'); 
    st.push('1'); 
    
    deleteMiddle(st, st.size()); 
    
    while(!st.empty()){ 
        char p=st.top(); 
        st.pop(); 
        cout << p << " "; 
    } 
    
    return 0; 
}
1 2 4 5

ಸ್ಟಾಕ್ನ ಮಧ್ಯದ ಅಂಶವನ್ನು ಅಳಿಸಲು ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

import java.io.*; 
import java.util.*; 
  
class delMiddle{ 
  
    static void deleteMiddle(Stack<Character> st, int n, int curr){ 
          
        if(st.empty() || curr == n){ 
            return; 
        }
          
        char x = st.pop(); 
          
        deleteMiddle(st, n, curr+1); 
          
        if(curr != n/2){ 
            st.push(x); 
        }
    } 
      
    public static void main(String args[]){
        
        Stack<Character> st = new Stack<Character>(); 
      
        st.push('5'); 
        st.push('4'); 
        st.push('3'); 
        st.push('2'); 
        st.push('1'); 
        
        deleteMiddle(st, st.size(), 0); 
      
        while(!st.empty()){ 
            char p=st.pop(); 
            System.out.print(p + " "); 
        } 
    } 
}
1 2 4 5

ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (ಎನ್) ಇಲ್ಲಿ n ಎಂಬುದು ಸ್ಟಾಕ್‌ನಲ್ಲಿರುವ ಅಂಶಗಳ ಸಂಖ್ಯೆ. ಏಕೆಂದರೆ ನಾವು ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಸ್ಟಾಕ್‌ನಿಂದ ತೆಗೆದುಹಾಕಿದ್ದೇವೆ ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ಮತ್ತೆ ಸ್ಟ್ಯಾಕ್‌ಗೆ ಸೇರಿಸಿದ್ದೇವೆ. ಸ್ಟ್ಯಾಕ್‌ನಿಂದ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸಲು ಮತ್ತು ತೆಗೆದುಹಾಕಲು O (1) ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಆದ್ದರಿಂದ ಅಲ್ಗಾರಿದಮ್ನ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು ರೇಖೀಯವಾಗಿರುತ್ತದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಒ (ಎನ್) ಏಕೆಂದರೆ ನಾವು ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ ಅದು ತೆಗೆದುಹಾಕಲಾದ ಅಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಜಾಗವನ್ನು ಬಳಸುತ್ತದೆ.