数据结构与算法---顺序表(C版)

顺序表的认识

顺序表概念：

• 顺序表： 把线性表中的所有元素按照其逻辑顺序依次存储到计算机中的指定存储位置开始的一块连续的存储空间中，从而使得逻辑上的相邻的两个元素在物理位置上也相邻。

顺序表的优缺点：

• 优点：
  顺序表的主要优点就是能够随机访问，即通过首地址和元素序号可以在时间O(1)内找到指定的元素。
  顺序表的存储密度高，每个结点只存储数据元素。
• 缺点：
  顺序表逻辑上相邻的元素物理上也相邻，所有插入和删除操作需要移动大量的元素。

顺序表的基本操作：

结构体的定义：

typedef int SLDataType; //定义顺序表中的数据类型

typedef struct SeqList {
	SLDataType *a;//定义一个数组
	size_t size; //定义数组中元素的个数
	size_t capacity; //定义存储元素的空间的最大容量。
}SL;

初始化顺序表：

void SeqListInit(SL *ps) {
	ps->a = NULL;	
	ps->capacity = 0; //容量为0
	ps->size = 0;     //实际的元素个数为0；
}

对顺序表进行扩容：

int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2; 这句话的意思是：如果顺序表的容量为0的时候，容量扩充4个，其他情况扩充为原来的容量的2倍。

void SeqListCheckCapacity(SL *ps) {
	if (ps->size == ps->capacity)
	{
		

		 int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;

		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

对顺序表进行后插：

void SeqListPushBack(SL *ps, SLDataType x) {
	SeqListCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}

对顺序表进行前插：

void SeqListPushFront(SL *ps, SLDataType x) {
	SeqListCheckCapacity(ps);
	int i = 0;
	for (i = ps->size; i > 0; i--) {
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
	ps->size++;
}

对顺序表进行后删：

void SeqListPopBack(SL *ps) {
	assert(ps->size > 0);  //断言的目的是判断ps是不是空指针
	ps->a[ps->size - 1] = 0;
	ps->size--;
}

对顺序表进行前删：

void SeqListPopFront(SL *ps) {
	assert(ps->size > 0);
	int i = 0;
	for (i = 1; i < ps->size; i++) {
		ps->a[i - 1] = ps->a[i];
	}
	ps->a[ps->size - 1] = 0; //这句可有可无
	ps->size--;
}

在顺序表中找出给定值的位置：

int SeqListFind(SL* ps, SLDataType x) {
	int i = 0;
	int flag = -1;
	for (i = 0; i < ps->size; i++) {
		if (ps->a[i] == x) {
			flag = i;
			break;
		}
	}
	return flag;
}

在顺序表中具体的位置插入元素：

void SeqListInsert(SL* ps, int pos, SLDataType x) { //在一个具体的位置插入一个元素
	
	SeqListCheckCapacity(ps);
	if (pos > ps->size) { 
		pos %= ps->size;
	}
	int i = 0;
	for (i = ps->size; i >= pos; i--) {
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[pos - 1] = x;
	ps->size++;
}

在顺序表中具体的位置删除元素：

void SeqListErase(SL* ps, int pos) {
	int i = 0;
	for (i = pos - 1; i < ps->size-1; i++) {
		ps->a[i] = ps->a[i + 1];
	}
	ps->a[ps->size - 1] = 0;
	ps->size--;
}

在顺序表中删除特定值的元素：

void SeqListDlete(SL *ps, SLDataType x) {  //删除一个特定值的元素
	int count = 0;
	int i = 0;
	for (i = 0; i < ps->size; i++) {
		if (ps->a[i] != x) {
			ps->a[count++] = ps->a[i];
		}
	}
	
	ps->size = count;
}

Visual Studio下实现的顺序表的基本操作：

头文件：SeqList.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType;
typedef struct SeqList {
	SLDataType *a;//定义一个数组
	size_t size; //定义数组中元素的个数
	size_t capacity; //定义存储元素的空间的最大容量。
}SL;
void SeqListInit(SL *ps);
void SeqListCheckCapacity(SL *ps);			  //扩容
void SeqListPrint(SL *ps);					
void SeqListPushBack(SL *ps, SLDataType x);	  //顺序表表尾插入
void SeqListPushFront(SL *ps, SLDataType x);  //顺序表表前插入
void SeqListPopBack(SL *ps);				  //顺序表表尾删除
void SeqListPopFront(SL *ps);                 //顺序表表头删除
int SeqListFind(SL* ps, SLDataType x);		  //顺序表中查某元素
void SeqListInsert(SL* ps, int pos, SLDataType x);  //在某个位置插入一个元素
void SeqListErase(SL* ps, int pos);	                //在个位置删除元素
void SeqListDlete(SL *ps, SLDataType x);	//删除元素为特定值的元素

源文件：SeqList.c

#include"SeqList.h"
void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}
void SeqListInit(SL *ps) {
	ps->a = NULL;
	ps->capacity = 0;
	ps->size = 0;
}
void SeqListPrint(SL *ps) {
	int i = 0;
	for (i = 0; i < ps->size; i++) {
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
void SeqListCheckCapacity(SL *ps) {
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}
void SeqListPushBack(SL *ps, SLDataType x) {
	SeqListCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}
void SeqListPushFront(SL *ps, SLDataType x) {
	SeqListCheckCapacity(ps);
	int i = 0;
	for (i = ps->size; i > 0; i--) {
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
	ps->size++;
}
void SeqListPopBack(SL *ps) {
	assert(ps->size > 0);
	ps->a[ps->size - 1] = 0;
	ps->size--;
}
void SeqListPopFront(SL *ps) {
	assert(ps->size > 0);
	int i = 0;
	for (i = 1; i < ps->size; i++) {
		ps->a[i - 1] = ps->a[i];
	}
	ps->a[ps->size - 1] = 0;
	ps->size--;
}
int SeqListFind(SL* ps, SLDataType x) {
	int i = 0;
	int flag = -1;
	for (i = 0; i < ps->size; i++) {
		if (ps->a[i] == x) {
			flag = i;
			break;
		}
	}
	return flag;
}
void SeqListInsert(SL* ps, int pos, SLDataType x) { //在一个具体的位置插入一个元素
	
	SeqListCheckCapacity(ps);
	if (pos > ps->size) { 
		pos %= ps->size;
	}
	int i = 0;
	for (i = ps->size; i >= pos; i--) {
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[pos - 1] = x;
	ps->size++;
}
void SeqListErase(SL* ps, int pos) {
	int i = 0;
	for (i = pos - 1; i < ps->size-1; i++) {
		ps->a[i] = ps->a[i + 1];
	}
	ps->a[ps->size - 1] = 0;
	ps->size--;
}
void SeqListDlete(SL *ps, SLDataType x) {  //删除一个特定值的元素
	int count = 0;
	int i = 0;
	for (i = 0; i < ps->size; i++) {
		if (ps->a[i] != x) {
			ps->a[count++] = ps->a[i];
		}
	}
	
	ps->size = count;
}

源文件：main.c

#include"SeqList.h"
int main() {
	SL sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushFront(&sl, 0);
	SeqListPushBack(&sl, 4);
	SeqListInsert(&sl, 2, 5);
	SeqListPushBack(&sl, 5);
	SeqListDlete(&sl, 5);
	//SeqListErase(&sl, 2);
	//SeqListPopBack(&sl);
	//SeqListPopBack(&sl);
	//SeqListPopFront(&sl);
	//SeqListDlete(&sl, 5);
	SeqListPrint(&sl);

	//int ret = SeqListFind(&sl, 2);
	//if (ret != -1) {
	//	printf("%d ", ret);
	//}
	//else {
    //  printf("找不到");

	//}


	return 0;
}