将无序数组插入有序链表

最新推荐文章于 2022-12-22 10:10:47 发布
最新推荐文章于 2022-12-22 10:10:47 发布
阅读量1.2k 收藏
点赞数 1
分类专栏： c 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alittlefish1/article/details/123865350
版权

使用场景：将生存周期短的数组存储到生存周期长的链表上，增加记录信息，减少长数组的内存开销

过程：
1、将无序数组排序
2、将有序数组插入有序链表

  • 链表为空的情况
  • 链表长度为1的情况
  • 链表长度大于1的情况

当然我这种做法比较复杂，但是优点是无反复申请释放内存，用有序链表插入有序链表简单一些。

c代码如下：

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

#define TYEPCHANGE 1
#define TYPE_NOT_CHANGE 0

/************** 有无序数组的结构体 *************/
typedef struct aa{
    int blocknum;
    int blocktype[40];
}AA;

/************** 定义链表结构 *************/
typedef struct node{
    int blocktype;
    struct node *next;
}NODE;

/************** 有序链表结构 *************/
typedef struct bb{
    int a;
    struct node *node_list;;
}BB;

/************** 冒泡排序 *************/
void sort(int *array, int num)
{
    int temp;
    int i,j;
    for (i=0; i<num-1; i++){
        for(j=0; j<num-i-1; j++){
            if(array[j] > array[j+1]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}

/************** 调试打印链表函数 *************/
void print(NODE *tmp){
    int i=0;
    NODE *cur = tmp;
    if (cur == NULL)
        return;
    //printf("********* list is: *********\r\n");
    while(cur){
        printf("%d->", cur->blocktype);
        cur = cur ->next;
    }
    printf("\r\n");
    printf("\r\n");
}

/************** 调试打印数组函数 *************/
void print_a(AA t_a){
    int i=0;
    //printf("****** blocknum is %d , after sort is:*******\r\n", t_a.blocknum);
    for(; i<t_a.blocknum; i++){
        printf("%d,", t_a.blocktype[i]);
    }
    printf("\r\n");
}

/************** 有序数组插入有序链表 *************/
static int co_block_type_code(NODE **node_list_par, AA *array_par){
    int index = 0;
    int ret = TYPE_NOT_CHANGE;
    
    NODE *next_t, *cur, *pre;
    NODE *blocktype_node_tmp;

    cur = *node_list_par;
    
    /****  避免空指针 ****/
    if (cur == NULL)
        next_t = NULL;
    else
        next_t = cur->next;

    while(cur && next_t && index < array_par->blocknum){
        /****** 插入的数小于链表最左边的数，将此数插到最左边，并以此为头 ******/
        if (cur->blocktype > array_par->blocktype[index]){
            blocktype_node_tmp = (NODE *)malloc(sizeof(NODE));
            if (NULL == blocktype_node_tmp){
                return TYEPCHANGE;
            }
            memset(blocktype_node_tmp, 0, sizeof(NODE));
            blocktype_node_tmp->blocktype = array_par->blocktype[index];
            blocktype_node_tmp->next = cur;
            next_t = cur;
            cur = blocktype_node_tmp;
            *node_list_par = blocktype_node_tmp;
            index++;
            ret = TYEPCHANGE;
        }
        
        else if (cur->blocktype == array_par->blocktype[index]) {
            while(index < array_par->blocknum && cur->blocktype == array_par->blocktype[index])
                index++;
        } 
        /****** 插入的数位于链表两个数之间 ******/
        else if (cur->blocktype < array_par->blocktype[index] && next_t->blocktype > array_par->blocktype[index]){
            blocktype_node_tmp = (NODE *)malloc(sizeof(NODE));
            if (NULL == blocktype_node_tmp){
                return TYEPCHANGE;
            }
            memset(blocktype_node_tmp, 0, sizeof(NODE));
            blocktype_node_tmp->blocktype = array_par->blocktype[index];
            cur->next = blocktype_node_tmp;
            blocktype_node_tmp->next = next_t;
            cur = blocktype_node_tmp;
            index++;
            ret = TYEPCHANGE;
        }
        /****** 插入的数大于于链表相邻的两个数 ******/
        else{
            cur = next_t;
            if (NULL == cur->next)
                break;
            next_t = cur->next;
        }
    }
    
    /**************** 链表长度为1 start ****************/
    if(index < array_par->blocknum && cur && cur->blocktype > array_par->blocktype[index]){
        blocktype_node_tmp = (NODE *)malloc(sizeof(NODE));
        if (NULL == blocktype_node_tmp){
            return TYEPCHANGE;
        }
        memset(blocktype_node_tmp, 0, sizeof(NODE));
        blocktype_node_tmp->blocktype = array_par->blocktype[index];
        blocktype_node_tmp->next = cur;
        *node_list_par = blocktype_node_tmp;
        pre = blocktype_node_tmp;
        index++;
        ret = TYEPCHANGE;
    }
    
    while(index < array_par->blocknum && cur && cur->blocktype > array_par->blocktype[index]){
        if ( array_par->blocktype[index] == array_par->blocktype[index-1]){
            index++;
            continue;
        }
        
        blocktype_node_tmp = (NODE *)malloc(sizeof(NODE));
        if (NULL == blocktype_node_tmp){
            return TYEPCHANGE;
        }
        memset(blocktype_node_tmp, 0, sizeof(NODE));
        blocktype_node_tmp->blocktype = array_par->blocktype[index];
        pre->next = blocktype_node_tmp;
        blocktype_node_tmp->next = cur;
        pre = blocktype_node_tmp;
        index++;
    }
    /************** 链表长度为1 end *************/
    
    /****** 已经走到了链表的尽头，或者链表长度为空 ******/
    for(;index < array_par->blocknum; index++) {
        /****** 去重 ******/
        while(index < array_par->blocknum && cur && cur->blocktype == array_par->blocktype[index])
            index++;

        if (index >= array_par->blocknum)
            break;
        
        ret = TYEPCHANGE;
        blocktype_node_tmp = (NODE *)malloc(sizeof(NODE));
        if (NULL == blocktype_node_tmp){
            return TYEPCHANGE;
        }
        memset(blocktype_node_tmp, 0, sizeof(NODE));
        blocktype_node_tmp->blocktype = array_par->blocktype[index];
        blocktype_node_tmp->next = NULL;
        if (cur==NULL){
            *node_list_par = blocktype_node_tmp;
            cur = *node_list_par;
        }
        else{
            cur->next = blocktype_node_tmp;
            cur = blocktype_node_tmp;
            ret = TYEPCHANGE;
        }
    }
    return ret;
}

void free_all(BB *temp_b){
    NODE *cur, *next;
    cur = temp_b->node_list;
    while(cur){
        next = cur->next;
        free(cur);
        cur = next;
    }
    
}

void print_status(int ret){
	if (ret == TYEPCHANGE)
        printf("list is changed!\r\n");
    else
        printf("list is not changed!\r\n");
}

int main(int argc, char *argv[]){
    AA a0, a1, a2, a3, a4, a5;
    BB b1;
    b1.node_list = NULL;
    int ret;
    
    a0.blocknum = 1;
    a0.blocktype[0] = 3;
    
    a1.blocknum = 6;
    a1.blocktype[0] = 23;
    a1.blocktype[1] = 3;
    a1.blocktype[2] = 12;
    a1.blocktype[3] = 23;
    a1.blocktype[4] = 3;
    a1.blocktype[5] = 27;

    a2.blocknum = 16;
    a2.blocktype[0] = 213;
    a2.blocktype[1] = 31;
    a2.blocktype[2] = 112;
    a2.blocktype[3] = 4;
    a2.blocktype[4] = 71;
    a2.blocktype[5] = 1;
    a2.blocktype[6] = 32;
    a2.blocktype[7] = 123;
    a2.blocktype[8] = 13;
    a2.blocktype[9] = 21;
    a2.blocktype[10] = 12;
    a2.blocktype[11] = 1;
    a2.blocktype[12] = 34;
    a2.blocktype[13] = 9;
    a2.blocktype[14] = 12;
    a2.blocktype[15] = 14;
    
    a3.blocknum = 3;
    a3.blocktype[0] = 18;
    a3.blocktype[1] = 10;
    a3.blocktype[2] = 31;
    
    a4.blocknum = 4;
    a4.blocktype[0] = 220;
    a4.blocktype[1] = 22;
    a4.blocktype[2] = 1;
    a4.blocktype[3] = 0;
    
    a5.blocknum = 0;
    
    sort(a0.blocktype, a0.blocknum);
    sort(a1.blocktype, a1.blocknum);
    sort(a2.blocktype, a2.blocknum);
    sort(a3.blocktype, a3.blocknum);
    sort(a4.blocktype, a4.blocknum);
    sort(a5.blocktype, a5.blocknum);
    
    
    ret = co_block_type_code(&b1.node_list, &a0);
	print_status(ret);
    printf("array a0 is :  ");
    print_a(a0);
    printf("after insert a0 is:  ");
    print(b1.node_list);
    
    
    ret = co_block_type_code(&b1.node_list, &a1);
	print_status(ret);
    printf("array a1 is :  ");
    print_a(a1);
    printf("after insert a1 is:  ");
    print(b1.node_list);

    
    
    ret = co_block_type_code(&b1.node_list, &a2);
	print_status(ret);
    printf("array a2 is :  ");
    print_a(a2);
    printf("after insert a2 is:  ");
    print(b1.node_list);
    
    
    ret = co_block_type_code(&b1.node_list, &a3);
    print_status(ret);
    printf("array a3 is :  ");
    print_a(a3);
    printf("after insert a3 is:  ");
    print(b1.node_list);
    
    
    ret = co_block_type_code(&b1.node_list, &a4);
    print_status(ret);
    printf("array a4 is :  ");
    print_a(a4);
    printf("after insert a4 is:  ");
    print(b1.node_list);
    
    
    ret = co_block_type_code(&b1.node_list, &a5);
    print_status(ret);
    printf("array a5 is :  ");
    print_a(a5);
    printf("after insert a5 is:  ");
    print(b1.node_list);
    
    free_all(&b1);
}

结果：
list is changed!
array a0 is :  3,
after insert a0 is:  3->

list is changed!
array a1 is :  3,3,12,23,23,27,
after insert a1 is:  3->12->23->27->

list is changed!
array a2 is :  1,1,4,9,12,12,13,14,21,31,32,34,71,112,123,213,
after insert a2 is:  1->3->4->9->12->13->14->21->23->27->31->32->34->71->112->123->213->

list is changed!
array a3 is :  10,18,31,
after insert a3 is:  1->3->4->9->10->12->13->14->18->21->23->27->31->32->34->71->112->123->213->

list is changed!
array a4 is :  0,1,22,220,
after insert a4 is:  0->1->3->4->9->10->12->13->14->18->21->22->23->27->31->32->34->71->112->123->213->220->

list is not changed!
array a5 is :  
after insert a5 is:  0->1->3->4->9->10->12->13->14->18->21->22->23->27->31->32->34->71->112->123->213->220->
黑黍
关注
专栏目录
将两个数组中的元素有序存入到一个链表中（C语言）
前端产品工程师
01-18 1876
思路： 1、现将数组元素排序 2、再将数组中的元素分别存入链表中 3、合并两个链表 代码实现： #include #include #include #define N 10 typedef struct LNode { int key; struct LNode*next; } LNode; void printList(LNode *head)
C 语言 将数组传到单链表中
salt4172的专栏
11-19 3545
# include # include # include struct chain {         int data;         struct chain *next; }; struct chain *create(int n,int *a) {         int i;         struct chain *head ,*rear,*p;  
数组实现链表及插入
weixin_30475039的博客
09-27 513
自定义node结构体，实现简单的链表初始化及插入操作 #include <iostream> using namespace std; struct node { int data; struct node *next; }; int main () { struct node *head, *p, *q, *t; int n; //the total number yo...
java怎么把数组存到单链表_java存储元素，两种设计方式，一种是数组；一种是链表（联络网）...
weixin_42360237的博客
02-27 1606
方式一、数组；数组默认长度；存放数据的数组；有效元素个数；add、remove、get、size；add；需要考虑数据长度>=size+1? 不大的话，需要扩容；扩容后，需要将原数组数据移到新数组；size++remove；索引是否合理？不合理的话，抛出异常，中断程序；合理的话，从索引+1处左移元素；原数组最后一位有效元素置为空；(int类型默认为0)；size--get;索引是否合理？不合...
无序列表的链表实现
kaakllhjkhjalv的博客
12-24 969
无序列表是一个没有特定顺序的列表项的集合，其特点为数据的排列不具有顺序性。无序表 List 的操作定义如下： List()：创建一个新的空列表。它不需要参数，并返回一个空列表。 add(item)：向列表中添加一个新项。它需要 item 作为参数，并不返回任何内容（假定该 item 不在列表中）。 remove(item)：从列表中删除该项。它需要 item 作为参数并修改列表（假设项存在于列表中）。 search(item)：搜索列表中的项目。它需要 item 作为参数，并返回一个布尔值。 isEmpty
LeetCode-04：实现链表的插入排序
qq_46993700的博客
08-11 1318
题目 使用插入排序对链表进行排序。 Sort a linked list using insertion sort. 输入 {3,2,4} 输出 {2,3,4} 思路 若要使得时间复杂度为O(nlogn)，常用排序算法有归并算法，但常用归并算法采用了递归的形式，因此此题解法暂时无法满足空间复杂度为常数的条件。 关键点： 1、题干给出的数据结构为链表，注意理清链表中结点的链接变换关系。如node.next=node与node=node.next之间的差异，前者意为将node的指针指向node，后者意为
优先队列实现探索：无序数组与有序数组方法
除了数组实现，优先队列还可以通过有序链表、二叉搜索树（BST）或者堆来实现。堆是一种特殊的完全二叉树，满足父节点的值小于或等于其子节点的值（最大堆）或大于或等于子节点的值（最小堆），这使得根节点始终是...
[数据结构]数组与链表的优缺点和区别 数组和链表.pdf
04-18
按值查找，无序数组和链表均为O(n)，有序数组可采用折半查找，时间复杂度降为O(logn)。 5. 插入和删除：数组平均需移动n/2个元素，链表只需修改指针。 6. 空间分配：数组受静态分配限制，动态分配可能导致效率下降；...
C++:数组、链表与哈希表
sinat_40628756的博客
12-04 2683
自我介绍一下个人情况：我对C++属于初学者，没有做过C++写的项目，只在菜鸟教程粗略过了一遍C++的基本概念。我刷题准备用的是C++语言，打算分类刷题，每次刷题前我都会补习相应的C++知识，顺便在此记录。 文章目录数组和链表数组什么是数组？访问数组元素可变长的动态数组：vectorVector基本用法链表什么是链表？链表的操作双向链表（list）list的成员函数总结 数组和链表 C++的数组和链表分别是什么？分别有什么种类？它们都有什么特性？针对这些特征，使用情形是什么？ 数组 什么是数组？
用数组实现3种类型的线性表(有序链表、无序链表、索引链表)
ThinkCode的专栏
07-15 1851
分别实现3种类型的链表，这一篇用数组来实现线性表--- 有序链表：链表元素或节点始终保持有序，链表元素为Comparable对象，主要体现在插入操作要插入在相应的序列位置 无序链表：无序，每次指定插入在哪（表头，尾，or指定元素之后） 索引链表：提供了许多与索引相关的操作 将三种实现的都有的公共操作定义在一个接口ADT中，对应于各自特征所特有的操作扩展在自己
用数组方式实现的链表
qq_16038625的博客
04-26 4719
链表是一种常用的线性表，可以快捷的进行插入和删除。但在常规的做法中，这些操作需要有动态内存分配的支持。偏偏有些编程环境，想要动态内存分配的话，需要额外添加一些库文件，比较繁琐。如何在没有动态内存分配函数的情况下，实现链表的随机删除和插入特性呢？ 首先，定义一个链表的节点。 typedef struct Node { } ...
将两个无序数组合并为有序链表
陆小小的专栏
10-19 6389
实现思想：把两个无序的数组首先排序，然后再按照链表结构把它们分别构造好，然后再把两个有序链表合并。int const array1_size = 5;//数组1的长度int const array2_size = 7;//数组2的长度//链表结构体typedef struct ListNode{ int data; ListNode * next;}ListNode;//合并两个有
2021/5/11 c语言---数据结构 将数组元素用链表存储
m0_52336986的博客
05-15 1244
头插法 #include<stdio.h> #include<stdlib.h> typedef struct node{ int data; struct node *next; }Node; int main(){ Node *head, *p; int i,n; //输入数组的元素个数 scanf("%d", &n); //创建对应个数的数组 int arr[n]; //输入每个数组元素 for(i = 0; i < n; i++){
数组实现链表
最新发布
自学嵌入式
12-22 480
再看《深入理解C指针》第一页的时候，就看到说可以用数组实现链表，这么牛逼，看来一下他的示意图，直接干。然后写完链表的插入，擦除，显示链表，回过神来一想，这不是脱裤子放屁吗。我数组都已经知道元素关系了，还在内部添加元素之间的关系（插入的时候）。我可以遍历数组，却还用链表的思路遍历（删除的时候）。本以为这种链表会像数组队列一样在单片机中大放异彩，但是思来想去似乎找不到应用场景。我就先做个记录吧，也许有一天能够用到。 运行结果： 最后12没打印出来，实际是链表满了
用数组+链表实现哈希表
ALi的博客
11-21 885
代码地址https://gitee.com/ALi_L/javaDataStructurs.git目录 思路 图解如下 各个代码 整体代码 思路 用链表来存储数据；Emp 用数组来存放一个一个的链表；EmpLinkedList 再用一个类来管理数组。HashTab 图解如下 各个代码 1.节点Emp class Emp { private int id; private String name; public Emp next; public..
【数据结构】（双链表）无序数组正序创建链表，插入排序
C_xixixixi的博客
01-11 278
#include #include using namespace std; // 结点的定义 typedef struct DLNode{ int data; struct DLNode* prior; struct DLNode* next; }DLNode; // 初始化循环双链表 //void initLinklist(DLNode *&S) //{ // S = (DLNode...
LeetCode-学会对无序链表进行插入排序(详解)
qq_53505979的博客
04-17 697
目录前言一、对无序链表进行插入排序题链接题目描述题目思路代码1代码2总结 前言 请坐 一、对无序链表进行插入排序题链接 题目描述 对链表进行插入排序。 插入排序算法： 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。 每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。 重复直到所有输入数据插入完为止。 测试样例1： 输入: 4->2->1->3 输出: 1->2->3->4
【数据结构】（单链表）无序数组正序创建链表，插入排序
C_xixixixi的博客
01-11 756
#include #include using namespace std; // 结点的定义 typedef struct LNode{ int data; struct LNode* next; }LNode; // 创建单循环链表 (尾插法) void createLinklist(LNode *&S,int a[],int n) // a?? { LNode *s,*r; /...
【图文详解】数组与链表的插入与读取
qq_51869518的博客
10-26 1221
这是一篇关于数组与链表的插入与读取文章，详细的通过图文结合的方式讲解知识点。通过例子的讲解，简洁易懂，了解并记住数组与链表的插入与读取的优劣对比。只需要这一篇文章就够了。如果看完对你有所帮助，希望你能动动你的小手，点个赞，点个收藏，点个关注支持一下。因为你的支持就是我创作的动力！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值