【洋哥带你玩转线性表（一）——顺序表】

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 前言
• 一、顺序表的概念及其结构：
• 1.静态顺序表
• 2.动态顺序表算法概念及其结构
• 3.顺序表的代码实现
• 二、顺序表的代码实现：
  • 1.打印数据
  • 2.定义线性表
  • 3.销毁线性表
  • 4.扩充容量
  • 5.头插法插入元素
  • 6.尾插法插入元素
  • 7.头删法删除元素
  • 8.尾删法删除元素
  • 9.任意位置插入元素
  • 10.任意位置删除元素
  • 11.查找元素位置引入库
• 总结

---

前言

线性表：

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

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

1.顺序表的定义以及代码实现。

2.单链表的定义以及代码实现。

3.双向链表的定义以及代码实现

---

一、顺序表

1概念及其结构

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

        顺序表的结构

1

2

3

4

5

6

7

        顺序表往往分为静态顺序表和动态顺序表

        1）静态顺序表：采用定长的数组存储元素。

        拓展：在使用静态顺序表的时候需要定义一个定长的数组，再利用宏定义，为数组定义一个固定的容量,定义如下所示：

​#define MAX_SIZE 50

typedef int DataType;
typedef struct SeqList{
    DataType arr[MAX_SIZE];
    int size;
}SList;

        2）静态顺序表的不足：

        在对数组的容量进行定义时若定义的数组过大则会造成内存空间的浪费，若过小则会使得剩余数据无法存放，给操作带来不便。所以我们在使用的时候往往采用动态类型，而不采用静态类型。

        3）动态顺序表：采用动态开辟的数组存储

typedef int DataType;

typedef struct SeqList{
    DataType* arr;    //定义一个指针指向动态开辟的数组
    int size;        //有效数据的个数
    int capacity;    //空间容量的大小
}SList;

1

2

3

4

NULL

NULL

NULL

若是空间不足则可以扩容

        4）拓展：

        a：typedef的使用：

        这里的typedef的使用相当于重命名相当于为原来的结构体“struct SeqList”重命名为“SList”，这样在后续写代码的时候就可以直接用“SList”来定义结构体了。

        b：定义DataType的意义：

        正如上文所说“typedef”相当于重定义、重命名的意思，将这里的“int”类型定义为”DataType“，如果需要将顺序表中的数据类型修改为”double“或是”char“等其他类型的时候可以直接修改”DataType“为”double“或”char“等其他类型即可，否则的话需要将全体代码中的”int“类型做修改。

        c:指针的使用：

        在动态内存开辟里并没有直接使用数组，而是利用数组指针（数组的地址）。

在顺序表空间不足时可以直接利用动态内存开辟函数直接进行内存开辟。

2代码实现

1）头文件：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int DataType;

typedef struct SeqList {
	DataType* arr;
	int capacity;
	int size;
}SList;

void SListPrint(SList* L);
void SListInit(SList* L);
void SListDestroy(SList* L);
void SListCheckCapacity(SList* L);
void SListPushBack(SList* L, DataType x);
void SListPushFront(SList* L, DataType x);
void SListPopFront(SList* L);
void SListPopBack(SList* L);
void SListInsert(SList* L,int pos,DataType x);
void SListErase(SList* L);
int SListFind(SList* L);
void SListModify(SList* L, int pos, DataType x);

2）源代码展示：
1）元素打印：

拓展：

a）”assert“断言，可以理解为一定满足或者一定正确。

例如：”assert（L）“意味着顺序表的地址L一定存在，如果不存在，代码不会再往下执行，也就是说代码运行的时候，参数传递必须正确，如果给函数传入了一个空地址，代码不会执行。

b）由于函数接口的参数为形参，形参只是实参的一个临时拷贝，形参的改变是不可以影响实参的，所以函数接口当中必须传地址。

​
#define  _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

void SListPrint(SList* L)
{
	assert(L);
	for (int i = 0; i < L->size; i++)
	{
		printf("%d", L->arr[i]);
	}
	printf("\n");
}

​

2）线性表的初始化：

拓展：”size“代表顺序表当中元素的时机个数，”capacity“代表容量大小，在初始化时二者都为零。

void SListInit(SList* L)
{
	assert(L);
	L->arr = NULL;
	L->size = L->capacity = 0;
}

3）线性表的销毁：

拓展：只有动态开辟的内存才可以用”free“来释放，释放后需要置空，当然也可以不置空（置为NULL），因为系统最后会自动回收，但我们建议最好回收，否则很容易造成野指针,指针如果不置为NULL，意味着他还对地址具有访问权限，但是地址已经被”free“释放掉了，这个时候会导致非法访问。

void SListDestroy(SList* L)
{
	assert(L);
	if (L->arr)
	{
		free(L->arr);
		L->arr = NULL;
		L->capacity = L->size = NULL;
	}
}

4）扩充容量：

拓展：

a）”DataType* tmp“是定义一个”DataType“类型的数组，”tmp“是这个数组的地址。

b）”realloc“也是动态内存分配函数，它用于扩容，首先传入要扩容对象的首地址，在传入要扩容的大小。

void SListCheckCapacity(SList* L)
{
	assert(L);
	if (L->capacity == L->size)
	{
		int newcapacity = L->capacity == 0 ? 4 : L->capacity * 2;
		DataType* tmp = (DataType*)realloc(L->arr, newcapacity * sizeof(DataType));
		if (tmp == NULL)
		{
			printf("realloc is fail\n");
			return;
		}
		L->arr = tmp;
		L->capacity = newcapacity;
	}
}

5）尾插法：

拓展：这里的”size“代表数组当中最后一个元素的下一个位置。

void SListPushBack(SList* L, DataType x)
{
	assert(L);
	SListCheckCapacity(L);
	L->arr[L->size] = x;
	L->size++;
}

6）头插法：

拓展：头插法必须把要插入的位置的元素及其之后的元素统统向后移动一个位置才可以进行插入操作，而且移动必须从最后一个元素开始移动，否则的话胡造成元素的相互覆盖。

        而且要注意到在每一次插入的时候必须进行扩容检查，多以才有了扩容函数的存在。

void SListPushFront(SList* L, DataType x)
{
	assert(L);
	SListCheckCapacity(L);
	int end = L->size - 1;
	while (end >= 0)
	{
		L->arr[end + 1] = L->arr[end];
		--end;
	}
	L->arr[0] = x;
	L->size++;
}

7）头删法：

拓展：从第二个元素开始将每一个元素向前移动覆盖前一个元素，就达到删除第一个元素的目的，第二个元素覆盖第一个元素，第三个元素覆盖第二个元素，以此类推。

void SListPopFront(SList* L)
{
	assert(L);
	assert(L->size > 0);
	int begin = 1;
	while (begin < L->size)
	{
		L->arr[begin - 1] = L->arr[begin];
		++begin;
	}
	L->size--;
}

8）尾删法：

拓展：直接将”size“进行调整即可

void SListPopBack(SList* L)
{
	assert(L);
	assert(L->size > 0);
	L->size--;
}

9）任意位置插入：

void SListInsert(SList* L, int pos, DataType x)
{
	assert(L);
	assert(pos >= 0 && pos <= L->size);
	SListCheckCapacity(L);
	int end = L->size - 1;
	while (end >= pos)
	{
		L->arr[end + 1] = L->arr[end];
		--end;
	}
	L->arr[pos] = x;
	L->size++;
}

10）任意位置删除：

void SListErase(SList* L,int pos)
{
	assert(L);
	assert(pos >= 0 && pos <= L->size);
	int begin = pos + 1;
	while (begin < L->size)
	{
		L->arr[begin - 1] = L->arr[begin];
		++begin;
	}
	L->size--;
}

11）元素查找：

int SListFind(SList* L,DataType x)
{
	assert(L);
	for (int i = 0; i < L->size; i++)
	{
		if (L->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

12）数据修改：

void SListModify(SList* L, int pos, DataType x)
{
	assert(L);
	assert(pos >= 0 && pos <= L->size);
	L->arr[pos] = x;
}​

未完待续，咱们下期再见 ! ! !

二、单链表

三、双向链表

---

总结与心得：

1）顺序表的结构

2）顺序表的类型（动态和静态）

3）顺序表的优点：相比较链表它可以实现随机访问任意位置的结点

4）想要学好数据结构C语言的基础必须打扎实，尤其是指针、结构体、动态内存开辟这三大主干，否则数据结构学起来会非常困难

5）想要学好编程，动手能力必须强，量变堆死质变，努力才能创造奇迹，当你发现你对某一个知识点掌握不足，那很大程度上是量的缺失，所以必须动手多敲代码，但是敲代码也必须建立在理解的基础上，否则就是敲得再多也是徒劳，编程要理解代码，而不是对代码死记硬背。