数据结构和算法——旋转打印链表

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

typedef struct node node;

struct node{
    int value;
    node *nextRightNode;
    node *nextLeftNode;
    node *nextUpNode;
    node *nextDownNode;
};


node* setMatrix(int start, int n){

    node* p_left_up = (node*)malloc(sizeof(node));
    p_left_up->value = start;

    if (n < 2){
        p_left_up->nextRightNode = NULL;
        p_left_up->nextLeftNode = NULL;
        p_left_up->nextUpNode = NULL;
        p_left_up->nextDownNode = NULL;
    }else{
        node* p_right_up = (node*)malloc(sizeof(node));
        p_right_up->value = 1 * (n - 1) + p_left_up->value;
        node* p_right_down = (node*)malloc(sizeof(node));
        p_right_down->value = 1 * (n - 1) + p_right_up->value;
        node* p_left_down = (node*)malloc(sizeof(node));
        p_left_down->value = 1 * (n - 1) + p_right_down->value;

        //设置
        p_left_up->nextRightNode = p_right_up;
        p_left_up->nextLeftNode = NULL;
        p_left_up->nextUpNode = NULL;
        p_left_up->nextDownNode = p_left_down;

        p_right_up->nextRightNode = NULL;
        p_right_up->nextLeftNode = p_left_up;
        p_right_up->nextUpNode = NULL;
        p_right_up->nextDownNode = p_right_down;

        p_right_down->nextRightNode = NULL;
        p_right_down->nextLeftNode = p_left_down;
        p_right_down->nextUpNode = p_right_up;
        p_right_down->nextDownNode = NULL;

        p_left_down->nextRightNode = p_right_down;
        p_left_down->nextLeftNode = NULL;
        p_left_down->nextUpNode = p_left_up;
        p_left_down->nextDownNode = NULL;


        //设置中间的值
        //p_left_up=p_right_up
        node* p_1 = p_left_up;
        int i = 0;
        for (i = 0; i < (n-2); i++){
            node* p = (node*)malloc(sizeof(node));
            p->value = p_1->value + 1;

            p->nextRightNode = p_right_up;
            p_1->nextRightNode = p;

            p->nextLeftNode = p_1;
            p_right_up->nextLeftNode = p;

            p_1 = p;
        }

        //p_left_down-->p_left_up
        //p_left_down-->p_right_down
        node* p_2 = p_left_down;
        node* p_3 = p_left_down;
        for (i = 0; i < (n-2); i++){
            //up
            node* p_up = (node*)malloc(sizeof(node));
            p_up->value = p_2->value + 1;

            p_up->nextUpNode = p_left_up;
            p_2->nextUpNode = p_up;

            p_up->nextDownNode = p_2;
            p_left_up->nextDownNode = p_up;

            p_2 = p_up;

            //right
            node* p_right = (node*)malloc(sizeof(node));
            p_right->value = p_3->value - 1;

            p_right->nextRightNode = p_right_down;
            p_3->nextRightNode = p_right;

            p_right->nextLeftNode = p_3;
            p_right_down->nextLeftNode = p_right;

            p_3 = p_right;
        }

        //p_right_up-->p_right_down
        node* p_4 = p_right_up;
        node* r = p_left_up;
        for (i = 0; i < (n-2); i++){
            node* p = (node*)malloc(sizeof(node));
            p->value = p_4->value + 1;

            r = r->nextDownNode;

            p->nextDownNode = p_right_down;
            p_4->nextDownNode = p;

            p->nextUpNode = p_4;
            p_right_down->nextUpNode = p;

            r->nextRightNode = p;
            p->nextLeftNode = r;

            p_4 = p;
        }
    }
    return p_left_up;
}


node* setAll(int start, int n){
    node* p = NULL;
    if (n <= 0){
        printf("please input correct n\n");
    }else{
        p = setMatrix(start, n);
        n = n - 2;
        node* p_tmp = p;

        while (n > 0){
            node* p_down = p_tmp->nextDownNode;
            start = p_down->value + 1;
            node* f = setMatrix(start, n);
            node* p_1 = f;


            //deal
            int i = 0;
            for (i = 0; i < n; i++){
                node* r = p_down;
                node* r_2 = p_1;


                while (r_2->nextRightNode != NULL){
                    r_2 = r_2->nextRightNode;
                }

                r_2->nextRightNode = r->nextRightNode;
                r->nextRightNode->nextLeftNode = r_2;

                r->nextRightNode = p_1;
                p_1->nextLeftNode = r;

                p_down = p_down->nextDownNode;
                p_1 = p_1->nextDownNode;
            }

            n = n - 2;
            p_tmp = f;
        }
    }

    return p;
}

void printMatrix(node* p){
    node* q = p;
    while (q != NULL){
        node* r = q;
        while (r != NULL){
            printf("%d\t",  r->value);
            r = r->nextRightNode;
        }
        printf("\n");
        q = q->nextDownNode;
    }
}

int main(int argc, char** argv){
    if (argc != 2){
        printf("useage : int n\n");
        exit(0);
    }

    int n = atoi(argv[1]);

    //node* p = setMatrix(25, n);
    node* p = setAll(1, n);

    printMatrix(p);

    return 0;
}