c语言常用数据结构有哪几种,C语言实现常用数据结构（一）

最新推荐文章于 2023-05-25 16:21:37 发布
最新推荐文章于 2023-05-25 16:21:37 发布
阅读量810 收藏
点赞数
文章标签： c语言常用数据结构有哪几种

C语言实现常用数据结构

实现了链表，栈、哈希表等

哈希表由数组加链表实现。通过计算key的哈希值，将哈希值转成int类型并与数组长度进行与运算得到数组下标，数组每个元素都是一个链表，默认为NULL。

通过InitHashTable函数得到初始化的哈希表。已实现功能有：添加键值、删除键值、根据键获取值，清理所有键值对、回收哈希表，可以根据例子遍历键值。

Key可以扩展为任何类型，但需要实现相应类型HashCode的算法，此处只支持字符串类型。

md5.h

#pragma once

#ifndef MD5_H

#define MD5_H

typedef struct

{

unsigned int count[2];

unsigned int state[4];

unsigned char buffer[64];

}MD5_CTX;

#define F(x,y,z) ((x & y) | (~x & z))

#define G(x,y,z) ((x & z) | (y & ~z))

#define H(x,y,z) (x^y^z)

#define I(x,y,z) (y ^ (x | ~z))

#define ROTATE_LEFT(x,n) ((x << n) | (x >> (32-n)))

#define FF(a,b,c,d,x,s,ac) \

{ \

a += F(b,c,d) + x + ac; \

a = ROTATE_LEFT(a,s); \

a += b; \

}

#define GG(a,b,c,d,x,s,ac) \

{ \

a += G(b,c,d) + x + ac; \

a = ROTATE_LEFT(a,s); \

a += b; \

}

#define HH(a,b,c,d,x,s,ac) \

{ \

a += H(b,c,d) + x + ac; \

a = ROTATE_LEFT(a,s); \

a += b; \

}

#define II(a,b,c,d,x,s,ac) \

{ \

a += I(b,c,d) + x + ac; \

a = ROTATE_LEFT(a,s); \

a += b; \

}

void MD5Init(MD5_CTX *context);

void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen);

void MD5Final(MD5_CTX *context, unsigned char digest[16]);

void MD5Transform(unsigned int state[4], unsigned char block[64]);

void MD5Encode(unsigned char *output, unsigned int *input, unsigned int len);

void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len);

#endif

md5.c

#include

#include "md5.h"

unsigned char PADDING[] = { 0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };

void MD5Init(MD5_CTX *context)

{

context->count[0] = 0;

context->count[1] = 0;

context->state[0] = 0x67452301;

context->state[1] = 0xEFCDAB89;

context->state[2] = 0x98BADCFE;

context->state[3] = 0x10325476;

}

void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen)

{

unsigned int i = 0, index = 0, partlen = 0;

index = (context->count[0] >> 3) & 0x3F;

partlen = 64 - index;

context->count[0] += inputlen << 3;

if (context->count[0] < (inputlen << 3))

context->count[1]++;

context->count[1] += inputlen >> 29;

if (inputlen >= partlen)

{

memcpy(&context->buffer[index], input, partlen);

MD5Transform(context->state, context->buffer);

for (i = partlen; i + 64 <= inputlen; i += 64)

MD5Transform(context->state, &input[i]);

index = 0;

}

else

{

i = 0;

}

memcpy(&context->buffer[index], &input[i], inputlen - i);

}

void MD5Final(MD5_CTX *context, unsigned char digest[16])

{

unsigned int index = 0, padlen = 0;

unsigned char bits[8];

index = (context->count[0] >> 3) & 0x3F;

padlen = (index < 56) ? (56 - index) : (120 - index);

MD5Encode(bits, context->count, 8);

MD5Update(context, PADDING, padlen);

MD5Update(context, bits, 8);

MD5Encode(digest, context->state, 16);

}

void MD5Encode(unsigned char *output, unsigned int *input, unsigned int len)

{

unsigned int i = 0, j = 0;

while (j < len)

{

output[j] = input[i] & 0xFF;

output[j + 1] = (input[i] >> 8) & 0xFF;

output[j + 2] = (input[i] >> 16) & 0xFF;

output[j + 3] = (input[i] >> 24) & 0xFF;

i++;

j += 4;

}

}

void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len)

{

unsigned int i = 0, j = 0;

while (j < len)

{

output[i] = (input[j]) |

(input[j + 1] << 8) |

(input[j + 2] << 16) |

(input[j + 3] << 24);

i++;

j += 4;

}

}

void MD5Transform(unsigned int state[4], unsigned char block[64])

{

unsigned int a = state[0];

unsigned int b = state[1];

unsigned int c = state[2];

unsigned int d = state[3];

unsigned int x[64];

MD5Decode(x, block, 64);

FF(a, b, c, d, x[0], 7, 0xd76aa478); /* 1 */

FF(d, a, b, c, x[1], 12, 0xe8c7b756); /* 2 */

FF(c, d, a, b, x[2], 17, 0x242070db); /* 3 */

FF(b, c, d, a, x[3], 22, 0xc1bdceee); /* 4 */

FF(a, b, c, d, x[4], 7, 0xf57c0faf); /* 5 */

FF(d, a, b, c, x[5], 12, 0x4787c62a); /* 6 */

FF(c, d, a, b, x[6], 17, 0xa8304613); /* 7 */

FF(b, c, d, a, x[7], 22, 0xfd469501); /* 8 */

FF(a, b, c, d, x[8], 7, 0x698098d8); /* 9 */

FF(d, a, b, c, x[9], 12, 0x8b44f7af); /* 10 */

FF(c, d, a, b, x[10], 17, 0xffff5bb1); /* 11 */

FF(b, c, d, a, x[11], 22, 0x895cd7be); /* 12 */

FF(a, b, c, d, x[12], 7, 0x6b901122); /* 13 */

FF(d, a, b, c, x[13], 12, 0xfd987193); /* 14 */

FF(c, d, a, b, x[14], 17, 0xa679438e); /* 15 */

FF(b, c, d, a, x[15], 22, 0x49b40821); /* 16 */

/* Round 2 */

GG(a, b, c, d, x[1], 5, 0xf61e2562); /* 17 */

GG(d, a, b, c, x[6], 9, 0xc040b340); /* 18 */

GG(c, d, a, b, x[11], 14, 0x265e5a51); /* 19 */

GG(b, c, d, a, x[0], 20, 0xe9b6c7aa); /* 20 */

GG(a, b, c, d, x[5], 5, 0xd62f105d); /* 21 */

GG(d, a, b, c, x[10], 9, 0x2441453); /* 22 */

GG(c, d, a, b, x[15], 14, 0xd8a1e681); /* 23 */

GG(b, c, d, a, x[4], 20, 0xe7d3fbc8); /* 24 */

GG(a, b, c, d, x[9], 5, 0x21e1cde6); /* 25 */

GG(d, a, b, c, x[14], 9, 0xc33707d6); /* 26 */

GG(c, d, a, b, x[3], 14, 0xf4d50d87); /* 27 */

GG(b, c, d, a, x[8], 20, 0x455a14ed); /* 28 */

GG(a, b, c, d, x[13], 5, 0xa9e3e905); /* 29 */

GG(d, a, b, c, x[2], 9, 0xfcefa3f8); /* 30 */

GG(c, d, a, b, x[7], 14, 0x676f02d9); /* 31 */

GG(b, c, d, a, x[12], 20, 0x8d2a4c8a); /* 32 */

/* Round 3 */

HH(a, b, c, d, x[5], 4, 0xfffa3942); /* 33 */

HH(d, a, b, c, x[8], 11, 0x8771f681); /* 34 */

HH(c, d, a, b, x[11], 16, 0x6d9d6122); /* 35 */

HH(b, c, d, a, x[14], 23, 0xfde5380c); /* 36 */

HH(a, b, c, d, x[1], 4, 0xa4beea44); /* 37 */

HH(d, a, b, c, x[4], 11, 0x4bdecfa9); /* 38 */

HH(c, d, a, b, x[7], 16, 0xf6bb4b60); /* 39 */

HH(b, c, d, a, x[10], 23, 0xbebfbc70); /* 40 */

HH(a, b, c, d, x[13], 4, 0x289b7ec6); /* 41 */

HH(d, a, b, c, x[0], 11, 0xeaa127fa); /* 42 */

HH(c, d, a, b, x[3], 16, 0xd4ef3085); /* 43 */

HH(b, c, d, a, x[6], 23, 0x4881d05); /* 44 */

HH(a, b, c, d, x[9], 4, 0xd9d4d039); /* 45 */

HH(d, a, b, c, x[12], 11, 0xe6db99e5); /* 46 */

HH(c, d, a, b, x[15], 16, 0x1fa27cf8); /* 47 */

HH(b, c, d, a, x[2], 23, 0xc4ac5665); /* 48 */

/* Round 4 */

II(a, b, c, d, x[0], 6, 0xf4292244); /* 49 */

II(d, a, b, c, x[7], 10, 0x432aff97); /* 50 */

II(c, d, a, b, x[14], 15, 0xab9423a7); /* 51 */

II(b, c, d, a, x[5], 21, 0xfc93a039); /* 52 */

II(a, b, c, d, x[12], 6, 0x655b59c3); /* 53 */

II(d, a, b, c, x[3], 10, 0x8f0ccc92); /* 54 */

II(c, d, a, b, x[10], 15, 0xffeff47d); /* 55 */

II(b, c, d, a, x[1], 21, 0x85845dd1); /* 56 */

II(a, b, c, d, x[8], 6, 0x6fa87e4f); /* 57 */

II(d, a, b, c, x[15], 10, 0xfe2ce6e0); /* 58 */

II(c, d, a, b, x[6], 15, 0xa3014314); /* 59 */

II(b, c, d, a, x[13], 21, 0x4e0811a1); /* 60 */

II(a, b, c, d, x[4], 6, 0xf7537e82); /* 61 */

II(d, a, b, c, x[11], 10, 0xbd3af235); /* 62 */

II(c, d, a, b, x[2], 15, 0x2ad7d2bb); /* 63 */

II(b, c, d, a, x[9], 21, 0xeb86d391); /* 64 */

state[0] += a;

state[1] += b;

state[2] += c;

state[3] += d;

}

m_hashtable.h

#pragma once

#ifndef MaxHashTableLength

#include

#define MaxHashTableLength 16

typedef char* Key;

typedef void* Value;

typedef unsigned char byte;

byte* int2byte(int32_t num);

typedef struct HashElem

{

Key key;

Value value;

struct HashElem* next;

int linkLen;

}hash_elem;

typedef struct HashTable

{

hash_elem* data[MaxHashTableLength];

int size;

}hash_table;

unsigned char* GetHashCode(unsigned char* msg);

int GetTableIndex(unsigned char* hash_code);

hash_table* InitHashTable();

void ClearHashTable(hash_table* table);

void DestroyHashTable(hash_table** table);

void RemoveElem(hash_table* table, Key key);

void UpdateValue(hash_table* table, Key key, Value newValue);

hash_elem* GetElem(hash_table* table, Key key);

Value GetValue(hash_table* table, Key key);

#endif

m_hashtable.c

#pragma once

#include "m_hashtable.h"

#include

#include

#include "md5.h"

#include "Util.h";

unsigned char* GetHashCode(unsigned char* encrypt) //MD5加密

{

MD5_CTX md5;

uint8_t * decrypt = malloc(16);

MD5Init(&md5);

MD5Update(&md5, encrypt, strlen(encrypt));

MD5Final(&md5, decrypt);

//for (int i = 0; i < 16; i++) //测试打印

//{

// printf("%02x", decrypt[i]);

//}

//printf("\n");

return decrypt;

}

int GetTableIndex(unsigned char* hash_bytes) //将MD5码转成int，并限制在MaxHashTableLength - 1内

{

int hash_code = byte2int(hash_bytes); //MD5码转int

//sscanf_s(hash_bytes, "%d",hash_code);

return hash_code & (MaxHashTableLength - 1);

}

hash_table * InitHashTable()

{

hash_table* table = (hash_table*)malloc(sizeof(hash_table));

table->size = 0;

for (int i = 0; i < MaxHashTableLength; i++)

{

table->data[i] = NULL; //初始化地址

}

return table;

}

void ClearHashTable(hash_table* table)

{

for (int i = 0; i < MaxHashTableLength; i++)

{

hash_elem* temp = table->data[i];

if (temp == NULL)

{

continue;

}

int linkLen = temp->linkLen;

for (int j = 1; j < linkLen; j++) //回收首节点后续节点

{

hash_elem* node = temp;

hash_elem* pre = node;

for (int k = 1; k < temp->linkLen; k++) //找到倒数第一个节点

{

pre = &(*node);

node = node->next;

}

free(node); //回收最后一个节点内存

pre->next = NULL;

temp->linkLen--; //该条链表长度减一

}

free(temp); //回收该条链表首节点

table->data[i] = NULL;

}

}

void DestroyHashTable(hash_table** table)

{

ClearHashTable(*table);

free(*table);

*table = NULL;

}

void AddElem(hash_table* table, hash_elem * elem)

{

uint8_t* hash_code = GetHashCode(elem->key); //计算key的哈希值

int index = GetTableIndex(hash_code);

if (table->data[index] == NULL) //该节点未有数据，占用首节点

{

table->data[index] = elem;

elem->next = NULL;

elem->linkLen = 1;

}

else

{

hash_elem* origin = table->data[index];

if (m_str_cmp(origin->key, elem->key) == 0)//首节点比较key是否已存在

{

printf("key已存在，key=%s", elem->key);

return;

}

for (int i = 1; i < origin->linkLen; i++) //找到该链表最后一个节点

{

if (m_str_cmp(origin->key, elem->key) == 0)

{

printf("key已存在，key=%s", elem->key);

return;

}

origin = origin->next;

}

origin->next = elem;

elem->next = NULL;

table->data[index]->linkLen++;

}

table->size++;

}

void RemoveElem(hash_table * table, Key key)

{

uint8_t* hash_code = GetHashCode(key);

int index = GetTableIndex(hash_code);

if (table->data[index] == NULL)

{

printf("remove elem error,index=%d is null", index);

return;

}

hash_elem* current = table->data[index];

hash_elem* pre = current;

for (int i = 1; i <= table->data[index]->linkLen; i++)

{

if (m_str_cmp(current->key, key) == 0) //找到键了

{

if (current == pre)

{

table->data[index] = current->next; //首节点移除

int linkLen = current->linkLen; //获取这条链表长度

if (linkLen > 1)

{

table->data[index]->linkLen = linkLen - 1; //链表长度减1

}

else

{

table->data[index] = NULL;

}

free(current);

current = NULL;

}

else if (current->next != NULL) //中间节点移除，连接断续节点

{

pre->next = &(*current->next);

free(current);

current = NULL;

table->data[index]->linkLen--;

}

else

{

pre->next = NULL; //尾节点移除

free(current);

current = NULL;

table->data[index]->linkLen--;

}

table->size--;

return;

}

pre = &(*current);

current = current->next;

}

}

void UpdateValue(hash_table * table, Key key, Value newValue)

{

hash_elem* elem = GetElem(table, key);

if (elem==NULL)

{

printf("update value faild,key=%s is null", key);

return;

}

else

{

elem->value = newValue;

}

}

hash_elem * GetElem(hash_table * table, Key key)

{

uint8_t* hash_code = GetHashCode(key);

int index = GetTableIndex(hash_code);

if (table->data[index] == NULL)

{

printf("get value,index=%d is null", index);

return NULL;

}

hash_elem* current = table->data[index];

for (int i = 1; i <= table->data[index]->linkLen; i++)

{

if (m_str_cmp(current->key, key) == 0)

{

return current;

}

current = current->next;

}

printf("key not find,key=%s", key);

}

Value GetValue(hash_table* table, Key key)

{

hash_elem* elem = GetElem(table, key);

if (elem==NULL)

{

return NULL;

}

else

{

return elem->value;

}

}

int32_t byte2int(byte* bytes)

{

return (int)((((bytes[3] & 0xff) << 24)

| ((bytes[2] & 0xff) << 16)

| ((bytes[1] & 0xff) << 8) | ((bytes[0] & 0xff) << 0)));

}

测试使用

int main()

{

hash_table* table=InitHashTable();

hash_elem* elem = (hash_elem*)malloc(sizeof(hash_elem));

elem->key = "1";

elem->value = "my1";

AddElem(table, elem);

hash_elem* elem2= (hash_elem*)malloc(sizeof(hash_elem));

elem2->key = "2";

elem2->value = "my2";

AddElem(table, elem2);

hash_elem* elem3 = (hash_elem*)malloc(sizeof(hash_elem));

elem3->key = "3";

elem3->value = "my3";

AddElem(table, elem3);

//hash_elem* elem4 = (hash_elem*)malloc(sizeof(hash_elem));

//elem4->key = "asd";

//elem4->value = "my5";

//AddElem(table, elem4);

//RemoveElem(table,“1”);

//RemoveElem(table, "2");

RemoveElem(table, "3");

UpdateValue(table, "1", "hello");

//ClearHashTable(table);

//DestroyHashTable(&table);

if (table==NULL)

{

return;

}

for (int i = 0; i < MaxHashTableLength; i++)

{

hash_elem* temp = table->data[i];

if (temp==NULL)

{

continue;;

}

for (int j = 0; j < table->data[i]->linkLen; j++)

{

printf("\nkey=%s,value=%s",temp->key,temp->value);

temp = temp->next;

}

}

return 0;

}

weixin_40000457
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言八大数据结构有哪些,C语言中都有哪些常见的数据结构你都知道几个？？...
weixin_35976993的博客
05-18 1882
上次在面试时被面试官问到学了哪些数据结构，那时简单答了栈、队列/(ㄒoㄒ)/~~其它就都想不起来了，今天有空整理了一下几种常见的数据结构，原来我们学过的数据结构有这么多~首先，先来回顾下C语言中常见的基本数据类型吧O(∩_∩)OC语言的基本数据类型有：整型int，浮点型float，字符型char等等添加描述那么，究竟什么是数据结构呢？数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一...
C语言实现常用数据结构：简要一览（第1篇）
qq_43351159的博客
08-05 2035
线性表 最简单的一种数据结构，具有相同类型的数据元素组成的序列。顺序表、链表是其两种简单实现。 备注：数组也可以算一种简单的线性表。 链表可以分为： 带头结点的简单链表 不带头结点的简单链表 静态链表 循环链表 双向链表 栈 限定增加和删除数据操作只能在线性表的末端进行，因此是一种受限的特殊线性表。 实现方式有： 顺序栈 链栈 栈典型的特点是：数据“后进先出”，栈可以用来实现递归。栈数据结构的主要操作是出栈、入栈。 队列 限定增加数据元素在线性
C语言中常用的数据结构
2301_76510320的博客
05-25 4159
链表是一种动态的数据结构，它由一系列结点组成，每个结点包含数据和指向下一个结点的指针。树是一种由一组结点和一组连接这些结点的边组成的数据结构，每个结点有一个父结点和零个或多个子结点。图是一种由一组结点和一组连接这些结点的边组成的数据结构，每个结点可以有零个或多个相邻结点。树（Tree）：由一组结点和一组连接这些结点的边组成的数据结构，每个结点有一个父结点和零个或多个子结点。图（Graph）：由一组结点和一组连接这些结点的边组成的数据结构，每个结点可以有零个或多个相邻结点。
数据结构的C基础
yun_gao_的博客
09-25 756
1.计算机程序:对数据进行加工，处理。一个程序应包括对数据的描述（数据结构——C语言中，以数据类型的形式出现）和对数据处理的描述（算法——以语句序列实现） 一、数据类型： 1.基本数据类型：整型(int)，实型(float,double),字符型(char) 2.构造类型：数组，结构体 3.指针 二、数据的值有两种表示形式： 常量： \qquad直接常量（常数）——整型、实型、字符、字符串 \qquad符号常量（宏名）——# define 标识符 常量 变量： 具有五个要素——名称，数据类型，取值大小，内存
用c语言实现基本数据结构（栈）
learntodeath的博客
03-03 291
用c语言实现基本数据结构（栈） 准备用c语言将所有基本数据结构实现一遍，从栈开始。 下面是int类型的栈，结构体如下 typedef struct{ int top; int n; int *s; }Stack; 方法 void init_stack(Stack *stack, int n) //给struct中的s指针初始化n个int空间 int pop(Stack *stack)//出...
C语言数据结构代码-包含所有常用数据结构实现方式
12-02
本压缩包"**C语言数据结构代码-包含所有常用数据结构实现方式**"提供了C语言实现的各种常见数据结构和算法，这对于学习和理解数据结构以及提升编程技能非常有帮助。 1. **线性表**: 线性表是最基本的数据结构之一，...
C语言实现数据结构算法初阶算法
06-15
6. **二叉树遍历**：二叉树是一种非线性数据结构，有前序、中序和后序三种遍历方式。这些遍历方法在搜索、排序等问题中非常有用。C语言实现二叉树，需要定义结构体表示节点，并编写递归或迭代的遍历函数。 7. **...
libcstl，C语言编写的一个通用的数据结构和常用的算法库
最新发布
03-22
libcstl是一个基于C语言开发的通用数据结构和算法库，它旨在提供类似于标准模板库（SGI STL）的功能，使开发者能够在C语言环境中享受到STL带来的便利。这个库的核心目标是提高代码的复用性、效率和可读性，同时保持...
用C语言来实现数据结构和算法.zip
10-09
C语言，作为一种强大的、低级的编程语言，是学习和实现数据结构与算法的理想选择，因为它允许程序员对内存进行直接操作，从而更好地理解底层工作原理。 标题"用C语言来实现数据结构和算法"暗示我们将探讨如何利用...
数据结构——基于C语言实现杨辉三角
08-11
C语言是一种底层编程语言，它允许直接操作内存，因此非常适合实现数据结构。 首先，让我们了解杨辉三角。杨辉三角，又称帕斯卡三角，是二项式系数的一种图形表示，具有对称的形状。在每个位置上，数字是其上方两个...
C语言实现动态可变长结构体
weixin_42103223的博客
03-16 2052
C语言实现动态可变长结构体 可使用此方法进行变长数据缓存,在FIFO,FILO等数据结构中可以用到 #define MEM_BUFF_SIZE(x) (sizeof(Mem_t) + x*sizeof(char)) typedef struct tagMem{ int val; char buff[0]; }Mem_t; int main() { Mem_t * myMem; ...
数据结构（C语言）Learning Way
1+1=王的博客
11-04 724
一、First of all 基本术语一、数据1.数据数据（Data）数据元素（Data element）数据对象（Data Object）2.数据结构逻辑结构物理结构3.数据类型4.总结逻辑图功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个...
C++几种常见的数据结构
ymhdt的博客
07-27 9206
由于vector是顺序存储结构，所以如果发生了扩容，需要重新申请一块更大的连续内存空间，并将原数据复制过去，所以存储地址有可能发生变化。顺序表相邻（逻辑地址相邻）的两个节点，在内存中具有相邻的物理地址。线性表存储的数据是依次排列的，具有一对一的相连方式。链表相邻（逻辑地址相邻）的两个节点，在内存中的物理地址不一定相同。的对应关系的数据存储结构。如下图所示是我们比较常用的二叉树结构，二叉树具有1对2的对应关系。栈和队列是特殊的线性表，因为他们对数据的进出顺序做出了明确的要求。的对应关系的数据存储结构。...
C语言基础——数据结构
yty19970212的博客
02-02 9871
线性表 线性表的定义    定义n个数据元素的有限序列，记作（a1, a2, …, an）ai 是表中数据元素，n 是表长度 线性表的特点     除第一个元素外，其他每一个元素有一个且仅有一个直接前驱。     除最后一个元素外其他每一个元素有一个且仅有一个直接后继。 顺序表的定义和特点 定义  将线性表中的元素相继存放在一个连续的存储空间中。           可利用一维
C语言数据类型与三大结构
qq_43607588的博客
02-01 2356
C语言数据类型与三大结构 数据类型 C语言数据类型可以分为基本类型和派生类型。 基本类型：整型，字符型，浮点型，布尔型。 派生类型：指针类型，枚举类型，数组类型，结构体类型，共用体类型 在不同的编译器环境下同一个数据类型可能占用不同的内存空间 32位环境下数据类型的长度一般如下： 三大结构 顺序结构 就是按照语句写入的先后顺序依次执行。 选择结构 在不同的条件下执行不同的语句c语言中支持这种结...
C语言三种结构
m0_46917254的博客
05-11 4006
C语言概述 1.C语言特点 语言简洁，紧凑，灵活 运算符丰富 数据结果类型丰富 程序设计结构化，模块化 语法限制不太严格，程序设计自由度大 能实现汇编语言的大部分功能，可以直接对硬件操作 生成目标代码质量高 可移植性好 C语言程序的基本结构 一.顺序结构 它是c语言最简单最基础的控制结构，即就是按照顺序从上到下依次执行。 例 #include<stdio.h> int main() { int x,y,z; scanf("%d %d",&x,&y); z=x+y; p
[ 数据结构-C语言 ] 二叉树--初阶 大总结~~
热门推荐
CSDN博客
04-14 1万+
今天要和大家一起步入一个新的数据结构--二叉树。在学习了解二叉树之前我们先来了解什么是树。 目录 1.树的概念及其结构 1.1树的概念 1.2树的相关概念(重点*) 1.3树的表示 2.二叉树概念及结构 2.1概念 2.2特殊的二叉树 2.3二叉树的性质（重要*） 2.4练习题 2.5 二叉树的存储结构 1. 顺序存储 2.链式存储 3.二叉树的顺序结构及实现 3.1 二叉树的顺序结构 3.2堆概念及其结构 3.2.1堆的实现 3.2.2堆的时间复杂...
C语言实现常用数据结构,C语言实现常用数据结构——图
weixin_35682992的博客
05-18 185
#include#include#define SIZE 20#define LENGTH(a) (sizeof(a)/sizeof(a[0]))/** 用链表存弧信息，一个存弧指向的顶点位置，第二存指向下条弧的指针，这样就将一个顶点指向的所有弧串起来*/typedefstructenode {intv_index;struct enode *next_edge;} enode;/** 在顶点存...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值