DS-顺序表的基本操作（超级齐全）

最新推荐文章于 2024-07-13 12:01:25 发布
最新推荐文章于 2024-07-13 12:01:25 发布
阅读量725 收藏
点赞数 1
分类专栏： DS 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/X_Mrjw/article/details/107582765
版权

数据结构-顺序表的基本操作(C语言实现)

实现的具体功能如下：

  1. 初始化顺序表
  2. 显示顺序表
  3. 尾部插入数据
  4. 头部插入数据
  5. 尾部删除数据
  6. 头部删除数据
  7. 顺序表扩容
  8. 查找数据（遍历式）
  9. 二分查找数据
  10. 排序
  11. 按值插入数据
  12. 按位置插入数据
  13. 按值删除数据
  14. 按位置删除数据
  15. 删除所有（与给定值相等的）数据
  16. 清空顺序表
  17. 获取头部元素
  18. 获取尾部元素
  19. 获取顺序表长度
  20. 获取顺序表容量
  21. 逆置顺序表
  22. 摧毁顺序表

这一大堆有被吓到吗？22个功能可还行？试问还有比我更全的吗？！！
在这里插入图片描述
注：上述个别功能是不暴露给用户的，所以菜单中加上退出总共是20个选项。

源代码如下：
main.c

#include "SeqList.h"

static void Menu()
{
	printf("**************************************************\n");
	printf("**************************************************\n");
	printf("--------  Please enter your choice:       --------\n");
	printf("--------  0.Quit           1.Print        --------\n");
	printf("--------  2.PushBack       3.PushFront    --------\n");
	printf("--------  4.PopBack        5.PopFront     --------\n");
	printf("--------  6.Find           7.Sort         --------\n");
	printf("--------  8.Val_Insert     9.Pos_Insert   --------\n");
	printf("--------  10.Pos_Erase    11.Val_Erase    --------\n");
	printf("--------  12.EraseAllVal  13.Clear        --------\n");
	printf("--------  14.GetFront     15.GetBack      --------\n");
	printf("--------  16.Length       17.Capacity     --------\n");
	printf("--------  18.Reverse      19.Find_Binary  --------\n");
	printf("**************************************************\n");
	printf("**************************************************\n");
}

int main()
{
	SeqList_t list;//定义结构体变量
	InitSeqList(&list);//初始化顺序表
	ELEM_TYPE item = 0;
	size_t pos = 0;
	int select = 1;
	while (select){
		Menu();
		scanf("%d", &select);
		if (0 == select){
			printf("退出成功!\n");
			break;
		}
		switch (select){
		case 1:
			SeqListPrint(&list);
			break;
		case 2:
			printf("请输入你要插入的元素(以-1结尾): ");
			while (scanf("%d", &item), item != -1){
				SeqListPushBack(&list, item);
			}
			printf("尾部插入元素成功!\n");
			break;
		case 3:
			printf("请输入你要插入的元素(以-1结尾): ");
			while (scanf("%d", &item), item != -1){
				SeqListPushFront(&list, item);
			}
			printf("头部插入元素成功!\n");
			break;
		case 4:
			SeqListPopBack(&list);
			break;
		case 5:
			SeqListPopFront(&list);
			break;
		case 6:
			printf("请输入你要查找的数据: ");
			scanf("%d", &item);
			int ret = SeqListFind(&list, item);
			if (ret == -1){
				printf("当前顺序表为空，无法进行数据查找!\n");
			}
			else if (ret == -2){
				printf("查找数据失败,顺序表中没有该数据!\n");
			}
			else{
				printf("查找数据成功，该数据在顺序表中的下标为%d!\n", ret);
			}
			break;
		case 7:
			SeqListSort(&list);
			break;
		case 8:
			printf("请输入你要插入的数据: ");
			scanf("%d", &item);
			SeqListVal_Insert(&list, item);
			break;
		case 9:
			printf("请输入你要插入的数据和位置: \n");
			printf("数据: ");
			scanf("%d", &item);
			printf("位置: ");
			scanf("%u", &pos);
			SeqListPos_Insert(&list, pos, item);
			break;
		case 10:
			printf("请输入你要删除的数据的位置: ");
			scanf("%d", &pos);
			SeqListPos_Erase(&list, pos);
			break;
		case 11:
			printf("请输入你要删除的值: ");
			scanf("%d", &item);
			SeqListVal_Erase(&list, item);
			break;
		case 12:
			printf("请输入你要删除的值: ");
			scanf("%d", &item);
			SeqListEraseAllVal(&list, item);
			break;
		case 13:
			SeqListClear(&list);
			break;
		case 14:
			if (SeqListGetFront(&list) == -1){
				printf("当前顺序表为空，无法取表头元素!\n");
			}
			else{
				printf("该顺序表的头部元素为[%d]!\n", SeqListGetFront(&list));
			}
			break;
		case 15:
			if (SeqListGetBack(&list) == -1){
				printf("当前顺序表为空，无法取表尾元素!\n");
			}
			else{
				printf("该顺序表的尾部元素为[%d]!\n", SeqListGetBack(&list));
			}
			break;
		case 16:
			printf("该顺序表的当前长度为[%d]!\n", SeqListLength(&list));
			break;
		case 17:
			printf("该顺序表的当前容量为[%d]!\n", SeqListCapacity(&list));
			break;
		case 18:
			SeqListReverse(&list);
			break;
		case 19:
			printf("请输入你要进行查找的数据: ");
			scanf("%d", &item);
			int bin_ret = SeqListFind_Binary(&list, item);
			if (bin_ret == -1){
				printf("当前顺序表为空，无法进行数据查找!\n");
			}
			else if (bin_ret == -2){
				printf("查找数据失败,顺序表中没有该数据!\n");
			}
			else{
				printf("二分查找数据成功，该数据在顺序表中的下标为%d!\n", bin_ret);
			}
			break;
		default:
			printf("输入有误，请重新输入!\n");
			system("pause");
			system("cls");
			continue;
		}
		system("pause");
		system("cls");
	}

	DestorySeqList(&list);//摧毁顺序表

	system("pause");
	return 0;
}

SeqList.h

#ifndef _SEQLIST_H_
#define _SEQLIST_H_

#include <stdio.h>
#include <windows.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

#pragma warning(disable:4996)

#define ELEM_TYPE int //元素类型
#define SEQLIST_DEFAULT_SIZE 8  //顺序表默认大小


typedef struct SeqList{
	ELEM_TYPE *base;//指向申请堆空间，保存元素
	size_t size;//当前元素个数
	size_t cap;//容量
}SeqList_t;

void InitSeqList(SeqList_t *plist);//初始化顺序表
void DestorySeqList(SeqList_t *plist);//摧毁顺序表
void SeqListPrint(SeqList_t *plist);//打印顺序表
void SeqListPushBack(SeqList_t *plist, ELEM_TYPE x);//尾插
void SeqListPushFront(SeqList_t *plist, ELEM_TYPE x);//头插
void SeqListPopBack(SeqList_t *plist);//尾删
void SeqListPopFront(SeqList_t *plist);//头删
int  SeqListFind(SeqList_t *plist, ELEM_TYPE x);//按值查找
void SeqListSort(SeqList_t *plist);//排序
void SeqListPos_Insert(SeqList_t *plist, size_t pos, ELEM_TYPE x);//按位置插入
void SeqListVal_Insert(SeqList_t *plist, ELEM_TYPE x);//按值插入
void SeqListPos_Erase(SeqList_t *plist, size_t pos);//按位置删除
void SeqListVal_Erase(SeqList_t *plist, ELEM_TYPE x);//按值删除
void SeqListEraseAllVal(SeqList_t *plist, ELEM_TYPE x);//删除所有值为x的数据
void SeqListClear(SeqList_t *plist);//清空顺序表
ELEM_TYPE SeqListGetFront(SeqList_t *plist);//获取头部元素
ELEM_TYPE SeqListGetBack(SeqList_t *plist);//获取尾部元素
int  SeqListLength(SeqList_t *plist);//获取长度
int  SeqListCapacity(SeqList_t *plist);//获取容量
void SeqListReverse(SeqList_t *plist);//顺序表逆置
int SeqListFind_Binary(SeqList_t *plist, ELEM_TYPE x);//二分查找数据


#endif /*_SEQLIST_H_*/

SeqList.c

#include "SeqList.h"

static void Swap(ELEM_TYPE *x, ELEM_TYPE *y)
{
	*x ^= *y;
	*y ^= *x;
	*x ^= *y;
}

void InitSeqList(SeqList_t *plist)
{
	assert(plist);
	plist->cap = SEQLIST_DEFAULT_SIZE;
	plist->base = (ELEM_TYPE *)malloc(plist->cap * sizeof(ELEM_TYPE));
	plist->size = 0;
}

static bool Inc(SeqList_t *plist, size_t new_cap)
{
	assert(plist);
	assert(new_cap > plist->cap);
	ELEM_TYPE *new_base = (ELEM_TYPE *)realloc(plist->base, sizeof(ELEM_TYPE)* new_cap);
	if (new_base == NULL){
		return false; //扩容失败
	}
	plist->base = new_base;
	plist->cap = new_cap;
	printf("顺序表已成功扩容!\n");
	return true; //扩容成功
}

static bool IsFull(SeqList_t *plist)
{
	assert(plist);
	return plist->cap == plist->size;
}

static bool IsEmpty(SeqList_t *plist)
{
	assert(plist);
	return plist->size == 0;
}

void SeqListPushBack(SeqList_t *plist, ELEM_TYPE x)
{
	assert(plist);
	if (IsFull(plist) && !Inc(plist, plist->cap*2)){//顺序表已满且扩容失败
		printf("顺序表已满，无法继续插入!\n");
		return;
	}
	plist->base[plist->size] = x;
	plist->size++;
}

void SeqListPrint(SeqList_t *plist)
{
	assert(plist);
	if (IsEmpty(plist)){
		printf("当前顺序表为空!\n");
		return;
	}
	size_t i = 0;
	for (; i < plist->size; i++){
		printf("%d ", plist->base[i]);
	}
	printf("\n");
}

void SeqListPushFront(SeqList_t *plist, ELEM_TYPE x)
{
	assert(plist);
	if (IsFull(plist) && !Inc(plist, plist->cap * 2)){
		printf("顺序表已满，无法继续插入!\n");
		return;
	}
	size_t i = plist->size;
	for (; i > 0; i--){
		plist->base[i] = plist->base[i - 1];
	}
	plist->base[0] = x;
	plist->size++;

}

void SeqListPos_Insert(SeqList_t *plist, size_t pos, ELEM_TYPE x)
{
	assert(plist);
	assert(pos >= 0);
	if (IsFull(plist) && !Inc(plist, plist->cap * 2)){
		printf("顺序表已满，无法继续插入!\n");
		return;
	}
	if (pos < 0 || pos > plist->size){
		printf("你要插入的位置非法, 无法成功插入!\n");
		return;
	}
	size_t i = plist->size;
	for (; i > pos; i--){
		plist->base[i] = plist->base[i - 1];
	}
	plist->base[pos] = x;
	plist->size++;
	printf("插入元素成功!\n");
}



void SeqListSort(SeqList_t *plist)
{
	assert(plist);
	if (IsEmpty(plist)){
		printf("当前顺序表为空,无法进行排序操作!\n");
		return;
	}
	else if(plist->size == 1){
		printf("当前顺序表只有一个元素，排序操作无意义!\n");
		return;
	}

	//冒泡排序
	size_t i = 0;
	for (; i < plist->size - 1; i++){
		size_t j = 0;
		for (; j < plist->size - 1 - i; j++){
			if ((plist->base[j]) > (plist->base[j + 1])){
				Swap(&(plist->base[j]), &(plist->base[j + 1]));
			}
		}
	}
	printf("顺序表排序成功!\n");
}

void SeqListVal_Insert(SeqList_t *plist, ELEM_TYPE x)
{
	assert(plist);
	if (IsFull(plist) && !Inc(plist, plist->cap * 2)){
		printf("顺序表已满，无法继续插入!\n");
		return;
	}
	SeqListSort(plist);//按值插入即按顺序插入，所以在插入之前顺序表必须有序
#if 0 //方法一，容易想到，但并不是最简单的做法
	size_t i = 0;
	while (i < plist->size && x > plist->base[i]){
		i++;//先找到插入数据的位置
	}
	size_t j = plist->size;
	for (; j > i; j--){
		plist->base[j] = plist->base[j - 1];//向后移动
	}
	plist->base[j] = x;	
	plist->size++;
	printf("数据插入成功!\n");
#endif
	//方法二
	size_t end = plist->size - 1;//定义一个指向顺序表尾部的"指针"
	while (end >= 0 && x < plist->base[end]){
		plist->base[end + 1] = plist->base[end];//向后移动
		end--;
	}
	plist->base[end + 1] = x;//插入数据
	plist->size++;
	printf("数据插入成功!\n");
}

void SeqListPopBack(SeqList_t *plist)
{
	assert(plist);
	if (IsEmpty(plist)){
		printf("当前顺序表为空，无法继续删除!\n");
		return;
	}
	plist->size--;
	printf("尾部删除成功!\n");
}

void SeqListPopFront(SeqList_t *plist)
{
	assert(plist);
	if (IsEmpty(plist)){
		printf("当前顺序表为空，无法继续删除!\n");
		return;
	}
	size_t i = 0;
	for (; i < plist->size - 1; i++){
		plist->base[i] = plist->base[i + 1];
	}
	plist->size--;
	printf("头部删除成功!\n");
}

void SeqListPos_Erase(SeqList_t *plist, size_t pos)
{
	assert(plist);
	assert(pos >= 0);
	if (IsEmpty(plist)){
		printf("当前顺序表为空，无法进行删除操作!\n");
		return;
	}
	if (pos < 0 || pos >= plist->size){
		printf("你要删除的位置非法, 无法成功删除!\n");
		return;
	}
	size_t i = pos;
	for (; i < plist->size; i++){
		plist->base[i] = plist->base[i + 1];
	}
	plist->size--;
	printf("数据删除成功!\n");
}

void SeqListVal_Erase(SeqList_t *plist, ELEM_TYPE x)
{
	assert(plist);
	if (IsEmpty(plist)){
		printf("当前顺序表为空, 无法进行删除操作!\n");
		return;
	}
	//有了前面已经实现的一些功能，我们只需借助某些功能就可以实现按值删除
	int pos = 0;
	pos = SeqListFind(plist, x);//先找到需要删除数据的所在位置
	if (pos == -1){
		printf("对不起,你要删除的值[%d]不存在!\n", x);
		return;
	}
	else{
		SeqListPos_Erase(plist, pos);//找到该数据所在位置后按位置删除即可
	}
}

void SeqListEraseAllVal(SeqList_t *plist, ELEM_TYPE x)
{
	assert(plist);
	if (IsEmpty(plist)){
		printf("当前顺序表为空，无法进行删除操作!\n");
		return;
	}
	size_t i = 0;
	int flag = 0;//用于检测该数据是否存在
	while (i < plist->size){
		while (x != plist->base[i] && i < plist->size){
			i++;
		}
		if (x == plist->base[i]){
			flag = 1;//如果进入过该分支，则证明找到了数据，即数据存在
			size_t j = i;
			for (; j < plist->size - 1; j++){
				plist->base[j] = plist->base[j + 1];
			}
			plist->size--;
		}
	}
	if (flag ==0 ){
		printf("对不起,你要删除的值[%d]不存在!\n", x);
		return;
	}
	printf("数据删除成功!\n");
}

int SeqListFind(SeqList_t *plist, ELEM_TYPE x)
{
	assert(plist);
	if (IsEmpty(plist)){//空表查找操作无意义
		return -1;
	}
	size_t pos = 0;
	while (pos < plist->size && plist->base[pos] != x){
		pos++;
	}
	if (pos == plist->size){
		return -2;//表示没找到
	}
	return pos;//找到就返回该数据的下标
}

ELEM_TYPE SeqListGetFront(SeqList_t *plist)
{
	assert(plist);
	if (IsEmpty(plist)){
		//由于插入数据的机制，表中的数据不可能有-1，因此此处逻辑可行，不过这同样也算是一个小的缺陷吧
		return -1;
	}
	return plist->base[0];
}

ELEM_TYPE SeqListGetBack(SeqList_t *plist)
{
	assert(plist);
	if (IsEmpty(plist)){
		return -1;
	}
	return plist->base[plist->size-1];
}

int  SeqListLength(SeqList_t *plist)
{
	assert(plist);
	return plist->size;
}
int  SeqListCapacity(SeqList_t *plist)
{
	assert(plist);
	return plist->cap;
}

void SeqListReverse(SeqList_t *plist)
{
	assert(plist);
	if (IsEmpty(plist)){
		printf("当前顺序表为空,无法进行逆置操作!\n");
		return;
	}
	else if (plist->size == 1){
		printf("当前顺序表中只有一个元素,逆置操作无意义!\n");
		return;
	}
	int start = 0;
	int end = plist->size - 1;
	while (start < end){
		Swap(&(plist->base[start]), &(plist->base[end]));
		start++;
		end--;
	}
	printf("顺序表逆置成功!\n");
}

int SeqListFind_Binary(SeqList_t *plist, ELEM_TYPE x)
{
	assert(plist);
	if (IsEmpty(plist)){//空表查找操作无意义
		return -1;
	}
	SeqListSort(plist);//二分查找的前提是顺序表有序
	int start = 0;
	int end = plist->size - 1;
	int mid;
	while (start <= end){
		mid = (start + end) / 2;
		if (x > plist->base[mid]){
			start = mid + 1;
		}
		else if (x < plist->base[mid]){
			end = mid - 1;
		}
		else{
			return mid;
		}
	}
	return -2;
}

void SeqListClear(SeqList_t *plist)
{
	assert(plist);
	plist->size = 0;
	printf("顺序表已成功清空!\n");
}

void DestorySeqList(SeqList_t *plist)
{
	assert(plist);
	free(plist->base);
	plist->base = NULL;//预防野指针
	plist->size = plist->cap = 0;
}
丶阿部
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DS顺序表--连续操作
luoyeliufeng的博客
11-29 1595
DS顺序表–连续操作 题目描述 建立顺序表的类，属性包括：数组、实际长度、最大长度（设定为1000） 该类具有以下成员函数： 构造函数：实现顺序表的初始化。 插入多个数据的multiinsert(int i, int n, int item[])函数，实现在第i个位置，连续插入来自数组item的n个数据，即从位置i开始插入多个数据。 删除多个数据的multidel(int i, int n)函数，...
C++ 数据结构：DS顺序表--合并操作
hhhertzzz的博客
09-17 2209
题目描述 建立顺序表的类，属性包括：数组、实际长度、最大长度（设定为1000） 已知两个递增序列，把两个序列的数据合并到顺序表中，并使得顺序表的数据递增有序 输入 第1行先输入n表示有n个数据，接着输入n个数据，表示第1个序列，要求数据递增互不等 第2行先输入m表示有m个数据，接着输入m个数据，表示第2个序列，要求数据递增互不等 输出 顺序表内容包括顺序表的实际长度和数据，数据之间用空格隔开 第1行输出创建后的顺序表内容 样例输入 3 11 33 55 5 22 44 66 88 99 样例输出 8 11.
【C语言】超详细讲解顺序表的各种操作
云泽野の编程日记
07-02 5849
数据结构在内存中的表示通常有两种形式，一种是顺序存储，另一种是链式存储。线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表的数据元素，我们把这种存储形式存储的线性表称为顺序表。1.顺序表的逻辑结构和物理结构是一致的。2.顺序表中任意一个数据元素都可以随机存取，所以顺序表是一种随机存取的存储结构。 定义MAXLEN为100，表示顺序表最大的存储空间 利用宏方便对顺序表的大小进行修改利用typedef将DataType定义成int类型的数据，如果顺序表存放的数据要修改成其他类型的，可以直接 利用
基础数据结构-线性表-顺序表的连续操作
weixin_34416754的博客
03-02 219
建立顺序表的类，属性包括：数组、实际长度、最大长度（设定为1000） 该类具有以下成员函数： 构造函数：实现顺序表的初始化。 插入多个数据的multiinsert(int i, int n, int item[])函数，实现在第i个位置，连续插入来自数组item的n个数据，即从位置i开始插入多个数据。 删除多个数据的multidel(int i, int n)函数，实现从第i个位置开始，连...
DS之顺序表
life is wonderful
04-18 1066
顺序表定义        线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。线性表的顺序存储结构或顺序映像通常被叫做顺序表。顺序表的特点为：以元素在计算机内“物理位置相邻”来表示线性表中数据元素之间的逻辑关系。每一个数据元素的存储位置都和线性表的起始位置相差一个和数据元素在线性表中的位序成正比的常数。因此，只要确定了存储线性表的起始位置，线性表中任一数据元素都可以随机存取，
[DS]顺序表
weixin_30757793的博客
08-07 95
1.线性表的第一个表项称为表头，最后一个表项称为表尾；（线性表是线性结构的典型） 2.线性表的存储表示有两种：顺序存储和链式存储。用顺序存储方式实现的线性表称为顺序表，使用数组作为表的存储结构的。 3.线性表的存储方式有基于数组的存储表示、基于链表的存储表示、基于散列的存储表示等多种方式，基于数组的存储表示是其中最简单、最常用的一种，顺序表是线性表基于数组的存储表示。 4.顺序表的定义是：把...
DS_【顺序表】
java_Maxhui
04-06 194
数据结构的顺序表 01线性结构 （1）除第一个和最后一个数据元素外，每个数据元素只有一个前驱数据元素和一个后继数据元素； （2）第一个数据元素没有前驱数据元素； （3）最后一个数据元素没有后继数据元素。 02线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性...
海康威视硬盘录像机DS-7104N-SN升级包
01-29
海康威视硬盘录像机DS-7104N-SN升级包。老版本的录像机了，这个升级包难找。官方没得下载 分享给大家 V3.0.23_180720
海康威视DS-K6300 系列消费机用户手册
02-14
总而言之，海康威视DS-K6300系列消费机用户手册提供了全面的产品信息和安全操作指南，帮助用户安全、有效地使用这些消费机设备。用户在使用前应仔细阅读并遵循手册中的各项说明，以确保设备的稳定运行和自身的安全。
DS-7100N-SL操作手册
11-05
hikvision DS7100N系列操作手册
ds-5 linux crack
02-18
适用于qualcomm modem的编译，linux环境。DS500-PA-00003-r5p0-17rel0.crack sudo ArmLicGen -o /opt/ARM/DS-5/ export LM_LICENSE_FILE/ARMLMD_LICENSE_FILE = /opt/ARM/DS-5/license.dat 具体参见readme.txt
【DS】顺序表基本操作
CHAOQIWEN的博客
05-10 272
1、顺序表的插入 头插 public void pushFront(int item){ if(this.size==array.length){ int capacity=this.array.length*2; int[] newArray = new int[capacity]; ...
DS--顺序表和链表
yirenDM的博客
03-19 823
/**************** 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:顺序表实例
CoolSuperman的博客
03-07 278
文章目录顺序表与链表顺序表静态顺序表(编译期间决定的)动态顺序表(运行期间决定的)初始化与销毁增加(插入)数据扩容删除数据查找数据修改数据缺点链表分类基本形式初始化销毁增加数据删除数据打印 顺序表与链表 顺序表 逻辑上线性的，物理存储上地址连续的存储单元； 静态顺序表(编译期间决定的) typedef struct SeqList { int arry[100];//能存100个数的静...
DS---顺序表的相关操作
koala__的博客
04-15 302
顺序表 顺序表：用一段地址连续的存储单元依次存储数据元素的线性结构 地址连续的空间：一般情况下采用数组，但数组有静态数组和动态数组， 所以顺序表分为：静态顺序表和动态顺序表 首先我们先来看看两种顺序表的结构： 静态顺序表 #define MAX_SIZE 10 typedef int DataType;//int的别名，如此定义方便后期数据类型修改 struct SeqList ...
DS 线性表1：顺序存储结构
Osseyda's Nation
05-02 303
任务和代码： main.cpp /* *All rights reserved *文件名称:main.c *作者: Osseyda 完成日期：2018.5.2 *版本号：v2. * *问题描述：顺序表的应用 *问题输出：1.程序的多文件组织形式 ; 2.要求算法的时间复杂度为O(n) */ #include "list.h" #include <stdio.h> ...
【DS】链表基本操作
CHAOQIWEN的博客
05-12 188
1、头插 如果原链表不为空，要插入的节点的下一个节点就是原来链表的头节点，新链表的头节点就是要插入的节点； 如果原链表为空，直接插入，头节点就是要插入的节点 public void pushFront(Node node){ if(head!=null) { node.next = this.head; this.head=nod...
访问者模式(大话设计模式)C/C++版本
最新发布
m0_47104421的博客
07-13 118
【代码】访问者模式(大话设计模式)C/C++版本。
jmu-ds-顺序表区间元素删除
09-02
顺序表是一种常见的线性数据结构，元素排列在连续的物理内存空间中。顺序表区间元素删除指的是从顺序表中删除指定范围的元素。 对于顺序表来说，需要首先确定要删除的区间范围。可以根据具体需求选择使用索引或元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值