స్టాక్ యొక్క మధ్య మూలకాన్ని తొలగించండి


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది అమెజాన్
సూత్రం స్టాక్

సమస్యల నివేదిక

డేటా నిర్మాణం (స్టాక్) ఇవ్వబడింది. స్టాక్ యొక్క ప్రాథమిక విధులను ఉపయోగించి ఇచ్చిన స్టాక్ యొక్క మధ్య మూలకాన్ని తొలగించడానికి ఒక ప్రోగ్రామ్ రాయండి -

  • 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) సమయం పడుతుంది. అందువల్ల అల్గోరిథం యొక్క సమయ సంక్లిష్టత సరళంగా ఉంటుంది.

అంతరిక్ష సంక్లిష్టత

పై) ఎందుకంటే మేము తొలగించబడిన మూలకాలను నిల్వ చేయడానికి స్థలాన్ని ఉపయోగించే పునరావృత్తిని ఉపయోగిస్తున్నాము.