2021-09-20

最新推荐文章于 2024-08-30 21:09:25 发布
最新推荐文章于 2024-08-30 21:09:25 发布
阅读量178 收藏 1
点赞数
分类专栏： 王道习题 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kankan_1234/article/details/120396191
版权

数据结构-王道-习题-顺序表（1-8）

1、从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除的元素的值。空出的位置由最后的一个元素填补，若顺序表为空，则显示错误信息并退出运行。

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct SQList {
	int * pData;
	int length=0;
	int Maxsize=10 ;
}SqList,*pSqList;
bool DelMinElement(pSqList pL, int *val);
void Traverse(pSqList pL);
void InitSqlist(pSqList pL);
int main(void){
	SqList L;
	int val;
	InitSqlist(&L);
	Traverse(&L);
	if (DelMinElement(&L, &val)) {
		printf_s("最小元素：%d  已删除！\n",val);
	}
	Traverse(&L);
	return 0;
}
void InitSqlist(pSqList pL) {
	pL->pData = (int*)malloc(sizeof(int)*pL->Maxsize);
	int a[5] = { 3,5,9,1,10 };
	for (int i = 0; i < 5; i++) {
		pL->pData[i] = a[i];
		pL->length++;
	}
	return;
}
void Traverse(pSqList pL) {
	int i;
	if (pL->length == 0) {
		exit(-1);
	}
	for (i = 0; i < pL->length; i++) {
		printf_s("%d	", pL->pData[i]);
	}
	printf_s("\n");
}
bool DelMinElement(pSqList pL, int *val) {
	if (pL->length == 0){
		printf_s("顺序表为空！\n");
		return false;
}
	int pos=0;//标记最小元素的位置
	int i;
	*val = pL->pData[0];
	for (i = 1; i < pL->length; i++) {
		if (*val > pL->pData[i]) {
			*val = pL->pData[i];
			pos = i;
		}
	}
	pL->pData[pos] = pL->pData[pL->length - 1];
	pL->length--;
	return true;
}

运行结果：
在这里插入图片描述

2、设计一个高效的算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)。

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct SQList {
	int * pData;
	int length = 0;
	int Maxsize = 10;
}SqList, *pSqList;
void Traverse(pSqList pL);
void InitSqlist(pSqList pL);
void Inversion(pSqList pL);
int main(void) {
	SqList L;
	InitSqlist(&L);
	Traverse(&L);
	printf_s("倒置\n");
	Inversion(&L);
	Traverse(&L);
	return 0;
}
void InitSqlist(pSqList pL) {//初始化
	pL->pData = (int*)malloc(sizeof(int)*pL->Maxsize);
	int a[7] = { 3,5,9,1,10,8,11 };
	for (int i = 0; i < 7; i++) {
		pL->pData[i] = a[i];
		pL->length++;
	}
	return;
}
void Traverse(pSqList pL) {//遍历
	int i;
	if (pL->length == 0) {
		exit(-1);
	}
	for (i = 0; i < pL->length; i++) {
		printf_s("%d	", pL->pData[i]);
	}
	printf_s("\n");
}
void Inversion(pSqList pL) {//倒置
	int i = 0;
	int j = pL->length -1;
	for (i, j; i < j; i++, j--) {
		int t;
		t = pL->pData[i];
		pL->pData[i] = pL->pData[j];
		pL->pData[j] = t;
	}
	return;
}

运行结果：
在这里插入图片描述

3、对长度为n的顺序表l编写一个时间复杂度为o(n)，空间复杂度为o(1) 的算法，该算法删除线性表中所有值为x的数据元素。

方法一、用k记录所有等于x的数据元素个数

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct sqlist {
	int * pdata;
	int length = 0;
	int maxsize = 15;
}sqlist, *psqlist;
void traverse(psqlist pl);//遍历
void initsqlist(psqlist pl);//初始化
void delvalofx(psqlist pl, int x);//删除
int main(void) {
	sqlist l;
	initsqlist(&l);
	traverse(&l);
	delvalofx(&l, 3);
	traverse(&l);
	return 0;
}
void initsqlist(psqlist pl) {//初始化
	pl->pdata = (int*)malloc(sizeof(int)*pl->maxsize);
	int a[10] = { 1,7,3,5,9,3,10,3,11 ,3};
	for (int i = 0; i < 10; i++) {
		pl->pdata[i] = a[i];
		pl->length++;
	}
	return;
}
void traverse(psqlist pl) {//遍历
	int i;
	if (pl->length == 0) {
		exit(-1);
	}
	for (i = 0; i < pl->length; i++) {
		printf_s("%d	", pl->pdata[i]);
	}
	printf_s("\n");
}
void delvalofx(psqlist pl, int x) {
	if (pl->length == 0)
		exit(-1);
	int k = 0;//用于记录所有等于x的数据元素个数
	int i = 0;
	while (i < pl->length) {
		if (pl->pdata[i] == x) {
			k++;
		}
		else {
			pl->pdata[i - k] = pl->pdata[i];
		}
		i++;
	}
	pl->length = pl->length - k;
	return;
}

方法二、用k记录所有不等于x的数据元素个数

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct SQList {
	int * pData;
	int length = 0;
	int Maxsize = 15;
}SqList, *pSqList;
void Traverse(pSqList pL);//遍历
void InitSqlist(pSqList pL);//初始化
void DelValOfx2(pSqList pL, int x);//删除
int main(void) {
	SqList L;
	InitSqlist(&L);
	Traverse(&L);
	DelValOfx2(&L, 3);
	Traverse(&L);
	return 0;
}
void InitSqlist(pSqList pL) {//初始化
	pL->pData = (int*)malloc(sizeof(int)*pL->Maxsize);
	int a[10] = { 1,7,3,5,9,3,10,3,11 ,3 };
	for (int i = 0; i < 10; i++) {
		pL->pData[i] = a[i];
		pL->length++;
	}
	return;
}
void Traverse(pSqList pL) {//遍历
	int i;
	if (pL->length == 0) {
		exit(-1);
	}
	for (i = 0; i < pL->length; i++) {
		printf_s("%d	", pL->pData[i]);
	}
	printf_s("\n");
}
void DelValOfx2(pSqList pL, int x) {
	if (pL->length == 0)
		exit(-1);
	int k = 0;//用于记录所有不等于x的数据元素个数
	int i = 0;
	for (i; i < pL->length; i++) {
		if (pL->pData[i] != x) {
			pL->pData[k] = pL->pData[i];
			k++;
		}
	}
	pL->length = k;
	return;
}

运行结果：
在这里插入图片描述

4、从有序顺序表中删除其值在给定值s和t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示错误信息并退出运行。

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct SQList {
	int * pData;
	int length = 0;
	int Maxsize = 15;
}SqList, *pSqList;
void Traverse(pSqList pL);//遍历
void InitSqlist(pSqList pL);//初始化
void DelBetwST(pSqList pL, int s,int t);//删除3-7之间数据
int main(void) {
	SqList L;
	InitSqlist(&L);
	Traverse(&L);
	DelBetwST(&L, 3,7);
	Traverse(&L);
	return 0;
}
void InitSqlist(pSqList pL) {//初始化
	pL->pData = (int*)malloc(sizeof(int)*pL->Maxsize);
	int a[10] = { 1,3,3,4,4,5,6,7,8 ,9 };
	for (int i = 0; i < 10; i++) {
		pL->pData[i] = a[i];
		pL->length++;
	}
	return;
}
void Traverse(pSqList pL) {//遍历
	int i;
	if (pL->length == 0) {
		exit(-1);
	}
	for (i = 0; i < pL->length; i++) {
		printf_s("%d	", pL->pData[i]);
	}
	printf_s("\n");
}
void DelBetwST(pSqList pL, int s, int t) {
	if (s >= t ) {
		printf_s("s或t值不合理\n");
		exit(-1);
	}
	if (pL->length == 0) {
		printf_s("顺序表为空\n");
		exit(-1);
	}
	int i = 0, j = 0;
	for (i; pL->pData[i] < s; i++);//用于定位到第一个大于等于s的位置
	if (i > pL->length) {
		printf_s("表中无此区间的数据存在\n");
		exit(-1);
	}
	for (j; pL->pData[j] < t; j++);//用于定位到第一个大于等于t的位置
	for (i, j; j < pL->length; i++, j++) 
		pL->pData[i] = pL->pData[j];
	pL->length = i;
	return;
}

运行结果：
在这里插入图片描述

5、从顺序表中删除其值在给定值S和t之间（包括s和t，s<t）的所有元素，若s或t不合理或顺序表为空，则显示出错误信息并退出运行。

#include <stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct SQLIST {
	int * pdata;
	int length = 0;//有效数据长度
	int Maxsize = 20;//申请空间（最大长度）
}SqList,*pSqList;
void InitSqList(pSqList pL);//初始化
void Traverse(pSqList pL);//遍历
void DelBetwst(pSqList pL,int s,int t);//删除
int main(void) {
	SqList L;
	InitSqList(&L);
	Traverse(&L);
	DelBetwst(&L,4,9);
	printf_s("删除4到9之间的所有元素!\n");
	Traverse(&L);
	return 0;
}
void InitSqList(pSqList pL) {
	pL->pdata = (int *)malloc(sizeof(int)*pL->Maxsize);
	if (pL->pdata == NULL) {
		printf_s("动态分配空间失败!\n");
		exit(-1);
	}
	int a[15] = { 3,5,2,9,3,4,10,6,8,11,4,9,13,15,1 };
	for (int i = 0; i < sizeof(a) / sizeof(int); i++) {
		pL->pdata[i] = a[i];
		pL->length++;
	}
}
void Traverse(pSqList pL) {
	int i = 0;
	if (pL->length == 0) {
		printf_s("表为空!\n");
		exit(-1);
	}
	for(i;i<pL->length;i++){
		printf_s("%d	", pL->pdata[i]);
	}
	printf_s("\n");
	return;
}
void DelBetwst(pSqList pL,int s,int t) {
	int k = 0;//记录在范围内的元素的个数
	if (s >= t) {
		printf_s("s或t输入不合法!\n");
		exit(-1);
	}
	if (pL->length == 0) {
		printf_s("表为空!\n");
		exit(-1);
	}
	for (int i = 0; i < pL->length; i++) {
		if (pL->pdata[i] >= s && pL->pdata[i] <= t)
			k++;
		else
			pL->pdata[i - k] = pL->pdata[i];
	}
	pL->length = pL->length - k;
}

运行结果：
在这里插入图片描述

6、从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不相同。

#include <stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct SQLIST {
	int * pdata;
	int length = 0;//有效数据长度
	int Maxsize = 20;//申请空间（最大长度）
}SqList, *pSqList;
void InitSqList(pSqList pL);//初始化
void Traverse(pSqList pL);//遍历
void DelTheSames(pSqList pL);//删除
int main(void) {
	SqList L;
	InitSqList(&L);
	Traverse(&L);
	DelTheSames(&L);
	printf_s("去重!\n");
	Traverse(&L);
	return 0;
}
void InitSqList(pSqList pL) {
	pL->pdata = (int *)malloc(sizeof(int)*pL->Maxsize);
	if (pL->pdata == NULL) {
		printf_s("动态分配空间失败!\n");
		exit(-1);
	}
	int a[10] = { 3,5,7,7,7,8,9,9,9,11 };
	for (int i = 0; i < sizeof(a) / sizeof(int); i++) {
		pL->pdata[i] = a[i];
		pL->length++;
	}
}
void Traverse(pSqList pL) {
	int i = 0;
	if (pL->length == 0) {
		printf_s("表为空!\n");
		exit(-1);
	}
	for (i; i < pL->length; i++) {
		printf_s("%d	", pL->pdata[i]);
	}
	printf_s("\n");
	return;
}
void DelTheSames(pSqList pL) {
	int i, j;
	if (pL->length == 0) {
		printf_s("表为空!\n");
		exit(-1);
	}
	for ( i = 0, j = 1; j < pL->length; j++) {
		if (pL->pdata[i] != pL->pdata[j]) {//有序的顺序表，相同值一定相邻
			i++;   //第一个元素即pL->pdata[0]一定存在
			pL->pdata[i] = pL->pdata[j];
		}
	}
	pL->length = i + 1;
	return;
}

运行结果：
在这里插入图片描述

7、将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表

#include <stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct SQLIST {
	int * pdata;
	int length = 0;//有效数据长度
	int Maxsize = 20;//申请空间（最大长度）
}SqList, *pSqList;
void InitSqList(pSqList pL1, pSqList pL2, pSqList pL3);//初始化
void Traverse(pSqList pL);//遍历
void MergeTwo(pSqList pL1, pSqList pL2, pSqList pL3);//合并两个表
int main(void) {
	SqList L1,L2,L3;
	InitSqList(&L1, &L2, &L3);
	Traverse(&L1);
	Traverse(&L2);
	printf_s("合并:\n");
	MergeTwo(&L1, &L2, &L3);
	Traverse(&L3);
	return 0;
}
void InitSqList(pSqList pL1, pSqList pL2, pSqList pL3) {
	pL1->pdata = (int *)malloc(sizeof(int)*pL1->Maxsize);
	pL2->pdata = (int *)malloc(sizeof(int)*pL1->Maxsize);
	pL3->pdata = (int *)malloc(sizeof(int)*pL1->Maxsize);
	if (pL1->pdata == NULL) {
		printf_s("pL1动态分配空间失败!\n");
		exit(-1);
	}
	if (pL2->pdata == NULL) {
		printf_s("pL2动态分配空间失败!\n");
		exit(-1);
	}
	if (pL3->pdata == NULL) {
		printf_s("pL3动态分配空间失败!\n");
		exit(-1);
	}
	int a1[5] = { 2,3,4,6,8};
	int a2[7] = { 3,5,6,7,8,9,15};
	for (int i = 0; i < sizeof(a1) / sizeof(int); i++) {
		pL1->pdata[i] = a1[i];
		pL1->length++;
	}
	for (int i = 0; i < sizeof(a2) / sizeof(int); i++) {
		pL2->pdata[i] = a2[i];
		pL2->length++;
	}
}
void Traverse(pSqList pL) {
	int i = 0;
	if (pL->length == 0) {
		printf_s("表为空!\n");
		exit(-1);
	}
	for (i; i < pL->length; i++) {
		printf_s("%d	", pL->pdata[i]);
	}
	printf_s("\n");
	return;
}
void MergeTwo(pSqList pL1, pSqList pL2, pSqList pL3) {
	int i=0, j=0,k=0;
	if ((pL1->length + pL2->length) > pL3->Maxsize) {
		printf_s("两个表长度之和超出最大范围!\n");
		exit(-1);
	}
	while (i < pL1->length&&j < pL2->length) {
		if (pL1->pdata[i] <= pL2->pdata[j])
			pL3->pdata[k++] = pL1->pdata[i++];
		else
			pL3->pdata[k++] = pL2->pdata[j++];
	}
	while (i < pL1->length) {
		pL3->pdata[k++] = pL1->pdata[i++];
	}
	while (j < pL2->length) {
		pL3->pdata[k++] = pL2->pdata[j++];
	}
	pL3->length = k;
	return;
}

运行结果：
在这里插入图片描述

8、题目8：已知一维数组A[m+n]中依次存放两个线性表（a1，a2，，am），和（b1，b2，，，bn）。试编写一个函数，将数组中两个顺序表的位置互换，即将（b1，b2，，，bn）放在（a1，a2，，am）前面。

#include <stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct SQLIST {
	int * pdata;
	int length = 0;//有效数据长度
	int Maxsize = 20;//申请空间（最大长度）
}SqList, *pSqList;
void InitSqList(pSqList pL1, pSqList pL2, pSqList pL3);//初始化
void Traverse(pSqList pL);//遍历
void MergeTwo(pSqList pL1, pSqList pL2, pSqList pL3);//合并两个表
int GetLength(pSqList pL);//获取顺序表的长度
void Reverse(pSqList pL, int left, int right);//倒置
int main(void) {
	SqList L1, L2, L3;
	InitSqList(&L1, &L2, &L3);
	printf_s("L1:	");
	Traverse(&L1);
	printf_s("L2:	");
	Traverse(&L2);
	printf_s("合并L3:	");
	MergeTwo(&L1, &L2, &L3);
	Traverse(&L3);
	int m = GetLength(&L1);
	int n = GetLength(&L2);
	printf_s("实现L1和L2位置的交换:\n");
	Reverse(&L3, 0, m + n - 1);
	Reverse(&L3, 0, n - 1);/*第一次整体倒置后，前m个现在是后m个并为倒置的；
	原第二部分即后n个现在是前n个，且为倒置的，此时要分别把两部分的次
	序恢复,此时的第一部分再倒置一次，第二部分在倒置一次。
	*/
	Reverse(&L3, n, m + n - 1);
	Traverse(&L3);
	return 0;
}
void InitSqList(pSqList pL1, pSqList pL2, pSqList pL3) {
	pL1->pdata = (int *)malloc(sizeof(int)*pL1->Maxsize);
	pL2->pdata = (int *)malloc(sizeof(int)*pL1->Maxsize);
	pL3->pdata = (int *)malloc(sizeof(int)*pL1->Maxsize);
	if (pL1->pdata == NULL) {
		printf_s("pL1动态分配空间失败!\n");
		exit(-1);
	}
	if (pL2->pdata == NULL) {
		printf_s("pL2动态分配空间失败!\n");
		exit(-1);
	}
	if (pL3->pdata == NULL) {
		printf_s("pL3动态分配空间失败!\n");
		exit(-1);
	}
	int a1[5] = { 1,2,3,4,5 };
	int a2[7] = { 6,7,8,9,10,11,12 };
	for (int i = 0; i < sizeof(a1) / sizeof(int); i++) {
		pL1->pdata[i] = a1[i];
		pL1->length++;
	}
	for (int i = 0; i < sizeof(a2) / sizeof(int); i++) {
		pL2->pdata[i] = a2[i];
		pL2->length++;
	}
}
void Traverse(pSqList pL) {
	int i = 0;
	if (pL->length == 0) {
		printf_s("表为空!\n");
		exit(-1);
	}
	for (i; i < pL->length; i++) {
		printf_s("%d	", pL->pdata[i]);
	}
	printf_s("\n");
	return;
}
void MergeTwo(pSqList pL1, pSqList pL2, pSqList pL3) {
	int i = 0, j = 0, k = 0;
	if ((pL1->length + pL2->length) > pL3->Maxsize) {
		printf_s("两个表长度之和超出最大范围!\n");
		exit(-1);
	}
	while (i < pL1->length&&j < pL2->length) {
		if (pL1->pdata[i] <= pL2->pdata[j])
			pL3->pdata[k++] = pL1->pdata[i++];
		else
			pL3->pdata[k++] = pL2->pdata[j++];
	}
	while (i < pL1->length) {
		pL3->pdata[k++] = pL1->pdata[i++];
	}
	while (j < pL2->length) {
		pL3->pdata[k++] = pL2->pdata[j++];
	}
	pL3->length = k;
	return;
}
int GetLength(pSqList pL) {
	int l = pL->length;
	return l;
}
void Reverse(pSqList pL, int left, int right) {
	if (pL->length == 0) {
		printf_s("顺序表为空!\n");
		exit(-1);
	}
	int i = left, j = right;
	int t = 0;
	for (i, j; i < j; i++, j--) {
		t = pL->pdata[i];
		pL->pdata[i] = pL->pdata[j];
		pL->pdata[j] = t;
	}
}

运行结果：
在这里插入图片描述

Evekkan
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
顺序表删除所有值为e的元素
又菜又爱玩的博客
09-24 2027
#include <stdio.h> #include <stdlib.h> #define MAXSIZE 20 //定义结构体 typedef struct sqlist{ int *data; int length; }Sqlist; //创建线性表 void creatList(Sqlist &L){ //开辟一个大小为 MAXSIZE 的空间 L.data = (int *)malloc(sizeof(int) * MAXSIZE); //判断开辟
删除线性表中所有为e的数据
段一的博客
06-28 676
对于长度为n的线性表，编写一个时间复杂度为O（n）、空间复杂度为O（1）的算法，算法删除线性表中所有值为e的数据元素。
6、顺序表区间元素删除——Linkedlist（java数据结构）
weixin_47202652的博客
10-18 1183
顺序表区间元素删除 若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。 输入格式: 三行数据，第一行是顺序表的元素个数，第二行是顺序表的元素，第三行是x和y。 输出格式: 删除元素值在[x,y]之间的所有元素后的顺序表。 输入样例: 10 5 1 9 10 67 12 8 33 6 2 3 10 输出样例: 1 67 12 33 2 代码如下： import java.util.LinkedLi
实验1.1 顺序表的操作
weixin_47500703的博客
10-17 1288
顺序表的操作头文件结构体的定义函数声明主函数建立线性表输出线性表在线性表的第i个位置插入元素e删除第i个元素并返回其值查找值为e的元素并返回它的位置输出结果*L 和 L 和 *L 和 ***&L** 欢迎评论区指正及讨论 头文件 #include<stdio.h> #include<stdlib.h> #define MAXSIZE 20 //定义最大存储内存为20 结构体的定义 typedef int ElemType;//数据元素的类型 typedef struct
顺序表——插入删除与查找
PD137的博客
04-27 241
一、【顺序表——插入删除与查找】#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define MAX 20 #define LISTINCREMENT 10 typedef struct{ int *elem; int length; int listsize; }SqList; void CreatLis...
TypeError: Cannot convert input [0 2021-11-16 1 2021-09-20 2 2021-05-28 Name: 合同开始日期, dtype: datetime64[ns]] of type <class 'pandas.core.series.Series'> to Timestamp
05-30
s = pd.Series(['2021-11-16', '2021-09-20', '2021-05-28'], name='合同开始日期') # 将第一个元素转换为Timestamp类型 timestamp = pd.to_datetime(s.iloc[0]) ``` 这样就可以得到一个Timestamp类型的变量...
2021-Spring-CA-課程綱要 Syllabus-2021-03-09.pdf
03-15
根据给定文件信息，以下是关于“2021-Spring-CA-課程綱要 Syllabus-2021-03-09.pdf”文件的详细知识点说明： 1. 课程概述 课程名称为《計算機架構》（Computer Architecture），属于研究生课程，由单智君（Jean Jyh...
2021-11-09 13-38-20.mp4
03-25
2021-11-09 13-38-20.mp4
顺序表的定义及其建立、插入、删除、查找、遍历、排序、合并、归并等操作的实现
qq_46009045的博客
05-21 1076
顺序表的定义及其建立、插入、删除、查找、遍历、排序、合并、归并等操作的实现 ```cpp #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #include<iostream> using namespace std; //线性表的顺序储存结构 typedef int ElemType; //定义ElemType为int类型 typedef struct{ ElemType *data; //存放顺序表中的元素 int
数据结构C语言实现——顺序线性表SqList
热门推荐
小刘同学_iOS的专栏
08-12 1万+
数据结构与算法是语言学习中的重点与难点。之前没学好，现在特地将严蔚敏的《数据结构》C语言版中的伪代码，予以实现，算作是自己再学习一次。同时希望能帮助到那些刚接触数据结构，对书中内容还不甚理解不知如何动手实现的童鞋。本篇是实现简单的顺序线性表，实现书中算法2.1和算法2.6。
算法设计题目一 顺序表查找
中国好利鹏
10-14 3168
/**/ #include "stdio.h" #include "malloc.h" #define LIST_SIZE 20   typedef struct{          charr[LIST_SIZE];          intlength; //length为表中元素的个数 }RecordList;   RecordList *SqLset(){  //建
算法设计题——顺序表
WYMei_529
12-05 1681
请写一个算法，在顺序表中查找指定的数据，查找成功则将该记录放到顺序表的最前面，而把其他记录后退到有限个位置。
王道——顺序表编程题
qq_43287952的博客
01-17 818
1.从顺序表中删除具有最小值的元素（假设唯一）并有函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。 struct ll { int nums[10]= {1,3,4,9,7,5,2,6,8,0}; int length=10; int max_size=10; int del_min() { if(length==0) { cout<<"顺序表为空".
查找算法--顺序表查找
u012256398的专栏
03-29 877
    查找又称检索，是指在某种数据结构中找出满足给定条件的元素。若在查找的同时对表做修改运算(如插入删除），则相应的表称为动态查找表，否则，称为静态查找表。我们分别从线性表查找，树表查找和哈希表查找来分析总结查找算法。   线性表查找  线性表是最简单的一种表的组织方式，我们不考虑在查找的同时对表做修改，即在静态表上进行查找 1）顺序查找 基本思路：       从表中一端开始，...
树、二叉树
最新发布
2301_79909332的博客
08-30 550
1、满二叉树：满二叉树是一种特殊的二叉树，其中每个层级的节点数都是最大值，即每个层级都是完全填充的。深度： 从根节点出发到达节点的分支节点个数称为该节点的深度。高度：从叶子节点出发到该节点最大的节点个数称为该节点的高度。树的高度：整个树形结构中高度最高的节点的高度称为树的高度。树的深度：整个树形结构中深度最深的节点的深度称为树的深度。3、二叉树特点：叶子节点、只有左孩子、只有右孩子、左右孩子都有。树的层数 == 树的高度 == 树的深度。3.叶子节点：没有后继的节点。节点的度： 叶子节点度数为0。
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 917
数组，双链表实现队列，附完整代码
【数据结构】-----哈希
m0_73470633的博客
08-29 1641
一文看懂哈希结构！
数据结构-单链表-详解-1
2401_86587256的博客
08-30 1665
数据结构初阶部分，单链表的详解-1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Evekkan

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

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

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

打赏作者

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

抵扣说明：

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

余额充值