数据结构-顺序表

数据结构-顺序表 2021/8/5 23:44

静态顺序表

#include <iostream>
#include <stdlib.h>
using namespace std;
#define Maxsize 50
typedef int ElemType;

//静态分配顺序表
typedef struct {
	ElemType data[Maxsize];
	int length;//顺序表当前长度
}sqlist;

//初始化静态顺序表
void Initlist(sqlist& L)
{
	
	L.length = 0;
}

/*
* 顺序表插入，在下标为i的位置插入e,将i位置及其以后元素后移
*/
bool ListInsert(sqlist& L, int i, ElemType e)
{
	if (i<0 || i>L.length||L.length>=Maxsize)
		return false;
	for (int j = L.length-1; j >= i; j--)
	{
		L.data[j+1] = L.data[j];
	}
	L.data[i] = e;
	L.length++;
	return true;
}

/*
* 顺序表删除，将下标为i的位置的元素删除，同时将i位置以后的元素前移
*/
bool ListDelete(sqlist& L, int i, ElemType & e)
{
	if (i<0 || i>L.length - 1)
		return false;
	e = L.data[i];
	for (int j = i+1; j < L.length; j++)
	{
		L.data[j-1] = L.data[j ];
	}
	L.length--;
	return true;
}

/*
* 按位查找，返回下标为i的元素
*/
ElemType GetElem(sqlist L, int i)
{
	return L.data[i];
}

/*
* 按值查找，返回元素值为e的元素下表i,未找到返回-1
* 若元素类型为结构体，要自己定义比较相等的函数
*/
int LocateElem(sqlist L, ElemType e)
{
	for (int i = 0; i < L.length; i++)
	{
		if (L.data[i] == e)
		{
			return i;
		}
	}
	return -1;
}

int main()
{
	sqlist s;
	Initlist(s);
	for (int i = 0; i < 10; i++)
	{
		ListInsert(s, i, i);
	}
	int r;
	ListDelete(s, 1, r);
	cout << s.length;
	for (int i = 0; i < s.length; i++)
	{
		cout << s.data[i] << endl;
	}
	return 0;

}

1.静态顺序表的初始化：初始化时设置长度length=0，在遍历寻找的时候按照length的界限寻找防止找到溢出无效数据
2.静态顺序表的数据插入：将i位置之后的数据依次后移一位，空出的位置插入待插数据，同时将length++
3.静态顺序表的数据删除：将i位置的数据保存到引用变量然后删除，将i后续位置的数据前移，同时length–
4.按位查找：顺序表可以随时查找，直接返回下标为i的数据即可
5.按值查找：遍历数组，找到所找值得下标返回即可，若没有，返回-1

动态顺序表

#include <iostream>
#include <stdlib.h>
#define Initsize 50//顺序表动态分配初始长度
typedef int ElemType;

//动态分配线性表
typedef struct {
	ElemType* data;
	int Maxsize;
	int length;//顺序表当前长度
}seqlist;

//初始化动态顺序表
void Initlist(seqlist& L)
{
	L.data = (ElemType*)malloc(sizeof(ElemType) * Initsize);
	L.length = 0;
	L.Maxsize = Initsize;
}

//动态增加顺序表长度
bool IncreaseSize(seqlist& L,int len)
{
	ElemType* p = L.data;
	L.data = (ElemType*)malloc(sizeof(ElemType) * (len + L.Maxsize));
	for (int i = 0; i < L.length; i++)
	{
		L.data[i] = p[i];
	}
	L.Maxsize = L.Maxsize + len;
	free(p);
	return true;
}

/*
* 按位查找，返回下标为i的元素
*/
ElemType GetElem(seqlist L, int i)
{
	return L.data[i];
}

1.动态顺序表：如果要扩展容量，则另开辟一个新的大内存，将数据整体迁移过去，改变data指针指向即可
2.初始化：开辟一个初始化大小的空间，将data指向该空间的地址
3.按位查找：直接返回下标为i的元素