Блог

У меня проблема с моим классом структуры данных. Моя задача-сгенерировать 30 случайных чисел, а затем распечатать их в списке в том порядке, в котором они были сгенерированы. После этого я должен удалить из списка числа, кратные 3, и числа, содержащие цифру «3». В конце мне нужно распечатать этот список в файл в порядке возрастания, но нам не разрешается сортировать список перед печатью в файл.

Мой код работает нормально, но я не могу найти решение для печати цифр в файл в порядке возрастания.

 #define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
#include<stdbool.h>
#define BUFFER_LENGTH 256

typedef struct lista* Poz;
typedef struct lista {
    int br;
    Poz next;
}lista;

bool containsDigit(int, int);
int PrintList(Poz);
int PrintRandom(int, int);
Poz StvoriCvor();
int PrintToFile(Poz);

bool containsDigit(int number, int digit) {
    while (number != 0) {
        int curr_digit = number % 10;
        if (curr_digit == digit)
            return true;
        number /= 10;
    }
    return false ;
}

int PrintToFile(Poz P) {
    int digit = 3;
    if (P == NULL) return -1;
    Poz temp;
    temp = StvoriCvor();
    if (temp == NULL) return -1;
    char* fileName = NULL;
    FILE* fp;

    fileName = (char*)malloc(sizeof(char) * BUFFER_LENGTH);
    if (fileName == NULL) return -1;

    printf("Unesite ime datoteke:n");
    scanf("%s", fileName);

    fp = fopen(fileName, "w ");
    if (fp == NULL) return -1;
    while (P != NULL) {
        if (P->br % 3 == 0 || containsDigit(P->br, digit) == true) {
            P = P->next;
        }
        else {
            fprintf(fp, "%dn", (int)P->br);
            P = P->next;
        }
        
    }
    fclose(fp);
    return 0;
}

int PrintRandom(int min, int max) {
    int num = (rand() % (max - min   1)   min);
    return num;
}

int PrintList(Poz P) {
    P = P->next;
    if (P == NULL) {
        printf("Lista je prazna.n");
    }
    else {
        printf("Sljedeci brojevi su u listi.n");
        while (P != NULL) {
            printf("%d ", P->br);
            P = P->next;
        }
    }
    return 0;
}

Poz StvoriCvor() {
    Poz Q = NULL;
    Q = (Poz)malloc(sizeof(lista));
    if (Q == NULL) {
        printf("Greska u funkciji StvoriCvor.n");
    }
    Q->next = NULL;
    return Q;
}

int main() {
    Poz Sort = NULL;
    lista head;
    head.next = NULL;
    Poz Q = NULL;
    Poz temp = NULL;
    int min = 0, max = 100, count = 30;
    srand(time(0));
    int pr = 100, x = 0;
    char* choice;
    choice = (char*)malloc(sizeof(char));
    if (choice == NULL) {
        printf("Greska.n");
    }

    for (int i = 0; i < count; i  ) {
        Q = StvoriCvor();
        if (Q == NULL) {
            printf("Greska u funkciji StvoriCvor.n");
        }
        else {
            Q->br = PrintRandom(min, max);
            Q->next = head.next;
            head.next = Q;
        }
    }
    PrintList(amp;head);
    PrintToFile(head.next);

    return 0;
}
 

Если «сортировка» запрещена, вы должны найти наименьшее число в списке, просто сравнив. Повторите список, найдите наименьшее число и удалите его, пока ваш список не опустеет, технически это все еще сортировка в файл

Список на самом деле не является хорошей структурой данных, чтобы пытаться перебирать ее по порядку. Если вы хотите выполнить обход по порядку, вам нужна другая структура данных, поэтому, похоже, нужно использовать одну из них. Использование вспомогательной структуры данных (или, в данном случае, использование вспомогательной структуры данных в качестве основной!) часто является хорошей идеей. Возможно, это нарушает дух директивы «не упорядочивать список», но такая директива немного странная, поскольку сортировка списка-глупая вещь. ТАК что это не служба кодирования, но такую игрушку писать весело и стоит делать (или, может быть, это чистая прокрастинация!) время от времени, так что без тщательного тестирования или какого-либо реального обзора, вот начало:

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

struct list_element {
    int val;
    struct list_element *next;
};

struct tree_element {
    int val;
    struct tree_element *child[2];
};

static void *
xmalloc(size_t s)
{
    void *rv = malloc(s);
    if( rv == NULL ){
        perror("malloc");
        exit(EXIT_FAILURE);
    }
    return rv;
}

static struct list_element *
push_list(struct list_element *h, int v)
{
    struct list_element *new = xmalloc(sizeof *new);
    new->val = v;
    new->next = h;
    return new;
}

static void
insert_tree(struct tree_element **t, int v)
{
    char buf[128];
    if( (v % 3 == 0) || snprintf(buf, sizeof buf, "%d", v) > 127 ||
            strchr(buf, '3') != NULL ){
        return;
    }
    if( *t == NULL ){
        struct tree_element *new = *t = xmalloc(sizeof **t);
        new->val = v;
        new->child[0] = NULL;
        new->child[1] = NULL;
    } else {
        struct tree_element *n = *t;
        insert_tree(n->child   ( n->val > v ? 0 : 1 ), v);
    }
}

static void
print_tree_node(const struct tree_element *t, FILE *out)
{
    fprintf(out, "%d ", t->val);
}

static void
in_order(struct tree_element *r, void (*f)(const struct tree_element *, FILE *),
    FILE *out)
{
    if( r ){
        in_order(r->child[0], f, out);
        f(r, out);
        in_order(r->child[1], f, out);
    }
}

int
main(int argc, char **argv)
{
    struct list_element *head = NULL;
    struct tree_element *root = NULL;
    int count = argc > 1 ? strtoul(argv[1], NULL, 10) : 10;
    int mod = argc > 2 ? strtoul(argv[2], NULL, 10) : INT_MAX;
    srand(time(NULL));
    for( int i = 0; i < count; i  = 1 ){
        int r = rand() % mod;
        head = push_list(head, r);
        insert_tree(amp;root, r);
    }

    puts("Original list:");
    for( ; head; head = head->next ){
        printf("%d ", head->val);
    }
    putchar('n');
    puts("Filtered and sorted:");
    in_order(root, print_tree_node, stdout);
    putchar('n');

    return 0;
}