Програмирање 2/Блок 3

Извор: SI Wiki
Пређи на навигацију Пређи на претрагу

Kompleksni brojevi

Napisati program u programskom jeziku C za rad sa kompleksnim brojevima. Pretpostaviti da se kompleksni brojevi u memoriji računara čuvaju pomoću sledeće strukture: 

typedef struct complexNumber {

          double real, imaginary;

} ComplexNumber;

Ova deklaracija se nalazi u fajlu sa nazivom type.h. Prilikom realizacije programa neophodno je uključiti ovaj fajl svugde gde se koristi dati tip. Program realizovati prema sledećim stavkama:

  1. Napisati potprogram ComplexNumber sum ( ComplexNumber a, ComplexNumber b ); koji sabira dva kompleksna broja a i b i rezultat vraća kao povratnu vrednost funkcije.
  2. Napisati potprogram void conjugate ( ComplexNumber *a ); koji konjuguje kompleksni broj na koji pokazuje pokazivač a.
  3. Napisati potprogram void write ( ComplexNumber a ); koji ispisuje kompleksni broj a.
  4. Napisati potprogram int isNumber ( char *string ); koji proverava da li niz karaktera na koji pokazuje pokazivač string predstavlja validan realan broj.
  5. Korišćenjem prethodno realizovanih potprograma napisati glavni program koji dobija četiri argumenata preko komandne linije. Glavni program treba da proveri da li su prosledjeni argumenti validni realni brojevi i ukoliko jesu da od prva dva formira jedna kompleksan broj, a od druga dva drugi kompleksni broj. Nakon toga potrebno je naći i ispisati sumu dva kompleksna broja, kao i konjugiovane vrednosti originalnih kompleksnih brojeva. Ukoliko argumenti ne predstavljaju validne realne brojeve potrebno je prekinuti izvršavanje program sa povratnom vrednošću 0.

Prva funkcija

#include <stdio.h>
#include "types.h"

ComplexNumber sum ( ComplexNumber a, ComplexNumber b) {
    ComplexNumber c;
    c.real = a.real + b.real;
    c.imaginary = a.imaginary + b.imaginary;
    
    return c;
}

Druga funkcija

#include "types.h"

void conjugate ( ComplexNumber *a ) {
    a->imaginary *= -1;
}

Treća funkcija

#include <stdio.h>
#include "types.h"

void write ( ComplexNumber a ) {
    char op = a.imaginary >= 0 ? '+' : '-';
    a.imaginary *= (a.imaginary >= 0 ? 1 : -1);
    
    printf("%.4f %c %.4fi", a.real, op, a.imaginary);
}

Četvrta funkcija

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int isNumber ( char *string ) {
    if (string == NULL) {
    return 0;
    }
    int a;
    double b;
    return sscanf(string, "%*[+-]%lf%n", &b, &a) == 1 && a == strlen(string);
}

Peta funkcija

#include <stdio.h>
#include <stdlib.h>
#include "types.h"
#include <string.h>

int main(int argc, char** argv)
{
    for(int i = 1; i < 5; i++)
      if(!isNumber(argv[i]))
          return 0;

    ComplexNumber a, b, c;
    
    a.real = atof(argv[1]);
    a.imaginary = atof(argv[2]);
    
    b.real = atof(argv[3]);
    b.imaginary = atof(argv[4]);
    
    c.real = a.real + b.real;
    
    c.imaginary = a.imaginary + b.imaginary;
    
    write(c);
    putchar('\n');
    conjugate(&a);
    conjugate(&b);
    
    write(a);
    putchar('\n');
    write(b);
    return 0;
}

Liste

Sastaviti na jeziku C paket funkcija za rad sa jednostruko ulančanim listama brojeva. Elementi liste se čuvaju u memoriji računara korišćenjem sledeće strukture: 

typedef struct node {
       int number;
       struct node *next;
} Node;

Data deklaracija se nalazi u datoteci type.h koju je potrebnu uključiti svigde gde se koristi dati tip. Paket realizovati prema sledećim stavkama:

  • Realizovati funkciju Node* formList(); koja čita brojeve sa standardnog ulaza i on njih formira listu tako što nove elemente ubacuje na kraj liste. Čitanje se završava kada se preko standardnog ulaza pročita nešto što nije broj. Funkcija kao povratnu vrednost vraća pokazivač na početak novoformirane liste.
  • Realizovati funkciju void printList(Node *head); koja na standardni izlaz ispisuje sadržaj liste na čiji prvi element pokazuje pokazivač head.
  • Realizovati funkciju int listSize(Node *head); koja kao povratnu vrednost vraća broj elemenata liste na čiji prvi element pokazuje pokazivač head.
  • Realizovati funkciju Node* searchFirst(Node *head, int number); koja u listi na čiji prvi element pokazuje pokazivač head pronalazi prvo pojavljivanje broja number i kao povratnu vrednost vraća pokazivač na taj element.
  • Realizovati funkciju Node* searchLast(Node *head, int number); koja u listi na čiji prvi element pokazuje pokazivač head pronalazi poslednje pojavljivanje broja number i kao povratnu vrednost vraća pokazivač na taj element.
  • Realizovati funkciju void sortList(Node *head); koja sortira listu na čiji prvi element pokazuje pokazivač head po neopadajućem poretku.
  • Realizovati funkciju void deallocateList(Node *head); koja vrši dealokaciju memorije koju je zauzela lista na čiji prvi element pokazuje pokazivač head.
  • Realizovati funkciju Node* insertSorted(Node *head, int number); koja u neopadajuće sortiranu listu na čiji prvi element pokazuje pokazivač head ubacuje broj number, ali tako da lista nakon toga ostane sortirana. Funkcija kao povratnu vrednost vraća pokazivač na izmenjenu listu.
  • Realizovati funkciju Node* removeElements(Node *head, int number); koja iz liste na čiji prvi element pokazuje pokazivač head izbacuje svako pojavljivanje broja number. Funkcija kao povratnu vrednost vraća pokazivač na početak izmenjene liste.
  • Realizovati funkciju Node* mergeLists(Node *head0, Node *head1); koja spaja dve neopadajuće sortirane liste na čije prve elemente pokazuju pokazivači head0 i head1 u novu neopadajuće sortiranu listu. Funkcija kao povratnu vrednost vraća pokazivač na prvi element nove liste.
  • Korišćenjem funkcije void deallocateList(Node *head);, koja dealocira prostor koji je zauzela lista na čiji prvi element pokazuje pokazivač head, realizovati funkciju void removeDuplicates(Node *head); koja iz liste na čiji prvi element pokazuje pokazivač head izbacuje sve uzastopne pojave istih elemenata.
  • Realizovati funkciju Node* reverseList(Node *head); koja obrće listu na čiji prvi element pokazuje pokazivač head.
  • Realizovati funkciju Node* getMiddle(Node *head); koja vraća pokazivač na element koji se nalaze na sredini liste na čiji prvi element pokazuje pokazivač head.
  • Realizovati funkciju Node* getNthFromEnd(Node *head); koja vraća pokazivač na N-ti element od kraja liste na čiji prvi element pokazuje pokazivač head.

Prva funkcija

#include <stdio.h>
#include <stdlib.h>
#include "type.h"

Node* formList ( ) {
    int number;
    Node* head = NULL, *tail = head;
    while(scanf("%d", &number) == 1)
    {
        Node* tmp = malloc(sizeof(Node));
        tmp->number = number;
        if(!head)
            head = tmp;
        else
            tail->next = tmp;
        tail = tmp;
    }
    return head;
}

Druga funkcija

#include <stdio.h>
#include "type.h"

void printList ( Node *head ) {
    while(head)
    {
        printf("%d ", head->number);
        head = head->next;
    }
    
}

Treća funkcija

#include "type.h"
int listSize ( Node *head ) {
    int size = 0;
    
    while(head)
    {
        size++;
        head = head->next;
    }
    
    return size;
}

Četvrta funkcija

#include "type.h"
Node* searchFirst ( Node *head, int number ) {
    while(head)
    {
        if(head->number == number)
        {
            break;
        }
        head = head->next;
    }
    return head;
}

Peta funkcija

#include "type.h"
#include <stdlib.h>
Node* searchLast ( Node *head, int number ) {
    Node* prev = NULL;
    while(head)
    {
        if(head->number == number)
            prev = head;
            
        head = head->next;
    }
    return prev;
}

Šesta funkcija

#include "type.h"
void sortList ( Node *head ) {
    for(Node *f = head; f; f = f->next)
    {
        for(Node *s = f->next; s; s = s->next)
        {
            if(f->number > s->number)
            {
                int tmp = f->number;
                f->number = s->number;
                s->number = tmp;
            }
        }
    }
}

Sedma funkcija

#include <stdlib.h>
#include "type.h"

void deallocateList ( Node *head ) {
    while(head)
    {
        Node* old = head;
        head = head->next;
        free(old);
    }
}

Osma funkcija

#include <stdlib.h>
#include "type.h"

Node* insertSorted ( Node *head, int number ) {
    Node *prev = NULL, *curr = head;
    while(curr && curr->number<number)
    {
        prev = curr;
        curr = curr->next;
    }
    
    Node *newNode = malloc(sizeof(Node));
    newNode->number = number;
    if(!prev)
    {
        head = newNode;
        newNode->next = NULL;
    }
    else
    {
    newNode->next = prev->next;
    prev->next = newNode;
    }
    
    return head;
}

Deveta funkcija

#include <stdlib.h>
#include "type.h"

Node* removeElements ( Node *head, int number ) {
  Node *curr = head, *prev = NULL,
       *old;
      while (curr)
        if (curr->number != number) 
        {
            prev = curr;
            curr = curr->next; 
        }

        else 
        {
           old = curr;
           curr = curr->next;
           if (!prev)
             head = curr;
           else
             prev->next = curr;
           free (old);
        }
  return head;
}

Deseta funkcija

#include <stdlib.h>
#include "type.h"

Node* mergeLists ( Node *head0, Node *head1 ) 
{
	Node* head = NULL;
	Node* last = NULL;

	Node* curr0 = head0;
	Node* curr1 = head1;

	while (curr0 && curr1)
	{
		Node* tmp = NULL;
		if (curr0->number < curr1->number)
		{
			tmp = curr0;
			curr0 = curr0->next;
		}
		else
		{
			tmp = curr1;
			curr1 = curr1->next;
		}
		tmp->next = NULL;
		if (!last)
		{
			head = tmp;
		}
		else
		{
			last->next = tmp;
		}
		last = tmp;
	}
	
	if (curr0)
	{
		if (last == NULL)
			head = curr0;
		else
			last->next = curr0;
	}
	if (curr1)
	{
		if (last == NULL)
			head = curr1;
		else
			last->next = curr1;
	}
	return head;
}

Jedanaesta funkcija

#include <stdlib.h>
#include "type.h"

void removeDuplicates ( Node *head )
{ 
   Node* current = head; 
  
   Node* next_next;  
    
    if (current == NULL)  
       return;  
  
    while (current->next != NULL)  
    { 
       if (current->number == current->next->number)  
       { 
           next_next = current->next->next; 
           free(current->next); 
           current->next = next_next;   
       } 
       else
       { 
          current = current->next;  
       } 
    } 
}

Dvanaesta funkcija

#include <stdlib.h>
#include "type.h"

Node* reverseList ( Node *head ) {
    Node *prev = NULL, *curr = NULL, *next = head;
    
    while(next)
    {
        curr = next;
        next = next->next;
        curr->next = prev;
        prev = curr;
    }
    
    return curr;
}

Trinaesta funkcija

#include <stdlib.h>
#include "type.h"

Node* getMiddle ( Node *head ) {
    Node *slow = head, *fast = slow;
    if(!head)
        return NULL;
    
    while(fast->next)
    {
        slow = slow->next;
        fast = fast->next;
        if(fast->next)
            fast = fast->next;
        
    }
    return slow;
}

Četrnaesta funkcija

#include <stdlib.h>
#include "type.h"

Node* getNthFromEnd ( Node *head, int n ) {
    
	Node* fast = head;
	for (int i = 0; i < n && fast; i++, fast = fast->next);
	Node* slow = head;
	for (; fast; fast = fast->next, slow = slow->next);

	return slow;
}
Преузето из „https://siwiki.rs/w/index.php?title=Програмирање_2/Блок_3&oldid=731”