严蔚敏数据结构题集 p18（2.25——2.30）（c语言代码实现）

最新推荐文章于 2024-06-12 15:24:14 发布
最新推荐文章于 2024-06-12 15:24:14 发布
阅读量814 收藏 22
点赞数 20
分类专栏： 严蔚敏数据结构题集代码题 文章标签： 算法 数据结构 链表 c语言 顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46702681/article/details/134745415
版权

目录

 2.25假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合(即同一表中的元素值各不相同),现要求另辟空间构成一个线性表C,其元素为A和B中元素的交集,且表C中的元素也依值递增有序排列。试对顺序表编写求C的算法。

2.26要求同2.25题。是对单链表编写求C的算法

2.27 对2.25题的条件作以下两点修改,对顺序表重新编写求得表C的算法(1)假设在同一表(A或B)中可能存在值相同的元素,但要求新生成的表C中的元素值各不相同;(2)利用A表空间存放表C。 

2.28 对2.25题的条件作以下两点修改,对单链表重新编写求得表C的算法(1)假设在同一表(A或B)中可能存在值相同的元素,但要求新生成的表C中的元素值各不相同;(2)利用A表空间存放表C。

2.29 已知A,B和C为三个递增有序的线性表,现要求对A表作如下操作:删去那些既在B表中出现又在C表中出现的元素。试对顺序表编写实现上述操作的算法,并分析你的算法的时间复杂度(注意:题中没有特别指明同一表中的元素值各不相同)。

2.30 要求同2.29题.试对单链表编写算法,请释放A表中的无用结点空间。

 2.25假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合(即同一表中的元素值各不相同),现要求另辟空间构成一个线性表C,其元素为A和B中元素的交集,且表C中的元素也依值递增有序排列。试对顺序表编写求C的算法。

本题代码如下

sqlist jiaoji(sqlist* a, sqlist* b)
{
	sqlist c; // 定义一个结构体变量，用于存储交集结果
	c.length = 0; // 初始化交集长度为0
	int i = 0; // 定义一个整型变量，用于遍历顺序表a
	int j = 0; // 定义一个整型变量，用于遍历顺序表b
	int k = 0; // 定义一个整型变量，用于记录交集元素在结果中的位置
	while (i < a->length && j < b->length) // 当两个顺序表都没有遍历完时，进行循环
	{
		if (a->s[i] == b->s[j]) // 如果顺序表a和b当前位置的元素相等
		{
			c.s[k++] = a->s[i++]; // 将该元素添加到交集结果中，并将交集长度加1
			j++; // 顺序表b的指针向后移动一位
		}
		else if (a->s[i] < b->s[j]) // 如果顺序表a当前位置的元素小于顺序表b当前位置的元素
		{
			i++; // 顺序表a的指针向后移动一位
		}
		else // 如果顺序表a当前位置的元素大于顺序表b当前位置的元素
		{
			j++; // 顺序表b的指针向后移动一位
		}
	}
	c.length = k; // 更新交集长度
	return c; // 返回交集结果
}

完整测试代码如下

#include<stdio.h>
#define Max 10
typedef struct sqlist
{
	int s[Max]; // 定义一个结构体数组，用于存储顺序表的元素
	int length; // 定义一个整型变量，用于存储顺序表的长度
}sqlist;
// 定义一个函数，用于求两个顺序表的交集
sqlist jiaoji(sqlist* a, sqlist* b)
{
	sqlist c; // 定义一个结构体变量，用于存储交集结果
	c.length = 0; // 初始化交集长度为0
	int i = 0; // 定义一个整型变量，用于遍历顺序表a
	int j = 0; // 定义一个整型变量，用于遍历顺序表b
	int k = 0; // 定义一个整型变量，用于记录交集元素在结果中的位置
	while (i < a->length && j < b->length) // 当两个顺序表都没有遍历完时，进行循环
	{
		if (a->s[i] == b->s[j]) // 如果顺序表a和b当前位置的元素相等
		{
			c.s[k++] = a->s[i++]; // 将该元素添加到交集结果中，并将交集长度加1
			j++; // 顺序表b的指针向后移动一位
		}
		else if (a->s[i] < b->s[j]) // 如果顺序表a当前位置的元素小于顺序表b当前位置的元素
		{
			i++; // 顺序表a的指针向后移动一位
		}
		else // 如果顺序表a当前位置的元素大于顺序表b当前位置的元素
		{
			j++; // 顺序表b的指针向后移动一位
		}
	}
	c.length = k; // 更新交集长度
	return c; // 返回交集结果
}
int main()
{
	sqlist a, b; // 定义两个顺序表变量a和b
	int i = 0; // 定义一个整型变量，用于遍历顺序表a和b
	a.length = 5; // 设置顺序表a的长度为5
	b.length = 5; // 设置顺序表b的长度为5
	printf("请输入A顺序表的元素："); // 提示用户输入顺序表a的元素
	for (i = 0; i < a.length; i++) // 遍历顺序表a
		scanf("%d", &a.s[i]); // 读取用户输入的元素并存储到顺序表a中
	printf("请输入B顺序表的元素："); // 提示用户输入顺序表b的元素
		for (i = 0; i < b.length; i++) // 遍历顺序表b
			scanf("%d", &b.s[i]); // 读取用户输入的元素并存储到顺序表b中
	sqlist c = jiaoji(&a, &b); // 调用函数求两个顺序表的交集，并将结果存储到变量c中
	printf("C顺序表中的元素："); // 提示用户输出交集结果
		for (i = 0; i < c.length; i++) // 遍历交集结果
			printf("%d ", c.s[i]); // 输出交集结果中的每个元素
	return 0; // 程序正常结束，返回0
}

测试结果如下

2.26要求同2.25题。是对单链表编写求C的算法

本题代码如下

linklist jiaoji(linklist* A, linklist* B)
{
	lnode* C = (lnode*)malloc(sizeof(lnode));
	C->next = NULL;
	lnode* ra = (*A)->next, * rb = (*B)->next;
	lnode* rc = C, * r;
	while (ra && rb)
	{
		if (ra->data == rb->data)
		{
			r = ra;
			ra = ra->next;
			rb = rb->next;
			rc->next = r;
			r->next = NULL;
			rc = r;
		}
		else if (ra->data < rb->data)
		{
			ra = ra->next;
		}
		else
		{
			rb = rb->next;
		}
	}
	return C;
}

完整测试代码如下

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode, * linklist;
int a[5] = { 1,2,3,4,5 };
int b[5] = { 3,4,5,6,7 };
int n = 5;
void buildlinklist(linklist* L, int str[])
{
	*L = (lnode*)malloc(sizeof(lnode));
	(*L)->next = NULL;
	int i = 0;
	lnode* s, * r = *L;
	for (i = 0; i < n; i++)
	{
		s = (lnode*)malloc(sizeof(lnode));
		s->data = str[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
linklist jiaoji(linklist* A, linklist* B)
{
	lnode* C = (lnode*)malloc(sizeof(lnode));
	C->next = NULL;
	lnode* ra = (*A)->next, * rb = (*B)->next;
	lnode* rc = C, * r;
	while (ra && rb)
	{
		if (ra->data == rb->data)
		{
			r = ra;
			ra = ra->next;
			rb = rb->next;
			rc->next = r;
			r->next = NULL;
			rc = r;
		}
		else if (ra->data < rb->data)
		{
			ra = ra->next;
		}
		else
		{
			rb = rb->next;
		}
	}
	return C;
}
void print(linklist* L)
{
	lnode* k = (*L)->next;
	while (k)
	{
		printf("%d ", k->data);
		k = k->next;
	}
}
int main()
{
	linklist A, B;
	buildlinklist(&A, a);
	printf("A单链表元素为：");
	print(&A);
	buildlinklist(&B, b);
	printf("\nB单链表元素为：");
	print(&B);
	linklist C = jiaoji(&A, &B);
	printf("\nC单链表元素为：");
	print(&C);
	return 0;
}

测试结果如下

2.27 对2.25题的条件作以下两点修改,对顺序表重新编写求得表C的算法
(1)假设在同一表(A或B)中可能存在值相同的元素,但要求新生成的表C中的元素值各不相同;
(2)利用A表空间存放表C。 

本题代码如下

sqlist jiaoji(sqlist* a, sqlist* b)
{
	int i = 0; // 定义一个整型变量，用于遍历顺序表a
	int j = 0; // 定义一个整型变量，用于遍历顺序表b
	int k = 0; // 定义一个整型变量，用于记录交集元素在结果中的位置
	int c[Max];
	for (i = 0; i < a->length; i++)
		c[i] = a->s[i];
	i = 0;
	while (i < a->length && j < b->length) // 当两个顺序表都没有遍历完时，进行循环
	{
		if (c[i] == b->s[j]) // 如果顺序表a和b当前位置的元素相等
		{
			a->s[k++] = c[i++]; // 将该元素添加到交集结果中，并将交集长度加1
			j++; // 顺序表b的指针向后移动一位
		}
		else if (c[i] < b->s[j]) // 如果顺序表a当前位置的元素小于顺序表b当前位置的元素
		{
			i++; // 顺序表a的指针向后移动一位
		}
		else // 如果顺序表a当前位置的元素大于顺序表b当前位置的元素
		{
			j++; // 顺序表b的指针向后移动一位
		}
	}
	a->length = k;
	return *a; // 返回交集结果
}

完整测试代码如下

#include<stdio.h>
#define Max 10
typedef struct sqlist
{
	int s[Max]; // 定义一个结构体数组，用于存储顺序表的元素
	int length; // 定义一个整型变量，用于存储顺序表的长度
}sqlist;
// 定义一个函数，用于求两个顺序表的交集
sqlist jiaoji(sqlist* a, sqlist* b)
{
	int i = 0; // 定义一个整型变量，用于遍历顺序表a
	int j = 0; // 定义一个整型变量，用于遍历顺序表b
	int k = 0; // 定义一个整型变量，用于记录交集元素在结果中的位置
	int c[Max];
	for (i = 0; i < a->length; i++)
		c[i] = a->s[i];
	i = 0;
	while (i < a->length && j < b->length) // 当两个顺序表都没有遍历完时，进行循环
	{
		if (c[i] == b->s[j]) // 如果顺序表a和b当前位置的元素相等
		{
			a->s[k++] = c[i++]; // 将该元素添加到交集结果中，并将交集长度加1
			j++; // 顺序表b的指针向后移动一位
		}
		else if (c[i] < b->s[j]) // 如果顺序表a当前位置的元素小于顺序表b当前位置的元素
		{
			i++; // 顺序表a的指针向后移动一位
		}
		else // 如果顺序表a当前位置的元素大于顺序表b当前位置的元素
		{
			j++; // 顺序表b的指针向后移动一位
		}
	}
	a->length = k;
	return *a; // 返回交集结果
}
int main()
{
	sqlist a, b; // 定义两个顺序表变量a和b
	int i = 0; // 定义一个整型变量，用于遍历顺序表a和b
	a.length = 5; // 设置顺序表a的长度为5
	b.length = 5; // 设置顺序表b的长度为5
	printf("请输入A顺序表的元素："); // 提示用户输入顺序表a的元素
	for (i = 0; i < a.length; i++) // 遍历顺序表a
		scanf("%d", &a.s[i]); // 读取用户输入的元素并存储到顺序表a中
	printf("请输入B顺序表的元素："); // 提示用户输入顺序表b的元素
	for (i = 0; i < b.length; i++) // 遍历顺序表b
		scanf("%d", &b.s[i]); // 读取用户输入的元素并存储到顺序表b中
	sqlist c = jiaoji(&a, &b); // 调用函数求两个顺序表的交集，并将结果存储到变量c中
	printf("交集存于A顺序表中的元素："); // 提示用户输出交集结果
	for (i = 0; i < c.length; i++) // 遍历交集结果
		printf("%d ", c.s[i]); // 输出交集结果中的每个元素
	return 0; // 程序正常结束，返回0
}

测试结果为

2.28 对2.25题的条件作以下两点修改,对单链表重新编写求得表C的算法
(1)假设在同一表(A或B)中可能存在值相同的元素,但要求新生成的表C中的元素值各不相同;
(2)利用A表空间存放表C。

本题代码如下

linklist Union(linklist* A, linklist* B)
{
	lnode* ra = (*A)->next, * rb = (*B)->next;
	(*A)->next = NULL;
	lnode* r = *A;
	while (ra && rb)
	{
		if (ra->data<rb->data)//若A中当前结点小于B中当前结点值
		{
			r->next = ra;
			r = ra;
			ra = ra->next;
			r->next = NULL;
		}
		else if (ra->data>rb->data)//若A中当前结点大于B中当前结点值
		{
			r->next = rb;
			r = rb;
			rb = rb->next;
			r->next = NULL;
		}
		else
		{
			r->next = ra;
			r = ra;
			ra = ra->next;
			rb= rb->next;
			r->next = NULL;
		}
	}
	r->next = NULL; //结果表的表尾结点置空
	return *A;
}

完整测试代码如下

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode, * linklist;
int na = 5;
int nb = 5;
int a[5] = { 1,3,5,7,9};
int b[5] = {1,2,3,4,5};
void buildlinklist(linklist* L, int arr[], int n)//创建链表
{
	*L = (lnode*)malloc(sizeof(lnode));
	(*L)->next = NULL;
	lnode* s = *L, * r = *L;
	int i = 0;
	for (i = 0; i < n; i++)
	{
		s = (lnode*)malloc(sizeof(lnode));
		s->data = arr[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
linklist Union(linklist* A, linklist* B)
{
	lnode* ra = (*A)->next, * rb = (*B)->next;
	(*A)->next = NULL;
	lnode* r = *A;
	while (ra && rb)
	{
		if (ra->data<rb->data)//若A中当前结点小于B中当前结点值
		{
			r->next = ra;
			r = ra;
			ra = ra->next;
			r->next = NULL;
		}
		else if (ra->data>rb->data)//若A中当前结点大于B中当前结点值
		{
			r->next = rb;
			r = rb;
			rb = rb->next;
			r->next = NULL;
		}
		else
		{
			r->next = ra;
			r = ra;
			ra = ra->next;
			rb= rb->next;
			r->next = NULL;
		}
	}
	r->next = NULL; //结果表的表尾结点置空
	return *A;
}
void print(linklist* L)//输出单链表
{
	lnode* k = (*L)->next;
	while (k)
	{
		printf("%d ", k->data);
		k = k->next;
	}
}
int main()
{
	linklist A, B;
	buildlinklist(&A, a, na);
	buildlinklist(&B, b, nb);
	printf("A链表为：");
	print(&A);
	printf("\nB链表为：");
	print(&B);
	linklist C = Union(&A, &B);
	printf("\n两个表元素交集的链表为：");
	print(&C);
	return 0;
}

2.29 已知A,B和C为三个递增有序的线性表,现要求对A表作如下操作:删去那些既在B表中出现又在C表中出现的元素。试对顺序表编写实现上述操作的算法,并分析你的算法的时间复杂度(注意:题中没有特别指明同一表中的元素值各不相同)。

本题代码如下

void delete_common_elements(int A[], int B[], int C[], int* lenA, int* lenB, int* lenC) 
{
    int i = 0, j = 0, k = 0;
    while (i < *lenA && j < *lenB && k < *lenC) 
    {
        if (A[i] == B[j] && A[i] == C[k])
        {
            for (int m = i; m < *lenA - 1; m++) 
            {
                A[m] = A[m + 1];
            }
            (*lenA)--;
        }
        else if (A[i] < B[j]) 
        {
            j++;
        }
        else if (A[i] < C[k])
        {
           k++;
        }
        else 
        {
            i++;
        }
    }
}

完整测试代码为

#include <stdio.h>
void delete_common_elements(int A[], int B[], int C[], int* lenA, int* lenB, int* lenC) 
{
    int i = 0, j = 0, k = 0;
    while (i < *lenA && j < *lenB && k < *lenC) 
    {
        if (A[i] == B[j] && A[i] == C[k])
        {
            for (int m = i; m < *lenA - 1; m++) 
            {
                A[m] = A[m + 1];
            }
            (*lenA)--;
        }
        else if (A[i] < B[j]) 
        {
            j++;
        }
        else if (A[i] < C[k])
        {
            k++;
        }
        else 
        {
            i++;
        }
    }
}
int main() {
    int A[] = { 1, 2, 3, 4, 5 };
    int B[] = { 2, 3, 4,5,6 };
    int C[] = { 3, 4, 5,6,7 };
    int lenA = sizeof(A) / sizeof(A[0]);
    int lenB = sizeof(B) / sizeof(B[0]);
    int lenC = sizeof(C) / sizeof(C[0]);
    delete_common_elements(A, B, C, &lenA, &lenB, &lenC);
    for (int i = 0; i < lenA; i++) {
        printf("%d ", A[i]);
    }
    return 0;
}

 测试结果为

2.30 要求同2.29题.试对单链表编写算法,请释放A表中的无用结点空间。

本题代码如下

void deleterepeat(linklist* A, linklist* B, linklist* C)
{
	lnode* ra = (*A)->next, *rb = (*B)->next, * rc = (*C)->next;
	lnode* r = *A,*q;
	while (ra&&rb&&rc)
	{
			if (ra->data == rb->data && ra->data == rc->data)
			{
				q = ra;
				r->next = ra->next;
				ra = ra->next;
				rb = rb->next;
				rc = rc->next;
                free(q);
			}
			else if(rb->data<ra->data)
			{
				rb = rb->next;
			}
			else if (rc->data < ra->data)
			{
				rc = rc->next;
			}
			else
			{
				r = ra;
				ra = ra->next;
			}
	}
}

完整测试代码如下

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode,*linklist;
int a[5] = { 2,3,4,5,6 };
int b[5] = { 3,4,5,6,7 };
int c[5] = { 1,2,3,4,5 };
int n = 5;
void buildlinklist(linklist* L,int str[])
{
	*L = (lnode*)malloc(sizeof(lnode));
	(*L)->next = NULL;
	lnode* s, * r = *L;
	int i = 0;
	for (i = 0; i < n; i++)
	{
		s = (lnode*)malloc(sizeof(lnode));
		s->data = str[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
void deleterepeat(linklist* A, linklist* B, linklist* C)
{
	lnode* ra = (*A)->next, *rb = (*B)->next, * rc = (*C)->next;
	lnode* r = *A,*q;
	while (ra&&rb&&rc)
	{
			if (ra->data == rb->data && ra->data == rc->data)
			{
				q = ra;
				r->next = ra->next;
				ra = ra->next;
				rb = rb->next;
				rc = rc->next;
                free(q);
			}
			else if(rb->data<ra->data)
			{
				rb = rb->next;
			}
			else if (rc->data < ra->data)
			{
				rc = rc->next;
			}
			else
			{
				r = ra;
				ra = ra->next;
			}
	}
}
void print(linklist* L)
{
	lnode* k = (*L)->next;
	while (k)
	{
		printf("%d ", k->data);
		k = k->next;
	}
}
int main()
{
	linklist A, B, C;
	buildlinklist(&A, a);
	buildlinklist(&B, b);
	buildlinklist(&C, c);
	deleterepeat(&A, &B, &C);
	printf("删除之后的A单链表中的元素为：");
	print(&A);
	return 0;
}

测试结果为

 

 

努力敲代码的小火龙
关注
  • 20
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
严蔚敏版数据结构（C语言版）算法实现代码
weixin_45741097的博客
07-15 1万+
严蔚敏版数据结构（C语言版）算法实现代码数据结构（C语言版）代码实现线性表顺序表 数据结构（C语言版）代码实现 部分采用C++的语法实现 线性表 顺序表与链表 顺序表 代码如下： #include <bits/stdc++.h> using namespace std; #define MaxSize 100 #define ElemType int #define Status int #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10
pdf数据结构题集c语言版,数据结构题集答案(c语言版)(严蔚敏-吴伟民著).pdf
weixin_32808905的博客
05-19 2878
第 1 章 绪论1.1 简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型解：数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理数据对象是性质相同的数据元素的集合，是数据的一个子集数据结构是相互之间存在一种或多种特定关系的数据元素的集合存储结构是数据...
《数据结构题集（C语言版）》第2章（线性表）习题自解答
holer的博客
04-02 3712
《数据结构题集（C语言版）》是《数据结构（C语言版）》（严蔚敏）的配套书籍。本文是第2章（线性表）习题的部分自解答，完成后经过订正、简单测试运行。
数据结构题集（c语言版）严蔚敏答案pdf
Clown_pan的博客
01-11 6万+
前言：最近在学习数据结构，在做习题的时候找答案费了一番力气，好不容易找到了，分享出来，希望想学的人找得没那么累 图书目录： 第一篇 习题与学习指导 第0章 本篇提要与作业规范 第1章 绪论(预备知识) 第2章 线性表 第3章 栈和队列 第4章 串 第5章 数组与广义表 第6章 树和二叉树 第7章 图 第8章 动态存储管理 第9章 查找 第10章 内部排序 第11章 外部排序 第12章 文件 第二...
严蔚敏数据结构p17（2.19）——p18(2.24) (c语言代码实现)
m0_46702681的博客
12-04 2090
本题代码如下完整测试代码如下测试结果为。
数据结构（严蔚敏版）与算法的实现（含全部代码）
关注网络安全、云原生安全
09-13 13万+
目录 基础 c/c++ 代码优化及常见错误 c语言位运算的妙用-程序优化 c/c++进制转换方法汇总（含全部代码） 二进制数-北邮2012研究生复试 质因子分解 除树和图外的数据结构可以使用STL: C++ STL的使用 数据结构 线性表 顺序表 循环左移（2010联考真题） 单链表 单链表相邻结点逆置(2019北邮考研真...
严蔚敏数据结构C语言版——线性表的链式存储方式详细代码
NJ_zbx的博客
03-12 1035
严蔚敏数据结构C语言版线性表的链式存储方式代码
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
chongyang_的博客
11-07 25万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 40万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
严蔚敏数据结构题集(C语言版)完整答案.doc
03-12
数据结构题集（C语言版）完整答案 本资源提供了数据结构题集的完整答案，涵盖了数据结构的基本概念、抽象数据类型、存储结构、数据类型等方面的知识点。下面是对资源中提到的知识点的详细解释： 1. 数据结构的基本...
严蔚敏数据结构题集C语言版答案
08-21
严蔚敏《数据结构题集》C语言版本答案与详解，PDF版。
严蔚敏数据结构题集 C语言版 答案
12-18
严蔚敏数据结构题集 C语言版 答案 简述下列术语:数据 数据元素 数据对象 数据结构 存储结构 数据类型和抽象数据类型
严蔚敏《数据结构(c语言版)习题集》全答案.pdf
12-30
本资源摘要信息涵盖了严蔚敏《数据结构(c语言版)习题集》全答案，涵盖了数据结构的基本概念、算法和实现细节。下面是从给定的文件中提取的知识点： 1. 冒泡排序：在 print_descending 函数中，使用冒泡排序算法来按...
严蔚敏数据结构C语言版本-可运行源码-完全C语言代码实现.zip
08-17
严蔚敏数据结构C语言版本_可运行源码_完全C语言代码实现 ----- 毕业设计，课程设计，项目源码均经过助教老师测试，运行无误，欢迎下载交流 ----- 下载后请首先打开README.md文件（如有），某些链接可能需要魔法打开...
力扣2187.完成旅途的最少时间
最新发布
Pisasama的博客
06-12 431
二分答案。
指针和数组
2301_77634163的博客
06-10 463
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
C++的算法：Kosaraju算法与Tarjan算法
全栈工程师Linda的博客
06-10 482
C++的算法：Kosaraju算法与Tarjan算法
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 735
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
严蔚敏数据结构队列代码
05-16
以下是严蔚敏老师所著《数据结构》中队列的代码实现（C语言）： ```c #define MAXQSIZE 100 // 最大队列长度 typedef int QElemType; // 队列元素类型 typedef struct{ QElemType *base; // 初始化的动态分配存储空间 int front; // 头指针，若队列不空，指向队列头元素 int rear; // 尾指针，若队列不空，指向队列尾元素的下一个位置 }SqQueue; // 初始化队列 Status InitQueue(SqQueue &Q){ Q.base = (QElemType*)malloc(MAXQSIZE * sizeof(QElemType)); if(!Q.base) exit(OVERFLOW); // 存储分配失败 Q.front = Q.rear = 0; // 队头、队尾指针置为0 return OK; } // 销毁队列 Status DestroyQueue(SqQueue &Q){ free(Q.base); Q.base = NULL; // 防止产生“野指针” Q.front = Q.rear = 0; return OK; } // 清空队列 Status ClearQueue(SqQueue &Q){ Q.front = Q.rear = 0; return OK; } // 判断队列是否为空 Status QueueEmpty(SqQueue Q){ if(Q.front == Q.rear) return TRUE; else return FALSE; } // 队列长度 int QueueLength(SqQueue Q){ return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE; } // 获取队头元素 Status GetHead(SqQueue Q, QElemType &e){ if(Q.front == Q.rear) return ERROR; // 队列为空 e = Q.base[Q.front]; return OK; } // 入队 Status EnQueue(SqQueue &Q, QElemType e){ if((Q.rear + 1) % MAXQSIZE == Q.front) return ERROR; // 队列满 Q.base[Q.rear] = e; Q.rear = (Q.rear + 1) % MAXQSIZE; return OK; } // 出队 Status DeQueue(SqQueue &Q, QElemType &e){ if(Q.front == Q.rear) return ERROR; // 队列为空 e = Q.base[Q.front]; Q.front = (Q.front + 1) % MAXQSIZE; return OK; } ``` 以上就是严蔚敏老师所著《数据结构》中队列的代码实现，希望能对你有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力敲代码的小火龙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值