基础数据结构---顺序表（顺序结构实现）

固定长度的顺序表

sqlist头文件

#pragma once //预防头文件被重复引用

//顺序表,固定长度(非常简单,不实用)

typedef struct SQList
{
	int elem[10];//存放数据,固定长度为10
	int length;//有效数据的个数
}SQList, * PSQList;

//typedef struct SQList * PSQList;

//初始化
void InitSqList(PSQList ps);//PSQList == SQList*

//插入数据,在ps顺序表的pos下标插入val
bool Insert(PSQList ps, int pos, int val);

//判空
bool IsEmpty(PSQList ps);

//在ps中查找第一个key,找到返回下标,没有找到返回-1
int Search(PSQList ps, int key);

//删除pos位置的值
bool DelPos(PSQList ps, int pos);

//删除第一个val值
bool DelVal(PSQList ps, int val);

//返回key的前驱下标,如果不存在前驱则返回-1
int GetPrio(PSQList ps, int key);

//返回key的后继,如果不存在后继则返回-1
int GetNext(PSQList ps, int key);

//输出
void Show(PSQList ps);

//清空数据
void Clear(PSQList ps);

//销毁整个内存
void Destroy(PSQList ps);

sqlist .cpp文件

#include <stdio.h>
#include <assert.h>
#include "sqlist.h"

//初始化
void InitSqList(PSQList ps)
{
	assert(ps != NULL);//1,断言只在Debug模式下有效
	if (ps == NULL)//2
		return;

	ps->length = 0;//没有一个有效数字
}

//判满
static bool IsFul(PSQList ps)
{
	return ps->length == 10;
}

//插入数据,在ps顺序表的pos下标插入val
//插入的数据必须是左边连续
bool Insert(PSQList ps, int pos, int val)
{
	if (pos<0 || pos>ps->length || IsFul(ps))
	{
		return false;
	}

	//移到后面的数据
	for (int i = ps->length - 1; i >= pos; i--)
	{
		ps->elem[i + 1] = ps->elem[i];
	}

	//插入新的数据
	ps->elem[pos] = val;

	//有效数据个数+1
	ps->length++;

	return true;
}

//判空
bool IsEmpty(PSQList ps)
{
	return ps->length == 0;
}

//在ps中查找第一个key,找到返回下标,没有找到返回-1
int Search(PSQList ps, int key)
{
	for (int i = 0; i < ps->length; i++)
	{
		if (key == ps->elem[i])
			return i;
	}

	return -1;
}

//删除pos位置的值
bool DelPos(PSQList ps, int pos)
{
	//判断pos位置是否合法
	if (pos < 0 || pos >= ps->length)
		return false;

	//将后面的数据前移
	for (int i = pos; i < ps->length - 1; i++)
	{
		ps->elem[i] = ps->elem[i + 1];
	}

	ps->length--;

	return true;
}

//删除第一个val值
bool DelVal(PSQList ps, int val)
{
	int i = Search(ps, val);
	if (i < 0)
		return false;

	return DelPos(ps, i);
}

//返回key的前驱下标,如果不存在前驱则返回-1
int GetPrio(PSQList ps, int key)
{
	int i = Search(ps, key);
	if (i <= 0)//注意头也没有前驱
		return -1;
	return i - 1;
}

//返回key的后继,如果不存在后继则返回-1
int GetNext(PSQList ps, int key)
{
	int i = Search(ps, key);
	if (i < 0 || i == ps->length - 1)//注意,尾也没有后继
		return -1;
	return i + 1;
}

//输出
void Show(PSQList ps)
{
	for (int i = 0; i < ps->length; i++)
	{
		printf("%d ", ps->elem[i]);
	}
	printf("\n");
}

//清空数据
void Clear(PSQList ps)
{
	ps->length = 0;
}

//销毁整个内存(动态内存)
void Destroy(PSQList ps)
{
	Clear(ps);//没有动态内存
	//ps->elem = {};
}

固定不长度的顺序表

dsqlist头文件

#pragma once //预防头文件被重复引用

//顺序表,长度不固定

/*
顺序表的特点:逻辑相邻,物理也相邻
  1.插入数据的时间复杂度为O(n),如果是尾插时间复杂度为O(1)
  2.删除数据的时间复杂度为O(n),如果是尾删时间复杂度为O(1)
  3.通过下标访问数据时间复杂度为O(1)
  4.简单
*/

#define INIT_SIZE 10

typedef struct DSQList
{
	int* elem;//动态内存的地址
	int length;//有效数据的个数
	int listsize;//总容量
}DSQList, * DPSQList;

//初始化
void InitSqList(DPSQList ps);

//插入数据,在ps顺序表的pos下标插入val
bool Insert(DPSQList ps, int pos, int val);

//判空
bool IsEmpty(DPSQList ps);

//在ps中查找第一个key,找到返回下标,没有找到返回-1
int Search(DPSQList ps, int key);

//删除pos位置的值
bool DelPos(DPSQList ps, int pos);

//删除第一个val值
bool DelVal(DPSQList ps, int val);

//返回key的前驱下标,如果不存在前驱则返回-1
int GetPrio(DPSQList ps, int key);

//返回key的后继,如果不存在后继则返回-1
int GetNext(DPSQList ps, int key);

//输出
void Show(DPSQList ps);

//清空数据
void Clear(DPSQList ps);

//销毁整个内存
void Destroy(DPSQList ps);

dsqlist .cpp文件

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "dsqlist.h"

//初始化,动态创建初始容量
void InitSqList(DPSQList ps)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return;
	}
	ps->elem = (int*)malloc(INIT_SIZE * sizeof(int));//STL中容器的初始大小为0
	ps->length = 0;
	ps->listsize = INIT_SIZE;
}

//判满
static bool IsFull(DPSQList ps)
{
	return ps->length == ps->listsize;
}

//容量增长函数,容量变为原来的2倍(注意STL中有可能是2倍或1.5倍)
static bool Inc(DPSQList ps)
{
	ps->elem = (int*)realloc(ps->elem, ps->listsize * 2 * sizeof(int));
	assert(ps->elem != NULL);
	ps->listsize *= 2;
	//ps->length;不变

	return true;
}

//插入数据,在ps顺序表的pos下标插入val
bool Insert(DPSQList ps, int pos, int val)
{
	if (pos<0 || pos>ps->length)
	{
		return false;
	}

	if (IsFull(ps))//满
	{
		Inc(ps);
	}

	//移动后面的数据
	for (int i = ps->length - 1; i >= pos; i--)
	{
		ps->elem[i + 1] = ps->elem[i];
	}

	//插入新数据
	ps->elem[pos] = val;

	//有效数据+
	ps->length++;

	return true;
}

//判空
bool IsEmpty(DPSQList ps)
{
	return ps->length == 0;
}

//在ps中查找第一个key,找到返回下标,没有找到返回-1
int Search(DPSQList ps, int key)
{
	for (int i = 0; i < ps->length; i++)
	{
		if (key == ps->elem[i])
			return i;
	}

	return -1;
}

//删除pos位置的值
bool DelPos(DPSQList ps, int pos)
{
	if (pos < 0 || pos >= ps->length)
		return false;

	//后面的数据前移
	for (int i = pos; i < ps->length - 1; i++)
	{
		ps->elem[i] = ps->elem[i + 1];
	}

	ps->length--;

	return true;
}

//删除第一个val值
bool DelVal(DPSQList ps, int val)
{
	int i = Search(ps, val);
	if (i < 0)
		return false;

	return DelPos(ps, i);
}

//返回key的前驱下标,如果不存在前驱则返回-1
int GetPrio(DPSQList ps, int key)
{
	int i = Search(ps, key);
	if (i <= 0)
		return -1;
	return i - 1;
}

//返回key的后继,如果不存在后继则返回-1
int GetNext(DPSQList ps, int key)
{
	int i = Search(ps, key);
	if (i < 0 || i == ps->length - 1)
		return -1;

	return i + 1;
}

//输出
void Show(DPSQList ps)
{
	for (int i = 0; i < ps->length; i++)
	{
		printf("%d ", ps->elem[i]);
	}
	printf("\n");
}

//清空数据
void Clear(DPSQList ps)
{
	ps->length = 0;
}

//销毁整个内存
void Destroy(DPSQList ps)
{
	free(ps->elem);//1
	ps->elem = NULL;//2  ps->elem == (*ps).elem;   arr[i] == *(arr+i)
	ps->length = 0;//3
	ps->listsize = 0;//4
	//ps = NULL;//5  无效代码
}