C++几种常见的数据结构，顺序表 链表 栈 队列 二叉树 哈希表

已于 2023-11-01 18:47:19 修改
阅读量281 收藏 2
点赞数
分类专栏： 剑指offer-leetcode 文章标签： 数据结构 c++ 链表
于 2023-03-14 11:10:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45179361/article/details/129520460
版权

一. 内容简介

C++几种常见的数据结构，顺序表 链表 栈 队列 二叉树 哈希表

二. 软件环境

2.1 Visual studio 2017

三.主要流程

3.1 顺序表

3.2 链表

3.3 栈

3.4 队列

3.5 二叉树

3.6 哈希表

四.具体步骤

4.1 顺序表

头文件

#pragma once
typedef int data_t;// 根据自己需要换数据类型
#define N 100

typedef struct {
	data_t data[N];
	int last;
}sqlist,*sqlink;

sqlink list_create();
int list_free(sqlink l);
int list_clear(sqlink l);
int iist_empty(sqlink l);
int list_length(sqlink l);
int list_locate(sqlink l,data_t value);
int list_insert(sqlink l, data_t value,int pos);
int list_delete(sqlink l,int pos);
int list_merge(sqlink l1,sqlink l2);
int list_purge(sqlink l);
int list_show(sqlink l);

cpp文件

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sqlist.h"
/*
 * list_create: 判断表是否为空
 * para:
 * @ret: 返回常见好的顺序表
 */
sqlink list_create() {
	// 申请内存
	sqlink L;
	L = (sqlink)malloc(sizeof(sqlist));
	if (L==NULL) {
		printf("list malloc failed\n");
		return L;
	}
	// 初始化
	memset(L,0, sizeof(sqlist));//清零
	L->last = -1;
	// 返回
	return L;
}
int list_free(sqlink l) {
	if (l == NULL) {
		return -1;
	}
	free(l);
	l = NULL;
	return 0;
}
/*
 * list_clear: 清空数据表
 * para: sqlink l 要清空的表
 * @ret: 0 清空成功 -1 表示失败
 */
int list_clear(sqlink l) {
	if (l==NULL)
	{
		return -1;
	}
	// 初始化
	memset(l, 0, sizeof(sqlist));//清零
	l->last = -1;
	return 0;
}
/*
 * iist_empty: 数据表是否为空
 * para: sqlink l 要清空的表
 * @ret: 1 为空 0 表示不为空
 */
int iist_empty(sqlink l) {
	if (l->last==-1) {
		return 1;
	}
	else
	{
		return 0;
	}
}
int list_length(sqlink l) {
	if (l == NULL)
	{
		return -1;
	}
	return (l->last+1);
}

int list_locate(sqlink l, data_t value) {
	for (int i = 0; i <= l->last ; i++)
	{
		if (l->data[i]==value) {
			return i;
		}
	}
	return -1;
}
int list_insert(sqlink l, data_t value, int pos) {
	// full
	if (l->last == N-1) {
		printf("list is full\n");
		return -1;
	}
	// check para
	if (pos<0 ||pos>l->last+1) {
		printf("pos is invalid\n");
		return -1;
	}
	// move 
	for (int i = l->last; i >=pos; i--)
	{
		l->data[i + 1] = l->data[i];
	}
	// update
	l->data[pos] = value;
	l->last++;

	return 0;
}

int list_show(sqlink l) {
	if (l==NULL) {
		return -1;
	}
	if (l->last==-1)
	{
		printf("list is empty\n");
	}
	for (int i = 0; i <= l->last; i++)
	{
		printf("%d",l->data[i]);
	}
	puts("");
}

int list_delete(sqlink l, int pos) {
	if (l->last == -1) {
		printf("list is empty\n");
		return -1;
	}
	if (pos<0||pos>l->last) {
		printf("delete pos is invalid\n");
		return -1;
	}
	for (int i = pos+1; i <=l->last; i++)
	{
		l->data[i - 1] = l->data[i];
	}
	l->last--;
	return 0;
}
int list_merge(sqlink l1, sqlink l2) {
	int i = 0;
	int ret;
	while (i<=l2->last)
	{
		ret = list_locate(l1,l2->data[i]);
		if (ret == -1) {
			if (list_insert(l1, l2->data[i], l1->last + 1) == -1) {
				return -1;
			}
		}
	}
	return 0;
}
int list_purge(sqlink l) {
	if (l->last == 0) {
		return 0;
	}
	int i = 1;
	int j;
	while (i<= l->last)
	{
		j = i - 1;
		while (j>= 0)
		{
			if (l->data[i] == l->data[j]) {
				list_delete(l,i);
			}
			else
			{
				j--;
			}
		}
		if (j<0) {
			i++;
		}
	}
	return 0;
}

4.2 链表

实现了链表一些基本的功能，还加了几个简单的算法， 链表反转，求链表种相邻两节点data值之和最大的，第一节点的指针，链表拼接，以及排序
链表头文件

#pragma once
typedef int data_t;
typedef struct node {
	data_t data;
	struct node * next;
}listnode, *linklist;
linklist list_create();
linklist list_free();
int list_tail_insert(linklist h, data_t value);
linklist list_get(linklist h,int pos);
int list_insert(linklist h,data_t value,int pos);
int list_delete(linklist h,int pos);
int list_show(linklist h);
int list_reverse(linklist h);
linklist list_adjmax(linklist h);
int list_merge(linklist l1,linklist l2);

链表cpp文件

#include "linklist.h"
#include <stdlib.h>
#include <stdio.h>

linklist list_create() {
	linklist h = (linklist)malloc(sizeof(listnode));
	if (h == NULL) {
		printf("malloc failed\n");
		return h;
	}
	h->data = 0;
	h->next = NULL;
	return h;
}
linklist list_free(linklist h) {
	linklist p = h;
	if ( h == NULL) {
		return NULL;
	}
	while (h != NULL)
	{
		p = h;
		h = h->next;
		free(p);
	}
	return NULL;
}

int list_tail_insert(linklist h,data_t value) {
	if (h==NULL) {
		printf("H is NULL\n");
		return -1;
	}
	linklist p = (linklist)malloc(sizeof(listnode));
	linklist q = h;
	if (p == NULL) {
		printf("malloc failed\n");
		return -1;
	}
	p->data = value;
	p->next = NULL;
	while (q->next != NULL)
	{
		q=q->next;
	}
	q->next = p;
	return 0;
}

linklist list_get(linklist h, int pos) {
	linklist p;
	int i = -1;
	if (h == NULL) {
		printf("h is null\n");
		return NULL;
	}
	if (pos == -1) {
		return h;
	}
	if (pos < -1) {
		printf("pos is null\n");
		return NULL;
	}
	p = h;
	while (i<pos)
	{
		p = p->next;
		if (p==NULL)
		{
			break;
			printf("pos is invalid\n");
		}
		i++;
	}
	return p;
}

int list_insert(linklist h, data_t value, int pos) {
	linklist p;
	linklist q;
	if (h == NULL) {
		printf("h is null\n");
		return -1;
	}
	p = list_get(h,pos-1);
	if (p == NULL) {
		return -1; 
	}
	if ((q = (linklist)malloc(sizeof(listnode)))==NULL) {
		printf("malloc failed\n");
		return -1;
	}
	q->data = value;
	q->next = p->next;
	p->next = q;
	return 0;
}

int list_delete(linklist h, int pos) {
	linklist p;
	linklist q;
	if (h == NULL) {
		printf("h is NULL\n");
	}
	p = list_get(h,pos - 1);
	if (p == NULL) {
		return -1;
	}
	if (p->next == NULL) {  
		printf("delete pos is invalid\n");
	}
	q = p->next;
	p->next = q->next;
	free(q);
	q = NULL;
}

int list_show(linklist h) {
	if (h == NULL) {
		printf("H is NULL\n");
		return -1;
	}
	linklist p = h;
	while (p->next != NULL)
	{
		printf("%d\n",p->next->data);
		p = p->next;
	}
	// puts("");
	return 0;
}

链表相关算法
// 链表反转
int list_reverse(linklist h) {
	linklist p;
	linklist q;
	if (h==NULL) {
		printf("h is null\n");
		return -1;
	}
	if (h->next==NULL||h->next->next==NULL)
	{
		return 0;
	}
	p = h->next->next;
	h->next->next = NULL;
	while (p!=NULL)
	{
		q = p;
		p = p->next;

		q->next = h->next;
		h->next = q;
	}
	return 0;
}
// 求链表种相邻两节点data值之和最大的，第一节点的指针
linklist list_adjmax(linklist h) {
	linklist p, q, r;
	data_t sum;
	if (h==NULL) {
		printf("h is Null\n");
		return NULL;
	}
	if (h->next == NULL || h->next->next == NULL || h->next->next->next == NULL) {
		return h;
	}
	q = h->next;
	p = h->next->next;
	r = q;
	sum = q->data + p->data;
	while (p->next != NULL)
	{
		p = p->next;
		q = q->next;
		if (sum < q->data + p->data)
		{
			sum = q->data + p->data;
			r = q;
		}
	}
	return r;
}
// 链表拼接，以及排序
int list_merge(linklist l1, linklist l2) {
	linklist p, q, r;

	if (l1 == NULL||l2==NULL) {
		printf("l1,l2 is null");
	}
	p = l1->next;
	q = l2->next;
	r = l1;
	l1->data = NULL;
	l2->data = NULL;
	while (p&&p)
	{
		if (p->data<=q->data) {
			r->next = p;
			p = p->next;
			r = r->next;
			r->next = NULL;
		}
		else
		{
			r->next = q;
			q = q->next;
			r = r->next;
			r->next = NULL;
		}
	}
	if (p==NULL)
	{
		r->next = q;
	}
	else
	{
		r->next = p;
	}
	return 0;
}

4.3 栈

栈是先用数组实现的栈
头文件

#pragma once
typedef int data_t;
typedef struct {
	data_t *data;
	int maxlen;
	int top;
}sqstack;
sqstack * stack_create(int len);
int stack_push(sqstack *s,data_t value);
int stack_empty(sqstack *s);
int stack_full(sqstack *s);
data_t stack_pop(sqstack *s);
data_t stack_top(sqstack *s);
int stack_clear(sqstack *s);
int stack_free(sqstack *s);

cpp文件

#include "sqstack.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
sqstack * stack_create(int len) {
	sqstack * s;
	if ((s=(sqstack *)malloc(sizeof(sqstack)))==NULL) {
		printf("malloc sqstack failed\n");
		return NULL;
	}
	if ((s->data = (data_t *)malloc(len*sizeof(data_t))) == NULL) {
		printf("malloc data failed\n");
		return NULL;
	}
	memset(s->data,0,len*sizeof(data_t));
	s->maxlen = len;
	s->top = -1;
	return s;
}
int stack_push(sqstack *s, data_t value) {
	if (s==NULL) {
		printf("s is null\n");
		return -1;
	}
	if (s->top == s->maxlen-1) {
		printf("stack is full\n");
		return -1;
	}
	s->top++;
	s->data[s->top] = value;
	return 0;
}
int stack_empty(sqstack *s) {
	if (s == NULL) {
		printf("s is null\n");
		return -1;
	}
	return (s->top == -1 ? 1 : 0);
}
int stack_full(sqstack *s) {
	if (s == NULL) {
		printf("s is null\n");
		return -1;
	}
	return (s->top == s->maxlen-1 ? 1 : 0);
}
data_t stack_pop(sqstack *s) {
	s->top--;
	return (s->data[s->top+1]);
}  
data_t stack_top(sqstack *s) {
	return (s->data[s->top]);
}
int stack_clear(sqstack *s) {
	if (s == NULL) {
		printf("s is null\n");
		return -1;
	}
	s->top = -1;
	return 0;
}
int stack_free(sqstack *s) {
	if (s == NULL) {
		printf("s is null\n");
		return -1;
	}
	if (s->data!=NULL) {
		free(s->data);
	}
	free(s);
}

然后接下来是链表栈，都是一些很简单的功能
头文件

#pragma once
typedef int data_t;
typedef struct node{
	data_t data;
	struct  node *next;
}listnode,*linkstack;
linkstack stack_create();
int stack_push(linkstack s,data_t value);
data_t stack_pop(linkstack s);
int stack_empty(linkstack s);
data_t stack_top(linkstack s);
linkstack stack_free(linkstack s);

cpp文件

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

linkstack stack_create() {
	linkstack s;
	s = (linkstack)malloc(sizeof(listnode));
	if (s == NULL) {
		printf("malloc failed\n");
		return NULL;
	}
	s->data = 0;
	s->next = NULL;
	return s;
}
int stack_push(linkstack s, data_t value) {
	linkstack p;
	if (s == NULL) {
		printf("s is NULL\n");
		return -1;
	}
	p = (linkstack)malloc(sizeof(listnode));
	if (p == NULL) {
		printf("malloc failed\n");
		return -1;
	}
	p->data = value;
	p->next = NULL;

	p->next = s->next;
	s->next = p;
	return 0;
}
data_t stack_pop(linkstack s) {
	linkstack p;
	data_t t;
	p = s->next;
	s->next = p->next;
	t = p->data;
	free(p);
	p = NULL;
	return t;
}

int stack_empty(linkstack s) {
	if (s == NULL) {
		printf("s is NULL\n");
		return -1;
	}
	return (s->next == NULL ? 1:0);
}
data_t stack_top(linkstack s) {
	if (s == NULL) {
		printf("s is NULL\n");
		return -1;
	}
	return (s->next->data);
}
linkstack stack_free(linkstack s) {
	linkstack p;
	if (s == NULL) {
		printf("s is NULL\n");
		return NULL;
	}
	while (s!=NULL)
	{
		p = s;
		s = s->next;
		free(p);
	}
}

4.4 队列

队列也是分成两块，一块顺序队列
头文件

#pragma once
#define N 128
typedef int datatype;
typedef struct
{
	datatype data[N];
	int front;
	int rear;
}sequeue;
sequeue * queue_create();
int enqueue(sequeue *sq,datatype x);
datatype dequeue(sequeue *sq);
int queue_empty(sequeue *sq);
int queue_full(sequeue *sq);
int queue_clear(sequeue *sq);
sequeue * queue_free(sequeue *sq);

cpp文件，

#include "sequeue.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
sequeue * queue_create() {
	sequeue *sq;
	if ((sq=(sequeue*)malloc(sizeof(sequeue)))==NULL) {
		printf("malloc failed\n");
		return NULL;
	}
	memset(sq->data,0,sizeof(sq->data));
	sq->front = sq->rear = 0;
	return sq;
}
int enqueue(sequeue *sq, datatype x) {
	if ((sq->rear + 1 )% N == sq->front) {
		printf("sequenue is full\n");
		return -1;
	}
	sq->data[sq->rear] = x;
	sq->rear = (sq->rear + 1) % N;
	return 0;
}
datatype dequeue(sequeue *sq) {
	datatype ret;
	ret = sq->data[sq->front];
	sq->front = (sq->front + 1) % N;
	return ret;
}
int queue_empty(sequeue *sq) {
	return (sq->rear % N == sq->front ? 1 : 0);
}
int queue_full(sequeue *sq) {
	if ((sq->rear + 1) % N == sq->front) {
		printf("sequenue is full\n");
		return 1;
	}
	else
	{
		return -1;
	}
}
int queue_clear(sequeue *sq) {
	sq->front = sq->rear = 0;
	return 0; 
}
sequeue * queue_free(sequeue *sq) {
	free(sq);
	sq = NULL;
	return NULL;
}

然后接着是链表队列
头文件

#pragma once
#define N 128
typedef int datatype;

typedef struct node
{
	datatype data;
	struct  node * next;
}listnode,*linklist;

typedef struct {
	linklist front;
	linklist rear;
}linkqueue;

linkqueue * queue_create();
int enqueue(linkqueue *lq,datatype x);
datatype dequeue(linkqueue *lq);
int queue_empty(linkqueue *lq);
int queue_clear(linkqueue *lq);
linklist queue_free(linkqueue *lq);

cpp文件

#include "linkqueue.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
linkqueue * queue_create() {
	linkqueue *lq;
	if ((lq=(linkqueue*)malloc(sizeof(linkqueue)))==NULL) {
		printf("malloc linkqueue failed\n");
		return NULL;
	}
	lq->front = lq->rear = (linklist)malloc(sizeof(listnode));
	if (lq->front ==NULL) {
		printf("malloc failed\n");
		return NULL;
	}
	lq->front->data = 0;
	lq->front->next = NULL;

	return lq;
}
int enqueue(linkqueue *lq, datatype x) {
	if (lq == NULL) {
		printf("lq is null\n");
		return -1;
	}
	linklist p;
	if ((p=(linklist)malloc(sizeof(listnode)))==NULL) {
		printf("malloc failed\n");
		return -1;
	}
	p->data = x;
	p->next = NULL;
	lq->rear->next = p;
	lq->rear = p;
	return 0;
}
datatype dequeue(linkqueue *lq) {
	linklist p;
	p = lq->front;
	lq->front = p->next;
	free(p);
	p = NULL;
	return (lq->front->data);
}
int queue_empty(linkqueue *lq) {
	return (lq->front == lq->rear ? 1:0);
}
int queue_clear(linkqueue *lq) {
	linklist p;
	if (lq == NULL) {
		printf("lq is null\n");
		return NULL;
	}
	while (lq->front->next)
	{
		p = lq->front;
		lq->front = p->next;
		free(p);
		p = NULL;
	}
}
linklist queue_free(linkqueue *lq) {
	linklist p;
	if (lq==NULL) {
		printf("lq is null\n");
		return NULL;
	}	
	while (lq->front)
	{
		p = lq->front;
		lq->front = p->next;
		free(p);
	}
	free(lq);
	lq = NULL;//应该没啥用
	return NULL;
}

4.5 二叉树

二叉树实现
头文件

#pragma once
#include "tree.h"
#define N 128
typedef bitree datatype;

typedef struct node
{
	datatype data;
	struct  node * next;
}listnode, *linklist;

typedef struct {
	linklist front;
	linklist rear;
}linkqueue;

linkqueue * queue_create();
int enqueue(linkqueue *lq, datatype x);
datatype dequeue(linkqueue *lq);
int queue_empty(linkqueue *lq);
int queue_clear(linkqueue *lq);
linklist queue_free(linkqueue *lq);

cpp文件

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "linkqueue.h"
linkqueue * queue_create() {
	linkqueue *lq;
	if ((lq = (linkqueue*)malloc(sizeof(linkqueue))) == NULL) {
		printf("malloc linkqueue failed\n");
		return NULL;
	}
	lq->front = lq->rear = (linklist)malloc(sizeof(listnode));
	if (lq->front == NULL) {
		printf("malloc failed\n");
		return NULL;
	}
	lq->front->data = 0;
	lq->front->next = NULL;
	return lq;
}

int enqueue(linkqueue *lq, datatype x) {
	if (lq == NULL) {
		printf("lq is null\n");
		return -1;
	}
	linklist p;
	if ((p = (linklist)malloc(sizeof(listnode))) == NULL) {
		printf("malloc failed\n");
		return -1;
	}
	p->data = x;
	p->next = NULL;
	lq->rear->next = p;
	lq->rear = p;
	return 0;
}
datatype dequeue(linkqueue *lq) {
	linklist p;
	p = lq->front;
	lq->front = p->next;
	free(p);
	p = NULL;
	return (lq->front->data);
}
int queue_empty(linkqueue *lq) {
	return (lq->front == lq->rear ? 1 : 0);
}
int queue_clear(linkqueue *lq) {
	linklist p;
	if (lq == NULL) {
		printf("lq is null\n");
		return NULL;
	}
	while (lq->front->next)
	{
		p = lq->front;
		lq->front = p->next;
		free(p);
		p = NULL;
	}
}
linklist queue_free(linkqueue *lq) {
	linklist p;
	if (lq == NULL) {
		printf("lq is null\n");
		return NULL;
	}
	while (lq->front)
	{
		p = lq->front;
		lq->front = p->next;
		free(p);
	}
	free(lq);
	lq = NULL;//应该没啥用
	return NULL;
}

4.6 哈希表

哈希表头文件

#pragma once
#define N 15
typedef int datatype;
typedef struct node
{
	datatype key;
	datatype value;
	struct  node * next;
}listnode,*linklist;
typedef struct {
	listnode data[N];
}hash;
hash * hash_create();
int hash_insert(hash *HT,datatype key);
linklist  hash_search(hash *HT,datatype key);

cpp文件

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

hash * hash_create() {
	hash * HT;
	if ((HT = (hash*)malloc(sizeof(hash)))==NULL) {
		printf("malloc failed");
		return NULL;
	}
	memset(HT,0,sizeof(hash));
	return HT;
}
int hash_insert(hash *HT, datatype key) {
	linklist p,q;
	if (HT == NULL) {
		printf("HT is NULL\n");
		return -1;
	}

	if ((p=(linklist)malloc(sizeof(listnode)))=NULL) {
		printf("malloc failed\n");
		return -1;
	}
	p->key = key;
	p->value = key % N;
	p->next = NULL;
	
	q = &(HT->data[key % N]);
	while (q->next && (q->next->key<p->key))
	{
		q = q->next;
	}
	p->next = q->next;
	q->next = p;
	return 0;
}
linklist hash_search(hash *HT, datatype key) {
	linklist p;
	if (HT == NULL) {
		printf("HT is NULL\n");
		return NULL;
	}
	p = &(HT->data[key%N]);
	while (p->next && (p->next->key!=key))
	{
		p = p->next;
	}
	if (p->next == NULL) {
		return NULL;
	}
	else
	{
		return p->next;
	} 
}

五. 参考

华清远见嵌入式课程

+++.
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C C++ 常用数据结构 算法
09-05
常用数据结构和算法，为C/C++编程提供最好的帮助。
C++常用数据结构总结
热门推荐
W.J.Z
10-07 3万+
前言 所有的容器归根到底都是内存空间的排列方式和在空间上施加各种各种不同的限制所得的。空间排列方式只有线性和链式两种方式，链式是通过记录每一个数据的地址来实现查找下一位数据的。而每一个容器所具有的特性就决定了它所适用的情况，总的来看容器常用的无非是增删改查操作，下面将从适用场景、常用操作来进行总结。 array数组 内存空间为连续的一段地址，适用于提前已知所要存储的数据类型和数量、进行大量...
C++中常见的数据结构，包括数组、链表、栈、队列、树和图
最新发布
03-02 412
在C++编程中，数据结构是一种组织和存储数据的方式，它定义了数据之间的关系，使得数据能够被有效地访问和修改。选择适当的数据结构对于解决特定的问题至关重要，因为它能直接影响到程序的效率和性能。下面是一些在C++中常见的数据结构，包括数组、链表、栈、队列、树和图等。
C++常用数据结构
火柴的初心的博客
10-23 1万+
常用数据结构 目录 1.线性表 定义： 特点： 1.1顺序表 定义： 特点： 实现： 基本操作： c语言版本： c++版本： 1.2链表 定义： 特点： 实现： 基本操作： 完整程序 c++版本...
C++常用数据结构或技巧
XiaoFengsen的博客
03-09 4787
链表 链表（单链表）的基本操作及C语言实现 链表中存放的不是基本数据类型，需要用结构体实现自定义： typedef struct Link { char elem;//代表数据域 struct Link * next;//代表指针域，指向直接后继元素 }link; next的值实际上就是下一个节点的地址，当前节点为末节点时，next的值设为空指针。像上面这种只包含一个指针域、由n个节点链接形成的链表，就称为线型链表或者单向链表，链表只能顺序访问，不能随机访问，链表这种存储方式最大缺点就是容易出现断链。
c++数据结构总结（干货）
weixin_44378800的博客
05-23 2万+
C++数据结构实用干货！！看到就是赚到！
数据结构与常见算法，从递归开始，排序，至链表，队列，栈，树，图等。.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
18.双向链表.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
C++实现 数据结构与算法视频教程 01交换算法 02冒泡排序 03选择排序 04顺序排序 05折半排序 06递归算法 07递归折半查找 08算法_perm 09插入排序 10快速排序 11归并排序 12顺序栈 13顺序队列 14链表的基本概率 15...
04.顺序查找.wmv（C C++实现 数据结构与算法视频教程（目前上传最好的视频））
03-12
C++实现 数据结构与算法视频教程（目前上传最好的视频） 01交换算法 02冒泡排序 03选择排序 04顺序排序 05折半排序 06递归算法 07递归折半查找 08算法_perm 09插入排序 10快速排序 11归并排序 12顺序栈 13顺序队列...
17.循环链表.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
C++实现 数据结构与算法视频教程 01交换算法 02冒泡排序 03选择排序 04顺序排序 05折半排序 06递归算法 07递归折半查找 08算法_perm 09插入排序 10快速排序 11归并排序 12顺序栈 13顺序队列 14链表的基本概率 15...
15.链表.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
C++实现 数据结构与算法视频教程 01交换算法 02冒泡排序 03选择排序 04顺序排序 05折半排序 06递归算法 07递归折半查找 08算法_perm 09插入排序 10快速排序 11归并排序 12顺序栈 13顺序队列 14链表的基本概率 15...
C/C++经典算法 常用数据结构
04-07
c/c++ 经典常用算法，常用数据结构总结.精心收集。 c/c++ 经典常用算法，常用数据结构总结.精心收集。
c++常用算法及数据结构
04-28
总结了c++最常用的一些功能和方法,可以对C++中的常见的数据结构和算法进行总结,提高开发的复用性
C++----常用数据结构或原理（持续更新）
weixin_42382758的博客
03-18 157
栈与队列 栈（stack）又名堆栈，它是一种运算受限的线性表。其限 制是仅允许在表的一端进行插入和删除运算。这一端被称为 栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又 称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上 面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈 或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的 栈顶元素。 队列(queue)的的性质刚好与栈相反，功能类似，但队列是 先进先出. 定义: ...
常用数据结构总结（基于C++）
li_il的博客
11-19 904
目录 栈（stack） 简介 声明 基本操作 代码示例 队列（queue） 简介 声明 基本操作 代码示例 优先队列(priority_queue) 简介 声明 基本操作 调整输出次序 二叉搜索树 简介 基本概念 C++的STL中基于二叉搜索树有数据结构set和map 1.set 常用操作 2.map 声明 常用...
C/C++基本数据结构：顺序表/链表 队列
Lucky Soldier
04-17 910
队列 1.基本特征：先进先出——FIFO 2.基本操作：压入（push），弹出（pop） 3.实现要点：初始化空间，前指针（front）用于弹出，后指针（rear）用于压入，循环使用，判空判满。
C++几种常见的数据结构
ymhdt的博客
07-27 9077
由于vector是顺序存储结构，所以如果发生了扩容，需要重新申请一块更大的连续内存空间，并将原数据复制过去，所以存储地址有可能发生变化。顺序表相邻（逻辑地址相邻）的两个节点，在内存中具有相邻的物理地址。线性表存储的数据是依次排列的，具有一对一的相连方式。链表相邻（逻辑地址相邻）的两个节点，在内存中的物理地址不一定相同。的对应关系的数据存储结构。如下图所示是我们比较常用的二叉树结构，二叉树具有1对2的对应关系。栈和队列是特殊的线性表，因为他们对数据的进出顺序做出了明确的要求。的对应关系的数据存储结构。...
C++ 常用到的数据结构的使用 STL
与
05-25 634
1 string 头文件: #include <string> 使用 #include <iostream> #include <string> using namespace std; int main() { string a = "abcdf"; int k = a.find('r'); //寻找r在字符串中第一次出现的位置，从0开始，不存在返回-1； cout << k << endl; a.substr(1,3); .
C语言中大批量存储数据的方式链表 队列 数组 hash表，还有其他的？
06-10
除了链表、队列、数组和哈希表，还有其他的数据结构可以用来存储大批量数据，例如： 1. 栈（Stack）：栈是一种后进先出（Last In First Out，LIFO）的数据结构，只能在栈顶进行插入和删除操作。栈可以用来实现函数...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值