Author: Not specified Language: c
Description: Timestamp: 2013-05-28 09:57:42 +0000
View raw paste Reply
  1.  
  2.  
  3.     #include <stdio.h>
  4.     #include <stdlib.h>
  5.     #include <string.h>
  6.     // ?????????
  7.     const int SIZE = 20;
  8.     const char *msgs[]={"0. End","1. Add Item", "2. Find Items", "3. Delete Items", "4. Show Table"};
  9.     const int Nmsgs = sizeof(msgs)/sizeof(msgs[0]);
  10.      
  11.     typedef struct Item
  12.     {
  13.         int key;
  14.         int release;
  15.         char *info;
  16.     }Item ;
  17.      
  18.     // ??????? ?????
  19.     char *getStr();
  20.     int getInt(int *N);
  21.     char* antispace(char *str);
  22.     //?????????? ???????
  23.     int dialog(const char *msgs[], int N);
  24.     int D_Add(Item *table, int *ntab),           // ??????? ???????? ? ???????
  25.         D_Find(Item *table, int *ntab),         // ????? ???????? ? ???????
  26.         D_Delete(Item *table, int *ntab),      // ???????? ???????? ?? ???????
  27.         D_Show(Item *table, int *ntab);       // ????? ??????????? ???????
  28.     int (*fptr[])(Item *table, int *ntab) = {NULL,D_Add,D_Find,D_Delete,D_Show};
  29.      
  30.     //????????? ???????
  31.     int insert(Item *table, int *n, int key, char *info);
  32.     int find(Item* table, int n, int key);
  33.      
  34.     int main()
  35.     {
  36.         int i, ntab;
  37.         Item *table=(Item*)malloc(SIZE*sizeof(Item));
  38.         ntab=0;
  39.         int rc;
  40.         while(rc = dialog(msgs, Nmsgs))
  41.         {
  42.      
  43.             fptr[rc](table, &ntab);
  44.           //  for (i=0;i<20;i++)
  45.           //      printf("number %d is %s\n",i,table[i].info);
  46.         }
  47.         return 0;
  48.      
  49.     }
  50.      
  51.     char* antispace(char* str)
  52.     {
  53.         for(;*str!='\0';str++)
  54.             if (*str != ' ' && *str != '\t')
  55.                 return str;
  56.         return NULL;
  57.     }
  58.      
  59.     char* getstr()
  60.     {
  61.      
  62.         char *ptr = (char *)malloc(1);
  63.         char buf[21];
  64.         int n, len = 0;
  65.         *ptr = '\0';
  66.         do
  67.         {
  68.             n = scanf("%20[^\n]", buf);
  69.             if(n < 0)
  70.             {
  71.      
  72.                 free(ptr);
  73.                 ptr = NULL;
  74.                 break;
  75.      
  76.             }
  77.             if(n == 0)
  78.                 scanf("%*c");
  79.      
  80.      
  81.             else
  82.             {
  83.                 len += strlen(buf);
  84.                 ptr = (char *) realloc(ptr, len + 1);
  85.                 strcat(ptr, buf);
  86.             }
  87.      
  88.         }
  89.      
  90.         while(n > 0);
  91.         return ptr;
  92.     }
  93.      
  94.     int getInt(int *N)
  95.     {
  96.         int n;
  97.         n=scanf("%d",N);
  98.      
  99.             if (n < 0)
  100.             {
  101.                 *N=0;
  102.                 return 0;
  103.             }
  104.      
  105.             if( (n == 0) || (scanf("%[a-z]") == 1) )
  106.             {
  107.                 *N=-1;
  108.                 fflush(stdin);
  109.                 return*N;
  110.             }
  111.             else
  112.             {
  113.                 fflush(stdin);
  114.                 return n;
  115.             }
  116.      
  117.      
  118.     }
  119.      
  120.      
  121.     int dialog(const char *msgs[], int N)
  122.     {
  123.         int rc=1, i;
  124.         do
  125.         {
  126.             if (rc < 0 || rc >= N)
  127.                 puts("Sorry, your request is wrong. Please, try again");
  128.             else
  129.                 puts("Please put the number of selected action:");
  130.             for (i=0;i<N;i++)
  131.                 puts(msgs[i]);
  132.      
  133.             getInt(&rc);
  134.         }
  135.         while (rc < 0 || rc >= N) ;
  136.         return rc;
  137.     }
  138.      
  139.      
  140.     int D_Add(Item *table, int *ntab)
  141.     {
  142.         int k,n=1;
  143.         char *info = NULL;
  144.         info=(char*)malloc(sizeof(char));
  145.      
  146.         do
  147.         {
  148.             if(n<0 || k<0)
  149.                 puts("Your key is wrong. Please try again:");
  150.             else
  151.                 puts("Enter key:");
  152.             n=getInt(&k);
  153.         }
  154.         while (n<0 || k<0);
  155.      
  156.         if(n == 0)
  157.             return 0;
  158.         do
  159.         {
  160.             if (info == NULL)
  161.                 puts("Info is empty. Please try again:");
  162.             else
  163.                 puts("Enter info:");
  164.      
  165.             info = getstr();
  166.             if (info != NULL)
  167.             info = antispace(info);
  168.                 else
  169.             return 0;
  170.         }
  171.         while (info == NULL);
  172.      
  173.      
  174.         insert(table,ntab,k,info);
  175.         return 1;
  176.     }
  177.      
  178.     int D_Find(Item *table, int *ntab)
  179.     {
  180.         int i,j,k,rel=0,n=1,nnew=0;
  181.         Item *newtable;
  182.      
  183.         do
  184.         {
  185.             if(n<0 || k<0)
  186.                 puts("Your key is wrong. Please try again:");
  187.             else
  188.                 puts("Enter key:");
  189.             n=getInt(&k);
  190.         }
  191.         while (n<0 || k<0);
  192.      
  193.         if(n == 0)
  194.             return 0;
  195.      
  196.         n=0;
  197.             do
  198.         {
  199.             if(n<0 || rel<0)
  200.                 puts("Your release is wrong. Please try again:");
  201.             else
  202.                 puts("Enter release[if necessary] or <0>");
  203.             n=getInt(&rel);
  204.         }
  205.         while (n<0 || rel<0);
  206.      
  207.         if(n == 0)
  208.             return 0;
  209.      
  210.         if (find(table,*ntab,k) >= 0)
  211.         {
  212.             j=i=find(table,*ntab,k);
  213.             if (rel<=0)
  214.             {
  215.                 for(;table[j].key == k;j++,nnew++);
  216.      
  217.                 newtable=(Item *)malloc(nnew*sizeof(Item));
  218.                 for(j=i;table[j].key == k;j++)
  219.                     newtable[j-i]=table[j];
  220.      
  221.             }
  222.      
  223.             else
  224.                 for(j=i;table[j].key == k;j++)
  225.                 {
  226.                     if(table[j].release == rel)
  227.                     {
  228.                         nnew++;
  229.                         newtable=(Item *)malloc(sizeof(Item));
  230.                         newtable[0]=table[j];
  231.                     }
  232.      
  233.                 }
  234.      
  235.         }
  236.         if(nnew>0)
  237.             D_Show(newtable,&nnew);
  238.         else
  239.             puts("Item not found");
  240.      
  241.         return 1;
  242.     }
  243.      
  244.     int D_Show (Item *table, int *ntab)
  245.     {
  246.         int i;
  247.         puts("///////////////////////////");
  248.         if (*ntab>0)
  249.             for(i=0;i<*ntab;i++)
  250.                 printf("Table[%d]: key - %d, release - %d, info - %s\n",i,table[i].key,table[i].release,table[i].info);
  251.         else
  252.             puts("Table is empty");
  253.         puts("///////////////////////////");
  254.         return 1;
  255.     }
  256.      
  257.     int D_Delete (Item *table, int *ntab)
  258.     {
  259.      
  260.         int i,j;
  261.         for(i=0;i<*ntab;i++)
  262.         {
  263.             if(table[i].release>table[i-1].release)
  264.             {
  265.                     for(j=i;j<*ntab;j++)
  266.                         table[j-1]=table[j];
  267.      
  268.                     *ntab=*ntab-1;
  269.                     i--;
  270.                     table[i].release=1;
  271.             }
  272.         }
  273.         puts("Table changed");
  274.         return 1;
  275.     }
  276.      
  277.     int find(Item* table, int ntab, int key)
  278.     {
  279.         int i;
  280.         for (i=0;i<ntab;i++)
  281.         {
  282.             if (table[i].key == key)
  283.                 return i;
  284.      
  285.      
  286.         }
  287.         return -1;
  288.     }
  289.      
  290.     int insert(Item *table, int *ntab, int key, char *info)
  291.     {
  292.         int i,j,rel;
  293.         rel=1;
  294.         if (*ntab == 0)
  295.             i=0;
  296.      
  297.        else
  298.        {
  299.            i=find(table,*ntab,key);
  300.         if (i >= 0)
  301.             {
  302.      
  303.      
  304.      
  305.                 while (table[i].key == key)
  306.                 {
  307.      
  308.                     i++;
  309.                     rel++;
  310.      
  311.                 }
  312.                 for(j=*ntab;j>i;j--)
  313.                     table[j]=table[j-1];
  314.      
  315.      
  316.      
  317.             }
  318.         else
  319.             {
  320.                 i=0;j=0;
  321.                 while (i<*ntab)
  322.                 {
  323.      
  324.                     if(table[i].info == NULL)
  325.                     {
  326.                         table[j]=table[i];
  327.                         j++;
  328.                     }
  329.                     i++;
  330.                 }
  331.                 j=i;
  332.             }
  333.        }
  334.      
  335.         table[i].key=key;
  336.         table[i].info=info;
  337.         table[i].release=rel;
  338.         *ntab=*ntab+1;
  339.      
  340.         return 1;
  341.     }
  342.  
  343.  
View raw paste Reply