C++ 带头结点的链表(linked list)逆序、排序(索引从1开始)


#ifndef __LINKED_LIST_C2025__
#define __LINKED_LIST_C2025__



typedef int linked_data_t;

struct linked_list_node_t
{
    linked_data_t data;
    struct linked_list_node_t *next;
};

typedef struct linked_list_node_t linked_list_node, *linked_list_node_ptr;

linked_list_node_ptr make_linked_node(linked_data_t data);

linked_list_node_ptr create_linked_root();

void destroy_linked_list_since_root(linked_list_node_ptr root);

#define destroy_linked_list(r)             \
    do                                     \
    {                                      \
        destroy_linked_list_since_root(r); \
        r = NULL;                          \
    } while (0)

bool insert_data_linked_list(linked_list_node_ptr root, int index, linked_data_t data);

bool delete_index_linked_list(linked_list_node_ptr root, int index);

bool delete_data_linked_list(linked_list_node_ptr root, linked_data_t data);

void out_linked_list(linked_list_node_ptr root);

int find_data_index_linked_list(linked_list_node_ptr root, linked_data_t data);

int length_linked_list(linked_list_node_ptr root);

bool set_index_data_linked_list(linked_list_node_ptr root, int index, linked_data_t data);

linked_data_t get_data_linked_list(linked_list_node_ptr root, int index);

void reverse_linked_list(linked_list_node_ptr root);

void bubble_sort_linked_list(linked_list_node_ptr root);


#endif

#include "../util.h"
#include "linked_list.h"

linked_list_node_ptr make_linked_node(linked_data_t data)
{
    linked_list_node_ptr p = malloc(sizeof(linked_list_node));
    if (p)
    {
        p->data = data;
        p->next = NULL;
    }
    return p;
}

linked_list_node_ptr create_linked_root()
{
    return make_linked_node(0);
}

void destroy_linked_list_since_root(linked_list_node_ptr root)
{
    if (root)
    {
        linked_list_node_ptr p = root;
        while (p)
        {
            linked_list_node_ptr r = p;
            p = p->next;
            // r->next = NULL;
            xr(r);
        }
    }
}

bool insert_data_linked_list(linked_list_node_ptr root, int index, linked_data_t data)
{
    if (index <= 0)
    {
        return false;
    }
    if (root)
    {
        linked_list_node_ptr p = root;
        int i = 0;
        while (p && i < index - 1)
        {
            i++;
            p = p->next;
        }

        // error next condition if
        //  overstep the boundary
        //  if (i < index - 1) //i==index-1 at end+1 is error
        //  {
        //      return false;
        //  }
        //  overstep the boundary
        if (!p)
        {
            return false;
        }

        linked_list_node_ptr new_node = make_linked_node(data);
        new_node->next = p->next;
        p->next = new_node;
        return true;
    }
    return false;
}

bool delete_index_linked_list(linked_list_node_ptr root, int index)
{
    if (index <= 0)
    {
        return false;
    }
    if (root)
    {
        linked_list_node_ptr p = root;
        int i = 0;
        while (p && i < index - 1)
        {
            i++;
            p = p->next;
        }
        if (!p && !p->next)
        {
            return false;
        }
        linked_list_node_ptr index_node = p->next;
        p->next = p->next->next;
        xr(index_node);
        return true;
    }
    return false;
}

bool delete_data_linked_list(linked_list_node_ptr root, linked_data_t data)
{
    if (root)
    {
        linked_list_node_ptr p = root->next;
        linked_list_node_ptr prev = root;
        bool delete_flag = false;
        while (p)
        {

            if (p->data == data)
            {
                prev->next = p->next;
                xr(p);
                p = prev->next;
                delete_flag = true;
            }
            else
            {
                prev = p;
                p = p->next;
            }
        }
        return delete_flag;
    }
    return false;
}

void out_linked_list(linked_list_node_ptr root)
{

    if (root && root->next)
    {
        linked_list_node_ptr p = root->next;
        while (p->next)
        {
            printf("%d ", p->data);
            p = p->next;
        }
        printf("%d\n", p->data);
    }
}

int find_data_index_linked_list(linked_list_node_ptr root, linked_data_t data)
{
    int idx = -1;

    if (root)
    {
        linked_list_node_ptr p = root->next;
        idx++;
        while (p)
        {
            idx++;
            if (p->data == data)
            {
                break;
            }
            p = p->next;
        }
        if (!p)
        {
            idx = -1;
        }
    }

    return idx;
}

int length_linked_list(linked_list_node_ptr root)
{
    int idx = 0;

    if (root)
    {
        linked_list_node_ptr p = root->next;
        while (p)
        {
            idx++;
            p = p->next;
        }
    }

    return idx;
}

bool set_index_data_linked_list(linked_list_node_ptr root, int index, linked_data_t data)
{

    if (index <= 0)
    {
        return false;
    }
    if (root)
    {
        linked_list_node_ptr p = root;
        while (p && index)
        {
            p = p->next;
            index--;
        }

        if (!p)
        {
            return false;
        }

        p->data = data;

        return true;
    }

    return false;
}

linked_data_t get_data_linked_list(linked_list_node_ptr root, int index)
{
    if (index <= 0)
    {
        return 0;
    }

    if (root)
    {
        while (root && index)
        {
            root = root->next;
            index--;
        }
        if (!root)
        {
            return 0;
        }
        return root->data;
    }

    return 0;
}

void reverse_linked_list(linked_list_node_ptr root)
{
    if (root)
    {

        linked_list_node_ptr p1 = root->next, p2 = NULL, s = NULL;
        if (p1)
        {
            p2 = p1->next;
            if (p2)
            {
                s = p2->next;
                p1->next = NULL;
                p2->next = p1;
            }
        }
        while (s)
        {

            p1 = p2;
            p2 = s;
            s = s->next;

            p2->next = p1;
        }
        root->next = p2;
    }
}

void bubble_sort_linked_list(linked_list_node_ptr root)
{
    if (root)
    {
        linked_list_node_ptr prev = root, p1 = root->next, p2 = NULL, end = NULL;

        while (root->next != end)
        {
            if (p1)
            {
                p2 = p1->next;
                while (p2 != end)
                {
                    if (p1->data > p2->data)
                    {
                        p1->next = p2->next;
                        p2->next = p1;
                        prev->next = p2;

                        prev = p2;
                    }
                    else
                    {
                        prev = p1;
                        p1 = p2;
                    }
                    p2 = p1->next;
                }
                end = p1;
                prev = root,
                p1 = root->next;
                p2 = p1->next;
            }
        }
    }
}
#include"../util.h"
#include "linked_list.h"

int main()
{

    /**
     *
     * 下标从1开始,不是从0开始
     *
     *
     */

    linked_list_node_ptr root = create_linked_root();

    srand(time(0));

    for (int i = 0; i < 10; i++)
    {
        linked_data_t d = rand() % 100;
        if (insert_data_linked_list(root, 1, d))
        {
            printf("index 1 insert data:%d\n", d);
        }
    }

    out_linked_list(root);

    for (int i = 0; i < 10; i++)
    {
        linked_data_t d = rand() % 100;
        if (insert_data_linked_list(root, 10, d))
        {
            printf("index 10 insert data:%d\n", d);
        }
    }

    out_linked_list(root);

    for (int i = 0; i < 10; i++)
    {
        linked_data_t d = rand() % 100;
        if (insert_data_linked_list(root, 21, d))
        {
            printf("index 21 insert data:%d\n", d);
        }
    }

    out_linked_list(root);

    p_i(delete_index_linked_list(root, 1));
    out_linked_list(root);
    p_i(delete_data_linked_list(root, 88));
    out_linked_list(root);

    for (int i = 0; i < 10; i++)
    {
        linked_data_t d = 99;
        if (insert_data_linked_list(root, 1, d))
        {
            printf("index 1 insert data:%d\n", d);
        }
    }

    out_linked_list(root);

    p_i(delete_data_linked_list(root, 99));
    out_linked_list(root);

    p_i(find_data_index_linked_list(root, 99));
    p_i(find_data_index_linked_list(root, 88));
    p_i(insert_data_linked_list(root, 5, 87));
    out_linked_list(root);
    p_i(find_data_index_linked_list(root, 87));

    p_i(insert_data_linked_list(root, 1, 987));
    out_linked_list(root);
    p_i(find_data_index_linked_list(root, 987));

    p_i(insert_data_linked_list(root, -1, -98756));
    p_i(insert_data_linked_list(root, 0, -98756));
    p_i(insert_data_linked_list(root, 1, -98756));
    out_linked_list(root);
    p_i(delete_index_linked_list(root, -1));
    p_i(delete_index_linked_list(root, 0));
    p_i(delete_index_linked_list(root, 1));
    out_linked_list(root);

    p_i(length_linked_list(root));

    p_i(set_index_data_linked_list(root, 1, 10000));
    p_i(set_index_data_linked_list(root, 3, 30000));
    out_linked_list(root);

    p_i(get_data_linked_list(root, 1));

    p_str("=============reverse==================");
    reverse_linked_list(root);
    out_linked_list(root);

    destroy_linked_list(root);

    p_str("======================================");

    root = create_linked_root();

    for (int i = 0; i < 10; i++)
    {
        linked_data_t d = rand() % 100;
        if (insert_data_linked_list(root, 1, d))
        {
            printf("index 1 insert data:%d\n", d);
        }
    }

    out_linked_list(root);

    reverse_linked_list(root);
    out_linked_list(root);

    bubble_sort_linked_list(root);
    out_linked_list(root);

    destroy_linked_list(root);

    return 0;
}
index 1 insert data:48
index 1 insert data:61
index 1 insert data:3
index 1 insert data:62
index 1 insert data:92
index 1 insert data:58
index 1 insert data:51
index 1 insert data:68
index 1 insert data:69
index 1 insert data:48
48 69 68 51 58 92 62 3 61 48
index 10 insert data:77
index 10 insert data:52
index 10 insert data:31
index 10 insert data:20
index 10 insert data:54
index 10 insert data:47
index 10 insert data:12
index 10 insert data:82
index 10 insert data:35
index 10 insert data:8
48 69 68 51 58 92 62 3 61 8 35 82 12 47 54 20 31 52 77 48
index 21 insert data:13
index 21 insert data:5
index 21 insert data:7
index 21 insert data:92
index 21 insert data:95
index 21 insert data:66
index 21 insert data:80
index 21 insert data:11
index 21 insert data:59
index 21 insert data:56
48 69 68 51 58 92 62 3 61 8 35 82 12 47 54 20 31 52 77 48 56 59 11 80 66 95 92 7 5 13
1
69 68 51 58 92 62 3 61 8 35 82 12 47 54 20 31 52 77 48 56 59 11 80 66 95 92 7 5 13
0
69 68 51 58 92 62 3 61 8 35 82 12 47 54 20 31 52 77 48 56 59 11 80 66 95 92 7 5 13
index 1 insert data:99
index 1 insert data:99
index 1 insert data:99
index 1 insert data:99
index 1 insert data:99
index 1 insert data:99
index 1 insert data:99
index 1 insert data:99
index 1 insert data:99
index 1 insert data:99
99 99 99 99 99 99 99 99 99 99 69 68 51 58 92 62 3 61 8 35 82 12 47 54 20 31 52 77 48 56 59 11 80 66 95 92 7 5 13
1
69 68 51 58 92 62 3 61 8 35 82 12 47 54 20 31 52 77 48 56 59 11 80 66 95 92 7 5 13
-1
-1
1
69 68 51 58 87 92 62 3 61 8 35 82 12 47 54 20 31 52 77 48 56 59 11 80 66 95 92 7 5 13
5
1
987 69 68 51 58 87 92 62 3 61 8 35 82 12 47 54 20 31 52 77 48 56 59 11 80 66 95 92 7 5 13
1
0
0
1
-98756 987 69 68 51 58 87 92 62 3 61 8 35 82 12 47 54 20 31 52 77 48 56 59 11 80 66 95 92 7 5 13
0
0
1
987 69 68 51 58 87 92 62 3 61 8 35 82 12 47 54 20 31 52 77 48 56 59 11 80 66 95 92 7 5 13
31
1
1
10000 69 30000 51 58 87 92 62 3 61 8 35 82 12 47 54 20 31 52 77 48 56 59 11 80 66 95 92 7 5 13
10000
=============reverse==================
13 5 7 92 95 66 80 11 59 56 48 77 52 31 20 54 47 12 82 35 8 61 3 62 92 87 58 51 30000 69 10000
======================================
index 1 insert data:99
index 1 insert data:59
index 1 insert data:17
index 1 insert data:54
index 1 insert data:21
index 1 insert data:9
index 1 insert data:64
index 1 insert data:73
index 1 insert data:30
index 1 insert data:85
85 30 73 64 9 21 54 17 59 99
99 59 17 54 21 9 64 73 30 85
9 17 21 30 54 59 64 73 85 99

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值