DS|顺序表

已于 2023-12-17 18:13:32 修改
阅读量245 收藏
点赞数
分类专栏： DS 文章标签： 算法 开发语言 C++
于 2023-12-17 18:11:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2203_75720729/article/details/135044213
版权

问题一：DS顺序表--存储结构与操作

题目描述：

实现顺序表的存储结构和操作

属性包括：数组、实际长度、最大长度（设定为1000）

操作包括：创建、插入、删除、查找

输入要求：

第1行先输入n表示有n个数据，即n是实际长度；接着输入n个数据
第2行输入要插入的位置和新数据
第3行输入要插入的位置和新数据
第4行输入要删除的位置
第5行输入要删除的位置
第6行输入要查找的位置
第7行输入要查找的位置

输出要求：

数据之间用空格隔开

第1行输出创建后的顺序表内容，包括顺序表实际长度和数据

每成功执行一次操作（插入或删除），输出执行后的顺序表内容

每成功执行一次查找，输出查找到的数据

如果执行操作失败（包括插入、删除、查找等失败），输出字符串error，不必输出顺序表内容

输入样例：

6 11 22 33 44 55 66
3 777
1 888
1
9
0
5

输出样例：

6 11 22 33 44 55 66 
7 11 22 777 33 44 55 66 
8 888 11 22 777 33 44 55 66 
7 11 22 777 33 44 55 66 
error
error
44

代码示例：

#include <iostream>
using namespace std;

#define MAX_SIZE 100

class SList {
public:
	SList();
	~SList();
	void InitList(int arr[], int n);
	int Insert(int x, int pos);
	int Delete(int pos);
	int Get(int i);
	void Display();
	void Operation();
private:
	int* data;
	int lenth;
	int listsize;
};
//无参构造
SList::SList(){
	data = new int[MAX_SIZE];
	listsize = MAX_SIZE;
	lenth = 0;
}
//初始化链表
void SList::InitList(int arr[], int n){
	for (int i = 0; i < n; i++)	data[i] = arr[i];
	lenth = n;
}
//插入数据
int SList::Insert(int x, int pos){
	if ((pos < 1) || (pos > lenth + 1)){
		cout << "error" << endl;
		return 0;
	}
	else{
		for (int i = lenth; i >= pos; i--) data[i] = data[i - 1];
		data[pos - 1] = x;
		lenth++;
		return 1;
	}
}
//删除数据
int SList::Delete(int pos){
	if ((pos < 1) || (pos > lenth)){
		cout << "error" << endl;
		return 0;
	}
	else{
		for (int i = pos; i < lenth; i++) data[i - 1] = data[i];
		lenth--;
		return 1;
	}
}
//获取数据
int SList::Get(int pos){
	if ((pos < 1) || (pos > lenth)) return 0;
	else return data[pos - 1];
}
//打印链表
void SList::Display(){
	cout << lenth << " ";
	for (int i = 0; i < lenth; i++) cout << data[i] << " ";
	cout << endl;
}
//执行操作
void SList::Operation() {
	int number, site;

	//插入两个数
	for (int i = 0; i < 2; i++) {
		cin >> site >> number;
		if (Insert(number, site)) Display();
	}
	//删除两个数
	for (int i = 0; i < 2; i++) {
		cin >> number;
		if (Delete(number)) Display();
	}
	//查找两个数
	for (int i = 0; i < 2; i++) {
		cin >> site;
		if (Get(site) != NULL)cout << Get(site);
		else cout << "error" << endl;
	}
}

SList::~SList(){
	delete[]data;
}

int main() {
	SList slist;
	int n;
	cin >> n;
	int* array = new int[n];
	for (int i = 0; i < n; i++) cin >> array[i];
	slist.InitList(array, n);
	slist.Display();
	slist.Operation();
	return 0;
}

问题二：DS顺序表--连续操作

题目描述：

建立顺序表的存储结构，属性包括：数组、实际长度、最大长度（设定为1000）

编写如下函数

实现顺序表的初始化函数。

插入多个数据的multiinsert(int i, int n, int item[])函数，实现在第i个位置，连续插入来自数组item的n个数据，即从位置i开始插入多个数据。

删除多个数据的multidel(int i, int n)函数，实现从第i个位置开始，连续删除n个数据，即从位置i开始删除多个数据。

编写main函数测试该顺序表。

输入要求：

第1行先输入n表示有n个数据，即n是实际长度；接着输入n个数据

第2行先输入i表示插入开始的位置，再输入k表示有k个插入数据，接着输入k个数据

第3行先输入i表示删除开始的位置，再输入k表示要删除k个数据

输出要求：

顺序表内容包括顺序表的实际长度和数据，数据之间用空格隔开

第1行输出创建后的顺序表内容

第2行输出执行连续插入后的顺序表内容

第3行输出执行连续删除后的顺序表内容

输入样例：

6 11 22 33 44 55 66
2 3 99 88 77
4 5

输出样例：

6 11 22 33 44 55 66 
9 11 99 88 77 22 33 44 55 66 
4 11 99 88 66

代码示例：

#include <iostream>
using namespace std;

#define MAX_SIZE 100

class SList {
public:
	SList();
	~SList();
	void InitList(int arr[], int n);
	int Insert(int x, int pos);
	int Delete(int pos);
	int Get(int pos);
	int multInsert(int pos, int n, int arr[]);
	int multiDel(int i, int n);
	void Display();
	void Operation();
private:
	int* data;
	int lenth;
	int listsize;
};
//无参构造
SList::SList(){
	data = new int[MAX_SIZE];
	listsize = MAX_SIZE;
	lenth = 0;
}
//初始化链表
void SList::InitList(int arr[], int n){
	for (int i = 0; i < n; i++)	data[i] = arr[i];
	lenth = n;
}
//插入数据
int SList::Insert(int x, int pos){
	if ((pos < 1) || (pos > lenth + 1)){
		cout << "error" << endl;
		return 0;
	}
	else{
		for (int i = lenth; i >= pos; i--) data[i] = data[i - 1];
		data[pos - 1] = x;
		lenth++;
		return 1;
	}
}
//删除数据
int SList::Delete(int pos){
	if ((pos < 1) || (pos > lenth)){
		cout << "error" << endl;
		return 0;
	}
	else{
		for (int i = pos; i < lenth; i++) data[i - 1] = data[i];
		lenth--;
		return 1;
	}
}
//获取数据
int SList::Get(int pos){
	if ((pos < 1) || (pos > lenth)) return 0;
	else return data[pos - 1];
}
//插入多个数据
int SList::multInsert(int pos, int n, int arr[]) {
	if (pos < 1 || pos > lenth + 1){
		cout << "error" << endl;
		return 0;
	}
	else {
		for (int i = lenth + n - 1; i >= pos + n - 1; i--) data[i] = data[i - n];
		for (int i = 0; i < n; i++)data[pos + i - 1] = arr[i];
		lenth += n;
		return 1;
	}
}
//删除多个数据
int SList::multiDel(int pos, int n) {
	if (pos < 1 || pos > lenth) {
		cout << "error" << endl;
		return 0;
	}
	else {
		for (int i = 0; i < n; i++) {
			data[pos - 1 + i] = data[pos - 1 + i + n];
		}
		lenth -= n;
		return 1;
	}
}
//打印链表
void SList::Display(){
	cout << lenth << " ";
	for (int i = 0; i < lenth; i++) cout << data[i] << " ";
	cout << endl;
}
//执行操作
void SList::Operation() {
	int number, site;
	cin >> site >> number;
	int* array = new int[number];
	for (int i = 0; i < number; i++) {
		cin >> array[i];
	}
	if (multInsert(site, number, array)) Display();
	else cout << "error" <<  endl;

	cin >> site >> number;
	if (multiDel(site, number)) Display();
	else cout << "error" << endl;
}

SList::~SList(){
	delete[]data;
}

int main() {
	SList slist;
	int n;
	cin >> n;
	int* array = new int[n];
	for (int i = 0; i < n; i++) cin >> array[i];
	slist.InitList(array, n);
	slist.Display();
	slist.Operation();
	return 0;
}

问题三：DS顺序表--合并操作

题目描述：

建立顺序表数据类型，属性包括：数组、实际长度、最大长度（设定为1000）

已知两个递增序列，把两个序列的数据合并到顺序表中，并使得顺序表的数据递增有序

输入要求：

第1行先输入n表示有n个数据，接着输入n个数据，表示第1个序列，要求数据递增互不等

第2行先输入m表示有m个数据，接着输入m个数据，表示第2个序列，要求数据递增互不等

输出要求：

顺序表内容包括顺序表的实际长度和数据，数据之间用空格隔开

第1行输出创建后的顺序表内容

输入样例：

3 11 33 55
5 22 44 66 88 99

输出样例：

3 11 33 55
5 22 44 66 88 99

代码示例：

#include <iostream>
using namespace std;

#define MAX_SIZE 100

class SList {
public:
	SList();
	~SList();
	void InitList(int arr[], int n);
	int Insert(int x, int pos);
	int Delete(int pos);
	int Get(int pos);
	int multInsert(int pos, int n, int arr[]);
	int multiDel(int i, int n);
	void Add(int arr[], int n, int brr[], int m);
	void Display();
	void Operation();
private:
	int* data;
	int lenth;
	int listsize;
};
//无参构造
SList::SList(){
	data = new int[MAX_SIZE];
	listsize = MAX_SIZE;
	lenth = 0;
}
//初始化链表
void SList::InitList(int arr[], int n){
	for (int i = 0; i < n; i++)	data[i] = arr[i];
	lenth = n;
}
//插入数据
int SList::Insert(int x, int pos){
	if ((pos < 1) || (pos > lenth + 1)){
		cout << "error" << endl;
		return 0;
	}
	else{
		for (int i = lenth; i >= pos; i--) data[i] = data[i - 1];
		data[pos - 1] = x;
		lenth++;
		return 1;
	}
}
//删除数据
int SList::Delete(int pos){
	if ((pos < 1) || (pos > lenth)){
		cout << "error" << endl;
		return 0;
	}
	else{
		for (int i = pos; i < lenth; i++) data[i - 1] = data[i];
		lenth--;
		return 1;
	}
}
//获取数据
int SList::Get(int pos){
	if ((pos < 1) || (pos > lenth)) return 0;
	else return data[pos - 1];
}
//插入多个数据
int SList::multInsert(int pos, int n, int arr[]) {
	if (pos < 1 || pos > lenth + 1){
		cout << "error" << endl;
		return 0;
	}
	else {
		for (int i = lenth + n - 1; i >= pos + n - 1; i--) data[i] = data[i - n];
		for (int i = 0; i < n; i++)data[pos + i - 1] = arr[i];
		lenth += n;
		return 1;
	}
}
//删除多个数据
int SList::multiDel(int pos, int n) {
	if (pos < 1 || pos > lenth) {
		cout << "error" << endl;
		return 0;
	}
	else {
		for (int i = 0; i < n; i++) {
			data[pos - 1 + i] = data[pos - 1 + i + n];
		}
		lenth -= n;
		return 1;
	}
}
//合并两个链表
void SList::Add(int arr[], int n, int brr[], int m) {
	lenth = m + n;
	int j = 0, k = 0;
	for (int i = 0; i < m + n; i++) {
		if (*(arr + j) <= *(brr + k) && j < n) *(data + i) = *(arr + j), j++;
		else if (*(arr + j) >= *(brr + k) && k < m) *(data + i) = *(brr + k), k++;
		else if (j == n) *(data + i) = *(brr + k), k++;
		else if (k == m) *(data + i) = *(arr + j), j++;
	}
}
//打印链表
void SList::Display(){
	cout << lenth << " ";
	for (int i = 0; i < lenth; i++) cout << data[i] << " ";
	cout << endl;
}
//执行操作
void SList::Operation() {}

SList::~SList(){
	delete[]data;
}

int main() {
	SList slist;
	int n;
	cin >> n;
	int* array = new int[n];
	for (int i = 0; i < n; i++) cin >> array[i];
	
	int m;
	cin >> m;
	int* brray = new int[m];
	for (int i = 0; i < m; i++) cin >> brray[i];
	slist.Add(array, n, brray, m);
	slist.Display();
	return 0;
}

问题四：DS顺序表--循环移位

题目描述：

顺序表的移位是循环移位，例如顺序表：1，2，3，4，5，6。如果左移1位，即原来的头元素移动到末尾，其它元素向左移1位，变成2，3，4，5，6，1。同理，如果右移1位，即原来的尾元素移动到头，其它元素向右移1位，变成6，1，2，3，4，5。以下是移位的多个例子：

原数据：1，2，3，4，5，6

左移3位：4，5，6，1，2，3，与原数据对比

右移4位：3，4，5，6，1，2，与原数据对比

请编写程序实现顺序表的循环移位操作

输入要求：

第1行输入n表示顺序表包含的·n个数据

第2行输入n个数据，数据是小于100的正整数

第3行输入移动方向和移动的位数，左移方向为0，右移方向为1

第4行输入移动方向和移动的位数，左移方向为0，右移方向为1

注意：移动操作是针对上一次移动后的结果进行的

输出要求：

第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开

第二行输出第一次移位操作后，顺序表内的所有数据，数据之间用空格隔开

第三行输出第二次移位操作后，顺序表内的所有数据，数据之间用空格隔开

输入样例：

5
11 22 33 44 55
0 2
1 4

输出样例：

11 22 33 44 55 
33 44 55 11 22 
44 55 11 22 33

代码示例：

#include <iostream>
using namespace std;

#define MAX_SIZE 100

class SList {
public:
	SList();
	~SList();
	void InitList(int arr[], int n);
	int Insert(int x, int pos);
	int Delete(int pos);
	int Get(int pos);
	int multInsert(int pos, int n, int arr[]);
	int multiDel(int i, int n);
	void Add(int arr[], int n, int brr[], int m);
	void TurnSequence(int dir, int amount);
	void Display();
	void Operation();
private:
	int* data;
	int lenth;
	int listsize;
};
//无参构造
SList::SList(){
	data = new int[MAX_SIZE];
	listsize = MAX_SIZE;
	lenth = 0;
}
//初始化链表
void SList::InitList(int arr[], int n){
	for (int i = 0; i < n; i++)	data[i] = arr[i];
	lenth = n;
}
//插入数据
int SList::Insert(int x, int pos){
	if ((pos < 1) || (pos > lenth + 1)){
		cout << "error" << endl;
		return 0;
	}
	else{
		for (int i = lenth; i >= pos; i--) data[i] = data[i - 1];
		data[pos - 1] = x;
		lenth++;
		return 1;
	}
}
//删除数据
int SList::Delete(int pos){
	if ((pos < 1) || (pos > lenth)){
		cout << "error" << endl;
		return 0;
	}
	else{
		for (int i = pos; i < lenth; i++) data[i - 1] = data[i];
		lenth--;
		return 1;
	}
}
//获取数据
int SList::Get(int pos){
	if ((pos < 1) || (pos > lenth)) return 0;
	else return data[pos - 1];
}
//插入多个数据
int SList::multInsert(int pos, int n, int arr[]) {
	if (pos < 1 || pos > lenth + 1){
		cout << "error" << endl;
		return 0;
	}
	else {
		for (int i = lenth + n - 1; i >= pos + n - 1; i--) data[i] = data[i - n];
		for (int i = 0; i < n; i++)data[pos + i - 1] = arr[i];
		lenth += n;
		return 1;
	}
}
//删除多个数据
int SList::multiDel(int pos, int n) {
	if (pos < 1 || pos > lenth) {
		cout << "error" << endl;
		return 0;
	}
	else {
		for (int i = 0; i < n; i++) {
			data[pos - 1 + i] = data[pos - 1 + i + n];
		}
		lenth -= n;
		return 1;
	}
}
//合并两个链表
void SList::Add(int arr[], int n, int brr[], int m) {
	lenth = m + n;
	int j = 0, k = 0;
	for (int i = 0; i < m + n; i++) {
		if (*(arr + j) <= *(brr + k) && j < n) *(data + i) = *(arr + j), j++;
		else if (*(arr + j) >= *(brr + k) && k < m) *(data + i) = *(brr + k), k++;
		else if (j == n) *(data + i) = *(brr + k), k++;
		else if (k == m) *(data + i) = *(arr + j), j++;
	}
}
//循环移位
void SList::TurnSequence(int dir, int amount) {
	int* tmp = new int[lenth];
	if (dir == 0) {
		for (int i = 0; i < lenth; i++) {
			if (i < amount) tmp[lenth - amount + i] = data[i];
			else tmp[i - amount] = data[i];
		}
	}
	else {
		for (int i = 0; i < lenth; i++) {
			if (i + amount >= lenth) tmp[amount + i - lenth] = data[i];
			else tmp[i + amount] = data[i];
		}
	}
	for (int i = 0; i < lenth; i++) data[i] = tmp[i];
}
//打印链表
void SList::Display(){
	cout << lenth << " ";
	for (int i = 0; i < lenth; i++) cout << data[i] << " ";
	cout << endl;
}
//执行操作
void SList::Operation() {
	int direction, digit;
	for (int i = 0; i < 2; i++) {
		cin >> direction >> digit;
		TurnSequence(direction, digit);
		Display();
	}
}

SList::~SList(){
	delete[]data;
}

int main() {
	SList slist;
	int n;
	cin >> n;
	int* array = new int[n];
	for (int i = 0; i < n; i++) cin >> array[i];
	slist.InitList(array, n);
	slist.Display();
	slist.Operation();
	return 0;
}

问题五：计算2支股票的M天运动平均价格

题目描述：

给定2支股票的开盘价和收盘价的N天历史数据，

要求按开盘和收盘，分别计算每支股票的每个日期对应的M天移动平均价格。

假定两个股票数据如下：

日期            开盘/收盘      第1支股票价格S1       第2支股票价格S2

2004/7/29 close 6 4

2004/7/25 close 2 6

2004/7/26 open 8 12

2004/7/30 open 2 4

2004/7/27 close 8 10

2004/7/28 open 4 2

按M=2天（日期不用连续）计算移动平均价格，按先开盘，后收盘价，输出如下：（若某日期之前，没有M-1条的记录（日期不用连续），则不用输出）

2004/7/28 open 6 7

2004/7/30 open 3 3

2004/7/27 close 5 8

2004/7/29 close 7 7

其中, 2004/7/28日的S1的值为(8+4)/2 = 6， 即将2004/7/28和（最近1条记录2004/7/26，最近2条记录，最近M-1条记录）的价格，求和并计算平均。

输入要求：

第1行：N天记录   M天平均

第2行到N+1行：N天2支股票的开盘与收盘价格（注意日期是无序的）

6  2

2004/7/29 close 6 4

2004/7/25 close 2 6

2004/7/26 open 8 12

2004/7/30 open 2 4

2004/7/27 close 8 10

2004/7/28 open 4 2

输出要求：

每个日期的最近M条记录（包括该日期的价格在内）的平均价格（若某日期之前没有M-1条的记录（日期不用连续），则不用输出）

2004/7/28 open 6 7

2004/7/30 open 3 3

2004/7/27 close 5 8

2004/7/29 close 7 7

输入样例：

6  2
2004/7/29  	close      6	 4
2004/7/25  	close      2      6
2004/7/26  	open      8      12
2004/7/30  	open      2      4
2004/7/27  	close      8      10
2004/7/28  	open      4       2

输出样例：

2004/7/28 open 6 7
2004/7/30 open 3 3
2004/7/27 close 5 8
2004/7/29 close 7 7

代码示例：

#include <iostream>
using namespace std;

#define MAX_SIZE 100
int M;

struct Stock
{
	string date;
	int price1, price2;
};

class SList {
public:
	SList();
	~SList();
	void InitList(int arr[], int n);
	int Insert(int x, int pos);
	void InsertStock(Stock s);
	int findPos(Stock s);
	void Display();
	void Calculate(string type);
private:
	int* data;
	Stock* Sdata;
	int lenth;
	int listsize;
};
//无参构造
SList::SList(){
	data = new int[MAX_SIZE];
	Sdata = new Stock[MAX_SIZE];
	listsize = MAX_SIZE;
	lenth = 0;
}
//初始化链表
void SList::InitList(int arr[], int n){
	for (int i = 0; i < n; i++)	data[i] = arr[i];
	lenth = n;
}
//查找股票应插入的位置
int SList::findPos(Stock s) {
	if (!lenth) return 0;
	else {
		int idx0 = atoi(s.date.substr(s.date.length() - 2, 2).c_str());
		for (int i = 0; i < lenth; i++) {
			int idxi = atoi(Sdata[i].date.substr(Sdata[i].date.length() - 2, 2).c_str());
			if (idxi > idx0) return i;
		}
		return lenth;
	}
}
//插入股票
void SList::InsertStock(Stock s) {
	if (lenth == 0) Sdata[0] = s;
	else {
		int pos = findPos(s);
		for (int i = lenth; i > pos; i--) Sdata[i] = Sdata[i - 1];
		Sdata[pos] = s;
	}
	lenth++;
}
//计算并输出
void SList::Calculate(string type) {
	for (int i = M - 1; i < lenth; i++) {
		cout << Sdata[i].date << " " << type;
		int sum1 = 0, sum2 = 0;
		for (int j = i; j >= i - M + 1; j--) {
			sum1 += Sdata[j].price1;
			sum2 += Sdata[j].price2;
		}
		cout << " " << sum1 / M << " " << sum2 / M << endl;
	}
}

SList::~SList(){
	delete[]data;
}

int main() {
	SList olist,clist;
	int n;
	cin >> n >> M;
	for (int i = 0; i < n; i++){
		Stock stock;
		string type;
		cin >> stock.date >> type >> stock.price1 >> stock.price2;
		if (type == "open") olist.InsertStock(stock);
		else clist.InsertStock(stock);
	}

	olist.Calculate("open");
	clist.Calculate("close");

	return 0;
}

问题五复习一下关于string的几个知识点：

  1. string转int，运用atoi(str.c_str())即可完成转化；
  2. string提取字串，运用str.substr(pos, lenth)，pos是被提取的字串的开始位置，lenth为被提取字串的长度。
再给艾克三年
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
XK3190-DS3耀华称重仪表说明书含通信协议
09-03
维护保养和注意事项方面，用户应定期进行设备检查，确保清洁，避免在极端环境下长时间使用，遵循正确的电源开启和关闭顺序，以及合理使用打印功能以延长设备寿命。 总之，XK3190-DS3是一款功能强大、兼容性广的称重...
XK3190-DS8耀华称重仪表说明书含通信协议
09-03
打印机接口则为标准并行输出，需使用25芯D型插头座，并注意正确的接线顺序以防止设备损坏。 操作方法部分涵盖了开机、置零、去皮、日期时间设定、数据存储、打印操作等一系列日常功能。仪表还配备了大屏幕显示接口...
数据结构期末复习（线性结构 OJ）
weixin_74385534的博客
12-29 439
深圳大学数据结构线性表复习
|DS线性表的顺序存储_顺序表|静态数组&动态分配
weixin_44769957的博客
03-16 498
线性表的基本操作： InitList(&L):初始化表，构造1个空的线性表 ListInsert(&L,i,e):插入操作，在表L的第i个位置插入指定元素e ListDelete(&L,i,&e):删除操作，删除表中第i个位置的元素,并用e返回删除元素的值 GetElem(L,i):按位查找操作，获取表中第i个位置上的元素的值 LocateElem(L,e):安置查找操作，在表L中查找具有给定关键字值得元素 PrintList(L):输出操作,按前后顺序输出线性表L的所有元.
DS---顺序表的相关操作
koala__的博客
04-15 305
顺序表 顺序表：用一段地址连续的存储单元依次存储数据元素的线性结构 地址连续的空间：一般情况下采用数组，但数组有静态数组和动态数组， 所以顺序表分为：静态顺序表和动态顺序表 首先我们先来看看两种顺序表的结构： 静态顺序表 #define MAX_SIZE 10 typedef int DataType;//int的别名，如此定义方便后期数据类型修改 struct SeqList ...
Java 顺序表-创建、有序表插入
m0_46527503的博客
10-30 3333
设计能存储int型元素的顺序表类SeqList。要求： 顺序表的最大容量在创建顺序表对象时指定； 实现从尾部追加（输入一组数，以-1结束）、打印顺序表的所有元素、插入元素至指定位置等基本操作。 实现向升序表中插入元素x，插入后依旧是升序表 import java.util.Scanner; class SeqList{ //顺序表=数组+表长 int [] a; int size; int len; SeqList(int x){ size = x; a=new int [x]; }
DS-顺序表的基本操作（超级齐全）
X_Mrjw的博客
07-25 730
数据结构-顺序表的基本操作(C语言实现) 实现的具体功能如下： 初始化顺序表 显示顺序表 尾部插入数据 头部插入数据 尾部删除数据 头部删除数据 顺序表扩容 查找数据（遍历式） 二分查找数据 排序 按值插入数据 按位置插入数据 按值删除数据 按位置删除数据 删除所有（与给定值相等的）数据 清空顺序表 获取头部元素 获取尾部元素 获取顺序表长度 获取顺序表容量 逆置顺序表 摧毁顺序表 这一大堆有被吓到吗？22个功能可还行？试问还有比我更全的吗？！！ 注：上述个别功能是不暴露给用户的，所以菜单中加上退出总
DS顺序表--存储结构与操作
m0_74919335的博客
01-21 487
实现顺序表的存储结构和操作属性包括：数组、实际长度、最大长度（设定为1000）操作包括：创建、插入、删除、查找。
DS--顺序表和链表
yirenDM的博客
03-19 824
/**************** Project: List(Sequence List and LinkList) Data: 2021/09/14,2021/11/11整理完毕 Author: Alex_yrdm ****************/ /***************** Part1: Sequence List *****************/ /* Sequence List dynamic allocation: void show(SqList L);
数据结构-DS顺序表
a_growing_tree的博客
09-19 762
顺序表实验课题记
DS：顺序表的实现
热门推荐
weixin_51142926的博客
01-25 1万+
本文为博主在DS学习阶段的第一篇博客，所以会介绍一下数据结构，并在最后学习对顺序表的实现，在友友们深入理解指针（3）学习之前，一定要对三个部分的知识——指针、结构体、动态内存管理的内容有一定的了解，如果友友们对这三块知识不熟悉的话，可以去看看博主的文章哦！
DS顺序表--类实现
Littlsecr的博客
09-05 1124
#include&lt;iostream&gt; using namespace std; #define ok 0 #define error -1 // 顺序表类定义 class seqlist { private: int *list; int maxsize; int size; public: seqlist(); ~seqlist();...
tem.rar_DS18B20 数码管
09-22
其中，“ds18b20的初始化、读写时序”涉及了DS18B20传感器的硬件接口操作，包括如何配置传感器，以及按照特定的时间顺序进行数据读取和写入。这些步骤对于正确通信至关重要，因为DS18B20使用的是单线协议，所有的...
【DS18B120测温】_单片机DS18B20测量温度_
10-03
5. **DS18B20测温.dep**：这是一个依赖关系文件，记录了项目中各源文件之间的依赖关系，有助于编译器确定正确的编译顺序。 6. **DS18B20测温.eww**：这是IAR IDE的工作窗口设置文件，保存了用户的工作区布局、窗口...
NCHU_DS_EXPERIMENT
10-10
10. **查找算法**：如顺序查找、二分查找、二叉搜索树查找等，用于在数据集中定位特定元素。 这些基础知识在实际编程和软件开发中扮演着重要角色，是构建高效算法和复杂系统的基础。通过"DS_C"这个标签，我们可以...
学习记录day18——数据结构 算法
最新发布
weixin_64918301的博客
07-24 768
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 304
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
Codeforces Round 961 (Div. 2)
2301_80105412的博客
07-24 1011
Codeforces Round 961 (Div. 2) ABC
1137. 第 N 个泰波那契数
weixin_45256307的博客
07-24 355
1137. 第 N 个泰波那契数
DS顺序表--连续操作
09-14
DS顺序表（也称为数组）是一种线性数据结构，它使用连续的存储空间来存储元素。我可以告诉你如何进行一些常见的操作，例如插入、删除和访问元素。 1. 插入元素： 要在顺序表中插入元素，首先需要确定插入的位置。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

再给艾克三年

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

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

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

打赏作者

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

抵扣说明：

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

余额充值