冒泡排序在双向循环链表中的一种体现

冒泡里面的换结点：

void bobble_sort_val(node *head)
{
    node *p = head->next;
    int len = 0;
    int i, j;
    while (p != head)
    {
        p = p->next;
        len++;
    }

    node *log = head->next;
    node *temp = head;

    for (i = 0; i < len - 1; i++)
    {
        //刷新一次位置
        log = head->next;   
        for (j = 0; j < len - i - 1; j++)
        {
            
            if (log->data > log->next->data)
            {
                //记录位置
                // log->prev log temp temp->next
                temp = log->next;

                //断开log节点
                log->prev->next = log->next;
                log->next->prev = log->prev;

                //连接log节点
                log->prev = temp;
                log->next = temp->next;
                temp->next->prev = log;
                temp->next = log;

                //回退位置，log比之前前进了一步
                log = log->prev;

            }
            //遍历节点
            log = log->next;
        }
        
    }
}

这里贴出写的全部代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct node
{
    int data;
    struct node *next;
    struct node *prev;
} node;

node *initList(void);
node *insert(node *head, int num);
node *insert_end(node *head, int num);
node *insert_sort(node *head, int num);
void display(node *head);
node *find_node(node *head, int find_data);
node *dele_node(node *head, int del_data);
node *modify_data(node *head, int data, int new_data);
void destroy(node *head);

node *deuion(node *head, int de_data);
void bobble_sort(node *head);
void bobble_sort_val(node *head);
void insert_p(node *head, node *new);

int main(void)
{
    char ch;
    int find_data, new_data, del_data, data;
    int num;
    node *head1, *head2, *head3;
    // head变量用于存储头节点地址
    node *head, *new, *find, *del;
    node *pos;
    head = initList();
    if (head == NULL)
        return -1;
    while (1)
    {
        printf("a)insert  d)delete  f)find  p)print  q)quit\n");
        // 在获取字符之前，缓冲区为空
        scanf("%c", &ch);
        if (ch == 'q')
            break;
        switch (ch)
        {
        case 'a':
            printf("enter your number:");
            scanf("%d", &num);
            pos = insert(head, num);
            if (pos == NULL)
            {
                break;
            }
            printf("new node adress:%p\n", pos);
            printf("insert sucess\n");
            break;

        case 'd':
            printf("enter your need to delete number:");
            scanf("%d", &del_data);
            del = dele_node(head, del_data);
            if (del == NULL)
            {
                printf("delate is failure\n");
            }
            else
            {
                printf("deltete sucess,node adress:%p\n", del);
            }
            break;

        case 'f':
            printf("enter you need find number:");
            scanf("%d", &find_data);

            find = find_node(head, find_data);
            if (find == NULL)
            {
                printf("non number\n");
            }
            else
            {
                printf("find sucess,node adress:%p\n", find);
            }
            break;

        case 'p':
            display(head);
            break;
        default:
            break;
        }
        // 循环清空缓冲区
        while (getchar() != '\n');
    }
    destroy(head);
    return 0;
}

node *initList(void)
{
    node *p = (node *)malloc(sizeof(node));
    if (p == NULL)
    {
        printf("out of space!\n");
    }
    p->next = p;
    p->prev = p;
    return p;
}

node *insert(node *head, int num)
{
    node *new = initList();
    if (new == NULL)
    {
        printf("out of space!\n");
        return NULL;
    }
    new->data = num;

    new->next = head->next;
    new->prev = head;
    head->next->prev = new;
    head->next = new;

    return new;
}

node *insert_end(node *head, int num)
{
    node *new = initList();
    if (new == NULL)
    {
        printf("out of space!\n");
        return NULL;
    }
    new->data = num;

    new->next = head;
    new->prev = head->prev;
    head->prev->next = new;
    head->prev = new;
    return new;
}

void display(node *head)
{
     //bobble_sort(head);
    bobble_sort_val(head);
    node *p = head->next;
    while (p != head)
    {
        printf("%d\t", p->data);
        p = p->next;
    }
    printf("\n");
}

node *find_node(node *head, int find_data)
{
    node *p = head->next;
    while (p != head)
    {
        if (p->data == find_data)
        {
            return p;
        }
        else
        {
            p = p->next;
        }
    }
    return NULL;
}

node *dele_node(node *head, int del_data)
{
    node *del = find_node(head, del_data);
    node *p = del;

    del->next->prev = del->prev;
    del->prev->next = del->next;

    del->next = del;
    del->prev = del;
    free(del);
    return p;
}

node *modify_data(node *head, int data, int new_data)
{
    node *mod = find_node(head, data);
    if (mod == NULL)
    {
        return mod;
    }
    mod->data = new_data;
    return mod;
}

void destroy(node *head)
{
    node *p = head->next;
    node *temp = p->next;
    while (p != head)
    {
        free(p);
        p = temp;
        temp = p->next;
    }
    free(head);
}

node *insert_sort(node *head, int num)
{
    node *new = initList();
    node *node_1 = head->next;
    node *p = find_node(head, num);
    if (p == NULL)
    {
        printf("similar number!\n");
        return NULL;
    }
    while (node_1->data < num)
    {
        node_1 = node_1->next;
    }

    new->data = num;

    new->next = node_1;
    new->prev = node_1->prev;
    node_1->prev->next = new;
    node_1->prev = new;
    return new;
}

node *deuion(node *head, int de_data)
{
    node *del = find_node(head, de_data);

    del->next->prev = del->prev;
    del->prev->next = del->next;

    del->next = del;
    del->prev = del;
    return del;
}

void bobble_sort(node *head)
{
    node *p = head->next;
    int len = 0;
    int i, j;
    while (p != head)
    {
        p = p->next;
        len++;
    }

    node *log = head->next;
    node *tmp;

    for (i = 0; i < len - 1; i++)
    {
        log = head->next;
        for (j = 0; j < len - i - 1; j++)
        {
            if (log->data > log->next->data)
            {
                tmp = log->next;
                log = deuion(head, log->data);
                insert_p(tmp, log);
            }
            else
            {
                log = log->next;
            }
        }
    }
}

void bobble_sort_val(node *head)
{
    node *p = head->next;
    int len = 0;
    int i, j;
    while (p != head)
    {
        p = p->next;
        len++;
    }

    node *log = head->next;
    node *temp = head;

    for (i = 0; i < len - 1; i++)
    {
        //刷新一次位置
        log = head->next;   
        for (j = 0; j < len - i - 1; j++)
        {
            
            if (log->data > log->next->data)
            {
                //记录位置
                // log->prev log temp temp->next
                temp = log->next;

                //断开log节点
                log->prev->next = log->next;
                log->next->prev = log->prev;

                //连接log节点
                log->prev = temp;
                log->next = temp->next;
                temp->next->prev = log;
                temp->next = log;

                //回退位置，log比之前前进了一步
                log = log->prev;

            }
            //遍历节点
            log = log->next;
        }
        
    }
}
void insert_p(node * head, node * new)
{

    node *p = head->next;
    new->next = p;
    new->prev = head;
    p->prev = new;
    head->next = new;
}