int main(void)
{
    int n;

    printf("Enter the seize of stack: ");
    scanf("%d", &n);
    STACKinit(n);
    STACKpush(1);
    STACKpush(2);
    printf("%d, %d\n", STACKpop(), STACKpop());
    printf("Stack empty? %d\n", STACKempty());
    return 0;
}
Example #2
0
void CRUELfree() {
    int i;
    for( i = 0; i < 4; i++ )
        while( !STACKempty(suitStack[i]) )
            CARDremove( STACKpop( &(suitStack[i]) ) );
            
    for( i = 0; i < 12; i++ )
        while( !STACKempty(cardStack[i]) )
            CARDremove( STACKpop( &(cardStack[i]) ) );
            
    /* Como funciona:
        Para cada pilha, de naipe e de carta, desempilha 
          uma carta e a remove. */
}
int main(int argc, char *argv[]) {
	STACKinit(N);
	
	STACKpush(1);
	STACKpush(2);
	STACKpush(3);
	STACKpush(2);
	STACKpush(4);
	printf("Popped %i\n", STACKpop());
	printf("Popped %i\n", STACKpop());
	printf("Popped %i\n", STACKpop());
	printf("Popped %i\n", STACKpop());
	
	return 0;
}
int main(void) 
{
  int n=4;
  
  STACKinit(n);
  STACKpush(0);
  STACKpush(1);
  STACKpush(2);
  STACKpush(2); 
  STACKpush(2);
  printf("%d\n", STACKpop());
  printf("%d\n", STACKpop());
  printf("%d\n", STACKpop());
  return 0;
}
Example #5
0
void CRUELredistribute() {
    list ll = LISTinit(), q;
    int j = 0, i = 0;
    while( i < 12 ) {
        if( STACKempty( cardStack[i] ) )
            i++;
        else
            LISTaddEnd( ll, STACKpop( &cardStack[i] ) );
    }
    i = 0;
    while( !LISTempty( ll ) ) {
        if( j >= 4 ) {
            j = 0;
            i++;
        }
        q = LISTgetNterm( ll, 3 - j );
        if( q ) {
            STACKpush( &cardStack[i], LISTgetVal( q ) );
            LISTremove(q);
        }
        j++;
    }
    LISTdestroy(ll);
    movedSinceDist = 0;
    lastSugest = ACTIONcreate(-1,-1,-1);
}
Example #6
0
File: tour.c Project: ZoneMo/backup
void pathEshow(Graph g, int v, int w)
{
    STACKinit(g->e);
    printf("%d",w);
    while((path(g,v) == v) && !STACKempty()){
        v = STACKpop();
        printf("-%d",v);
    }
    printf("\n");
}
Example #7
0
int CRUELaction(action a) {
    card c;
    stack 
        *from = &(cardStack[a.from]), 
        *to   = ( a.suit == 0 ) ? &(suitStack[a.to]) : &(cardStack[a.to]);
    c = STACKpop( from );
    STACKpush(to, c);
    if( a.suit == 0 ) cardLeft--;
    movedSinceDist = 1;
    lastSugest = ACTIONcreate(-1,-1,-1);
    return 1;
}
Example #8
0
/* --- Function: void pop_node(Stack stk) --- */
void pop_node(Stack stk)
{
  int tmp, *pi, *ptmp;
  char mess[BUFSIZ], ans;

  /* Initialize 'tmp'... */
  tmp = 0;

  do
    {
      if (tmp == -1)
        break;

      my_clearscrn();
      printf("--- POP NODE FROM STACK ---\n");
      printf("\nCurrent stack status(%d nodes): ", STACKsize(stk));
      SLISTtraverse(stk, print, SLIST_FWD);

      ptmp = (int *)STACKpeek(stk);

      if (ptmp  == NULL)
        {
          prompt_and_pause("\n\nStack is EMPTY - nothing to do..!");
          tmp = -1;
        }
      else
        {
          sprintf(mess, "\nAbout to pop node %d.. - Continue? (y/n): ", *ptmp);
          ans = read_char(mess, 0, 0, my_chkch);

          if (ans == 'y' || ans == 'Y')
            {
              if ((STACKpop(stk, (void **)&pi)) != OK)
                {
                  printf("\nFatal error popping data - exiting...!");
                  STACKdestroy(stk);
                  exit(-1);
                }
              else
                {
                  sprintf(mess, "Node %d will be popped!", *pi);
                  prompt_and_pause(mess);
                  my_destroy(pi);
                }
            }
          else
            tmp = -1;
        }
    } while (TRUE);
}
Example #9
0
int main(int argc, char *argv[])
{
	char *a = argv[1];
	printf("a = %s\n", a);
	int i, N = strlen(a);
	STACKinit(N);
	for (i = 0; i < N; ++i) {
		if (a[i] == ')')
			printf("%c ", STACKpop());
		if ((a[i] == '+') || (a[i] == '*'))
			STACKpush(a[i]);
		if ((a[i] >= '0') || (a[i] <= '9'))
			printf("%c ", a[i]);
	}
	printf("\n");
	return 0;
}	
void traverseTree(tnode h, void (*visit)(tnode)) {
	STACKinit();
	STACKpush(h);
	
	while (STACKcount() > 0) {
		h = STACKpop();

		if (h->l != NULL)
			STACKpush(h->l);
		
		// In-order Traversal
		(*visit)(h);

		if (h->r != NULL)
			STACKpush(h->r);
	}
}
Example #11
0
File: 5.15.c Project: soakiz/pinhub
 void traverse(link h, void (*visit)(link))
 {
 	STACKinit(max);
 	STACKpush(h);

 	while (!STACKempty())
 	{
 		(*visit)(h = STACKpop());
 		if(h->r != NULL)
 		{
 			STACKpush(h->r);
 		}
 		if(h->l != NULL)
 		{
 			STACKpush(h->l);
 		}
 	}
 }
Example #12
0
int main(int argc, char *argv[])
{
    char *e = NULL;
    int i, j, len, temp;
    STACKinit(argc-1);

    for (j=1; j<argc; j++)
    {
        e = argv[j];
        len = strlen(e);
        for (i=0; i<len; i++)
        {
            if (e[i] =='+')
            {
                STACKpush(STACKpop() + STACKpop());
            }

            if (e[i] == '-')
            {
                STACKpush((-1) * (STACKpop() - STACKpop()));
            }

            if (e[i] == '*')
            {
                STACKpush(STACKpop() * STACKpop());
            }

            if (e[i]>='0' && e[i]<='9')
            {
                temp = 0;
                while (e[i]>='0' && e[i]<='9')
                {
                    temp = temp*10 + (e[i]- '0');
                    i++;
                }
                STACKpush(temp);
            }

        }
    }

    printf("%d\n", STACKpop());
    STACKfree();
    free(e);
    e = NULL;
    return 0;
}
void traverse(link h, void (*visit)(link))
{
  STACKinit(MAX);

  while (!STACKempty() || h != NULL)
    {
      if (h != NULL)
	{
	  STACKpush(h);
	  h = h->l;
	}
      else
	{
	  (*visit) (h = STACKpop());
	  h = h->r;
	}
    }
}  
void traverse(int k, void(*visit)(int)) {
	link t;

	STACKinit();
	STACKpush(k);
	
	while (STACKcount() > 0) {
		k = STACKpop();
		if (visited[k] == 0) {
			(*visit)(k);
			visited[k] = 1;
			for (t = adj[k]; t != NULL; t = t->next) {
				if (visited[t->v] == 0) {
					STACKpush(t->v);
				}
			}
		}
	}
}
Example #15
0
File: main.c Project: dearxxj/C
int main(void) 
{
	int i = 0, N = 0;
	Item tmp;
	char *a = (char *)malloc(Nmax * sizeof(char));

	printf("Enter a postfix expression: \n");
	while ((a[i++] = getchar()) != '\n');
	N = i - 1;
	STACKinit(N);
	for (i = 0; i < N; i++)
	{
		if (a[i] == '+') 
		{
			STACKpush(POLYadd(STACKpop(), STACKpop()));
			continue;// 1
		}
		if (a[i] == '*')
		{
			STACKpush(POLYadd(STACKpop(), STACKpop()));
			continue;// 2
		}
		/*if (a[i] == '-') 
		{
			tmp = STACKpop();
			STACKpush(STACKpop() - tmp);
			continue;// 1
		}
		if (a[i] == '/') 
		{
			tmp = STACKpop();
			STACKpush(STACKpop() / tmp);
			continue;// 1
		}*/
		if ((a[i] >= '0') && (a[i] <= '9'))// 以下三行 把相邻的数字字符组合成十进制整数 
			STACKpush(POLYterm(0, 0));
		while ((a[i] >= '0') && (a[i] <= '9'))
			STACKpush(POLYadd(POLYmult(STACKpop(), POLYterm(1, 1)), POLYterm((a[i++] - '0'), 0)));
		if (a[i] != ' ') i--; // 3
											//1, 2, 3 使得+*和数字之间没有空格也能运行正确 
		
	}
	printf("%d \n", STACKpop());
	return 0;
}
Example #16
0
int main(int argc, char *argv[]){
  char *a = argv[1]; int i, N = strlen(a);
  STACKinit(N);
  for (i = 0; i < N; i++){
    switch( a[i] ){
    case '+':
      STACKpush(STACKpop()+STACKpop()); break;
    case '*':
      STACKpush(STACKpop()*STACKpop()); break;
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
      STACKpush(0);
      while ( isdigit(a[i]) )
	STACKpush(10*STACKpop() + (a[i++]-'0')); break;
    }
  }
  printf("%d \n", STACKpop());
  return 0;
}
Example #17
0
int main(int argc, char *argv[])
{
  int next_option;
  const char *const short_options = "hvad:i:mn:w:o:";
  const struct option long_options[] = {
  		{ "help", 		0, NULL, 'h' },
  		{ "verbose",	0, NULL, 'v' },
		{ "all",		0, NULL, 'a' },
  		{ "display",	1, NULL, 'd' },
  		{ "id",			1, NULL, 'i' },
  		{ "mouse",		0, NULL, 'm' },
  		{ "name",		1, NULL, 'n' },
  		{ "wid",			1, NULL, 'w' },
  		{ "opacity",	1, NULL, 'o' },
  		{ NULL,			0, NULL, 0	 }
  };
  	int verbose = 0;
  	program_name = argv[0];

  	double vopacity;
  	unsigned int opacity;
  	char *display_name = NULL;
  	char *window_name = NULL;
  	pid_t pid = 0;
  	unsigned use_mouse = 1;
  	unsigned all = 0;
  	Window wid = 0;
  	unsigned char *data = NULL;
  	Atom actual;
  	int format;
  	unsigned long n, left;

  	do
	{
  		next_option = getopt_long(argc, argv, short_options, long_options, NULL);
  		switch (next_option)
  		{
  			case 'h':
  				print_usage(stdout, 0);
  			case 'v':
  				verbose = 1;
  				break;
  			case 'd':
  				display_name = optarg;
  				break;
  			case 'i':
  				pid = atoi(optarg);
  				use_mouse = 0;
  				break;
  			case 'm':
  				use_mouse = 1;
  				break;
  			case 'n':
  				window_name = optarg;
  				use_mouse = 0;
  				break;
  			case 'w':
  				wid = atoi(optarg);
  				use_mouse = 0;
  				break;
  			case 'o':
  				vopacity = atof(optarg);
  				opacity = 1;
  				break;
			case 'a':
				all = 1;
				pid = 0;
				wid = 0;
				window_name = NULL;
				break;
  			case '?':
  				print_usage(stderr, 1);
  			case -1:
  				break;
  			default:
  				abort();
  		}
  	}
  	while (next_option != -1);
  	if (verbose) SetDebug(1);

  	Display *dpy = Open_Display (display_name);
  	unsigned screen = DefaultScreen(dpy);

  	if (opacity)
  	{
  			opacity = (unsigned int) (vopacity * OPAQUE);
  	}
  	else
  	{
  			XGetWindowProperty(dpy, target_win, XInternAtom(dpy, OPACITY, False),
  						0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left, (unsigned char **) &data);
  			if (data != NULL)
  			{
  				memcpy (&opacity, data, sizeof (unsigned int));
  				XFree(( void *) data );
  				if (verbose) fprintf(stdout, "Found property: %g\n", (double) opacity / OPAQUE);
  			}
  			else opacity = OPAQUE;
  			if (opacity != OPAQUE) opacity = OPAQUE;
  			else opacity = 0xc0000000;
  	}
  	if (verbose) fprintf(stdout, "opacity 0x%x\n", opacity);
	if (!all)
	{
		if (use_mouse)
		{
			if(verbose) fprintf(stdout, "Using mouse for selection.\n");
			target_win = Select_Window_by_Mouse(dpy);
			if(verbose) fprintf(stdout, "Window id : %lu(0x%lx)\n", target_win, target_win);
		}
		else if (wid)
		{
			if(verbose) fprintf(stdout, "Using window id for selection.\n");
			target_win = wid;
		}
		else if (pid)
		{
			if(verbose) fprintf(stdout, "Using process id for selection.\n");
			target_win = Get_Window_by_PID(dpy, pid);
			if(target_win) target_win = Get_Top_Window(dpy, target_win);
			if(verbose) fprintf(stdout, "Window id : %lu(0x%lx)\n", target_win, target_win);
		}
		else if (window_name != NULL)
		{
			if(verbose) fprintf(stdout, "Using window name for selection.\n");
			target_win = Get_Window_by_Name(dpy, DefaultRootWindow(dpy), window_name);
			if(target_win) target_win = Get_Top_Window(dpy, target_win);
			if(verbose) fprintf(stdout, "Window id : %lu(0x%lx)\n", target_win, target_win);
		}
		if ((opacity == OPAQUE)&&(target_win != 0))
			XDeleteProperty (dpy, target_win, XInternAtom(dpy, OPACITY, False));
		else
			if (target_win != 0) XChangeProperty(dpy, target_win, XInternAtom(dpy, OPACITY, False),
				XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &opacity, 1L);
    	}
	if (all)
	{
	  Get_All_Windows(dpy);
	  while(!STACKempty())
	  {
		 if (opacity == OPAQUE)
			 XDeleteProperty (dpy, STACKpop(), XInternAtom(dpy, OPACITY, False));
		 else
			 XChangeProperty(dpy, STACKpop(), XInternAtom(dpy, OPACITY, False),
				 XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &opacity, 1L);
	  }
	}
	XSync(dpy, False);
	if(verbose) fprintf(stdout, "Set Property to %g\n", (double) opacity / OPAQUE);
	return EXIT_SUCCESS;
}
Example #18
0
int main (int argc, char * argv[]) {
    GRAPH graph;
    FILE * finput;
    symboltable table;
    EDGE tmpedge;
    ITEM * items;

    finput=fopen(argv[1], "r");
    int V;
    fscanf(finput, "%d", &V);

    graph=GRAPHinit(V);
    table=HASHinit(V);

    items=malloc(V*sizeof(ITEM));
    int i;
    for(i=0; i<V; i++) items[i]=NULL;

    i=0;
    char v1[10+1];
    char v2[10+1];
    while(fscanf(finput, "%s %s", v1, v2)==2) {
        if(HASHreturn(table, v1)==-1) {
            items[i]=ITEMinit(v1);
            HASHinsert(table, items[i], i);
            i++;
        }

        if(HASHreturn(table, v2)==-1) {
            items[i]=ITEMinit(v2);
            HASHinsert(table, items[i], i);
            i++;
        }
        tmpedge=EDGEadd(HASHreturn(table, v1), HASHreturn(table, v2));
        GRAPHinsertE(graph, tmpedge);
    }

    int * solution;
    int cmd, exit=0, path, v, w, j, k;
    while(!exit) {
        i=1;
        printf("\n");
        printf("%d Caclolare il camino semplice di lunghezza minima tra due vertici\n", i++);
        printf("%d Caclolare il camino semplice di lunghezza massima tra due vertici\n", i++);
        printf("%d Caclolare il numero di camini semplici tra due vertici\n", i++);
        printf("%d Calcolare le componenti fortemente connesse al grafo\n", i++);
        printf("%d Individuare un possibile sottoinsieme di archi per ottenere un grafo fortemente connesso\n", i++);
        printf("%d Esci\n--> ", i++);
        scanf("%d", &cmd);
        switch(cmd) {
        case 1:
            printf("Inserire il nome dei due nodi separati da spazio: ");
            scanf("%s %s", v1, v2);
            path=0;
            v=HASHreturn(table, v1);
            w=HASHreturn(table, v2);
            solution = optimalmin(graph, v, w, V);
            printf("Nodi attraversati:\n");
            ITEMshow(items[v], stdout);
            while(v!=w) {
                printf(" -> ");
                v=solution[v];
                ITEMshow(items[v], stdout);
                path++;
            }
            printf("\nLa lunghezza è %d\n", path);
            break;
        case 2:
            printf("Inserire il nome dei due nodi separati da spazio: ");
            scanf("%s %s", v1, v2);
            path=0;
            v=HASHreturn(table, v1);
            w=HASHreturn(table, v2);
            solution = optimalmax(graph, v, w, V);
            printf("Nodi attraversati:\n");
            ITEMshow(items[v], stdout);
            while(v!=w) {
                printf(" -> ");
                v=solution[v];
                ITEMshow(items[v], stdout);
                path++;
            }
            printf("\nLa lunghezza è %d\n", path);
            break;
        case 3:
            printf("Inserire il nome dei due nodi separati da spazio: ");
            scanf("%s %s", v1, v2);
            printf("Il numero dei cammini e' %d\n", npath(graph, HASHreturn(table, v1), HASHreturn(table, v2), V));
            break;
        case 4:
            k=0;
            for(i=0; i<V; i++)
                for(j=i+1; j<V; j++) {
                    if(GRAPHpath(graph, i, j) && GRAPHpath(graph, j, i)) {
                        k++;
                        ITEMshow(items[i], stdout);
                        printf(" e' fortemente connesso con ");
                        ITEMshow(items[j], stdout);
                        printf("\n");
                    }
                }
            printf("Ci sono %d componenti fortemente connesse\n", k);
            break;
        case 5:
            k=0;
            STACK additionaledges=STACKinit();
            for(i=0; i<V; i++) for(j=i+1; j<V; j++) {
                    int ab=GRAPHpath(graph, i, j);
                    int ba=GRAPHpath(graph, j, i);
                    if(!(ab && ba)) {
                        if(!ab) {
                            tmpedge = EDGEadd(i, j);
                            STACKpush(additionaledges, tmpedge);
                            GRAPHinsertE(graph, tmpedge);
                        }
                        if(!ba) {
                            tmpedge = EDGEadd(j, i);
                            STACKpush(additionaledges, tmpedge);
                            GRAPHinsertE(graph, tmpedge);
                        }
                    }
                }
            while(STACKcardinality(additionaledges)) {
                tmpedge=STACKpop(additionaledges);
                ITEMshow(items[tmpedge.v], stdout);
                printf(" -> ");
                ITEMshow(items[tmpedge.w], stdout);
                printf("\n");
            }
            break;
        case 6:
            exit=1;
        }
    }
    return 0;
}
Example #19
0
void STACKcpy(S b, S a){
	while(STACKsize(b)!=0) STACKpop(b);
	cpyR(b, a->top);
}
Example #20
0
int main(int argc, char ** argv) {
    item it;
    int i, s;
    short **tab;
    if( argc != 2 )
        return 2;
    N = atoi(argv[1]);
    resp = STACKinit(N);
    queen = malloc( N * sizeof(*queen) );
    if( !queen ) exit(1);
    
    curX = curY = 0;
    printf("Hello there, and welcome to another backtracking program! I hope you enjoy your stay!\n"
        "We'll be trying to fit %d queens in a %dx%d board.\n", N, N, N);
    
    while( STACKsize( resp ) < N ) {   
        s = STACKsize( resp );
        it = ITEMcreate(curX, curY);
        /*printf("Queens: %d | Pos = ", STACKsize( resp ) );
        ITEMprint(it);
        printf("| ");
        STACKdump( resp );*/
        
        for(i = 0; i < s && !QUEEN_CONFLICT( queen[i], it ); i++);
        if( i == s ) {
            /* achou mais uma rainha */
            queen[i] = it;
            STACKpush( resp, it );
            curX = curY = 0;
            s++;
            
        } else {
            /* posicao invalida */
            invalid:
            curX++;
            if( curX == N ) {
                curX = 0;
                curY++;
                if( curY == N ) {
                    /* F**K, BACKTRACK! */
                    if( STACKempty( resp ) ) {
                        break;
                        /* tabuleiro imposivel! */
                    } else if( s < N ){
                        it = STACKpop( resp );
                        s--;
                        curX = ITEMkey(it);
                        curY = ITEMval(it);
                        goto invalid;
                    }
                }
            }
        }
    }
    if( s < N ) {
        printf("We're deeply sorry, but it's impossible to fit %d queens in a %dx%d board.\n", N, N, N);
    } else {
        tab = malloc( N * sizeof( *tab ) );
        if( !tab ) exit(1);
        for( i = 0; i < N; i++ ) {
            tab[i] = malloc( N * sizeof( **tab ) );
            if( !tab[i] ) exit(1);
            for( s = 0; s < N; s++ ) tab[i][s] = 0;
        }
        while( !STACKempty( resp ) ) {
            it = STACKpop( resp );
            tab[ITEMkey(it)][ITEMval(it)] = 1;
        }
        printf("\n");
        for( s = 0; s < N; s++ ) {
            for( i = 0; i < N; i++ )
                printf("%c ", tab[i][s] + '0');
            printf("\n");
        }
    }
    
    return 0;
}