【C语言入门数据结构】顺序表

news2025/1/17 0:49:34

🙈个人主页：阿伟@t

👉系列专栏：【C语言–大佬之路】

🎈今日心语：你所看到的惊艳，都曾被平庸所历练。在这里插入图片描述

前言：继【时间复杂度和空间复杂】度之后，本章我们来介绍数据结构中的顺序表和链表，若觉得文章不错，希望支持一下博主👍，如果发现有问题也欢迎❀大家在评论区指正。

文章目录

  • 1.线性表
  • 2.顺序表（数组）
    • 2.1概念及结构
    • 2.2 动态顺序表的接口实现
      • (1)初始化顺序表：
      • (2)内存空间的释放(销毁)
      • (3)检查容量，若满则扩容
      • (4)顺序表尾插
      • (5)顺序表打印
      • (6)顺序表尾删
      • (7)顺序表头插
      • (8)顺序表头删
      • (9)在指定下标位置插入数据
        • 头插尾插代码改进
      • (10)删除指定下标位置数据
        • 头删尾删代码改进：
      • (11)查找，删除指定数据
        • **查找数据最终代码:**
        • **测试，删除数据最终代码:**
      • (12)补充顺序表菜单
    • 2.3源码：
  • 结语：

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

2.顺序表（数组）

2.1概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表一般可以分为静态顺序表和动态顺序表：

  1. 静态顺序表：使用定长数组存储元素。
  • 缺陷：给小了不够用，给大了可能浪费，不实用。

  1. 动态顺序表：使用动态开辟的数组存储。
  • 动态顺序表可根据我们的需要分配空间大小
  • size 表示当前顺序表中已存放的数据个数
  • capacity 表示顺序表总共能够存放的数据个数

2.2 动态顺序表的接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

首先新建一个工程：

  • SeqList.h（顺序表的类型定义、接口函数声明、引用的头文件）
  • SeqList.c（顺序表接口函数的实现）
  • Test.c（主函数、测试顺序表各个接口功能）

(1)初始化顺序表：

  • 记得一定要加上断言，防止传进来的指针为空

  • “->”在声明结构体指针时，访问结构体成员变量时使用。

  • “.”在声明结构体时，访问结构体成员变量时使用。

void SLInit(SL* ps)//初始化顺序表
{
	assert(ps);//断言，为真执行，为假终止，报错

	ps->a = NULL;    //初始数据表为空   ->在声明结构体指针时，访问结构体成员变量时使用
	ps->size = 0;    //初始数据个数为0
	ps->capacity = 0;//初始空间容量为0
}

(2)内存空间的释放(销毁)

void SLDestroy(SL* ps)
{
	//if(ps->a !=NULL)
	assert(ps);
	if (ps->a)         //为真说明内存开辟成功，需要释放置空
	{
		free(ps->a);   //释放,free报错往往是越界，或者是释放的地方不对，一般free的时候才会检查越界
		ps->a = NULL;  //置空
		ps->size = ps->capacity = 0;//释放后进行初始化
	}
}

(3)检查容量，若满则扩容

size和capacity相等时，可能是还没有开辟空间（这时capacity和size为0），也可能是空间已满。为了方便，我们直接将已满的空间扩大2倍，所以还需要判断是哪种情况。

  • realloc后面的参数是大小，前面的参数是需要进行扩容的空间。

  • relloc返回的是新开空间的地址,需要用临时变量tmp接收地址。

void SLCheckCapacity(SL* ps)//检查，扩容
{
	assert(ps);
	//判断空间是否满，否则涉及到越界问题
	//判断size和capacity是否相等，相等则满，或者还没开辟空间，因为开始时都初始化为0
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//如果是0还没开辟空间，如果不是就直接扩为2倍
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));//扩容  ，realloc后面的参数是大小，前面的是需要扩容的空间//需要用临时变量tmp接收地址，因为relloc返回的是新开空间的地址
		if (tmp == NULL)//判断扩容是否成功
		{
			perror("relloc fail");
			exit(-1);       //-1异常终止程序，0代表正常终止
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}

}

(4)顺序表尾插

size指向的位置刚好是最后一个元素的后一个元素，所以尾插时直接插到size指向的位置即可。

//尾插   时间复杂度O(1)
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);//检查容量
	ps->a[ps->size] = x;
	ps->size++;

}
  • 写代码时应该边写边测，及时找到错误，否则后面很难找到。

(5)顺序表打印

size前面刚好是最后一个数据，所以这里 i < ps->size;

//打印函数
void SLPrint(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

(6)顺序表尾删

  • ps->a[ps->size - 1] = 0;将最后一个数据改为0，再size–，意义不大，因为print是以size为基础的，只会访问size前面的有效数据,再插入数据会将无效数据直接覆盖,所以直接ps-> size–;

  • size–;当size=0时再进行会导致size出现负数，后面如果再尾插，插入到了不属于自己的空间，就是越界访问,所以我们前面必须进行检查，而如下“温柔的检查”很难让我们发现错误，所以使用assert（断言，“暴力的检查”）可以帮助我们及时发现错误。

//尾删
void SLPopBack(SL* ps)
{
	//温柔的检查
	//*if (ps->size == 0)
	//{
	//	return;
	//}*/

	//暴力的检查(断言)
	assert(ps->size > 0);//会直接报错,为真继续走，为假结束

	//ps->a[ps->size - 1] = 0;//将最后一个数据改为0，再size--，意义不大，因为print是以size为基础的，只会访问size前面的数据,再插入数据会将无效数据直接覆盖
	ps->size--;
	
}

如下图：暴力检查的好处是，当size=0时，再向下执行，会直接终止程序报错。若没有检查，size取到负值。

若不加入assert，程序会在size变为负值后进行尾插时报错。但是去掉SLDestroy(&sl);会发现程序不报错，说明程序在释放的时候才会检查出问题，但也有随机性，这时一般会报错free。

越界不一定报错，系统对越界的检查是一种抽查

  • 越界读一般是检查不出来的
  • 越界写如果是修改到标志位才会检查出来

（系统在数组末尾后设的有标志位，越界写时，恰好修改到标志位了，就会被检查出来）

(7)顺序表头插

要想头插，就得先将后面的数据从后依次向后挪动：

//头插   时间复杂度O(N)
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);//检查容量

	//挪动数据
	int end = ps->size - 1;//size-1是最后一个元素的下标
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}

	ps->a[0] = x;
	ps->size++;



}

(8)顺序表头删

//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size>0);

	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}

	ps->size--;


}

(9)在指定下标位置插入数据

//在pos位置插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos <= ps->size);//必须是连续存储

	SLCheckCapacity(ps);//考虑到后面空间不够可能越界
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}

	ps->a[pos] = x;
	ps->size++;
}
  • 实现了此接口，同样可以进行头插和尾插，可以进行复用以改进顺序表头插和尾插的代码：

头插尾插代码改进

//头插O(N)
void SLPushFront(SL* ps, SLDataType x)
{
	//assert(ps);
	//SLCheckCapacity(ps);

	挪动数据
	//int end = ps->size - 1;//size-1是最后一个元素的下标
	//while (end >= 0)
	//{
	//	ps->a[end + 1] = ps->a[end];
	//	--end;
	//}

	//ps->a[0] = x;
	//ps->size++;

	SLInsert(ps, 0, x);//复用


}

//尾插O(1)
void SLPushBack(SL* ps, SLDataType x)
{
	/*assert(ps);
	SLCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;*/

	SLInsert(ps, ps->size, x);//复用
}

(10)删除指定下标位置数据

方法与头删类似，这里不作演示.

//删除pos位置数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos < ps->size);
	//assert(ps->size > 0);

	//挪动数据覆盖
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}

	ps->size--;
}
  • 实现了此接口，同样可以进行头删和尾删，同样可以进行复用以改进顺序表头删和尾删的代码：

头删尾删代码改进：

//头删
void SLPopFront(SL* ps)
{
	/*assert(ps);
	assert(ps->size>0);

	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}

	ps->size--;*/

	SLErase(ps, 0);//复用

}

//尾删
void SLPopBack(SL* ps)
{
	温柔的检查
	///*if (ps->size == 0)
	//{
	//	return;
	//}*/

	暴力的检查(断言)
	//assert(ps->size > 0);//会直接报错,为真继续走，为假结束

	ps->a[ps->size - 1] = 0;//将最后一个数据改为0，再size--，意义不大，因为print是以size为基础的，只会访问size前面的数据,再插入数据会将无效数据直接覆盖
	//ps->size--;
	
	SLErase(ps, ps->size - 1);//复用

}

(11)查找，删除指定数据

  • 查找数据初始代码:
//查找
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;//查找到，并返回下标位置
		}
	}
	return -1;未找到，返回-1
}
  • 测试，删除数据初始代码：

void TestSeqList6()
{

	SL sl;//定义顺序表的结构
	SLInit(&sl);//初始化，传给了SeqList.c中的函数，实参，传给形参，形参是实参的临时拷贝
	SLPushBack(&sl, 1);//尾插数据
	SLPushBack(&sl, 2);//尾插数据
	SLPushBack(&sl, 3);//尾插数据
	SLPushBack(&sl, 4);//尾插数据
	SLPushBack(&sl, 5);//尾插数据
	SLPushBack(&sl, 7);//尾插数据
	SLPushBack(&sl, 8);//尾插数据
	SLPushBack(&sl, 5);//尾插数据

	SLPrint(&sl);

	int pos = SLFind(&sl, 5);//查找5
	if (pos != -1)//为真，找到了
	{
		SLErase(&sl, pos);//删除下标位置数据
	}
	SLPrint(&sl);

	
	SLDestroy(&sl);
}
int main()
{
	TestSeqList6();
	return 0;
}

如上图删除了指定的数据5，但是如果有几个相同的数据呢，想要删除前面的，中间的，结尾的或者全部的5该怎么办呢？

查找数据最终代码:

//查找改进，针对有重复数据
//加入参数     从begin起始位置开始查找
int SLFind(SL* ps, SLDataType x,int begin)
{
	assert(ps);
	for (int i = begin; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;//查找到，并返回下标位置
		}
	}
	return -1;//未找到，返回-1
}

此时,测试，删除数据的代码也要进行略微改动。

测试，删除数据最终代码:

void TestSeqList6()
{

	SL sl;//定义顺序表的结构
	SLInit(&sl);//初始化，传给了SeqList.c中的函数，实参，传给形参，形参是实参的临时拷贝
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 7);
	SLPushBack(&sl, 8);
	SLPushBack(&sl, 5);

	SLPrint(&sl);

	/*int pos = SLFind(&sl, 5);
	if (pos != -1)
	{
		SLErase(&sl, pos);
	}
	SLPrint(&sl);*/ //原来代码

	int pos = SLFind(&sl, 4,0);//从0开始查找
	if (pos != -1)
	{
		SLErase(&sl, pos);
	}
	SLPrint(&sl);

	//删除所有的5
	pos = SLFind(&sl, 5, 0);
	while (pos != -1)
	{
		SLErase(&sl, pos);

		pos = SLFind(&sl, 5, pos);//从删除5的位置继续往后找
	}
	SLPrint(&sl);
	SLDestroy(&sl);
}
int main()
{
	TestSeqList6();
	return 0;
}

(12)补充顺序表菜单

菜单一般在程序结束后写，方便调试。

给出简单菜单：

//菜单
void menu()
{
	printf("********************************************\n");
	printf("1、尾插数据 2、尾删数据\n");
	printf("3、头插数据 2、头删数据\n");
	printf("5、打印数据 -1、退出\n");
	printf("********************************************\n");

}
int main()
{
	SL s;//定义顺序表
	SLInit(&s);//初始化
	int val = 0;
	int option = 0;
	do
	{
		menu();
		printf("请输入你的操作:>");
		scanf("%d", &option);
		switch (option)
		{
		case 1:
			printf("请依次输入你要尾插的数据,以-1结束");
			scanf("%d", &val);
			while (val != -1)
			{
				SLPushBack(&s, val);
				scanf("%d", &val);
			}
			break;
		case 2:
			SLPopFront(&s);
			break;

		case 3:
			break;

		case 4:
			break;

		case 5:
			SLPrint(&s);
				break;
			default:
				break;

		
		}
	}while (option != -1);
	
	SLDestroy(&s);

	return 0;
}

2.3源码：

SeqList.h文件

#pragma once//防止重复调用/包含
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//动态顺序表 --按需扩空间
typedef int SLDataType;     //为方便维护修改数据类型，重定义顺序表的数据类型
typedef struct SeqList      //多个数据定义为结构体,
{
	SLDataType* a;          //想到动态开辟内存函数malloc，定义一个指针，指向动态开辟的数组
	int size;               //有效数据个数
	int capacity;           //空间容量大小，满了relloc扩容

}SL;//typedef重定义

void SLPrint(SL* ps);           //打印函数的声明

//void SeqListInit(SL s);		//全称
void SLInit(SL* ps);            //定义一个顺序表
void SLDestroy(SL* ps);         //释放动态开辟的内存
void SLCheckCapacity(SL* ps);   //检查，扩容

//尾插尾删
void SLPushBack(SL* ps, SLDataType x);
void SLPopBack(SL* ps);               

//头插头删
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);              

//在pos位置插入数据
void SLInsert(SL* ps, int pos, SLDataType x);

//删除pos位置数据，删除指定位置的数据
void SLErase(SL* ps, int pos);

查找数据，为实现删除指定数据
//int SLFind(SL* ps, SLDataType x);
//查找改进，针对有重复数据
int SLFind(SL* ps, SLDataType x, int begin);

SeqList.c文件

#include"SeqList.h"//引用头文件
void SLInit(SL* ps)
{
	assert(ps);

	//初始化
	ps->a = NULL;//结构体指针用->
	ps->size = 0;
	ps->capacity = 0;
}

//打印函数
void SLPrint(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}


void SLDestroy(SL* ps)
{
	//if(ps->a !=NULL)
	assert(ps);
	if (ps->a)         //为真说明内存开辟成功，需要释放置空
	{
		free(ps->a);   //释放,free报错往往是越界，或者是释放的地方不对，一般free的时候才会检查越界
		ps->a = NULL;  //置空
		ps->size = ps->capacity = 0;//顺便修改他俩的值
	}
}

void SLCheckCapacity(SL* ps)//检查，扩容
{
	assert(ps);
	//插入前得开空间，判断空间是否满，否则涉及到越界问题
	//判断size和capacity是否相等，相等则满，或者还没开辟空间，因为开始时都初始化为0
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//如果是0还没开辟空间，如果不是就直接扩为2倍
		//ps->a = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));//扩容  ，realloc后面的参数是大小，前面的是需要扩容的空间//需要接收地址，因为relloc返回的是新开空间的地址
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));//扩容  ，realloc后面的参数是大小，前面的是需要扩容的空间//需要用临时变量tmp接收地址，因为relloc返回的是新开空间的地址
		if (tmp == NULL)//判断扩容是否成功
		{
			perror("relloc fail");
			exit(-1);//异常终止程序，0代表正常终止
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}

}

//尾插O(1)
void SLPushBack(SL* ps, SLDataType x)
{
	/*assert(ps);
	SLCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;*/

	SLInsert(ps, ps->size, x);//复用
}

//尾删
void SLPopBack(SL* ps)
{
	//温柔的检查
	/*if (ps->size == 0)
	{
		return;
	}*/

	//暴力的检查(断言)
	assert(ps->size > 0);//会直接报错,为真继续走，为假结束

	//ps->a[ps->size - 1] = 0;//将最后一个数据改为0，再size--，意义不大，因为print是以size为基础的，只会访问size前面的数据,再插入数据会将无效数据直接覆盖
	ps->size--;
	
	//SLErase(ps, ps->size - 1);//复用

}
//头插O(N)
void SLPushFront(SL* ps, SLDataType x)
{
	//assert(ps);
	//SLCheckCapacity(ps);

	挪动数据
	//int end = ps->size - 1;//size-1是最后一个元素的下标
	//while (end >= 0)
	//{
	//	ps->a[end + 1] = ps->a[end];
	//	--end;
	//}

	//ps->a[0] = x;
	//ps->size++;

	SLInsert(ps, 0, x);//复用


}
//头删
void SLPopFront(SL* ps)
{
	/*assert(ps);
	assert(ps->size>0);

	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}

	ps->size--;*/

	SLErase(ps, 0);//复用

}

//在pos位置插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos <= ps->size);//必须是连续存储

	SLCheckCapacity(ps);//考虑到后面空间不够可能越界
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}

	ps->a[pos] = x;
	ps->size++;
}

//删除pos位置数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos < ps->size);
	//assert(ps->size > 0);

	//挪动数据覆盖
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}

	ps->size--;
}

查找
//int SLFind(SL* ps, SLDataType x)
//{
//	assert(ps);
//	for (int i = 0; i < ps->size; i++)
//	{
//		if (ps->a[i] == x)
//		{
//			return i;
//		}
//	}
//	return -1;
//}

//查找改进，针对有重复数据
int SLFind(SL* ps, SLDataType x,int begin)
{
	assert(ps);
	for (int i = begin; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

test.c文件

在插入菜单前，main函数中调用的测试函数可以根据需要进行修改。

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"

void TestSeqList1()
{
	
	SL sl;//定义顺序表的结构
	SLInit(& sl);//初始化，传给了SeqList.c中的函数，实参，传给形参，形参是实参的临时拷贝
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 5);//插入了9个数据，扩了两次容
	
	SLPrint(&sl);

	SLDestroy(&sl);
}
void TestSeqList2()
{
	SL sl;//定义顺序表的结构
	SLInit(&sl);//初始化，传给了SeqList.c中的函数，实参，传给形参，形参是实参的临时拷贝
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);

	SLPopBack(&sl);
	SLPrint(&sl);

	SLPopBack(&sl);
	SLPrint(&sl);

	SLPopBack(&sl);
	SLPopBack(&sl);
	SLPopBack(&sl);
	SLPopBack(&sl);
	//SLPopBack(&sl);//越界调试,size--会导致size出现负数，后面如果再尾插，插入到了不属于自己的空间，就是越界访问

	SLPrint(&sl);

	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);

	SLDestroy(&sl);//去掉不报错
}


void TestSeqList3()
{

	SL sl;//定义顺序表的结构
	SLInit(&sl);//初始化，传给了SeqList.c中的函数，实参，传给形参，形参是实参的临时拷贝
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);

	SLPrint(&sl);
	SLPopFront(&sl);
	SLPopFront(&sl);
	SLPopFront(&sl);
	SLPopFront(&sl);
	SLPopFront(&sl);//四个数据删除五次size为空，运行正常，可能没测试到位

	SLPushBack(&sl, 10);//这时就出现了问题，发生了越界，free会报错
	SLPrint(&sl);
	
	SLDestroy(&sl);
}

void TestSeqList4()
{

	SL sl;//定义顺序表的结构
	SLInit(&sl);//初始化，传给了SeqList.c中的函数，实参，传给形参，形参是实参的临时拷贝
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);

	SLInsert(&sl, 2, 20);//第二个位置插入20
	SLPrint(&sl);

	SLInsert(&sl, 5, 500);//相当于尾插，需要考虑复用
	SLPrint(&sl);

	SLInsert(&sl, 0, 100);//相当于头插，需要考虑复用
	SLPrint(&sl);

	SLDestroy(&sl);
}

void TestSeqList5()
{

	SL sl;//定义顺序表的结构
	SLInit(&sl);//初始化，传给了SeqList.c中的函数，实参，传给形参，形参是实参的临时拷贝
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);

	SLErase(&sl, 2);//删除下标为2的值
	SLPrint(&sl);

	SLErase(&sl, 2);//删除下标为2的值
	SLPrint(&sl);

	SLErase(&sl, 0);//删除下标为2的值
	SLPrint(&sl);

	SLDestroy(&sl);
}

void TestSeqList6()
{

	SL sl;//定义顺序表的结构
	SLInit(&sl);//初始化，传给了SeqList.c中的函数，实参，传给形参，形参是实参的临时拷贝
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 7);
	SLPushBack(&sl, 8);
	SLPushBack(&sl, 5);

	SLPrint(&sl);

	/*int pos = SLFind(&sl, 5);
	if (pos != -1)
	{
		SLErase(&sl, pos);
	}
	SLPrint(&sl);*/

	int pos = SLFind(&sl, 4,0);//从0开始查找
	if (pos != -1)
	{
		SLErase(&sl, pos);
	}
	SLPrint(&sl);

	//删除所有的5
	pos = SLFind(&sl, 5, 0);
	while (pos != -1)
	{
		SLErase(&sl, pos);

		pos = SLFind(&sl, 5, pos);//从删除5的位置继续往后找
	}
	SLPrint(&sl);
	SLDestroy(&sl);
}



//int main()
//{
//	//TestSeqList1();
//	//TestSeqList2();
//	//TestSeqList3();
//	//TestSeqList4();
//	//TestSeqList5();
//	TestSeqList6();
//
//	//int* p1 = malloc(4);
//	//int* p2 = realloc(p1, 20);
//	//int* p3 = realloc(p2, 2000);//realloc原地扩容和异地扩容的演示
//
//	越界读基本不会被检查出来
//	//int a[10] = { 0 };
//	//printf("%d\n", a[10]);
//	//printf("%d\n", a[11]);
//	//
//	越界写，可能会被检查出来
//	a[10] = 0;//检查出来
//	//a[11] = 0;//未检查出来
//	//
//
//	return 0;
//}

//菜单
void menu()
{
	printf("********************************************\n");
	printf("1、尾插数据 2、尾删数据\n");
	printf("3、头插数据 2、头删数据\n");
	printf("5、打印数据 -1、退出\n");
	printf("********************************************\n");

}
int main()
{
	SL s;//定义顺序表
	SLInit(&s);//初始化
	int val = 0;
	int option = 0;
	do
	{
		menu();
		printf("请输入你的操作:>");
		scanf("%d", &option);
		switch (option)
		{
		case 1:
			printf("请依次输入你要尾插的数据,以-1结束");
			scanf("%d", &val);
			while (val != -1)
			{
				SLPushBack(&s, val);
				scanf("%d", &val);
			}
			break;
		case 2:
			SLPopFront(&s);
			break;
		case 3:
			break;
		case 4:
			break;
		case 5:
			SLPrint(&s);
				break;
			default:
				break;
		}
	}while (option != -1);
	
	SLDestroy(&s);

	return 0;
}

结语：

这里本章内容就介绍完了， 希望以上内容对大家有所帮助👀，如有不足望指出🙏
在这里插入图片描述

前路漫漫！努力变强💪💪 吧！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/23919.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

docker能干什么以及基本名词解释

docker能干什么以及基本名词解释

docker能干什么以及基本名词解释 docker能干什么&#xff1f;比较docker和虚拟机的不同DEVOps (开发&#xff0c;运维)基本名词解释docker能干什么&#xff1f; 比较docker和虚拟机的不同 传统虚拟机&#xff0c;虚拟出一条硬盘&#xff0c;然后再这个系统上安装和运行软件。…
阅读更多...
1.3-1.7 测度理论

1.3-1.7 测度理论

测度理论 (Durrett) 第五版 个人笔记 答案 Durrett高等概率论教材 (Probability) 攻读概率及统计/机器学习应用方向博士学位. 1. Measure Theory Probability SpacesDistributionsRandom VariablesIntegrationProperties of the IntegralExpected ValueProduct Measures, Fub…
阅读更多...
python实现科研通定时自动签到

python实现科研通定时自动签到

1 新建虚拟环境 python -m venv venv2 激活环境 3 官网下载edgedriver.exe Edge WebDriver链接在此&#xff0c;下载对应的浏览器的版本&#xff0c;然后改名为msedgedriver.exe放在\venv\Scripts下面。 main.py代码如下&#xff1a; from selenium import webdriver from…
阅读更多...
动态规划——完全背包问题（C++实现）

动态规划——完全背包问题（C++实现）

题目描述&#xff1a; 问题分析&#xff1a; 完全背包问题和01背包问题的不同点&#xff1a; 简单01背包中是从N个物品里选&#xff0c;每个物品只能用1次&#xff0c;完全背包则不同&#xff0c;每个物品可以用无限次。 01背包&#xff1a; 如果物品能放入背包&#xff08…
阅读更多...
PIC单片机1——按钮测试

PIC单片机1——按钮测试

#include "p18f458.h" #define Button PORTBbits.RB0 #define Led PORTCbits.RC0 void delay() { unsigned char i,j; for(i0;i<255;i) for(j0;j<255;j) ; } void main() { TRISBbits.TRISB01;//B0输入 TRISCbits.TRISC00;//C0输出 Led1;…
阅读更多...
[计算机毕业设计]大数据疫情分析与可视化系统

[计算机毕业设计]大数据疫情分析与可视化系统

前言 &#x1f4c5;大四是整个大学期间最忙碌的时光,一边要忙着准备考研,考公,考教资或者实习为毕业后面临的就业升学做准备,一边要为毕业设计耗费大量精力。近几年各个学校要求的毕设项目越来越难,有不少课题是研究生级别难度的,对本科同学来说是充满挑战。为帮助大家顺利通过…
阅读更多...
Unload data from Databend | 新手篇(4)

Unload data from Databend | 新手篇(4)

上篇我们讲了怎么利用 copy 命令借助于 Stage 把数据加载到 Databend 中&#xff0c;Databend 致力于构建一个完整的数据湖&#xff0c;也需要支持用户把数据从 Databend 中取走&#xff0c;这里 Databend 给三种可以把数据取走的办法&#xff1a; External table 把数据存储在…
阅读更多...
fiddler使用教程

fiddler使用教程

Fiddler教程 Fiddler简介 Fiddler是一款网络代理调试工具&#xff0c;可以将网络传输发送与接收的数据包进行截获、重发、编辑、转存等操作&#xff0c;是目前最常用的http抓包工具之一。 Fiddler工作原理 Fiddler通过改写HTTP代理&#xff0c;来监控并截取数据。当浏览器访…
阅读更多...
2022年第十二届APMCM亚太地区大学生数学建模竞赛--思路代码

2022年第十二届APMCM亚太地区大学生数学建模竞赛--思路代码

2022年第十二届APMCM亚太地区大学生数学建模竞赛--思路&代码报名时间节点往年真题赛题&翻译题目思路A题——赛题解读&解题思路B 题——赛题解读&解题思路C题——赛题解读&解题思路报名 官方网址&#xff1a;http://www.apmcm.org 报名网址&#xff1a;http…
阅读更多...
Similarity and Matching of Neural Network Representations 论文阅读笔记

Similarity and Matching of Neural Network Representations 论文阅读笔记

这是NIPS2021的一篇论文&#xff0c;文章主要是探究了通过一个stiching layer将两个已训练的不同初始化的相同结构的网络的某一层进行匹配的可能性。 前言 作者对 “什么情况下两个表征是相似的&#xff1f;” 提出了一个新的问题&#xff1a;“如果我们知道两个表征是相似的&…
阅读更多...
Qt 停靠布局QDockWidget使用

Qt 停靠布局QDockWidget使用

基本使用 QDockWidget是一个可以停靠在QMainWindow内的窗口控件&#xff0c;它可以保持浮动状态或在指定位置作为子窗口附加到主窗口中。停靠窗口QDockWidget类是应用程序中经常用到的&#xff0c;设置停靠窗口的一般流程如下。 创建一个QDockWidget对象的停靠窗体。设置此停…
阅读更多...
Kafka是什么？Rocket MQ在Spring Boot中怎么整合使用/Kafka在SpringBoot中简单配置使用

Kafka是什么？Rocket MQ在Spring Boot中怎么整合使用/Kafka在SpringBoot中简单配置使用

写在前面&#xff1a; 继续记录自己的SpringBoot学习之旅&#xff0c;这次是SpringBoot应用相关知识学习记录。若看不懂则建议先看前几篇博客&#xff0c;详细代码可在我的Gitee仓库SpringBoot克隆下载学习使用&#xff01; 3.5.4.5 SpringBoot整合RocketMQ 3.5.4.5.1 Rocket…
阅读更多...
怎么设计个性时尚的班服？一起来看看莱佛士学生的设计

怎么设计个性时尚的班服？一起来看看莱佛士学生的设计

校园时期&#xff0c;每个学生其实都拥有一次做“设计师”的经历&#xff0c;那就是为自己的班集体设计班服&#xff01; 莱佛士设计学院就曾与新加坡国立大学Yong Loo Lin 医学院合作&#xff0c;进行过一场别开生面的校园文创设计大赛&#xff0c;其中不仅有班服设计&#x…
阅读更多...
【iOS开发】-UIPickerView

【iOS开发】-UIPickerView

写在开头 昨天学习了iOS一个简单的控件。 UIPickerView; UIPickerView组件类似HTML都Select组件效果&#xff0c;提供数据供用户选择。可以通过plist文件提供数据。UIPickerView是一个选择器控件&#xff0c;可以生成单列的选择器&#xff0c;也可以生成多列的选择器&#xff…
阅读更多...
【待解决】Not a Prefab scene

【待解决】Not a Prefab scene

开发平台&#xff1a;Unity 2018.4.10f1 编程平台&#xff1a;Visual Studio   问题描述 注意&#xff1a;这是一个 意义不明 的报错内容。   问题发生环境&#xff08;可能不唯一&#xff09; 在 Unity 2018版本中&#xff0c;编辑场景内已有预制体的游戏对象时发生的问题…
阅读更多...
stm32cubemx hal学习记录：FreeRTOS消息队列

stm32cubemx hal学习记录：FreeRTOS消息队列

一、基本介绍 1、消息队列就是一个像容器一样的东西&#xff0c;我们所有的任务都可以往内部写&#xff0c;然后队列会将我们的消息按顺序存下来&#xff0c;所有的任务也可以按顺序将其读出来。 2、队列需要明确数据的大小以及队列的长度&#xff0c;写队列和读队列都是采用…
阅读更多...
16.面试重点CookieSession

16.面试重点CookieSession

一、文件上传&#xff08;使用频率高&#xff0c;但不是很重要&#xff09; 1.通过form表单 前端&#xff1a; form表单&#xff0c;method必须是POST, enctype属性是multipart/form-data, type是file 引起HTTP请求体的格式以multipart的形式传输 后端&#xff1a; 正常…
阅读更多...
UnRaid虚拟机安装Uos家庭版并由Windows远程桌面访问的成功流程

UnRaid虚拟机安装Uos家庭版并由Windows远程桌面访问的成功流程

文章目录0、前言1、UnRaid虚拟机安装Uos家庭版1.1、下载Uos系统镜像1.1.1、在https://home.uniontech.com/官网下载镜像安装包&#xff08;如下图&#xff1a;&#xff09;1.1.2、上传至Unraid1.1.3、添加虚拟机1.1.4、激活Uos家庭版2、开启Uos的远程桌面2.1、为Uos安装xrdp服务…
阅读更多...
【制作数字人】零门槛通过三维重建技术生成个人三维模型

【制作数字人】零门槛通过三维重建技术生成个人三维模型

依托各项技术的发展&#xff0c;数字人技术开始拔地而起。我们发现&#xff0c;各大一线互联网企业、三大运营商&#xff0c;还有不少创业型公司都纷纷入局数字人。 难道元宇宙的入门票是数字人&#xff1f;等不及了&#xff0c;马上接触下这门技术。经简单了解&#xff0c;现…
阅读更多...
前端学习路线（三）

前端学习路线（三）

往期回顾↓↓↓ 前端学习路线&#xff08;一&#xff09; 前端学习路线&#xff08;二&#xff09; 在前两章中&#xff0c;我们讲了如何去学习前端三剑客、js高级和bootstrap的重点&#xff0c;得到了很多前端初学者的好评&#xff0c;收藏量也是每天都在增加&#xff0c;所以…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023