meow

Homework/Hanoi Towers/func.c

@@ -1,140 +1,216 @@
-#include "head.h"
 
+#include "prot.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
 
-void linked_print(LinkList* l) {    
+void pr(node *tmp)
-    while (l != NULL) {
+{
-        printf("%d %s\n", l->x, l->name);
-        l = l->next;
-    }
-}
-
-LinkList* add_tail(LinkList* l, LinkList node) {
-    if (l->x == 0 && !strcmp(l->name, "\0")) {
-        l->x = node.x;
-        memcpy(l->name, node.name, LEN);
-        l->next = NULL;
-        l->prev = NULL;
-        return l;
-    }
-
-    LinkList* res = l;
-    while (l->next != NULL) l = l->next;
-
-    LinkList* tmp = malloc(sizeof(LinkList));
-    tmp->x = node.x;
-    memcpy(tmp->name, node.name, LEN);
-    tmp->prev = l;
-    l->next = tmp;
-    return res;
-}
-
-LinkList* add_head(LinkList* l, LinkList node) {
-    if (l->x == 0 && !strcmp(l->name, "\0")) {
-        l->x = node.x;
-        memcpy(l->name, node.name, LEN);
-        l->next = NULL;
-        l->prev = NULL;
-        return l;
-    }
-
-    LinkList* tmp = malloc(sizeof(LinkList));
     if (tmp == NULL)
-        exit(1);
+    {
-    
+        printf("[%p]\n", tmp);
-    tmp->next = l;
+        return;
-    l->prev = tmp;
+    }
+    while (tmp)
+    {
+        printf("[%14p]<-[%14p]->[%14p] ", tmp->prev, tmp, tmp->next);
+        printf("data: [%4ld] s[%s]\n", tmp->data, tmp->s);
+        tmp = tmp->next;
+    }
+    printf("-------------\n");
+}
+node *add_head(node *head, int hh)
+{
+    node *tmp = NULL;
+    int i;
+    if ((tmp = malloc(sizeof(node))) == NULL)
+    {
+        perror("malloc: NULL");
+        exit(2);
+    }
     tmp->prev = NULL;
-    tmp->x = node.x;
+    tmp->data = hh;
-    memcpy(tmp->name, node.name, LEN);
+    for (i = 0; i < N - 1; i++)
+        tmp->s[i] = ((char)(65 + rand() % 25));
+    tmp->s[N - 1] = '\0';
+    if (head == NULL)
+        tmp->next = NULL;
+    else
+    {
+        tmp->next = head;
+        head->prev = tmp;
+    }
     return tmp;
 }
-
+node *del_head(node *head)
-LinkList* del_head(LinkList* l) {
+{
-    if (l == NULL) return NULL;
+    node *tmp = head;
-    if (l->next == NULL) {
+    if (head == NULL)
-        free(l);
+        return NULL;
+    if (head->next == NULL)
+    {
+        free(head);
         return NULL;
     }
-    LinkList* tmp = l->next;
+    head = head->next;
-    tmp->prev = NULL;
+    head->prev = NULL;
-    free(l);
+    free(tmp);
-    return tmp;
+    return head;
 }
 
-void del_tail(LinkList* l) {
+int length(node *list)
-    if (l == NULL) return;
+{
-    else if (l->next == NULL) {
+    node *tmp = list;
-        free(l);
-        l = NULL;
-        return;
-    }
-    while (l->next != NULL) l = l->next;
-    LinkList* tmp = l->prev;
-    l->prev = NULL;
-    free(l);
-    tmp->next = NULL;
-}
-
-int len(LinkList* l) {
     int res = 0;
-    if (l->x == 0 && !strcmp(l->name, "\0"))
+    if (list == NULL)
         return 0;
-    
+    if (list->data == 0 && !strcmp(list->s, "\0"))
-    while (l != NULL) {
+        return 0;
+    else
+    {
+        while (tmp->prev != NULL)
+            tmp = tmp->prev;
+        while (tmp != NULL)
+        {
             res++;
-        l = l->next;
+            tmp = tmp->next;
+        }
     }
     return res;
 }
 
-LinkList get(LinkList* l, int n) {
+node *adv_add_head(node *head, int hh, char string[])
-    if (n > len(l)) exit(3);
+{
-    int i;
+    node *tmp = NULL;
-    for (i = 0; i < n; i++) {
+    if ((tmp = malloc(sizeof(node))) == NULL)
-        l = l->next;
+    {
+        perror("malloc: NULL");
+        exit(2);
     }
-    return *l;
+    tmp->prev = NULL;
+    tmp->data = hh;
+    memcpy(tmp->s, string, N);
+    if (head == NULL)
+        tmp->next = NULL;
+    else
+    {
+        tmp->next = head;
+        head->prev = tmp;
+    }
+    return tmp;
+}
+void swap(node *a, node *b)
+{
+    node *tmp = NULL;
+    if ((tmp = malloc(sizeof(node))) == NULL)
+        exit(1);
+    tmp->data = a->data;
+    a->data = b->data;
+    b->data = tmp->data;
+    memcpy(tmp->s, a->s, N);
+    memcpy(a->s, b->s, N);
+    memcpy(b->s, tmp->s, N);
+    free(tmp);
 }
 
-void tower_of_hanoi(int n, LinkList* start, LinkList* finish, LinkList* tmp) {
+node *get(node *list, int n)
-    if (n == 1) {
+{
-        finish = add_head(finish, get(start, 0));
+    if (n >= length(list))
-        start = del_head(start);
+        exit(3);
+    int i;
+    for (i = 0; i < n; i++)
+        list = list->next;
+    return list;
+}
+
+node *sort(node *head)
+{
+    if (head == NULL || head->next == NULL)
+        return head;
+    int i, j, n = length(head);
+    for (i = 0; i < n - 1; i++)
+    {
+        for (j = i + 1; j < n; j++)
+        {
+            if (get(head, j)->data < get(head, i)->data)
+                swap(get(head, i), get(head, j));
+        }
+    }
+    return head;
+}
+node *printextra(node *head, int len, int i)
+{
+    if (len < i || len == 0)
+    {
+        printf("*********************************|");
+        return head;
+    }
+    else
+    {
+        printf("[%14p] data: [%4ld] s[%s]|", head, head->data, head->s);
+        return head->prev;
+    }
+}
+node *end(node *head)
+{
+    node *tmp = NULL;
+    tmp = head;
+    if (head == NULL)
+        return head;
+    while (tmp->next != NULL)
+        tmp = tmp->next;
+    return tmp;
+}
+
+void printftof(node *head1, node *head2, node *head3)
+{
+    int a = length(head1), b = length(head2), c = length(head3), maximum, i;
+    maximum = max(a, b);
+    maximum = max(maximum, c);
+    head1 = end(head1);
+    head2 = end(head2);
+    head3 = end(head3);
+    for (i = maximum; i > 0; i--)
+    {
+        head1 = printextra(head1, a, i);
+        head2 = printextra(head2, b, i);
+        head3 = printextra(head3, c, i);
+        printf("\n");
+    }
+    printf("----------------------------------------------------------------------------------------------------------\n");
+    printf("Tower 1                           |Tower 2                           |Tower 3                           |\n");
+    printf("----------------------------------------------------------------------------------------------------------\n\n");
+}
+int max(int a, int b)
+{
+    if (a < b)
+        return b;
+    else
+        return a;
+}
+
+void hanoi_tower(int n, node **head_from, node **head_to, node **head_aux, node **const tower1, node **const tower2, node **const tower3)
+{
+    if (n == 0)
+    {
+        printf("No linked list");
+        exit(6);
+    }
+    else if (n == 1)
+    {
+        if (length(*head_to) == 0)
+            printftof(*tower1, *tower2, *tower3);
+        *head_to = adv_add_head(*head_to, (*head_from)->data, (*head_from)->s);
+        *head_from = del_head(*head_from);
+        if (length(*head_from) == 0)
+            printftof(*tower1, *tower2, *tower3);
         return;
     }
-
+    hanoi_tower(n - 1, head_from, head_aux, head_to, tower1, tower2, tower3);
-    tower_of_hanoi(n - 1, start, tmp, finish);
+    printftof(*tower1, *tower2, *tower3);
-
+    *head_to = adv_add_head(*head_to, (*head_from)->data, (*head_from)->s);
-    finish = add_head(finish, get(start, 0));
+    *head_from = del_head(*head_from);
-    start = del_head(start);
+    printftof(*tower1, *tower2, *tower3);
-
+    hanoi_tower(n - 1, head_aux, head_to, head_from, tower1, tower2, tower3);
-    tower_of_hanoi(n - 1, tmp, finish, start);
-
-    printf("\nPosition:\nStart:\n");
-    linked_print(start);
-    printf("Finish:\n");
-    linked_print(finish);
-    printf("Tmp:\n");
-    linked_print(tmp);
 }
-
-void linked_free(LinkList* l) {
-    while (l->next != NULL) l = l->next;
-
-    while (l->prev != NULL) {
-        LinkList* tmp = l;
-        l = l->prev;
-        free(tmp);
-    }
-}
-
-
-
-
-
-
-
-
-
-
-

Homework/Hanoi Towers/gen.c

@@ -1,38 +0,0 @@
-#include "head.h"
-
-
-int main(int argc, char* argv[]) {
-    srand(time(0));
-    LinkList* l1 = malloc(sizeof(LinkList));
-    LinkList* l2 = malloc(sizeof(LinkList));
-    LinkList* l3 = malloc(sizeof(LinkList));
-
-    if (l1 == NULL || l2 == NULL || l3 == NULL)
-        exit(1);
-
-    int i, j;
-    char s[LEN];
-    for (i = 0; i < N; i++) {        
-        for (j = 0; j < LEN - 1; j++)
-            s[j] = 'a' + rand() % 25;
-        s[j + 1] = '\0';
-        
-        LinkList l;
-        l.x = i;
-        memcpy(l.name, s, LEN);
-        l.next = NULL;
-        l.prev = NULL;
-
-        l1 = add_tail(l1, l);
-    }
-
-    tower_of_hanoi(N, l1, l3, l2);
-
-    // printf("Done:\n");
-
-    linked_free(l1);
-    linked_free(l2);
-    linked_free(l3);
-
-    return 0;
-}

Homework/Hanoi Towers/head.h

@@ -1,24 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#define N 3
-#define LEN 8
-
-typedef struct LinkList {
-    int x;
-    char name[LEN];
-    struct LinkList* next;
-    struct LinkList* prev;
-} LinkList;
-
-void linked_print(LinkList* l);
-LinkList* add_tail(LinkList* l, LinkList node);
-LinkList* add_head(LinkList* l, LinkList node);
-LinkList* del_head(LinkList* l);
-void del_tail(LinkList* l);
-int len(LinkList* l);
-LinkList get(LinkList* l, int n);
-void tower_of_hanoi(int n, LinkList* start, LinkList* finish, LinkList* tmp);
-void linked_free(LinkList* l);

Homework/Hanoi Towers/main.c

@@ -0,0 +1,28 @@
+#include "prot.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+int main(int argc, char *argv[])
+{
+
+    node *head = NULL, *head2 = NULL, *head3 = NULL;
+    int r;
+
+    srand(time(NULL));
+
+    printf("Generated linked list (method of head)\n");
+    while ((r = (rand() % 100)) < 75)
+        head = add_head(head, r);
+    pr(head);
+
+    printf("Length of linked list is: %d\n", length(head));
+
+    printf("Sorted linked list\n");
+    sort(head);
+    pr(head);
+
+    hanoi_tower(length(head), &head, &head3, &head2, &head, &head2, &head3);
+    return 0;
+}

Homework/Hanoi Towers/prot.h

@@ -0,0 +1,23 @@
+#define N 10
+
+typedef struct Node
+{
+    long int data;
+    struct Node *next;
+    struct Node *prev;
+    char s[N];
+} node;
+
+void pr(node *tmp);
+node *add_head(node *head, int hh);
+node *del_head(node *head);
+int length(node *list);
+node *sort(node *head);
+node *get(node *list, int n);
+void swap(node *a, node *b);
+node *adv_add_head(node *head, int hh, char string[]);
+void hanoi_tower(int n, node **head_from, node **head_to, node **head_aux, node **const tower1, node **const tower2, node **const tower3);
+void printftof(node *head1, node *head2, node *head3);
+node *end(node *head);
+node *printextra(node *head, int len, int i);
+int max(int a, int b);