基础数据结构--线性表——顺序表

唯一的头，唯一的尾，除头之外，其他节点都有唯一的前驱，除尾之外，其他节点都有唯一的后继，线性表有两种形式,先介绍一下顺序表。

顺序表

实际是一种权限更多的数组
数组功能：读和写
例如：

int ar[10];
ar[0] = 1;
int x = ar[0];

而顺序表除了这些外，还包括增，删，改，查，获取长度，清空和销毁等功能。

定长顺序表

设计一个十个空间的定长顺序表：

sqlist.h

//放函数的声明以及结构体的定义
#pragma once//防止头文件重复

//顺序表  定长的顺序表  10

typedef struct SQlist
{
	int data[10];
	int length;
}SQList, *PSQlist;	//typedef SQlist * PSQlist;

//增删改查
//初始化
void Init_SQlist(PSQlist ps);	//PSQlist == SQlist*
//按位置插入
bool Insert(PSQlist ps, int pos, int val);
//按位置删除
bool Del_pos(PSQlist ps, int pos);
//按值删除
bool Del_val(PSQlist ps, int val);
//判空
bool IsEmpty(PSQlist ps);
//判满
bool IsFull(PSQlist ps);
//获取长度
int Get_Length(PSQlist ps);
//清空
void Clear(PSQlist ps);
//销毁
void Destroy(PSQlist ps);
//打印
void Show(PSQlist ps);

sqlist.cpp

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

void Init_SQlist(PSQlist ps)//PSQlist == SQlist*
{
	assert(ps != nullptr);
	if(ps == nullptr)
	{
		return;
	}

	//ps->data 数据域不需要初始化
	ps->length = 0;
}

bool Insert(PSQlist ps, int pos, int val)
{
	assert(ps != nullptr && 0 <= pos && pos <= ps->length);
	if(ps == nullptr || pos < 0 || pos > ps->length)
	{
		return false;
	}

	if(IsFull(ps))
	{
		return false;
	}

	//挪动数据，将插入位置空出来
	for(int i = ps->length - 1; i >= pos; i--)
	{
		ps->data[i + 1] = ps->data[i];
	}

	//把值插进去
	ps->data[pos] = val;
	ps->length++;
	return true;
}

bool Del_pos(PSQlist ps, int pos)
{
	assert(ps != nullptr && pos >= 0 && pos < ps->length);
	if(ps == nullptr || pos < 0 || pos >= ps->length)
	{
		return false;
	}

	if(IsEmpty(ps))
	{
		return false;
	}

	//将数据向前覆盖
	for(int i = pos + 1; i < ps->length; i++)
	{
		ps->data[i - 1] = ps->data[i];
	}

	ps->length--;
	return true;
}

bool Del_val(PSQlist ps, int val)
{
	assert(ps != nullptr);
	if(ps == nullptr)
	{
		return false;
	}

	if(IsEmpty(ps))
	{
		return false;
	}

	//遍历一边，要删除的val存在与否
	int tmp = -1;
	for(int i = 0; i < ps->length; i++)
	{
		if(ps->data[i] == val)
		{
			tmp = i;
			break;
		}
	}
	if(tmp == -1)
	{
		return false;
	}
	//调用上一步写好的函数（按位置删除）
	Del_pos(ps, tmp);//这一个函数已经将length--了，所以不在需要length--

	return true;
}

bool IsEmpty(PSQlist ps)
{
	return ps->length == 0;
}

bool IsFull(PSQlist ps)
{
	return ps->length == 10;
}

int Get_Length(PSQlist ps)
{
	return ps->length;
}

void Clear(PSQlist ps)
{
	ps->length = 0;	//变为0就说明没有有效数据了
}

void Destroy(PSQlist ps)
{
	Clear(ps);
}

void Show(PSQlist ps)
{
	assert(ps != nullptr);

	for(int i=0; i<ps->length; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

main.cpp示例

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

int main(void)
{
	SQList sq;

	//初始化测试
	Init_SQlist(&sq);

	for (int i = 0; i < 10; ++i)
	{
		Insert(&sq, i, i + 1);
	}
	Show(&sq);
	//获取有效长度
	printf("Length = %d\n", Get_Length(&sq));

	//删除测试
	Del_pos(&sq, 3);
	Show(&sq);

	Del_val(&sq, 7);
	Show(&sq);

	printf("Length = %d\n", Get_Length(&sq));

	//清空，销毁
	Clear(&sq);
	Destroy(&sq);
	printf("Length = %d\n", Get_Length(&sq));
	return 0;
}

运行结果：

不定长顺序表

DSQlist.h

#pragma once
//sqlist = sequence list

#define INIT_SIZE 10

typedef struct DSQlist
{
	int* data;		//数据域 用来承接malloc申请的空间
	int length;		//有效长度个数
	int listsize;	//总的空间大小
}DSQlist, *PDSQlist;

//初始化函数
void Init_List(PDSQlist ps);

//插入数据 按pos
bool Insert(PDSQlist ps, int pos, int val);

//删除数据 按位置pos
bool Del_pos(PDSQlist ps, int pos);

//删除数据 按值删除 val
bool Del_val(PDSQlist ps, int val);

//查找 找到值为val的第一个元素，返回其下标
int Search(PDSQlist ps, int val);

//判空
bool IsEmpty(PDSQlist ps);

//判满
bool IsFull(PDSQlist ps);

//扩容
void Inc(PDSQlist ps);

//清空
void Clear(PDSQlist ps);

//销毁
void Destory(PDSQlist ps);

//打印
void Show(PDSQlist ps);

DSQlist.cpp

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

//关于顺序表的增删改查

//初始化函数
void Init_List(PDSQlist ps)
{
	assert(ps != nullptr);
	if (ps == nullptr)
	{
		return;
	}

	ps->data = (int*)malloc(sizeof(int) * INIT_SIZE);
	assert(ps->data != nullptr);

	ps->length = 0;
	ps->listsize = INIT_SIZE;
}

//插入数据 按pos
bool Insert(PDSQlist ps, int pos, int val)
{
	//安全性检测
	assert(ps != nullptr && pos >= 0 && pos <= ps->length);
	if (ps == nullptr || pos < 0 || pos > ps->length)
	{
		return false;
	}

	//如果满了，则扩容
	if (IsFull(ps))
	{
		Inc(ps);
	}

	//挪动数据，把插入位置空间空出来
	for (int i = ps->length - 1; i >= pos; --i)
	{
		ps->data[i + 1] = ps->data[i];
	}

	//把值放进去
	ps->data[pos] = val;

	//有效长度++
	ps->length++;

	return true;
}

//删除数据 按位置pos
bool Del_pos(PDSQlist ps, int pos)
{
	assert(ps != nullptr && pos >= 0 && pos < ps->length);
	if (ps == nullptr || pos < 0 || pos >= ps->length)
	{
		return false;
	}
	//判空（没必要写）
	if (IsEmpty(ps))
	{
		return false;
	}
	
	//挪动数据，往前覆盖
	for (int i = pos + 1; i < ps->length; ++i)
	{
		ps->data[i - 1] = ps->data[i];
	}

	//有效长度--
	ps->length--;

	return true;

}

//删除数据 按值删除 val
bool Del_val(PDSQlist ps, int val)
{
	assert(ps != nullptr);
	//通过函数Search来找val的下标
	int i = Search(ps, val);
	if (i == -1)	//i == -1，代表没找到，退出
	{
		return false;
	}

	//找到，则调用按位置pos删除函数,ps->length 不用--
	Del_pos(ps, i);

	return true;
}

//查找 找到值为val的第一个元素，返回其下标
int Search(PDSQlist ps, int val)
{
	assert(ps != nullptr);

	//遍历一遍
	for (int i = 0; i < ps->length; ++i)
	{
		if (val == ps->data[i])
		{
			return i;
		}
	}
	//如果没有找到
	return -1;
}

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

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

//扩容
static void Inc(PDSQlist ps)
{
	//realloc后面括号内的参数是：（要改变空间的指针名，新的大小）
	ps->data = (int*)realloc(ps->data, sizeof(int) * ps->listsize * 2);
	assert(ps->data != nullptr);
	ps->listsize *= 2;
}

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

//销毁
void Destory(PDSQlist ps)
{
	free(ps->data);
	ps->data = nullptr;
	ps->length = 0;
	ps->listsize = 0;
}

//打印
void Show(PDSQlist ps)
{
	assert(ps != nullptr);

	for (int i = 0; i < ps->length; ++i)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

main.cpp示例

#include<stdio.h>
#include"DSQlist.h"

int main(void)
{
	DSQlist dsq;

	//初始化
	Init_List(&dsq);

	for (int i = 0; i < 20; ++i)
	{
		Insert(&dsq, i, i + 1);
	}
	Show(&dsq);
	printf("Length = %d\n", Get_Length(&dsq));

	//删除测试
	Del_pos(&dsq, 5);
	Show(&dsq);
	Del_val(&dsq, 10);
	Show(&dsq);
	printf("Length = %d\n", Get_Length(&dsq));

	//清空
	Clear(&dsq);
	Destory(&dsq);
	printf("Length = %d\n", Get_Length(&dsq));

	return 0;
}

运行结果：

自己的错误

在我第一遍写完代码运行时，出现了这个情况：

但还是有显示的结果：

错误原因是由于realloc()这个函数，在此复习一下这个函数：

//头文件：
#include<stdlib.h>
#include<malloc.h>	//有些编译器需要
//原型：
extern void* realloc(void* mem_address, unsigned int newsize);

//语法：
指针名 = (数据类型*)realloc(要改变内存大小的指针名，新的大小);

在我第一次写扩容函数时候，新的大小忘记×2，导致堆损坏，非常难受。