C++ deque::push_front方法代码示例

	void update() {
		const ofVec3f &p = joint->getPosition();
        
        if (points.size() == 0 || p.distance(points.front()) > 1) {
            points.push_front(joint->getPosition());
        }

        if (points.size() > trackerLength){
			points.pop_back();
		}
	}

    void nextRound() {
        int winner = order_.back();
        pot_.remove();
        hands_[winner].add(pot_);
        pot_.clear();

        while (!passed_.empty()) {
            order_.push_front(passed_.back());
            passed_.pop_back();
        }
    }

 void update(ofVec3f _pos) {
     ofVec3f p = _pos;
     
     //if (p.distance(points.front()) > 1){
     points.push_front(p);
     //}
     
     if (points.size() > trackerLength){
         points.pop_back();
     }
 }

void TopSorter::recursiveTopSort(Vertex *v, deque<Vertex *> &s)
{
	v->setVisited(true);
	Vertices *adjacent = v->getAdjacent();
	for (Vertex *a : *adjacent) {
		if (!a->isVisited()) {
			recursiveTopSort(a, s);
		}
	}
	s.push_front(v);
}

	void update()
	{
		// 軌跡を追加
		if ((line_strip.front() - pos).lengthSquared() > 60)
		{
			line_strip.push_front(pos);
		}
		
		// 長くなりすぎた軌跡を削除
		if (line_strip.size() > 300) line_strip.pop_back();
	}

void enqueue(int u, int v, int previous_cost, int edge_cost, deque< pair<int, int> > &q) {
    printf("   trying to push (%d, %d) with cost %d (current cost is %d)\n", u + 1, v + 1, previous_cost + edge_cost, d[u][v]);
    if (d[u][v] == -1 or previous_cost + edge_cost < d[u][v]) {
        d[u][v] = previous_cost + edge_cost;
        assert(edge_cost == 0 or edge_cost == 1);
        if (edge_cost == 0) q.push_front(make_pair(u, v));
        else q.push_back(make_pair(u, v));
        
        printf("     pushed (%d, %d) with cost %d\n", u + 1, v + 1, d[u][v]);
    }
}

void Solver::minimizeAndStoreUIPClause(LiteralID uipLit,
		vector<LiteralID> & tmp_clause, bool seen[]) {
	static deque<LiteralID> clause;
	clause.clear();
	assertion_level_ = 0;
	for (auto lit : tmp_clause) {
		if (existsUnitClauseOf(lit.var()))
			continue;
		bool resolve_out = false;
		if (hasAntecedent(lit)) {
			resolve_out = true;
			if (getAntecedent(lit).isAClause()) {
				for (auto it = beginOf(getAntecedent(lit).asCl()) + 1;
						*it != SENTINEL_CL; it++)
					if (!seen[it->var()]) {
						resolve_out = false;
						break;
					}
			} else if (!seen[getAntecedent(lit).asLit().var()]) {
				resolve_out = false;
			}
		}

		if (!resolve_out) {
			// uipLit should be the sole literal of this Decision Level
			if (var(lit).decision_level >= assertion_level_) {
				assertion_level_ = var(lit).decision_level;
				clause.push_front(lit);
			} else
				clause.push_back(lit);
		}
	}

	if(uipLit.var())
	 assert(var(uipLit).decision_level == stack_.get_decision_level());

	//assert(uipLit.var() != 0);
	if (uipLit.var() != 0)
		clause.push_front(uipLit);
	uip_clauses_.push_back(vector<LiteralID>(clause.begin(), clause.end()));
}

 void noOperand(string& opCode)
 {
   double result;
        if(opCode == "pi") result = M_PI;
   else if(opCode == "e")  result = M_E;
   else {
     cout << "unknown operator " << opCode.c_str() << endl;
     return;
   }
   cout << result << endl;
   s.push_front(result);
 }

void initStep(Xpp *xpp) {
    int N; Window* win; tie(win,N) = xpp->getWindows();
    for(int i=0; i<N; i++) {
        if(xpp->isAWindow(win[i])) {
            windows.push_front  (win[i]);
            xpp->resizeAndCenter(win[i], minW, minH);
            XImage* image       = xpp->getImage(windows.front());
            if(image)           draw->add(windows.front(), image->data, (xpp->width-minW)/2, (xpp->height-minH)/2, image->width, image->height);
        }
    }
    XFree(win);
}

int choose(deque<int> de)
{
	void display(deque<int>, int);
	int temp;   
	char c; 
	int cal_num = 0;    // To calculate the size of the front stack. 
	
	cout<<"Option: 1-push from the front, 2-push from the back,\n"
	 	<<"        3-pop from the front, 4-pop from the back,\n"
	  	<<"        5-display the doublestack, #-quit.\n";  
	while(1){   
		cout<<"Input the option£º";   
		cin>>c;   
		switch(c)
		{    
			// push from the front
			case'1':cout<<"Input the element£º";     
					cin>>temp;    
					de.push_front(temp);
					cal_num++;
					break;
			// push from the back
			case'2':cout<<"Input the element£º";    
					cin>>temp;    
					de.push_back(temp);
					break;
			// pop from the front
			case'3':if (cal_num > 0){
						cal_num--; 
						de.pop_front();
						cout<<"popped from the front!\n";
					}
					// if there is no data, don't change cal_num and de.
					else	
						cout<<"Front Stack empty!\n";  	
					break;
			// pop from the back
			case'4':if (de.size()-cal_num > 0){
						de.pop_back();
						cout<<"popped from the back!\n";
					}
					// if there is no data, don't change de.
				 	else
				 		cout<<"Back Stack empty!\n";
					break;
			// display all the elements in the doublestack
			case'5':display(de, cal_num);
					break;
			case'#':return 0;
			default:cout<<"Error input! Please try again."<<endl;
		}    
	}  	
}

int main(){

    while (~scanf("%d", &n)) {
        idx = 0;
        vt.clear();
        for (int i = 0; i < n; ++i) {
            scanf("%d", &cmd[i]); 
            if (!cmd[i]) {
                ++idx;
            } else { 
                vt.push_back((Node){cmd[i], i, idx}); 
            }
        }

    
        sort(vt.begin(), vt.end());
        memset(vis, 0, sizeof(vis));
        memset(cnt, 0, sizeof(cnt));

        init();
        for (int i = 0; i < vt.size(); ++i) {
            for (int j = vt[i].belong; j < idx; j = find(j+1)) {
                if (cnt[vt[i].belong] < 3) {
                    vis[vt[i].id] = true;
                    ++cnt[vt[i].belong];
                    break;
                } else {
                    f[j] = j + 1; 
                }
            }
        }

        while (!st.empty()) st.pop();
        while (!que.empty()) que.pop();
        while (!que.empty()) dq.pop_front();

        addNum = 0, outNum = 0;
        for (int i = 0; i < n; ++i) {
            if (cmd[i]) {
                if (vis[i]) {
                    add(cmd[i]); 
                } else {
                    dq.push_front(i);
                    puts("pushBack");
                }
            } else {
                output();
            }
        }
    }
    return 0;
}

void producer(int id) {
    unique_lock<mutex> locker(mu, defer_lock); 
    for(int i = 0; i < LIMIT + 1; ++i) {
        locker.lock();
        cout << "producer: " << id << endl;
        d.push_front(i);
        if(i == LIMIT)
            ++_is_done;
        locker.unlock();
        std::this_thread::sleep_for(std::chrono::milliseconds(5));    
        cond.notify_all();
    }
}

// Shrinks one side of a blossom.
void shrink_one_side(int x, int y, int b){
  blossoms++;
  for (int i=f(x); i!=b; i=f(p[i])) {
    u(i, b);
    if (d[i]==1) { 
      c1[i]=x;
      c2[i]=y;
      // All nodes in blossom are reachable an even 
      // distance from the root, so push onto queue.
      q.push_front(i); // *qb++=i;  
    }
  }
}

int main(){
    int T;
    freopen("cubes.in","r",stdin);
    cin>>T;
    for(int cas=1;cas<=T;cas++){
        int n;
        cin>>n;
        for(int i=0;i<n;i++) cin>>a[i];
        sort(a,a+n);
        q.clear();
        q.push_front(a[0]);
        if(n&1){
            for(int i=1;i<n;i++){
                if(i&1) q.push_front(a[i]);
                else q.push_back(a[i]);
            }
        }
        else{
            for(int i=1;i<n;i++){
                if(i&1) q.push_back(a[i]);
                else q.push_front(a[i]);
            }
        }
        deque<int>::iterator it=q.begin();
        v.clear();
        while(it!=q.end()){
            v.push_back(*it);
            it++;
        }
        printf("Case %d:\n",cas);
        for(int i=0;i<v.size();i++){
            printf("%d",v[i]);
            if(i+1==v.size()) printf("\n");
            else printf(" ");
        }
    }
    return 0;
}

int main()
{
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%d",&element[i].value);
        element[i].position=i;
    }
    for(int i=0;i<n;i++)
    {
        while(!getMin.empty() && element[i].value<getMin.front().value)
        {
            getMin.pop_front();
        }
        getMin.push_front(element[i]);
        if(i-getMin.back().position>=k)
        {
            getMin.pop_back();
        }
        if(i>=k-1 && i<n-1) printf("%d ",getMin.back());
    }
    printf("%d\n",getMin.back());
    for(int i=0;i<n;i++)
    {
        while(!getMax.empty() && element[i].value>getMax.front().value)
        {
            getMax.pop_front();
        }
        getMax.push_front(element[i]);
        if(i-getMax.back().position>=k)
        {
            getMax.pop_back();
        }
        if(i>=k-1 && i<n-1) printf("%d ",getMax.back());
    }
    printf("%d\n",getMax.back());
    return 0;
}