fork download 
  1. /* =========================================================================
  2.  * Από: migf1
  3.  * Πρόγραμμα παρουσίασης απλών λειτουργιών σε πίνακα, γραμμένο σε C.
  4.  * =========================================================================
  5.  */
  6.  
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include <stdlib.h>
  10.  
  11. #define MAX_ELEMENTS		10			// μέγιστο πλήθος στοιχείων
  12. #define EMPTY_ELEMVAL		(-1)			// τιμή κενών στοιχείων
  13.  
  14. #define MAX_INBUF		256			// μέγιστο μήκος γραμμής εισόδου
  15.  
  16. #define MAX_COMMANDS		11			// μέγιστο πληθος εντολών
  17. #define MAX_CMDLEN		(5+1)			// μέγιστο μήκος εντολής
  18. #define MAX_TOKENS		(MAX_ELEMENTS+1)	// μέγιστο πλήθος παραμέτρων σε
  19. 							// μια εντολή + την εντολή
  20.  
  21. #define SET_ISEMPTY(set)	( (set).len == 0 )	// έλέγχος για κενή λίστα
  22. 							// έλέγχος για γεμάτη λίστα
  23. #define SET_ISFULL(set)		( (set).len == (set).maxlen )
  24.  
  25. typedef enum { FALSE=0, TRUE } Bool;			// ο δικός μας τύπος boolean
  26.  
  27. typedef enum {						// κωδικοί εντολών
  28. 	CMD_INVALID = -1,
  29. 	CMD_INS_APPEND,
  30. 	CMD_INS_PREPEND,
  31. 	CMD_INS_ASCEND,
  32. 	CMD_INS_DESCEND,
  33. 	CMD_DELETE,
  34. 	CMD_SRT_ASCEND,
  35. 	CMD_SRT_DESCEND,
  36. 	CMD_RESET,
  37. 	CMD_PRINT,
  38. 	CMD_HELP,
  39. 	CMD_EXIT
  40. }CmdIndex;
  41.  
  42. typedef struct set {					// δομή για τη λίστα ακεραίων
  43. 	int maxlen;					// μέγιστο μήκος λίστας
  44. 	int len;					// τρέχον μήκος λίστας
  45. 	int elem[MAX_ELEMENTS];				// η λίστα (πίνακας)
  46. } Set;
  47.  
  48. // -------------------------------------------------------------------------------------
  49. // Διάσπαση του c-string s σε έως maxtokens τμήματα, κι αποθήκευσή τους στον πίνακα
  50. // tokens (η διάσπαση γίνεται σύμφωνα με οποιονδήποτε από του χαρακτήρες στο c-string
  51. // delimiters). Επιστρέφει το πλήθος των τμημάτων που προέκυψαν από την διάσπαση.
  52. // -------------------------------------------------------------------------------------
  53. int s_tokenize(char *s, char *tokens[], const int maxtokens, const char *delimiters)
  54. {
  55. 	register int i=0;
  56.  
  57. 	tokens[0] = strtok(s, delimiters);
  58. 	if (tokens[0] == NULL)
  59. 		return 0;
  60. 	for (i=1; i < maxtokens && (tokens[i]=strtok(NULL, delimiters)) != NULL; i++)
  61. 		; 
  62.  
  63. 	return i;
  64. }
  65. // -------------------------------------------------------------------------------------
  66. // Μετατροπή εντολής από c-string σε κωδικό εντολής (επιστρέφει τον κωδικό της εντολής)
  67. // ΣΗΜΑΝΤΙΚΟ:
  68. //	ο κωδικός εντολής ισοδυναμεί με τη θέση της στον πίνακα των εντολών (δείτε
  69. //	στην αρχή της main() )
  70. // -------------------------------------------------------------------------------------
  71. CmdIndex cmd_getindex( const char *cmd, const char *commands[], const int maxcommands )
  72. {
  73. 	register int i;
  74. 	for (i=0; i < maxcommands && strcmp(cmd, commands[i]); i++)
  75. 		;
  76. 	return i == maxcommands ? -1 : i;
  77. }
  78. // -------------------------------------------------------------------------------------
  79. // Διάβασμα γραμμής εισόδου, διάσπασή της σε εντολή με παραμέτρους κι αποθήκευσή τους
  80. // στον πίνακα tokens[] (επιστρέφει τον κωδικό της εντολής)
  81. // -------------------------------------------------------------------------------------
  82. int get_input( int *ntokens, char *tokens[], const int maxtokens, const char *commands[], const int maxcommands)
  83. {
  84. 	char inbuf[ MAX_INBUF ] = "";		// η γραμμή εισόδου
  85. 	CmdIndex cmdcode;			// κωδικός εντολής
  86.  
  87. 	do {
  88. 		cmdcode = CMD_INVALID;		// αρχικοποίηση
  89. 		printf("> ");			// εμφάνιση prompt
  90. 		fgets(inbuf, MAX_INBUF, stdin);	// διάβασμα γραμμής εισόδου
  91. 						// διάσπαση σε εντολή & παραμέτρους
  92. 		*ntokens = s_tokenize(inbuf, tokens, maxtokens, "\t \n");
  93. 		if ( *ntokens > 0 )		// μετατροπήυ σε κωδικό εντολής
  94. 			cmdcode = cmd_getindex(tokens[0], commands, maxcommands);
  95. 		if (cmdcode == CMD_INVALID)	// ανύπαρκτη εντολή
  96. 			puts("\tunrecognized command\n");
  97. 	} while( cmdcode == CMD_INVALID);	// απαίτηση υπαρκτής εντολής
  98.  
  99. 	return cmdcode;				// επιστροφή κωδικού εντολής
  100. }
  101. // -------------------------------------------------------------------------------------
  102. // Αρχικοποίηση της λίστας
  103. // -------------------------------------------------------------------------------------
  104. void set_init( Set *set )
  105. {
  106. 	register int i;
  107.  
  108. 	set->maxlen = MAX_ELEMENTS;
  109. 	for (i=0; i < set->maxlen; i++)
  110. 		set->elem[i] = EMPTY_ELEMVAL;
  111. 	set->len = 0;
  112.  
  113. 	return;
  114. }
  115. // -------------------------------------------------------------------------------------
  116. // Εμφάνιση όλων των στοιχείων της λίστας (επιστρέφει FALSE αν η λίστα είναι κενή,
  117. // αλλιώς επιστρέφει TRUE)
  118. // -------------------------------------------------------------------------------------
  119. Bool set_print( Set set )
  120. {
  121. 	register int i;
  122. 	for (i=0; i < set.len; i++)
  123. 		printf("%d ", set.elem[i] );
  124.  
  125. 	return i == 0 ? FALSE : TRUE;
  126. }
  127. // -------------------------------------------------------------------------------------
  128. // Επιστρέφει 0 αν τα n1 και n2 είναι ίσα, 1 αν το n1 > n2 ή -1 αν το n1 < n2
  129. // ( χρησιμοποιείται στη στάνταρ συνάρτηση qsort() παρακάτω )
  130. // -------------------------------------------------------------------------------------
  131. int set_elemcmp(const void *n1, const void *n2)
  132. {
  133.   const int *a = (const int *) n1;
  134.   const int *b = (const int *) n2;
  135.  
  136.   return (*a > *b) - (*a < *b);
  137. }
  138. // -------------------------------------------------------------------------------------
  139. // Εισαγωγή νέου στοιχείου με τιμή val στο τέλος της λίστας (επιστρέφει είτε τη
  140. // θέση στην οποία εισήχθη το νέο στοιχειο, είτε -1 σε περίπτωση που η λίστα ήταν
  141. // ήδη γεμάτη, είτε -2 αν η τιμή val ισούται με την τιμή μηδενισμού EMPTY_ELEMVAL)
  142. // -------------------------------------------------------------------------------------
  143. int set_append( Set *set, const int val )
  144. {
  145. 	if ( val == EMPTY_ELEMVAL )			// η μηδενική τιμή δεν εισάγεται
  146. 		return -2;				// επιστροφή αποτυχίας
  147.  
  148. 	if ( SET_ISFULL(*set) )				// σε γεμάτο πίνακα...
  149. 		return -1;				// επιστροφή αποτυχίας
  150.  
  151. 	set->elem[ set->len ] = val;
  152. 	return (set->len)++;				// επιστροφή θέσης εισαγωγής
  153. }
  154. // -------------------------------------------------------------------------------------
  155. // Εισαγωγή νέου στοιχείου με τιμή val στην αρχή της λίστας (επιστρέφει είτε 0 σε
  156. // περίπτωση που η λίστα ήταν ήδη γεμάτη, ειτε -1 αν η τιμή val ισούται με την τιμή
  157. // μηδενισμού EMPTY_ELEMVAL, είτε 1 αν όλα πήγαν καλά)
  158. // -------------------------------------------------------------------------------------
  159. int set_prepend( Set *set, const int val )
  160. {
  161. 	if ( val == EMPTY_ELEMVAL )			// η μηδενική τιμή δεν εισάγεται
  162. 		return -1;				// επιστροφή αποτυχίας
  163.  
  164. 	if ( SET_ISFULL(*set) )				// σε γεμάτη λίστα
  165. 		return 0;				// επιστροφή αποτυχίας
  166.  
  167. 	if ( SET_ISEMPTY(*set) ) {			// σε κενή λίστα
  168. 		set->elem[0] = val;			// εισαγωγή νέου στοιχείου
  169. 		(set->len)++;				// ενημέρωση τρέχοντος μήκους
  170. 		return 1;				// επιστροφή επιτυχίας
  171. 	}
  172.  
  173. 	// μετακίνηση των στοιχείων μια θέση προς τα δεξιά, ξεκινώντας από το 1ο
  174. 	memmove( &(set->elem[1]), &(set->elem[0]), (set->len) * sizeof(int) );
  175. 	set->elem[0] = val;				// εισαγωγή νέου στοιχείου
  176. 	(set->len)++;					// ενημέρωση τρέχοντος μήκους
  177.  
  178. 	return 1;					// επιστροφή επιτυχίας
  179. }
  180. // -------------------------------------------------------------------------------------
  181. // Εισαγωγή νέου στοιχείου με τιμή val απευθείας στη σωστή θέση, σε λίστα που είναι
  182. // ήδη ταξινομημένη με αύξουσα σειρά
  183. // -------------------------------------------------------------------------------------
  184. int set_insascend( Set *set, const int val )
  185. {
  186. 	if ( val == EMPTY_ELEMVAL )			// η μηδενική τιμή δεν εισάγεται
  187. 		return -2;				// επιστροφή αποτυχίας
  188.  
  189. 	if ( SET_ISFULL(*set) )				// σε γεμάτη λίστα
  190. 		return -1;				// επιστροφή αποτυχίας
  191.  
  192. 	if ( SET_ISEMPTY(*set) ) {			// σε κενή λίστα...
  193. 		set->elem[0] = val;			// εισαγωγή στην αρχή της
  194. 		set->len = 1;				// ενημέρωση τρέχοντος μήκους
  195. 		return 0;				// επιστροφή 1ης θέσης
  196. 	}
  197.  
  198. 	register int i;
  199. 	for (i=0; val > set->elem[i] && i < set->len; i++)
  200. 		;
  201. 	// μετακίνηση των στοιχείων μια θέση προς τα δεξιά, ξεκινώντας από το στοιχείο i
  202. 	memmove( &(set->elem[i+1]), &(set->elem[i]), (set->len-i) * sizeof(int) );
  203.  
  204. 	set->elem[i] = val;				// εισαγωγή νέου στοιχείου
  205. 	(set->len)++;					// ενημέρωση τρέχοντος μήκους
  206.  
  207. 	return i;					// επιστροφή θέσης εισαγωγής
  208. }
  209. // -------------------------------------------------------------------------------------
  210. // Εισαγωγή νέου στοιχείου με τιμή val απευθείας στη σωστή θέση, σε λίστα που είναι
  211. // ήδη ταξινομημένη με φθίνουσα σειρά
  212. // -------------------------------------------------------------------------------------
  213. int set_insdescend( Set *set, const int val )
  214. {
  215. 	if ( val == EMPTY_ELEMVAL )			// η μηδενική τιμή δεν εισάγεται
  216. 		return -2;				// επιστροφή αποτυχίας
  217.  
  218. 	if ( SET_ISFULL(*set) )				// σε γεμάτη λίστα
  219. 		return -1;				// επιστροφή αποτυχίας
  220.  
  221. 	if ( SET_ISEMPTY(*set) ) {			// σε κενή λίστα...
  222. 		set->elem[0] = val;			// εισαγωγή στην αρχή της
  223. 		set->len = 1;				// ενημέρωση τρέχοντος μήκους
  224. 		return 0;				// επιστροφή 1ης θέσης
  225. 	}
  226.  
  227. 	register int i;
  228. 	for (i=0; val < set->elem[i] && i < set->len; i++)
  229. 		;
  230. 	// μετακίνηση των στοιχείων μια θέση προς τα δεξιά, ξεκινώντας από το i στοιχείο
  231. 	memmove( &(set->elem[i+1]), &(set->elem[i]), (set->len-i) * sizeof(int) );
  232.  
  233. 	set->elem[i] = val;				// εισαγωγή νέου στοιχείου
  234. 	(set->len)++;					// ενημέρωση τρέχοντος μήκους
  235.  
  236. 	return i;					// επιστροφή θέσης εισαγωγής
  237. }
  238. // -------------------------------------------------------------------------------------
  239. // Αναζήτηση του στοιχείου με τιμή val στη λίστα (επιστρέφει τη θέση στην οποία
  240. // βρέθηκε το στοιχείο, αλλιώς επιστρέφει -1)
  241. // -------------------------------------------------------------------------------------
  242. int set_elemindex( const Set *set, const int val )
  243. {
  244. 	if ( SET_ISEMPTY(*set) || val == EMPTY_ELEMVAL )
  245. 		return -1;
  246.  
  247. 	register int i;
  248. 	for (i=0; set->elem[i] != val && i < set->len; i++)
  249. 		;
  250. 	return i == set->len ? -1 : i;	// τέλειωσαν τα στοιχεία ? -1 αλλιώς i		
  251. }
  252. // ------------------------------------------------------------------------------------
  253. // Διαγραφή του στοιχείου με τιμή val από τη λίστα (επιστρέφει FALSE αν το στοιχείο
  254. // δεν βρέθηκε στη λίστα, αλλιώς το διαγράφει κι επιστρέφει TRUE)
  255. // -------------------------------------------------------------------------------------
  256. Bool set_delete( Set *set, const int val )
  257. {
  258. 	register int i;
  259. 							// εύρεση στοιχείου με τιμή val
  260. 	int elem = set_elemindex( set, val);
  261. 	if ( elem == -1 )				// το στοιχείο δεν βρέθηκε...
  262. 		return FALSE;				// επιστροφή αποτυχίας
  263.  
  264. 	// μετακίνηση στοιχείων μια θέση προς τα αριστερά,
  265. 	// ξεκινώντας από τη θέση που βρέθηκε το στοιχείο
  266. 	for (i=elem; set->elem[i+1] != EMPTY_ELEMVAL && i < set->len-1; i++)
  267. 		set->elem[i] = set->elem[i+1];
  268.  
  269. 	set->elem[i] = EMPTY_ELEMVAL;	// μηδενισμός του τέως τελευταίου στοιχείου 
  270. 	(set->len)--;					// ενημέρωση τρέχοντος μήκους
  271.  
  272. 	return TRUE;					// επιστροφή επιτυχίας
  273. }
  274. // -------------------------------------------------------------------------------------
  275. // Ταξινόμηση σε φθίνουσα σειρά των στοιχείων του πίνακα elem, ξεκινώντας από το στοιχείο
  276. // lo έως το στοιχείο hi (η ταξινόμηση γίνεται με απλή υλοποίηση του αναδρομικού
  277. // αλγόριθμου quick-sort)
  278. // -------------------------------------------------------------------------------------
  279. void qsort_descend(int elem[], int lo, int hi )
  280. {
  281. 	int i=lo, j=hi, temp;
  282. 	int pivot = elem[ (lo+hi)/2 ];			// επιλογή του στοιχείου pivot
  283.  
  284. 	do {						// διάσπαση του πίνακα
  285. 		while (elem[i] > pivot)
  286. 			i++; 
  287. 		while (elem[j] < pivot)
  288. 			j--;
  289. 		if ( i <= j)
  290. 		{
  291. 			temp = elem[i];
  292. 			elem[i] = elem[j];
  293. 			elem[j] = temp;
  294. 			i++;
  295. 			j--;
  296. 		}
  297. 	} while (i <= j);
  298.  
  299. 	if (lo < j)					// αναδρομή
  300. 		qsort_descend(elem, lo, j);
  301. 	if (i < hi)
  302. 		qsort_descend(elem, i, hi);
  303.  
  304. 	return;
  305. }
  306. // -------------------------------------------------------------------------------------
  307. // Εμφάνιση του μενού των εντολών
  308. // -------------------------------------------------------------------------------------
  309. void do_help( const char *commands[] )
  310. {
  311. 	puts("\nA R R A Y S\n");
  312. 	printf("SAMPLE OPERATIONS ON A LIST OF %d ELEMENTS\n", MAX_ELEMENTS);
  313. 	puts("------------------------------------------");
  314. 	printf("%s n1 n2 ...\tappend (up to %d numbers)\n", commands[0], MAX_ELEMENTS);
  315. 	printf("%s n1 n2 ...\tprepend(up to %d numbers)\n", commands[1], MAX_ELEMENTS);
  316. 	printf("%s  n1 n2 ...\tinsert in ascending  order\n", commands[2]);
  317. 	printf("%s  n1 n2 ...\tinsert in descending order\n", commands[3]);
  318. 	printf("%s   n\t\tdelete n\n", commands[4]);
  319. 	printf("%s \t\tsort in ascending order\n", commands[5]);
  320. 	printf("%s \t\tsort in descending order\n", commands[6]);
  321. 	printf("%s \t\treset\n", commands[7]);
  322. 	printf("%s \t\tprint\n", commands[8]);
  323. 	printf("%s \t\thelp\n", commands[9]);
  324. 	printf("%s \t\texit\n", commands[10]);
  325. 	puts("------------------------------------------");
  326. 	puts("   ONLY POSITIVE INTEGERS ARE ALLOWED");
  327. 	puts("------------------------------------------");
  328.  
  329. 	return;
  330. }
  331. // -------------------------------------------------------------------------------------
  332. // Εκτέλεση της εντολής "app n1 n2 ..."  που εισαγάγει τα n1 n2 ... στο τέλος της λίστας
  333. // (επιστρέφει FALSE σε περίπτωση σφάλματος, αλλιώς επιστρέφει TRUE)
  334. // -------------------------------------------------------------------------------------
  335. Bool do_append( const int ntokens, char *tokens[], Set *set )
  336. {
  337. 	if ( ntokens < 2 ) {				// ελλιπείς παράμετροι
  338. 		puts("\tspecify what to append\n");	// ...
  339. 		return FALSE;				// επιστροφή αποτυχίας
  340. 	}
  341.  
  342. 	Bool warn1=FALSE, warn2=FALSE;
  343. 	register int i, temp, val;
  344.  
  345. 	for (i=1; i < ntokens; i++)			// για κάθε n1, n2, ...
  346. 	{						// ...
  347. 		val = atoi( tokens[i] );		// μετατροπή σε ακέραιο
  348. 		if ( val < 0 ) {			// αρνητική τιμή...
  349. 			warn2 = TRUE;			// ενεργοποίηση προειδοποίησης #2
  350. 			continue;
  351. 		}
  352.  
  353. 		temp = set_append( set, val );		// εισαγωγή νέου στοιχείου
  354.  
  355. 		if ( temp == -2 )			// ήταν τιμή μηδενισμού...
  356. 			warn1 = TRUE;			// ενεργοποίηση προειδοποίησης #1
  357. 		else if ( temp == -1 ) {		// η λίστα ήταν γεμάτη...
  358. 			printf("\t%d was not appended (array is full)\n", val);
  359. 			return FALSE;			// επιστροφή αποτυχίας
  360. 		}
  361. 	}
  362.  
  363. 	if ( warn1 )					// τύπωμα προειδοποίησης #1
  364. 		printf(	"\t(values equal to the zero-value: %d were ignored)\n",
  365. 			EMPTY_ELEMVAL);
  366. 	if ( warn2 )					// τύπωμα προειδοποίησης #2
  367. 		puts("\t(negative values were ignored)");
  368.  
  369. 	return TRUE;					// επιστροφή επιτυχίας
  370. }
  371.  
  372. // -------------------------------------------------------------------------------------
  373. // Εκτέλεση της εντολής "pre n1 n2 ..."  που εισαγάγει τα n1 n2 ... στην αρχή της λίστας
  374. // (επιστρέφει FALSE σε περίπτωση σφάλματος, αλλιώς επιστρέφει TRUE)
  375. // -------------------------------------------------------------------------------------
  376. Bool do_prepend( const int ntokens, char *tokens[], Set *set )
  377. {
  378. 	if ( ntokens < 2 ) {				// ελλιπείς παράμετροι
  379. 		puts("\tspecify what to prepend\n");	// ...
  380. 		return FALSE;				// επιστροφή αποτυχίας
  381. 	}
  382.  
  383. 	Bool warn1=FALSE, warn2=FALSE;
  384. 	register int i, temp, val;
  385.  
  386. 	for (i=1; i < ntokens; i++)			// για κάθε n1, n2, ...
  387. 	{						// ...
  388. 		val = atoi( tokens[i] );		// μετατροπή σε ακέραιο
  389. 		if ( val < 0 ) {			// αρνητική τιμή...
  390. 			warn2 = TRUE;			// ενεργοποίηση προειδοποίησης #2
  391. 			continue;
  392. 		}
  393.  
  394. 		temp = set_prepend( set, val );		// εισαγωγή νέου στοιχείου
  395.  
  396. 		if ( temp == -1 )			// ήταν τιμή μηδενισμού...
  397. 			warn1 = TRUE;			// ενεργοποίηση προειδοποίησης #1
  398. 		else if ( temp == 0 ) {			// η λίστα ήταν γεμάτη...
  399. 			printf("\t%d was not prepended (array is full)\n", val);
  400. 			return FALSE;			// επιστροφή αποτυχίας
  401. 		}
  402. 	}
  403.  
  404. 	if ( warn1 )					// τύπωμα προειδοποίησης #1
  405. 		printf(	"\t(values equal to the zero-value: %d were ignored)\n",
  406. 			EMPTY_ELEMVAL);
  407. 	if ( warn2 )					// τύπωμα προειδοποίησης #2
  408. 		puts("\t(negative values were ignored)");
  409.  
  410. 	return TRUE;					// επιστροφή επιτυχίας
  411. }
  412. // -------------------------------------------------------------------------------------
  413. // Εκτέλεση της εντολής "id n1 n2 ..."  που εισαγάγει τα n1 n2 ... στη λίστα,
  414. // ταξινομημένα σε αύξουσα σειρά (επιστρέφει FALSE σε περίπτωση σφάλματος,
  415. // αλλιώς επιστρέφει TRUE)
  416. // -------------------------------------------------------------------------------------
  417. Bool do_insascend( const int ntokens, char *tokens[], Set *set )
  418. {
  419. 	if ( ntokens < 2 ) {				// ελλιπείς παράμετροι
  420. 		puts("\tspecify what to insert\n");	// ...
  421. 		return FALSE;				// επιστροφή αποτυχίας
  422. 	}
  423.  
  424. 	Bool warn1=FALSE, warn2=FALSE;
  425. 	register int i, temp, val;
  426.  
  427. 	for (i=1; i < ntokens; i++)			// για κάθε n1, n2, ...
  428. 	{						// ...
  429. 		val = atoi( tokens[i] );		// μετατροπή σε ακέραιο
  430. 		if ( val < 0 ) {			// αρνητική τιμή...
  431. 			warn2 = TRUE;			// ενεργοποίηση προειδοποίησης #2
  432. 			continue;
  433. 		}
  434.  
  435. 		temp = set_insascend( set, val );	// εισαγωγή νέου στοιχείου
  436.  
  437. 		if ( temp == -2 )			// ήταν τιμή μηδενισμού...
  438. 			warn1 = TRUE;			// ενεργοποίηση προειδοποίησης #1
  439. 		else if ( temp == -1 ) {		// η λίστα ήταν γεμάτη...
  440. 			printf("\t%d was not inserted (array is full)\n", val);
  441. 			return FALSE;			// επιστροφή αποτυχίας
  442. 		}
  443. 	}
  444.  
  445. 	if ( warn1 )					// τύπωμα προειδοποίησης #1
  446. 		printf(	"\t(values equal to the zero-value: %d were ignored)\n",
  447. 			EMPTY_ELEMVAL);
  448. 	if ( warn2 )					// τύπωμα προειδοποίησης #2
  449. 		puts("\t(negative values were ignored)");
  450.  
  451. 	return TRUE;					// επιστροφή επιτυχίας
  452. }
  453. // -------------------------------------------------------------------------------------
  454. // Εκτέλεση της εντολής "id n1 n2 ..."  που εισαγάγει τα n1 n2 ... στη λίστα,
  455. // ταξινομημένα σε φθίνουσα σειρά (επιστρέφει FALSE σε περίπτωση σφάλματος,
  456. // αλλιώς επιστρέφει TRUE)
  457. // -------------------------------------------------------------------------------------
  458. Bool do_insdescend( const int ntokens, char *tokens[], Set *set )
  459. {
  460. 	if ( ntokens < 2 ) {				// ελλιπείς παράμετροι
  461. 		puts("\tspecify what to insert\n");	// ...
  462. 		return FALSE;				// επιστροφή αποτυχίας
  463. 	}
  464.  
  465. 	Bool warn1=FALSE, warn2=FALSE;
  466. 	register int i, temp, val;
  467.  
  468. 	for (i=1; i < ntokens; i++)			// για κάθε n1, n2, ...
  469. 	{						// ...
  470. 		val = atoi( tokens[i] );		// μετατροπή σε ακέραιο
  471. 		if ( val < 0 ) {			// αρνητική τιμή...
  472. 			warn2 = TRUE;			// ενεργοποίηση προειδοποίησης #2
  473. 			continue;
  474. 		}
  475.  
  476. 		temp = set_insdescend( set, val );	// εισαγωγή νέου στοιχείου
  477.  
  478. 		if ( temp == -2 )			// ήταν τιμή μηδενισμού...
  479. 			warn1 = TRUE;			// ενεργοποίηση προειδοποίησης #1
  480. 		else if ( temp == -1 ) {		// η λίστα ήταν γεμάτη...
  481. 			printf("\t%d was not inserted (array is full)\n", val);
  482. 			return FALSE;			// επιστροφή αποτυχίας
  483. 		}
  484. 	}
  485.  
  486. 	if ( warn1 )					// τύπωμα προειδοποίησης #1
  487. 		printf(	"\t(values equal to the zero-value: %d were ignored)\n",
  488. 			EMPTY_ELEMVAL);
  489. 	if ( warn2 )					// τύπωμα προειδοποίησης #2
  490. 		puts("\t(negative values were ignored)");
  491.  
  492. 	return TRUE;					// επιστροφή επιτυχίας
  493. }
  494. // -------------------------------------------------------------------------------------
  495. // Εκτέλεση της εντολής "d n1" που διαγράφει το n από τη λίστα (επιστρέφει FALSE σε
  496. // περίπτωση σφάλματος, αλλιώς επιστρέφει TRUE)
  497. // -------------------------------------------------------------------------------------
  498. Bool do_delete( const int ntokens, char *tokens[], Set *set )
  499. {
  500. 	if ( ntokens < 2 ) {				// ελλιπείς παράμετροι
  501. 		puts("\tspecify what to delete\n");	// ...
  502. 		return FALSE;				// επιστροφή αποτυχίας
  503. 	}
  504.  
  505. 	int val = atoi( tokens[1] );			// μετατροπή n σε ακέραιο
  506. 	if ( !set_delete( set, val ) )			// το στοιχείο δεν βρέθηκε
  507. 			printf("\t%d was not found\n", val);
  508. 	else						// επιτυχής διαγραφή στοιχείου
  509. 		printf("\t%d deleted successfully\n", val);
  510.  
  511. 	return TRUE;					// επιστροφή επιτυχίας
  512. }
  513. // -------------------------------------------------------------------------------------
  514. // Εκτέλεση της εντολής "p" που τυπώνει τα περιεχομενα της λίστας
  515. // -------------------------------------------------------------------------------------
  516. void do_print( Set set )
  517. {
  518. 	printf("\tlist (%d) : ", set.len);
  519. 	if ( !set_print( set ) )
  520. 		puts("empty\n");
  521. 	else
  522. 		puts("\n");
  523.  
  524. 	return;
  525. }
  526. // -------------------------------------------------------------------------------------
  527. // Εκτέλεση της επιλεγμένης από τον χρήστη εντολής
  528. // -------------------------------------------------------------------------------------
  529. void do_command( const CmdIndex cmdcode, const char *commands[], const int ntokens, char *tokens[], Set *set )
  530. {
  531. 	switch ( cmdcode )
  532. 	{
  533. 		case CMD_INS_APPEND:
  534. 			if ( do_append( ntokens, tokens, set ) )
  535. 				do_print( *set );
  536. 			break;
  537.  
  538. 		case CMD_INS_PREPEND:
  539. 			if ( do_prepend( ntokens, tokens, set ) )
  540. 				do_print( *set );
  541. 			break;
  542.  
  543. 		case CMD_INS_ASCEND:
  544. 			if ( do_insascend( ntokens, tokens, set ) )
  545. 				do_print( *set );
  546. 			break;
  547.  
  548. 		case CMD_INS_DESCEND:
  549. 			if ( do_insdescend( ntokens, tokens, set ) )
  550. 				do_print( *set );
  551. 			break;
  552.  
  553. 		case CMD_DELETE:
  554. 			if ( do_delete( ntokens, tokens, set ) )
  555. 				do_print( *set );
  556. 			break;
  557.  
  558. 		case CMD_SRT_ASCEND:
  559. 			qsort( set->elem, set->len, sizeof(int), set_elemcmp);
  560. 			do_print( *set );
  561. 			break;
  562.  
  563. 		case CMD_SRT_DESCEND:
  564. 			qsort_descend( set->elem, 0, set->len-1 );
  565. 			do_print( *set );
  566. 			break;
  567.  
  568. 		case CMD_RESET:
  569. 			set_init( set );
  570. 			puts("\tarray was reset successfully\n");
  571. 			break;
  572.  
  573. 		case CMD_PRINT:
  574. 			do_print( *set );
  575. 			break;
  576.  
  577. 		case CMD_HELP:
  578. 			do_help( commands );
  579. 			break;
  580. 		default:
  581. 			break;
  582. 	}
  583.  
  584. 	return;
  585. }
  586. // -------------------------------------------------------------------------------------
  587. int main( void )
  588. {
  589. 	const char *commands[MAX_COMMANDS ] = {		// πίνακας εντολών
  590. 		"app", "pre", "ia", "id", "d", "sa", "sd", "r", "p", "h", "x"
  591. 	};
  592. 	CmdIndex cmdcode;				// κωδικός επιλεγμένης εντολής
  593. 	char *tokens[ MAX_TOKENS ];			// παράμετροι εντολής + εντολή
  594. 	int ntokens;					// πλήθος εντολής + παραμέτρων
  595. 	Set set = { MAX_ELEMENTS, 0, {-1} };		// η λίστα μας
  596.  
  597. 	set_init( &set );				// ΣΗΜΑΝΤΙΚΗ αρχικοποίηση
  598. 	do_help( commands );				// εμφάνιση μενού εντολών
  599.  
  600. 	do {						// ανάγνωση εντολής
  601. 		cmdcode = get_input( &ntokens, tokens,MAX_TOKENS, commands,MAX_COMMANDS);
  602. 							// εκτέλεση εντολής
  603. 		do_command(cmdcode, commands, ntokens, tokens, &set);
  604. 	} while( cmdcode != CMD_EXIT );
  605.  
  606. 	exit( EXIT_SUCCESS );				// επιτυχής τερματισμός
  607. }
  608.  
  609.  
Not running #stdin #stdout 0s 0KB
comments (?)
stdin 
Standard input is empty
stdout 
Standard output is empty
https://ideone.com/VccYM
language:
C (gcc 8.3)
created:
14 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!