Author: Not specified Language: c
Description: Not specified Timestamp: 2013-05-22 21:25:31 +0000
View raw paste Reply
  1. #pragma hdrstop
  2. #pragma argsused
  3.  
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <stdlib.h>
  7.  
  8. #define size 10
  9.  
  10. FILE *f_table;
  11.  
  12. typedef struct Item
  13. {
  14.         int release;
  15.         char *string;
  16.         struct Item *next;
  17. } Item;
  18.  
  19. typedef struct Node
  20. {
  21.         int key;
  22.         Item *info;
  23. } Node;
  24.  
  25. typedef struct File
  26. {
  27.    FILE *tab;
  28.    char *file_name;
  29. };
  30.  
  31. char *getStr()
  32. {
  33.         char buffer[21];
  34.         char *tmp=(char*)malloc(sizeof(char)*1);
  35.         int len=0, curlen, n;
  36.         *tmp='\0';
  37.         do
  38.         {
  39.                 n=scanf("%20[^\n]", buffer);
  40.                 if(n<0)
  41.                 {
  42.                         free(tmp);
  43.                         continue;
  44.                 }
  45.                 if(n>0)
  46.                 {
  47.                         curlen=strlen(buffer);
  48.                         len+=curlen;
  49.                         tmp=(char*)realloc(tmp, sizeof(char)*(len+1));
  50.                         strcat(tmp, buffer);
  51.                 }
  52.         }
  53.         while(n>0);
  54.         return tmp;
  55. }
  56.  
  57. int ReadFile(struct File *ptab, Node *top[])
  58. {
  59.         int key;
  60.         int len;
  61.         char *info;
  62.         puts("\nEnter Name Of File : ");
  63.         (ptab->file_name)=getStr();
  64.         if(ptab->tab=(fopen(ptab->file_name, "rb")))
  65.         {
  66.                 while(fread(&key, sizeof(int), 1, ptab->tab)!=-1 && !feof(ptab->tab))
  67.                 {
  68.                         if(fread(&len, sizeof(int), 1, ptab->tab)==-1)
  69.                         return 0;
  70.                         info=(char*)malloc(sizeof(char)*(len+1));
  71.                         if(fread(info, sizeof(char), len, ptab->tab)!=len)
  72.                         return 0;
  73.                         *(info+len)='\0';
  74.                         Add(ptab, key, info);
  75.                 }
  76.                 fclose(ptab->tab);
  77.         }
  78.         ptab->tab=fopen(ptab->file_name, "ab");
  79.         return 1;
  80. }
  81.  
  82. void AddFile(struct File *ptab, int k, char *info)
  83. {
  84.         int len=strlen(info);
  85.         fwrite(&k, sizeof(int), 1, ptab->tab);
  86.         fwrite(&len, sizeof(int), 1, ptab->tab);
  87.         fwrite(info, sizeof(char), len, ptab->tab);
  88. }
  89.  
  90. void SaveFile(Node *top[], struct File *ptab)
  91. {
  92.         int i;
  93.         struct Item *tmp;
  94.         tmp=(struct Item*)malloc(sizeof(struct Item));
  95.         fclose(ptab->tab);
  96.         ptab->tab=fopen(ptab->file_name, "wb+");
  97.         system("Cls");
  98.         for(i=0; i<size && top[i]; i++)
  99.         {
  100.                         tmp=top[i]->info;
  101.                         while(tmp)
  102.                         {
  103.                                 AddFile(&f_table, top[i]->key, tmp->string);
  104.                                 tmp=tmp->next;
  105.                         }
  106.         }
  107.         system("Pause");
  108. }
  109.  
  110. void Init(Node *top[]) {
  111.         int i;
  112.         for (i = 0; i < size; i++) {
  113.                 top[i] = NULL;
  114.         }
  115. }
  116.  
  117. void OutPut(Node *top[])
  118. {
  119.         int i;
  120.         Item *cur=malloc(sizeof(Item));
  121.         system("Cls");
  122.         for (i = 0; i<size && top[i]; i++)
  123.         {
  124.                 printf("Key-%i\n",top[i]->key);
  125.                 cur=top[i]->info;
  126.                 while(cur)
  127.                 {
  128.                         printf("\tRelease-%i Info-%s\n", cur->release,cur->string);
  129.                         cur=cur->next;
  130.                 }
  131.         }
  132.         system("Pause");
  133.  
  134. }
  135.  
  136. Node *AddElement(Node *top,int key,char* info)
  137. {
  138.         Item *temp;
  139.         if(!top)
  140.         {
  141.                 top=malloc(sizeof(Node));
  142.                 top->key=key;
  143.                 top->info=malloc(sizeof(Item));
  144.                 top->info->release=0;
  145.                 top->info->string=info;
  146.                 top->info->next=NULL;
  147.         }
  148.         else
  149.         {
  150.                 temp=malloc(sizeof(Item));
  151.                 temp->release=top->info->release+1;
  152.                 temp->string=info;
  153.                 temp->next=top->info;
  154.                 top->info=temp;
  155.         }
  156.         return top;
  157. }
  158. int Add(Node *top[], int key, char *info)
  159. {
  160.         int i;
  161.         for (i = 0; i<size && top[i] && top[i]->key!=key; i++);
  162.         if (i==size)
  163.                 return 1;
  164.         else
  165.         {
  166.                 top[i]=AddElement(top[i],key,info);
  167.                 return 0;
  168.         }
  169.  
  170. }
  171. void D_Add(Node *top[])
  172. {
  173.         int key,res;
  174.         char *info;
  175.         system("Cls");
  176.         printf("Enter key: ");
  177.         scanf("%i",&key);
  178.         scanf("%*c");
  179.         printf("Enter info: ");
  180.         info=getStr();
  181.         res=Add(top,key,info);
  182.         if(res)
  183.                 printf("Table is full\n");
  184.         else
  185.                 printf("Elment are inserted\n");
  186.         system("Pause");
  187. }
  188.  
  189.  
  190. void DeleteElement(Node *top[],int index)
  191. {
  192.         Item *temp;
  193.         int j;
  194.         while(top[index]->info)
  195.         {
  196.                 temp=top[index]->info;
  197.                 top[index]->info=top[index]->info->next;
  198.                 free(temp->string);
  199.                 free(temp);
  200.         }
  201.         top[index]=NULL;
  202.         for (j = index+1; j<size && top[j]; j++);
  203.         if(j!=index)
  204.         {
  205.            top[index]=malloc(sizeof(Node));
  206.            top[index]->info=malloc(sizeof(Node));
  207.            top[index]->key=top[j-1]->key;
  208.            top[index]->info=top[j-1]->info;
  209.            top[j-1]=NULL;
  210.         }
  211. }
  212. int DeleteRelease(Node *top[], int key,int release)
  213. {
  214.         int i;
  215.         Item *cur, *prev;
  216.         for (i = 0; i<size && top[i] && top[i]->key!=key; i++);
  217.         if(i==size || !top[i])
  218.                 return 1;
  219.         cur=top[i]->info;
  220.         while(cur && cur->release!=release)
  221.         {
  222.                 prev=cur;
  223.                 cur=cur->next;
  224.         }
  225.         if(cur)
  226.         {
  227.                 if(cur==top[i]->info)
  228.                         top[i]->info=top[i]->info->next;
  229.                 else
  230.                         prev->next=cur->next;
  231.                 free(cur->string);
  232.                 free(cur);
  233.                 if(!top[i]->info)
  234.                         DeleteElement(top,i);
  235.                 return 0;
  236.         }
  237.         return 1;
  238. }
  239. void DeleteByKeyAndRelease(Node *top[])
  240. {
  241.   int key,res;
  242.   int release;
  243.   system("Cls");
  244.   printf("Enter key: ");
  245.   scanf("%i", &key);
  246.   printf("Enter release: ");
  247.   scanf("%i", &release);
  248.   res=DeleteRelease(top,key,release);
  249.   if(res==1)
  250.         printf("Element was not found\n");
  251.   else
  252.         printf("Element is deleted\n");
  253.   system("Pause");
  254. }
  255. void DeleteByKey(Node *top[])
  256. {
  257.         int key,res,i;
  258.         system("Cls");
  259.         printf("Enter key: ");
  260.         scanf("%i",&key);
  261.         for (i = 0; i<size && top[i] && top[i]->key!=key; i++);
  262.         if (i==size || !top[i])
  263.                 printf("Element is not found\n");
  264.         else
  265.         {
  266.                 DeleteElement(top,i);
  267.                 printf("Element is deleted\n");
  268.         }
  269.         system("Pause");
  270. }
  271. void D_Delete(Node *top[])
  272. {
  273.         int key;
  274.         do
  275.         {
  276.                 system("Cls");
  277.                 printf("\nWhat Would You prefer");
  278.                 printf("1-Delete by key\n");
  279.                 printf("2-Delete by key and release\n");
  280.                 printf("0-Menu\n");
  281.                 scanf("%i",&key);
  282.                 if(key==1)
  283.                         DeleteByKey(top);
  284.                 else if(key==2)
  285.                         DeleteByKeyAndRelease(top);
  286.  
  287.         }while(key);
  288. }
  289.  
  290. void Search (Node *top[], Node *temp[],int key, int release)
  291. {
  292.    int i;
  293.    Node *cur=malloc(sizeof(Node));
  294.    cur->info=malloc(sizeof(Item));
  295.    for (i = 0; i<size && top[i] && top[i]->key!=key; i++);
  296.    if(i==size || !top[i])
  297.         return;
  298.    if(release <0)
  299.    {
  300.                 temp[0]=malloc(sizeof(Node));
  301.                 temp[0]=top[i];
  302.    }
  303.    else
  304.    {
  305.                 cur->info=top[i]->info;
  306.                 while(cur && cur->info->release>release)
  307.                         cur->info=cur->info->next;
  308.                 if(!cur || cur->info->release<release)
  309.                         return ;
  310.                 temp[0]=malloc(sizeof(Node));
  311.                 temp[0]->info=malloc(sizeof(Item));
  312.                 temp[0]->key=top[i]->key;
  313.                 temp[0]->info=cur->info;
  314.                 temp[0]->info->next=NULL;
  315.    }
  316. }
  317. void SearchByKey(Node *top[])
  318. {
  319.         int key;
  320.         Node *temp[size];
  321.         system("Cls");
  322.         printf("Enter key: ");
  323.         scanf("%i",&key);
  324.         Init(temp);
  325.         Search(top,temp,key,-1);
  326.         OutPut(temp);
  327. }
  328. void SearchByKeyAndRelease(Node *top[])
  329. {
  330.         int key,release;
  331.         Node *temp[size];
  332.         system("Cls");
  333.         printf("Enter key: ");
  334.         scanf("%i",&key);
  335.         printf("Enter release: ");
  336.         scanf("%i",&release);
  337.         Init(temp);
  338.         Search(top,temp,key,release);
  339.         OutPut(temp);
  340. }
  341. void D_Search(Node *top[])
  342. {
  343.         int key;
  344.         do
  345.         {
  346.                 system("Cls");
  347.                 printf("1-Search by key\n");
  348.                 printf("2-Search by key and release\n");
  349.                 printf("0-Menu\n");
  350.                 scanf("%i",&key);
  351.                 if(key==1)
  352.                         SearchByKey(top);
  353.                 else if(key==2)
  354.                         SearchByKeyAndRelease(top);
  355.         }while(key);
  356. }
  357.  
  358. void Menu() {
  359.         int key;
  360.         void(*function[])(Node**)={NULL, D_Add,D_Delete,D_Search,OutPut};
  361.         Node *top[size];
  362.         Init(top);
  363.         ReadFile(&f_table, top);
  364.         do {
  365.                 system("Cls");
  366.                 printf("1-Add\n2-Delete\n3-Search\n4-Output\n0-Exit\n");
  367.                 scanf("%i", &key);
  368.                 if (key<5 && key>0)
  369.                         function[key](top);
  370.         }
  371.         while (key);
  372.         SaveFile(top, &f_table);
  373. }
  374.  
  375. int main() {
  376.         Menu();
  377.         return 0;
  378. }
  379.  
View raw paste Reply