×

Welcome to TagMyCode

Please login or create account to add a snippet.
0
0
 
0
Language: C
Posted by: Damian Pytkowski
Added: Jun 9, 2016 11:49 AM
Modified: Jun 16, 2016 11:40 AM
Views: 23
Tags: no tags
  1. #include <stdio.h>
  2.     #include <stdlib.h>
  3.     #include <time.h>
  4.     #include <windows.h>
  5.     #include <string.h>
  6.     #include <stdarg.h>
  7.     #define ROZ 12
  8.     typedef struct wezel{
  9.             int liczba;
  10.             struct wezel* prev;
  11.             struct wezel* next;
  12.             }wezel;
  13.     typedef struct lista{
  14.             struct wezel* glowa;
  15.             struct wezel* ogon;
  16.             }lista;
  17.     void setNull(lista* l);
  18.     wezel* createElement(int data);
  19.     void pushFront(lista *l, wezel* w);
  20.     void pushBack(lista *l, wezel* w);
  21.     void push(lista *l,wezel* w,int pozycja);
  22.     void popFront(lista *l);
  23.     void popBack(lista *l);
  24.     void pop(lista *l, int pozycja);
  25.     void clear(lista *l);
  26.     int size(lista *l);
  27.     int isEmpty(lista *l);
  28.     wezel* Begin(lista *l);
  29.     wezel* End(lista *l);
  30.     int front(lista *l);
  31.     int back(lista *l);
  32.     int at(lista *l,int pozycja);
  33.     void printf_backward(lista *l);
  34.     void printf_forward(lista *l);
  35.  
  36.     void main(int argc,char *argv[])
  37.     {
  38.         lista l;
  39.         wezel *e1,*e2,*e3,*e4;
  40.         menu(&l);
  41.  
  42.     }
  43.     void menu(lista *l){
  44.         printf("1)PushFront\n2)PushBack\n3)Push\n4)PopFront\n5)PopBack\n6)Pop\n7)Zwroc pierwszy\n8)Zwroc ostatni\n9) Wyczysc\n10)Zwroc dany element\n11)Zwroc rozmiar\n12)Czy pusta\n13) Zwroc wskaznik glowy\n14) Zwroc wskaznik ogona\n15)Drukuj od poczatku\n16)Drukuj od konca\nq konczy\n\nWybierz opcje: ");
  45.         int choose;
  46.         wezel*wsk;
  47.         int pozycja,wartosc;
  48.         setNull(&l);
  49.         while(scanf("%d",&choose)==1){
  50.         switch(choose){
  51.                 case 1:
  52.                         printf("Podaj wartosc: ");scanf("%d",&wartosc);
  53.                         wsk=createElement(wartosc);
  54.                         pushFront(&l,wsk);
  55.                         printf("Wartosc zostala dodana pomyslnie!");Sleep(2000);
  56.                         break;
  57.                 case 2: printf("Podaj wartosc: ");
  58.                                 scanf("%d",&wartosc);
  59.                         wsk=createElement(wartosc);
  60.                         pushBack(&l,wsk);
  61.                         printf("Wartosc zostala dodana pomyslnie!");Sleep(2000);
  62.                         break;
  63.                 case 3: printf("Podaj wartosc: ");
  64.                                 scanf("%d",&wartosc);
  65.                                 printf("Podaj pozycje do dodania: ");
  66.                                 scanf("%d",&pozycja);
  67.                         wsk=createElement(wartosc);
  68.                         push(&l,wsk,pozycja);
  69.                         printf("Wartosc zostala dodana pomyslnie na pozycji %d !",pozycja);Sleep(2000);
  70.                         break;
  71.                case 4:  popFront(&l);
  72.                         printf("Pierwsza wartosc zostala usunieta!");Sleep(2000);
  73.                         break;
  74.                case 5:  popBack(&l);
  75.                         printf("Ostatnia wartosc zostala usunieta!");Sleep(2000);
  76.                         break;
  77.                case 6:  printf("Podaj pozycje elementu do usuniecia: ");
  78.                                 scanf("%d",&pozycja);
  79.                                                 pop(&l,pozycja);
  80.                         printf("Element %d zostal usuniety pomyslnie!",pozycja);Sleep(2000);
  81.                         break;
  82.                case 7:  printf("Pierwszy element to: %d",front(&l));Sleep(2000);
  83.                         break;
  84.                 case 8:  printf("Ostatni element to: %d",back(&l));Sleep(2000);
  85.                         break;
  86.             case 9: clear(&l);printf("Wyczysczono wszystkie elementy.");Sleep(2000);break;
  87.             case 10: printf("Podaj indeks: ");fflush(stdin);
  88.                     scanf("%d",&pozycja);
  89.                     printf("Zwrocona wartosc: %d",at(&l,pozycja));
  90.                     Sleep(2000);
  91.                     break;
  92.             case 11: printf("Rozmiar to: %d",size(&l));Sleep(2000);
  93.                     break;
  94.             case 12: printf("1-tak 0-nie: %d",isEmpty(&l));Sleep(2000);break;
  95.             case 13: printf("Wskznik z glowy zwrocony");wsk=Begin(&l);Sleep(2000);break;
  96.             case 14: printf("Wskznik z ogona zwrocony");wsk=end(&l);Sleep(2000);break;
  97.             case 15: printf_forward(&l);getch();break;
  98.             case 16: printf_backward(&l);getch();break;
  99.             default: printf("Niepoprawna komenda.");
  100.  
  101.         }
  102.         system("cls");
  103.         printf("1)PushFront\n2)PushBack\n3)Push\n4)PopFront\n5)PopBack\n6)Pop\n7)Zwroc pierwszy\n8)Zwroc ostatni\n9) Wyczysc\n10)Zwroc dany element\n11)Zwroc rozmiar\n12)Czy pusta\n13) Zwroc wskaznik glowy\n14) Zwroc wskaznik ogona\n15)Drukuj od poczatku\n16)Drukuj od konca\nq konczy\n\nWybierz opcje: ");
  104.    }
  105.     }
  106.     void setNull(lista* l)
  107.     {
  108.             l->glowa=NULL;
  109.             l->ogon=NULL;
  110.     }
  111.     wezel* createElement(int data)
  112.     {
  113.         wezel* el = (wezel*)malloc(sizeof(wezel));
  114.         el->liczba = data;
  115.         el->next = NULL;
  116.         el->prev = NULL;
  117.         return el;
  118.     }
  119.     void pushFront(lista *l, wezel* w)
  120.     {
  121.             if(l->glowa==NULL&&l->ogon==NULL){
  122.                     w->next=NULL;
  123.                     w->prev=NULL;
  124.                     l->glowa=w;
  125.                     l->ogon=w;
  126.             }
  127.             else{
  128.                     w->next=l->glowa;
  129.                     w->prev=NULL;
  130.                     l->glowa->prev=w;
  131.                     l->glowa=w;
  132.                     }
  133.     }
  134.  
  135.     void pushBack(lista *l, wezel* w)
  136.     {
  137.             if(l->glowa==NULL&&l->ogon==NULL){
  138.                     w->next=NULL;
  139.                     w->prev=NULL;
  140.                     l->glowa=w;
  141.                     l->ogon=w;
  142.             }
  143.             else{
  144.                     w->next=NULL;
  145.                     w->prev=l->ogon;
  146.                     l->ogon->next=w;
  147.                     l->ogon=w;
  148.                     }
  149.     }
  150.     void push(lista *l,wezel* w,int pozycja)
  151.     {
  152.             int i;
  153.             wezel* wsk=l->glowa;
  154.             if(pozycja<=0){
  155.                      w->next=l->glowa;
  156.                 w->prev=NULL;
  157.                 l->glowa->prev=w;
  158.                 l->glowa=w;
  159.             }
  160.             else{
  161.                     for(i=0;i<pozycja-1;i++){
  162.                             wsk=wsk->next;
  163.                     }
  164.                     w->next=wsk->next;
  165.                     w->prev=wsk;
  166.                     wsk->next=w;
  167.                     wsk->next->prev=w;
  168.             }
  169.     }
  170.     void popFront(lista *l)
  171.     {
  172.             wezel* temp;
  173.             if((l->glowa==l->ogon)!=NULL){
  174.                     l->ogon=NULL;
  175.                     free(l->glowa);
  176.                     l->glowa=NULL;
  177.             }
  178.             else{
  179.                     temp=l->glowa->next;
  180.                     l->glowa->next->prev=NULL;
  181.                     free(l->glowa);
  182.                     l->glowa=temp;
  183.             }
  184.     }
  185.  
  186.     void popBack(lista *l)
  187.     {
  188.             wezel* temp;
  189.             if((l->glowa==l->ogon)!=NULL){
  190.                     l->ogon=NULL;
  191.                     free(l->glowa);
  192.                     l->glowa=NULL;
  193.             }
  194.             else{
  195.                     temp=l->ogon->prev;
  196.                     temp->next=NULL;
  197.                     free(l->ogon);
  198.                     l->ogon=temp;
  199.             }
  200.     }
  201.  
  202.     void pop(lista *l, int pozycja)
  203.     {
  204.             int i;
  205.             wezel* wsk=l->glowa,*temp;
  206.             if(pozycja<=0){
  207.                     temp=l->glowa->next;
  208.                     l->glowa->next->prev=NULL;
  209.                     free(l->glowa);
  210.                     l->glowa=temp;
  211.             }
  212.             else{
  213.                     for(i=0;i<pozycja;i++){
  214.                             wsk=wsk->next;
  215.                     }
  216.                     wsk->prev->next=wsk->next;
  217.                     wsk->next->prev=wsk->prev;
  218.                     free(wsk);
  219.             }
  220.     }
  221.     void clear(lista *l)
  222.     {
  223.         wezel* wsk=l->glowa,*temp;
  224.         while(wsk)
  225.         {
  226.             temp=wsk;
  227.             wsk=wsk->next;
  228.             free(temp);
  229.         }
  230.  
  231.         l->glowa=NULL;
  232.     }
  233.     int size(lista *l){
  234.             int i=0;
  235.             wezel* wsk=l->glowa;
  236.             while(wsk){
  237.                     i++;
  238.                     wsk=wsk->next;
  239.             }return i;
  240.     }
  241.     int isEmpty(lista *l){
  242.             if((l->glowa==NULL&&l->ogon==NULL))return 1;
  243.             else return 0;
  244.     }
  245. wezel* End(lista *l)
  246.     {
  247.         return l->ogon;
  248.     }
  249. wezel* Begin(lista *l)
  250.     {
  251.         return l->glowa;
  252.     }
  253. int front(lista *l)
  254.     {
  255.         return l->glowa->liczba;
  256.     }
  257. int back(lista *l)
  258.     {
  259.         return l->ogon->liczba;
  260.     }
  261. int at(lista *l,int pozycja)
  262.     {
  263.         int i;
  264.         wezel *wsk=l->glowa;
  265.         for(i=0;i<pozycja;i++)
  266.         {
  267.             wsk=wsk->next;
  268.         }
  269.  
  270.         return wsk->liczba;
  271.     }
  272. void printf_forward(lista *l)
  273.     {
  274.             wezel* wsk=l->glowa;
  275.             while(wsk){
  276.                     printf("%d\t",wsk->liczba);
  277.                     wsk=wsk->next;
  278.             }
  279.     }
  280. void printf_backward(lista *l)
  281.     {
  282.             wezel* wsk=l->ogon;
  283.             while(wsk){
  284.                     printf("%d\t",wsk->liczba);
  285.                     wsk=wsk->prev;
  286.             }
  287.     }
  288.