算法导论代码　第10章 基本数据结构

最新推荐文章于 2024-05-13 03:24:23 发布
最新推荐文章于 2024-05-13 03:24:23 发布
阅读量573 收藏 2
点赞数
分类专栏： 算法 文章标签： 数据结构 算法 list struct null insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moxiaopeng/article/details/7165361
版权

第10章 基本数据结构

10.1 栈和队列

10.1.1 栈

10.1.1.1 基于数组实现

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef struct stack_type *stack;
struct stack_type {
	int top;
	int num;
	void **array;
};
stack stack_create(int num)
{
	stack s = malloc(sizeof(struct stack_type));
	s->top = -1;
	s->num = num;
	s->array = malloc(sizeof(void *) * num);
	return s;
}

bool stack_is_empty(stack s)
{
	return s->top == -1;
}

bool stack_is_full(stack s)
{
	return s->top == s->num - 1;
}

void stack_push(stack s, void *x)
{
	s->array[++s->top] = x;
}

void *stack_pop(stack s)
{
	return s->array[s->top--];
}

void stack_destroy(stack s, void (*free_key) (void *))
{
	while (!stack_is_empty(s)) {
		void *p = stack_pop(s);
		free_key(p);
	}
	free(s->array);
	free(s);
}

int main()
{
	stack s = stack_create(10);
	for (int i = 0; i < 10; i++) {
		int *p = malloc(sizeof(int));
		*p = i;
		stack_push(s, p);
	}
	printf("stack is full?%s\n", stack_is_full(s) ? "true" : "false");
	while (!stack_is_empty(s)) {
		int *p = stack_pop(s);
		printf("%d ", *p);
		free(p);
	}
	printf("\n");
	stack_destroy(s, free);
	return 0;
}


10.1.1.2 基于链表实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct stack_type *stack;
struct stack_node {
	void *key;
	struct stack_node *next;
};
struct stack_type {
	struct stack_node *head;
};
void stack_node_ini(struct stack_node *n, void *key)
{
	n->key = key;
	n->next = NULL;
}

stack stack_create()
{
	stack s = malloc(sizeof(struct stack_type));
	s->head = NULL;
	return s;
}


bool stack_is_empty(stack s)
{
	return s->head == NULL;
}

void stack_push(stack s, void *x)
{
	struct stack_node *node = malloc(sizeof(struct stack_node));
	stack_node_ini(node, x);
	node->next = s->head;
	s->head = node;
}

void *stack_pop(stack s)
{
	struct stack_node *p = s->head;
	s->head = s->head->next;
	void *key = p->key;
	free(p);
	return key;
}

void stack_destroy(stack s, void (*free_key) (void *))
{
	while (!stack_is_empty(s)) {
		void *p = stack_pop(s);
		free_key(p);
	}
	free(s);
}

int main()
{
	stack s = stack_create();
	for (int i = 0; i < 10; i++) {
		int *p = malloc(sizeof(int));
		*p = i;
		stack_push(s, p);
	}
	while (!stack_is_empty(s)) {
		int *p = stack_pop(s);
		printf("%d ", *p);
		free(p);
	}
	printf("\n");
	stack_destroy(s, free);
	return 0;
}


10.1.2 队列

10.1.2.1 基于数组实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct queue_type *queue;
struct queue_type {
	int num;
	int head;
	int tail;
	void **array;
};
queue queue_create(int num)
{
	queue q = malloc(sizeof(struct queue_type));
	/*num比要存放在队列中的元素个数多一，是为了区分队列满和空的状态 */
	q->num = num + 1;
	q->head = 0;
	q->tail = 0;
	q->array = malloc(sizeof(void *) * num);
	return q;
}

bool queue_is_empty(queue q)
{
	return q->head == q->tail;
}

bool queue_is_full(queue q)
{
	return q->head == (q->tail + 1) % q->num;
}

void queue_en_queue(queue q, void *x)
{
	q->array[q->tail++] = x;
	q->tail = q->tail % q->num;
}

void *queue_de_queue(queue q)
{
	void *x = q->array[q->head++];
	q->head = q->head % q->num;
	return x;
}

void queue_destroy(queue q,void (*free_key)(void *))
{
	while (!queue_is_empty(q)) {
		void *p = queue_de_queue(q);
		free_key(p);
	}
	free(q->array);
	free(q);
}

int main()
{
	queue q = queue_create(10);
	for (int i = 0; i < 10; i++) {
		int *p = malloc(sizeof(int));
		*p = i;
		queue_en_queue(q, p);
	}
	printf("queue is full?:%s\n", queue_is_full(q) ? "true" : "false");
	while (!queue_is_empty(q)) {
		int *p = queue_de_queue(q);
		printf("%d ", *p);
		free(p);
	}
	printf("\n");
	queue_destroy(q,free);
	return 0;
}


10.1.2.2 基于链表实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct queue_type *queue;
struct queue_node {
	void *key;
	struct queue_node *next;
};

struct queue_type {
	struct queue_node *head;
	struct queue_node *tail;
};

void queue_node_ini(struct queue_node *node, void *key)
{
	node->key = key;
	node->next = NULL;
}

queue queue_create()
{
	queue q = malloc(sizeof(struct queue_type));
	q->head = NULL;
	q->tail = NULL;
	return q;
}

bool queue_is_empty(queue q)
{
	return q->head == NULL;
}

void queue_en_queue(queue q, void *x)
{
	struct queue_node *p = malloc(sizeof(struct queue_node));
	queue_node_ini(p, x);
	if (q->head == NULL) {
		q->head = p;
		q->tail = p;
	} else {
		q->tail->next = p;
		q->tail = p;
	}
}

void *queue_de_queue(queue q)
{
	void *key = q->head->key;
	struct queue_node *p = q->head;
	q->head = q->head->next;
	free(p);
	return key;
}

void queue_destroy(queue q, void (*free_key) (void *))
{
	while (!queue_is_empty(q)) {
		void *p = queue_de_queue(q);
		free_key(p);
	}
	free(q);
}

int main()
{
	queue q = queue_create();
	for (int i = 0; i < 10; i++) {
		int *p = malloc(sizeof(int));
		*p = i;
		queue_en_queue(q, p);
	}
	while (!queue_is_empty(q)) {
		int *p = queue_de_queue(q);
		printf("%d ", *p);
		free(p);
	}
	printf("\n");
	queue_destroy(q,free);
	return 0;
}


10.2 链表

10.2.1 双链表

#include <stdio.h>
#include <stdlib.h>
typedef struct list_type *list;
struct list_node {
	void *key;
	struct list_node *prev;
	struct list_node *next;
};
struct list_type {
	struct list_node *head;
};
void list_node_ini(struct list_node *p, void *key)
{
	p->key = key;
	p->prev = NULL;
	p->next = NULL;
}

list list_create()
{
	list l = malloc(sizeof(struct list_type *));
	l->head = NULL;
	return l;
}

void list_destroy(list l, void (*free_key) (void *))
{
	struct list_node *x = l->head;
	while (x != NULL) {
		struct list_node *del = x;
		x = x->next;
		free_key(del->key);
		free(del);
	}
	free(l);
}

struct list_node *list_search(list l, void *k,
			      int (*comp) (const void *, const void *))
{
	struct list_node *x = l->head;
	while (x != NULL && comp(x->key, k) != 0) {
		x = x->next;
	}
	return x;
}

void list_insert(list l, struct list_node *x)
{
	x->next = l->head;
	if (l->head != NULL) {
		l->head->prev = x;
	}
	l->head = x;
	x->prev = NULL;
}

void list_delete(list l, struct list_node *x)
{
	if (x->prev != NULL) {
		x->prev->next = x->next;
	} else {
		l->head = x->next;
	}
	if (x->next != NULL) {
		x->next->prev = x->prev;
	}
}

void list_display(list l, void (*print_key) (const void *))
{
	struct list_node *x = l->head;
	while (x != NULL) {
		print_key(x->key);
		printf(" ");
		x = x->next;
	}
	printf("\n");
}

int cmp_int(const void *p1, const void *p2)
{
	const int *pa = p1;
	const int *pb = p2;
	if (*pa < *pb)
		return -1;
	if (*pa == *pb)
		return 0;
	return 1;
}
void print_key(const void *key)
{
	const int *p = key;
	printf("%d", *p);
}

int main()
{
	list l = list_create();
	for (int i = 0; i < 10; i++) {
		struct list_node *n = malloc(sizeof(struct list_node));
		int *p = malloc(sizeof(int));
		*p = i;
		list_node_ini(n, p);
		list_insert(l, n);
	}
	list_display(l, print_key);
	int k = 0;
	struct list_node *node = list_search(l, &k, cmp_int);
	printf("查找关键字:%d的结果:%s\n", k,
	       node != NULL ? "成功" : "失败");
	printf("删除关键字:%d的结果:\n", k);
	list_delete(l, node);
	free(node->key);
	free(node);
	list_display(l, print_key);
	list_destroy(l,free);
	return 0;
}


10.2.2 带哨兵的环形双向链表

#include <stdio.h>
#include <stdlib.h>
/*带哨兵的环形双向链表*/
typedef struct list_circle_type *list;
struct list_node {
	void *key;
	struct list_node *prev;
	struct list_node *next;
};
struct list_circle_type {
	struct list_node *nil;	/*哑元结点，用来代替NULL */
};
void list_node_ini(struct list_node *p, void *key)
{
	p->key = key;
	p->prev = NULL;
	p->next = NULL;
}

list list_create()
{
	list l = malloc(sizeof(struct list_circle_type *));
	l->nil = malloc(sizeof(struct list_node));
	l->nil->prev = l->nil;
	l->nil->next = l->nil;
	return l;
}

void list_destroy(list l, void (*free_key) (void *))
{
	struct list_node *x = l->nil->next;
	while (x != l->nil) {
		struct list_node *del = x;
		x = x->next;
		free_key(del->key);
		free(del);
	}
	free(l->nil);
	free(l);
}

struct list_node *list_search(list l, void *k,
			      int (*comp) (const void *, const void *))
{
	struct list_node *x = l->nil->next;
	while (x != l->nil && comp(x->key, k) != 0) {
		x = x->next;
	}
	return x;
}

void list_insert(list l, struct list_node *x)
{
	x->next = l->nil->next;
	l->nil->next->prev = x;
	l->nil->next = x;
	x->prev = l->nil;
}

void list_delete(list l, struct list_node *x)
{
	if (x == l->nil)
		return;
	x->next->prev = x->prev;
	x->prev->next = x->next;
}

void list_display(list l, void (*print_key) (const void *))
{
	struct list_node *x = l->nil->next;
	while (x != l->nil) {
		print_key(x->key);
		printf(" ");
		x = x->next;
	}
	printf("\n");
}

int cmp_int(const void *p1, const void *p2)
{
	const int *pa = p1;
	const int *pb = p2;
	if (*pa < *pb)
		return -1;
	if (*pa == *pb)
		return 0;
	return 1;
}
void print_key(const void *key)
{
	const int *p = key;
	printf("%d", *p);
}

int main()
{
	list l = list_create();
	for (int i = 0; i < 10; i++) {
		struct list_node *n = malloc(sizeof(struct list_node));
		int *p = malloc(sizeof(int));
		*p = i;
		list_node_ini(n, p);
		list_insert(l, n);
	}
	list_display(l, print_key);
	int k = 0;
	struct list_node *node = list_search(l, &k, cmp_int);
	printf("查找关键字:%d的结果:%s\n", k,
	       node != l->nil ? "成功" : "失败");
	printf("删除关键字:%d的结果:\n", k);
	list_delete(l, node);
	free(node->key);
	free(node);
	list_display(l, print_key);
	list_destroy(l,free);
	return 0;
}


10.3 指针和对象的实现

#include <stdio.h>
#include <stdlib.h>
typedef struct list_type *list;
enum { NIL = -1 };
struct list_type {
	int num;
	int *key;
	int *next;
	int *prev;
	int free;
	int head;
};
list list_create(int num)
{
	list l = malloc(sizeof(struct list_type));
	l->num = num;
	l->key = malloc(sizeof(int) * num);
	l->prev = malloc(sizeof(int) * num);
	l->next = malloc(sizeof(int) * num);
	/*自由表是一个单链表，只用到next数组 */
	l->free = 0;
	for (int i = 0; i < num - 1; i++) {
		l->next[i] = i + 1;
	}
	l->next[num - 1] = NIL;
	l->head = NIL;
	return l;
}

void list_destroy(list l)
{
	free(l->key);
	free(l->prev);
	free(l->next);
	free(l);
}

int list_allocate_object(list l)
{
	if (l->free == NIL) {
		return NIL;
	} else {
		int x = l->free;
		l->free = l->next[x];
		return x;
	}
}

void list_free_object(list l, int x)
{
	if(x==NIL)
		return;
	l->next[x] = l->free;
	l->free = x;
}

int list_search(list l, int k)
{
	int x = l->head;
	while (x != NIL && l->key[x] != k) {
		x = l->next[x];
	}
	return x;
}

void list_insert(list l, int x)
{
	l->next[x] = l->head;
	if (l->head != NIL) {
		l->prev[l->head] = x;
	}
	l->head = x;
	l->prev[x] = NIL;
}

void list_delete(list l, int x)
{
	if(x==NIL)
		return;
	if (l->prev[x] != NIL) {
		l->next[l->prev[x]] = l->next[x];
	} else {
		l->head = l->next[x];
	}
	if (l->next[x] != NIL) {
		l->prev[l->next[x]] = l->prev[x];
	}
}

void list_display(list l)
{
	int x = l->head;
	while (x != NIL) {
		printf("%d ", l->key[x]);
		x = l->next[x];
	}
	printf("\n");
}

int main()
{
	list l = list_create(10);
	for (int i = 0; i < 10; i++) {
		int x=list_allocate_object(l);
		l->key[x]=i;
		list_insert(l, x);
	}
	list_display(l);
	int k = 0;
	int pos = list_search(l, k);
	printf("查找关键字:%d的结果:%s\n", k,
	       pos != NIL ? "成功" : "失败");
	printf("删除关键字:%d的结果:\n", k);
	list_delete(l,pos );
	list_free_object(l,pos);
	list_display(l);
	list_destroy(l);
	return 0;
}


MoXiaopeng
关注
专栏目录
算法导论第十章基本数据结构
z84616995z的专栏
02-14 5518
10.1栈与队列 （1） 栈 概念定义：栈属于动态集合，采用先进后出策略（LIFO）。基本操作是压入（PUSH）和弹出（POP）。如果s.top=0，表示栈空，如果试图对空栈进行POP操作会发生下溢（underflow）。如果s.top>n,表示栈满，如果进行PUSH操作会发生上溢（overflow）。 基本代码： //基本的栈操作 #include #include using na
数据结构第一章导论
qq_38690854的博客
09-09 265
基数排序先将最高位选择,放入0到9三个桶中,在对下一位进行排序,直至形成一个有序数列数据结构第一章导论GCP问题 Welch Powell法 a).将G的结点按照度数递减的次序排列. b).用第一种颜色对第一个结点着色,并按照结点排列的次序 对与前面着色点不邻接的每一点着以相同颜色. c).用第二种颜色对尚未着色的点重复步骤b).用第三种颜色 继续这种作法, 直到所有点着色完为止. 回朔
void (*p)() 、 void *p()和void *（*p）(void)的区别
fzzjoy的专栏
03-04 1万+
void (*p)()是一个指向函数的指针，表示是一个指向函数入口的指地变量，该函数的返回类型是void类型。它的用法可参看下例: 例如：有一返加void值的函数swap，(swap用来交换两个数) void (*p)(); /*定义指向函数的指针变量p*/ p=swap; /*使指针变量p指向函数max*/ (*p)(a,b); /*通过指针变量p调用函数max*/ 它等价于:
《算法导论3rd第十四章》数据结构扩张
懒猫的脚印
12-01 889
算法导论，十四章，数据结构扩张。即如果通过附加属性使用基础数据结构满足各种需求
2024年C C++最全算法导论代码 第10章 基本数据结构_void ( p)(struct key key)，如果不想35岁被淘汰这篇文章必看
最新发布
2401_84976207的博客
05-13 948
*哑元结点，用来代替NULL */(img-V38dvkoJ-1715541840844)](img-s3PCeOYi-1715541840845)]/*num比要存放在队列中的元素个数多一，是为了区分队列满和空的状态 */printf(“查找关键字:%d的结果:%s\n”, k,“成功” : “失败”);printf(“删除关键字:%d的结果:\n”, k);带哨兵的环形双向链表。
算法导论第十七章习题解答
04-19
1. **图的基本概念**：图是由顶点（节点）和边构成的数据结构，可以用来模型化现实世界中的关系。图分为有向图（边有方向）和无向图（边无方向），还可以是加权图（边附带有数值，表示某种成本或距离）。 2. **深度...
《算法导论》第三版第10章 基本数据结构 练习&思考题 个人答案
张劲声的博客
12-28 2055
10.1 栈和队列 10.1-1 仿照图10-1，画图表示依次执行操作PUSH(S, 4)、PUSH(S, 1)、PUSH(S, 3)、POP(S)、PUSH(S, 8)和POP(S)每一步的结果，栈S初始为空，存储于数组S[1…6]中。 解： 4→41→413→41→418→41 10.1-2 说明如何在一个数组A[1…n]中实现两个栈，使得当两个栈的元素个数之和不为n时，两者都不会发生上溢。要...
算法导论第二十四章习题解答
04-05
通过深入学习和解决《算法导论》第二十四章的习题，你将能更好地掌握高级算法和数据结构，这对任何IT专业人员来说都是宝贵的技能。记住，实践是检验理论的最好方式，不断练习和应用这些知识，将使你在面对实际问题时...
算法导论——所有算法和数据结构的C++实现
01-09
所有代码都是在我学习这本书时亲手敲出来的，并且调试正确了，包括：第三部分到第六部分（即10-26章），外加第七部分31和32章所有的算法和数据结构以及编程习题还有思考题的C++实现源代码； 第一、二部分学习的较早...
算法导论第十二章总结以及课后题答案
wk_bjut_edu_cn的博客
03-07 3649
二叉搜索树 总结 查找二叉搜索树中最大关键字元素 TREE-MAXIMUM(x) while x.right!=NIL x=x.right return x 查找二叉搜索树中最小关键字元素 TREE-MINIMUM(x) while x.left!=NIL x=x.left return x 插入一个结点到二叉树 TREE-INSERT(T,z
C语言反转单链表
热门推荐
MoXiaopeng的专栏
07-22 2万+
反转单链表 定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的头结点。
翻转句子中单词的顺序 C语言
MoXiaopeng的专栏
08-10 1万+
C语言 字符串 算法
位图算法 C语言
MoXiaopeng的专栏
08-06 2904
位图算法 C语言
逆转字符串 C语言
MoXiaopeng的专栏
08-09 2605
#include #include char* Reverse(char *str) { if(str == NULL) return str; char *pLast = str + (strlen(str) - 1); char *pBegin = str; while(pBegin != pLast) {
递归合并有序链表C语言
MoXiaopeng的专栏
07-11 2419
递归逆转链表和递归合并有序链表的代码
算法导论代码　第13章 红黑树
MoXiaopeng的专栏
12-30 1310
#include #include #include typedef struct red_black_tree_type *tree; enum color_enum { color_red, color_black }; struct tree_node { void *key; enum color_enum color; struct tree_node *parent;
算法导论代码　第18章 B树
MoXiaopeng的专栏
12-30 1207
第18章 B树 #include #include #include #include #include /*两个约定:(1)B树的根结点始终在主存中，因而无需对根做DISK_READ, 但是根结点被改变后，都需要对根结点做一次DISK_WRITE (2)任何被当作参数的结点被传递之前，要先对它们做一次DISK_READ*/ #define DISK_READ(x) #define
算法导论代码　第25章 每对顶点间的最短路径
MoXiaopeng的专栏
12-31 1193
第25章 每对顶点间的最短路径 25.1 最短路径与矩阵乘法 #include #include #include #include typedef struct graph_type *graph; struct edge { int u; int v; int w; }; struct vertex { char str_vertex[256]; //顶点的字符串表示，
算法导论代码　第22章 图的基本算法
MoXiaopeng的专栏
12-30 1060
第22章 图的基本算法 22.1 图的表示 22.1.1 邻接表表示法 #include #include #include typedef struct graph_type *graph; struct edge { int u; int v; }; struct graph_node { int key; struct graph_node *next; }; void
《算法导论》第五版各章习题答案解析
"算法导论第五版答案包含了从第二章到第二十五章的部分习题解答，主要涉及算法分析和实现，包括排序、递归、分治等核心概念。" 《算法导论》是一本广泛用于大学计算机科学教育的经典教材，其第五版继续深化了对算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值