C语言数据结构之顺序结构（Sequence）

于 2024-10-10 09:13:57 发布
阅读量326 收藏 3
点赞数 6
分类专栏： 把C语言捡起来 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gwsong52/article/details/142812219
版权

C语言数据结构之顺序结构（Sequence）

简单的顺序结构，通常称之为序列

  • 定义数据结构struct Sequence，用数组来保存数据！！！
  • 结构体成员int *elts，其实是整数数组，只保存整数数据，也只能测试整数！！！
  • 实现基本功能，创建、释放、追加、插入、删除、更改、查找、判断、逐项操作等功能
  • sequence_new 创建
  • sequence_free 释放
  • sequence_is_empty 是否为空
  • sequence_is_full 是否已满
  • sequence_append 追加数据
  • sequence_insert 插入数据
  • sequence_remove 删除数据
  • sequence_set 更改数据
  • sequence_get 获取数据
  • sequence_reverse 倒置序列
  • sequence_foreach 对序列进行逐项操作
  • 我在每个函数前面加了一个mg_做为自己的命名空间标识，namespace很重要！！！
  • C++中的封装，在C语言中基本可以完成，只要实现了上述功能！！！

代码如下：

/* filename: seq.c */
#include <stdio.h>
#include <stdlib.h>

/* compile : gcc seq.c -o seq
       run : ./seq              */

/**/
#define SSIZE 32

/* function pointer with int arg and without return */
typedef void (*MgFunc) (int val);

/* define Sequence datatype */
typedef struct _Sequence Sequence;
struct _Sequence {
  int *elts;   //elements
  int size;    //size
  int maxsize; //maxsize
};

/* create a new sequence */
Sequence *
mg_sequence_new (void)
{
  Sequence *seq = (Sequence*) malloc (sizeof(Sequence));
  seq->size = 0; seq->maxsize = SSIZE;
  seq->elts = (int*) malloc (seq->maxsize * sizeof(int));
  return seq;
}

/* free the sequence */
void
mg_sequence_free (Sequence *seq)
{
  free (seq->elts);
  free (seq);
}

/* sequence is empty return 1 else return 0 */
int
mg_sequence_is_empty (Sequence *seq)
{
  if (seq->size == 0) return 1;
  return 0;
}

/* sequence is full return 1 else return 0 */
int
mg_sequence_is_full (Sequence *seq)
{
  if (seq->size == seq->maxsize) return 1;
  return 0;
}

/* append a val into sequence */
void
mg_sequence_append (Sequence *seq, int val)
{
  seq->elts[seq->size] = val;
  seq->size = seq->size + 1;
  if (seq->size >= seq->maxsize)
    printf ("Warnning: Sequence is full!\n");
}

/* insert a val at idx into sequence */
void
mg_sequence_insert (Sequence *seq, int idx, int val)
{
  for (int i = seq->size - 1; i >= idx; i--)
    seq->elts[i+1] = seq->elts[i];
  seq->elts[idx] = val;
  seq->size = seq->size + 1;
}

/* set a val at idx of sequence */
void
mg_sequence_set (Sequence *seq, int idx, int val)
{
  seq->elts[idx] = val;
}

/* remove a val at idx of sequence */
void
mg_sequence_remove (Sequence *seq, int idx)
{
  for (int i = idx; i <= seq->size; i++)
    seq->elts[i] = seq->elts[i+1];
  seq->size = seq->size - 1;
}

/* get a val at idx of sequence */
int
mg_sequence_get (Sequence *seq, int idx)
{
  return seq->elts[idx];
}

/* reverse the sequence */
void
mg_sequence_reverse (Sequence *seq)
{
  for (int i = 0, j = seq->size - 1; i < seq->size / 2; i++, j--)
    {
      int tmp = seq->elts[i];
      seq->elts[i] = seq->elts[j];
      seq->elts[j] = tmp;
    }
}

/* call mgfunc on each element */
void
mg_sequence_foreach (Sequence *seq, MgFunc mgfunc)
{
  for (int i = 0; i < seq->size; i++)
    mgfunc (seq->elts[i]);
}

/* ---------------------------------------- */

/* define function for MgFunc */
void
out_integer (int val)
{
  printf ("%d ", val);
}

/**/
int
main (int argc, char *argv[])
{
  Sequence *seq = mg_sequence_new ();

  for (int i = 0; i < 10; i++)
    mg_sequence_append (seq, i + 1000);

  printf ("Test sequence new, append, foreach method:\n");
  mg_sequence_foreach (seq, out_integer);

  printf ("\nTest sequence insert method:\n");
  mg_sequence_insert (seq, 5, 8888);
  mg_sequence_foreach (seq, out_integer);

  printf ("\nTest sequence reverse method:\n");
  mg_sequence_reverse (seq);
  mg_sequence_foreach (seq, out_integer);

  printf ("\nTest sequece remove method:\n");
  mg_sequence_remove (seq, 5);
  mg_sequence_foreach (seq, out_integer);
  printf ("\n");

  mg_sequence_free (seq);
  return 0;
}
/* -----(:/.^.\:)-----*/

编译运行，结果如下：

songvm@ubuntu:~/works/xdn/soo$ gcc seq.c -o seq
songvm@ubuntu:~/works/xdn/soo$ ./seq
Test sequence new, append, foreach method:
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 
Test sequence insert method:
1000 1001 1002 1003 1004 8888 1005 1006 1007 1008 1009 
Test sequence reverse method:
1009 1008 1007 1006 1005 8888 1004 1003 1002 1001 1000 
Test sequece remove method:
1009 1008 1007 1006 1005 1004 1003 1002 1001 1000
  • 基本完成了上述功能，并通过测试！！！
  • 注意：没有对出错情况做限制！！！

将功能扩展一下，让序列可以保存更多的数据类型

  • 上面的序列只能保存整型数据，完全可以将其改造成保存多种类型数据，就是用void*替换原来的int！！！
  • 因为void*和long的sizeof值都是8字节，所以既可以保存指针类型数据也可以保存长整型数据！！！
  • 而double的sizeof值也是8字节，所以还可以保存浮点型数据！！！
  • C++中的多态就是这么做的吧？！？
  • 不在限制数组的长度，理论上可以无限制分配内存，事实上要根据使用场合来做出限制！！！

代码如下：

/* filename: seqv.c */
#include <stdio.h>
#include <stdlib.h>

/* compile : gcc seqv.c -o seqv
       run : ./seqv              */

/**/
#define SPSIZE 8

/* function pointer with void* arg and without return */
typedef void (*MgFunc) (void *val);

/* define Sequence datatype */
typedef struct _Sequence Sequence;
struct _Sequence {
  int size;     //size
  int ps;       //page size
  void **elts;  //elements
};

/* create a new sequence */
Sequence *
mg_sequence_new (void)
{
  Sequence *seq = (Sequence*) malloc (sizeof(Sequence));
  seq->size = 0; seq->ps = 1;
  seq->elts = (void**) malloc (seq->ps * SPSIZE * sizeof(void*));
  for (int i = 0; i < SPSIZE; i++)
    seq->elts[i] = NULL;
  return seq;
}

/* free every elements */
void
mg_sequence_free_elements (Sequence *seq)
{
  for (int i = 0; i < seq->size; i++)
    free (seq->elts[i]);
}

/* free the sequence */
void
mg_sequence_free (Sequence *seq)
{
  free (seq->elts);
  free (seq);
}

/* sequence is empty return 1 else return 0 */
int
mg_sequence_is_empty (Sequence *seq)
{
  if (seq->size == 0) return 1;
  return 0;
}

/* sequence is full return 1 else return 0 */
/*int
mg_sequence_is_full (Sequence *seq)
{
  if (seq->size == seq->maxsize) return 1;
  return 0;
}
*/

/* */
int
mg_sequence_size (Sequence *seq)
{
  return seq->size;
}

/* append a val into sequence */
void
mg_sequence_append (Sequence *seq, void *val)
{
  seq->elts[seq->size] = val;
  seq->size = seq->size + 1;
  if (seq->size == seq->ps * SPSIZE)
    {
      seq->ps = seq->ps + 1;
      seq->elts = realloc (seq->elts, seq->ps * SPSIZE * sizeof(void*));
    }
}

/* insert a val at idx into sequence */
void
mg_sequence_insert (Sequence *seq, int idx, void *val)
{
  for (int i = seq->size - 1; i >= idx; i--)
    seq->elts[i+1] = seq->elts[i];
  seq->elts[idx] = val;
  seq->size = seq->size + 1;
}

/* set a val at idx of sequence */
void
mg_sequence_set (Sequence *seq, int idx, void *val)
{
  seq->elts[idx] = val;
}

/* remove a val at idx of sequence */
void
mg_sequence_remove (Sequence *seq, int idx)
{
  for (int i = idx; i <= seq->size; i++)
    seq->elts[i] = seq->elts[i+1];
  seq->size = seq->size - 1;
}

/* get a val at idx of sequence */
void *
mg_sequence_get (Sequence *seq, int idx)
{
  return seq->elts[idx];
}

/* reverse the sequence */
void
mg_sequence_reverse (Sequence *seq)
{
  for (int i = 0, j = seq->size - 1; i < seq->size / 2; i++, j--)
    {
      void *tmp = seq->elts[i];
      seq->elts[i] = seq->elts[j];
      seq->elts[j] = tmp;
    }
}

/* call mgfunc on each element */
void
mg_sequence_foreach (Sequence *seq, MgFunc mgfunc)
{
  for (int i = 0; i < seq->size; i++)
    mgfunc (seq->elts[i]);
}

/* ---------------------------------------- */

/* define function for MgFunc */
void
out_longint (void *val)
{
  printf ("%ld ", (long)(val));
}

/**/
void
test_sequence_longint (void)
{
  Sequence *seq = mg_sequence_new ();

  for (long i = 0; i < 10; i++)
    mg_sequence_append (seq, (void*)(i + 1000));

  printf ("Test sequence new, append, foreach method:\n");
  mg_sequence_foreach (seq, out_longint);

  printf ("\nTest sequence insert method:\n");
  mg_sequence_insert (seq, 5, (void*)(8888));
  mg_sequence_foreach (seq, out_longint);

  printf ("\nTest sequence reverse method:\n");
  mg_sequence_reverse (seq);
  mg_sequence_foreach (seq, out_longint);

  printf ("\nTest sequence remove method:\n");
  mg_sequence_remove (seq, 5);
  mg_sequence_foreach (seq, out_longint);

  printf ("\nSequence page size : %d\n", SPSIZE);
  printf ("Sequence size : %d\n", seq->size);
  printf ("Sequence page : %d\n", seq->ps);

  printf ("Sequence val at index 9 is %ld\n", (long)mg_sequence_get(seq, 9));

  mg_sequence_free (seq);
}

/*
void
out_string (void *val)
{
  printf ("%s ", (char*)val);
}

//
void
test_sequence_string (void)
{
  char *buff[6] = {"Not", "Only", "Test", "Here", "Another", "Behind"};
  Sequence *seq = mg_sequence_new ();
  for (int i = 0; i < 6; i++)
    mg_sequence_append (seq, buff[i]);
  mg_sequence_foreach(seq, out_string);
  printf ("\n");
  mg_sequence_free (seq);
}

//
void
test_sequence_string_malloc (void)
{
  Sequence *seq = mg_sequence_new ();

  for (int i = 1000; i < 1010; i++)
    {
      char *buf = (char*) malloc (16);
      sprintf (buf, "demo-%d", i);
      mg_sequence_append (seq, buf);
    }

  mg_sequence_foreach(seq, out_string);
  printf ("\n");

  mg_sequence_free_elements (seq);
  mg_sequence_free (seq);
}
*/

/**/
int
main (int argc, char *argv[])
{
  test_sequence_longint ();
  //test_sequence_string ();
  //test_sequence_string_malloc ();
  return 0;
}
/* -----(:/.^.\:)-----*/

编译运行，结果如下：

songvm@ubuntu:~/works/xdn/soo$ gcc seqv.c -o seqv
songvm@ubuntu:~/works/xdn/soo$ ./seqv
Test sequence new, append, foreach method:
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 
Test sequence insert method:
1000 1001 1002 1003 1004 8888 1005 1006 1007 1008 1009 
Test sequence reverse method:
1009 1008 1007 1006 1005 8888 1004 1003 1002 1001 1000 
Test sequence remove method:
1009 1008 1007 1006 1005 1004 1003 1002 1001 1000 
Sequence page size : 8
Sequence size : 10
Sequence page : 2
Sequence val at index 9 is 1000
songvm@ubuntu:~/works/xdn/soo$

再测试一下序列中保存字符串

  • 将上面代码中的注释去掉
  • sprintf 函数，用printf格式将内容输出到字符串中

代码如下：

/* filename: seqv.c */
#include <stdio.h>
#include <stdlib.h>

/* compile : gcc seqv.c -o seqv
       run : ./seqv              */

/* Sequence page size */
#define SPSIZE 8

/* function pointer with void* arg and without return */
typedef void (*MgFunc) (void *val);

/* define Sequence datatype */
typedef struct _Sequence Sequence;
struct _Sequence {
  int size;     //size
  int ps;       //page size
  void **elts;  //elements
};

/* create a new sequence */
Sequence *
mg_sequence_new (void)
{
  Sequence *seq = (Sequence*) malloc (sizeof(Sequence));
  seq->size = 0; seq->ps = 1;
  seq->elts = (void**) malloc (seq->ps * SPSIZE * sizeof(void*));
  for (int i = 0; i < SPSIZE; i++)
    seq->elts[i] = NULL;
  return seq;
}

/* free every elements */
void
mg_sequence_free_elements (Sequence *seq)
{
  for (int i = 0; i < seq->size; i++)
    free (seq->elts[i]);
}

/* free the sequence */
void
mg_sequence_free (Sequence *seq)
{
  free (seq->elts);
  free (seq);
}

/* sequence is empty return 1 else return 0 */
int
mg_sequence_is_empty (Sequence *seq)
{
  if (seq->size == 0) return 1;
  return 0;
}

/* sequence is full return 1 else return 0 */
/*int
mg_sequence_is_full (Sequence *seq)
{
  if (seq->size == seq->maxsize) return 1;
  return 0;
}
*/

/* */
int
mg_sequence_size (Sequence *seq)
{
  return seq->size;
}

/* append a val into sequence */
void
mg_sequence_append (Sequence *seq, void *val)
{
  seq->elts[seq->size] = val;
  seq->size = seq->size + 1;
  if (seq->size == seq->ps * SPSIZE)
    {
      seq->ps = seq->ps + 1;
      seq->elts = realloc (seq->elts, seq->ps * SPSIZE * sizeof(void*));
    }
}

/* insert a val at idx into sequence */
void
mg_sequence_insert (Sequence *seq, int idx, void *val)
{
  for (int i = seq->size - 1; i >= idx; i--)
    seq->elts[i+1] = seq->elts[i];
  seq->elts[idx] = val;
  seq->size = seq->size + 1;
}

/* set a val at idx of sequence */
void
mg_sequence_set (Sequence *seq, int idx, void *val)
{
  seq->elts[idx] = val;
}

/* remove a val at idx of sequence */
void
mg_sequence_remove (Sequence *seq, int idx)
{
  for (int i = idx; i <= seq->size; i++)
    seq->elts[i] = seq->elts[i+1];
  seq->size = seq->size - 1;
}

/* get a val at idx of sequence */
void *
mg_sequence_get (Sequence *seq, int idx)
{
  return seq->elts[idx];
}

/* reverse the sequence */
void
mg_sequence_reverse (Sequence *seq)
{
  for (int i = 0, j = seq->size - 1; i < seq->size / 2; i++, j--)
    {
      void *tmp = seq->elts[i];
      seq->elts[i] = seq->elts[j];
      seq->elts[j] = tmp;
    }
}

/* call mgfunc on each element */
void
mg_sequence_foreach (Sequence *seq, MgFunc mgfunc)
{
  for (int i = 0; i < seq->size; i++)
    mgfunc (seq->elts[i]);
}

/* ---------------------------------------- */

/* define function for MgFunc to output long int */
void
out_longint (void *val)
{
  printf ("%ld ", (long)(val));
}

/**/
void
test_sequence_longint (void)
{
  Sequence *seq = mg_sequence_new ();

  for (long i = 0; i < 10; i++)
    mg_sequence_append (seq, (void*)(i + 1000));

  printf ("Test sequence new, append, foreach method:\n");
  mg_sequence_foreach (seq, out_longint);

  printf ("\nTest sequence insert method:\n");
  mg_sequence_insert (seq, 5, (void*)(8888));
  mg_sequence_foreach (seq, out_longint);

  printf ("\nTest sequence reverse method:\n");
  mg_sequence_reverse (seq);
  mg_sequence_foreach (seq, out_longint);

  printf ("\nTest sequence remove method:\n");
  mg_sequence_remove (seq, 5);
  mg_sequence_foreach (seq, out_longint);

  printf ("\nSequence page size : %d\n", SPSIZE);
  printf ("Sequence size : %d\n", seq->size);
  printf ("Sequence page : %d\n", seq->ps);

  printf ("Sequence val at index 9 is %ld\n", (long)mg_sequence_get(seq, 9));

  mg_sequence_free (seq);
}

/* define function for MgFunc to output char* */
void
out_string (void *val)
{
  printf ("%s ", (char*)val);
}

/* */
void
test_sequence_string (void)
{
  char *buff[6] = {"Not", "Only", "Test", "Here", "Another", "Behind"};
  Sequence *seq = mg_sequence_new ();
  for (int i = 0; i < 6; i++)
    mg_sequence_append (seq, buff[i]);
  mg_sequence_foreach(seq, out_string);
  printf ("\n");
  mg_sequence_free (seq);
}

/* */
void
test_sequence_string_malloc (void)
{
  Sequence *seq = mg_sequence_new ();

  for (int i = 1000; i < 1010; i++)
    {
      char *buf = (char*) malloc (16);
      sprintf (buf, "demo-%d", i);
      mg_sequence_append (seq, buf);
    }

  mg_sequence_foreach(seq, out_string);
  printf ("\n");

  mg_sequence_free_elements (seq);
  mg_sequence_free (seq);
}

/**/
int
main (int argc, char *argv[])
{
  //test_sequence_longint ();
  test_sequence_string ();
  test_sequence_string_malloc ();
  return 0;
}
/* -----(:/.^.\:)-----*/

编译运行，结果如下：

songvm@ubuntu:~/works/xdn/soo$ gcc seqv.c -o seqv
songvm@ubuntu:~/works/xdn/soo$ ./seqv
Not Only Test Here Another Behind 
demo-1000 demo-1001 demo-1002 demo-1003 demo-1004 demo-1005 demo-1006 demo-1007 demo-1008 demo-1009 
songvm@ubuntu:~/works/xdn/soo$ valgrind --leak-check=yes ./seqv
==10181== Memcheck, a memory error detector
==10181== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==10181== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==10181== Command: ./seqv
==10181== 
Not Only Test Here Another Behind 
demo-1000 demo-1001 demo-1002 demo-1003 demo-1004 demo-1005 demo-1006 demo-1007 demo-1008 demo-1009 
==10181== 
==10181== HEAP SUMMARY:
==10181==     in use at exit: 0 bytes in 0 blocks
==10181==   total heap usage: 16 allocs, 16 frees, 1,472 bytes allocated
==10181== 
==10181== All heap blocks were freed -- no leaks are possible
==10181== 
==10181== For counts of detected and suppressed errors, rerun with: -v
==10181== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
songvm@ubuntu:~/works/xdn/soo$

结果如预期！下一步研究字符串！！！

麻瓜老宋
关注
专栏目录
数据结构笔记(C语言版)
去无人的岛，摸鲨鱼的角
09-20 5763
personal note
C语言数据结构知识点小结(全）
热门推荐
Shen Mu Xin's Blog
07-14 4万+
C语言数据结构小结，B站青岛大学-王卓授课笔记
C语言数据结构：线性表！
qq_42319810的博客
06-12 4673
线性表是具有相同(每个元素所占空间一样大)数据类型的 n（n>=0）个数据元素的有限序列（有次序），其中 n 为表长，当 n = 0 时，线性表是一个空表。若用 L 命名线性表。则一般表示为相关概念：1、ai 是线性表中的 “第 i 个” 元素线性表中的位序注意：位序从 1 开始，但是数组下标从 0 开始。2、a1 是表头元素；an 是表尾元素。3、除了第一个元素外，每个元素有且仅有一个直接前驱；4、除去最后一个元素外，每个元素有且仅有一个直接后继。顺序表。
【数据结构】顺序表（C语言）
weixin_44358957的博客
03-06 1730
数据结构，顺序表（C语言，带注释）
C语言数据结构——顺序表结构及算法
heihutaotie的博客
06-29 462
C语言数据结构——顺序表 #include<stdio.h>// 引入头文件 #define ListSize 100//定义表长为100 typedef int DataType;//定义一种int类型的类型符DataType typedef struct{ //定义一种结构体类型 DataType Data[ListSize];//定义一种int类型的数组，长度为100 int length;//定义长度 }SeqList;//新定义的结构类型名为SeqList void Ini
C语言 基本数据结构实现
小鹏AI
12-04 904
本文包含数据结构的实现如下顺序表定义顺序表 初始化顺序表,建立顺序表,判断是否为空,求顺序表长度,遍历操作...
【数据结构-C语言】顺序表
sakura0908的博客
03-02 231
对于一组拥有n个数据元素的线性表，其严格数学定义是：其中任何一个数据元素a(i)​，有且仅有一个直接前驱a(i-1)，有且仅有一个直接后继a(i+1)。首元素a0无直接前驱，尾元素a(n-1)无直接后继。 满足这种数学关系的一组数据，当中的数据是一个挨着一个的，常被称为一对一关系。反之，如果数据之间的关系不是一对一的，就是非线性的。
数据结构-顺序表操作
weixin_67273669的博客
03-30 487
创建一个空的顺序表，然后对顺序表进行插入数据，删除数据，遍历输出，查找数据等操作。
【数据结构|C语言版】顺序表
2302_80269373的博客
04-10 957
各位小伙伴大家好！时隔不久，小编来给大家讲解一下单链表的相关知识。}SLTNode;//创建一个结点//销毁单链表//单链表头插//单链表尾插//单链表头删//单链表尾删//单链表结点查找//单链表结点删除(删除pos位置的结点)//单链表结点插入(在pos之前插入)// 单链表结点插入(在pos之后插入)// 单链表结点修改//打印单链表。
【 数据结构 】顺序表的实现 - 详解（C语言版）
上上谦. 的博客
03-13 8183
目录 前言 线性表： ​ 顺序表： 概念及结构： 顺序表的实现： 头文件：SeqList.h realloc函数讲解： 具体函数的实现：SeqList.c 顺序表的初始化： 顺序表的打印： 容量的检查： 顺序表的尾插： 顺序表的尾删： 顺序表的头插： 顺序表的头删： 在顺序表的指定位置插入数据： 在顺序表的指定位置删除数据： 顺序表的查找： 顺序表的修改： 顺序表的销毁： 数组越界的检查： 前言 简单用C语言来描述数据结构中的顺序表......
数据结构c语言版 顺序表部分代码
03-06
在本资源中，我们关注的是数据结构的一种基础形式——顺序表，它是用C语言实现的。顺序表是将元素在内存中连续存放的数据结构，其操作简单直观，但对内存空间的需求较高。 `main.cpp` 是主程序文件，它包含了调用...
c语言八大数据结构有哪些,数据结构自学笔记(C语言)基本概念及顺序线性表
weixin_30672649的博客
05-18 1666
程序员等于数据结构加算法，之前对数据结构有一定程度的了解，但是想成为一名程序员，这点了解还远远不够，所以决定从头系统的学习一遍数据结构。在选择语言上也纠结了一段时间，现在在高级语言太多了，Python、C++ 、Java，都考虑过，但在知乎上看见一些大牛说的很有道理，高级语言之所以高级，就是把很多底层的东西替你做好了，你只有用最原始最低级的C语言去学数据结构才能真正的体会到数据结构底层的东西，所以...
C语言数据结构顺序表的实现
09-25
在C语言中，顺序表是一种基础的数据结构，通常通过数组的方式实现。它存储元素的方式是连续的内存空间，可以按照索引直接访问每个元素。下面是一个简单的顺序表实现： ```c #include #include // 定义顺序表...
Java：数据结构-ArrayList和顺序表（2）
blamep的博客
10-09 407
创建一个空的ArrayList，指定容量为initialCapacity。
深入理解 C# 中的集合与数据结构
qq_45728381的博客
10-02 1379
在日常开发中，集合与数据结构是处理数据的基础工具。C# 提供了一系列强大而灵活的集合类型，帮助我们存储、访问和管理数据。这篇文章将带你了解 C# 中常用的数组、列表、字典、队列、栈、集合和链表的特性和用法。
（JAVA）浅入数据结构 “堆” - 实现和理论
ZunXin_2580的博客
10-09 416
在树结构上做出一部分改变的堆结构，是如何实现的呢？强烈建议初学者来看一看噢~！
数据结构篇（绪论）
wlcass zhengge blog
10-05 828
字符类型：char布尔类型：boolean数值类型：byte、short、int、long、float、double。如果系统自定义的数据类型不够，可以自定义数据类型。例如：Person、Animal、. . .算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令。算法代表着用系统的方法描述解决问题的策略机制。
数据结构森林的遍历（先序遍历和中序遍历）C语言代码
2305_78057683的博客
10-09 82
【代码】数据结构森林的遍历（先序遍历和中序遍历）C语言代码。
嵌入式面试——C语言和数据结构篇（二）
最新发布
yxun403的博客
10-09 1267
在C语言中，关键字static有三个明显的作用： 1>在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 2>在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。 3>在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值