数据结构——顺序表总结

1. 顺序表的概念和结构

1.1 顺序表的概念

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

1.2 顺序表的结构

静态顺序表：使用定长数组存储数据。
动态顺序表：使用动态开辟数组存储数据。

2. 动态顺序表的实现

2.1 顺序表的的定义

typedef int SLDataType;
//顺序表定义
typedef struct SqList {
	SLDataType* _data;
	int _size;
	int _capacity;
}SqList;

2.2 顺序表的功能实现

2.2.1顺便表初始化

void SqListInit(SqList* ps) {
	assert(ps);
	ps->_capacity = 4;
	ps->_data = (SLDataType*)malloc(sizeof(SLDataType) * ps->_capacity);
	ps->_size = 0;
}

2.2.2增容

void CheckCapacity(SqList* ps) {
	assert(ps);
	if (ps->_capacity == ps->_size) {
		ps->_capacity *= 2;
		SLDataType* temp = (SLDataType*)realloc(ps->_data, sizeof(SLDataType) * ps->_capacity);
		if (temp == NULL) {
			perror("realloc\n");
			exit(-1);
		}
		ps->_data = temp;
	}
}

2.2.3尾插

void SqListPushBack(SqList* ps, SLDataType x) {
	assert(ps);
	CheckCapacity(ps);
	ps->_data[ps->_size] = x;
	ps->_size++;
	
}

2.2.4尾删

//尾删
void SqListPopBack(SqList* ps) {
	assert(ps && ps->_size > 0);
	ps->_size--;
}

2.2.5头插

先把元素往后挪：从后往前挪 ：防止元素覆盖

void SqListPushFront(SqList* ps, SLDataType x) {
	assert(ps);
	CheckCapacity(ps);
	for (int i = ps->_size; i >= 1; i--) {
		ps->_data[i] = ps->_data[i - 1];
	}
	ps->_data[0] = x;
	ps->_size++;
}

2.2.6头删

把元素往前挪，从前往后挪：防止元素覆盖

void SqListPopFront(SqList* ps) {
	assert(ps && ps->_size > 0);
	for (int i = 0; i < ps->_size - 1; i++) {
		ps->_data[i] = ps->_data[i + 1];
	}
	ps->_size--;
}

2.2.7顺序表查找(返回下标)

找不到返回-1

int SqListFind(SqList* ps, SLDataType x) {
	assert(ps);
	for (int i = 0; i < ps->_size; i++) {
		if (ps->_data[i] == x)
			return i;
	}
	return -1;

}

2.2.8顺序表在pos位置插入x

把pos位置和他之后的元素往后挪，从后往前挪：防止元素覆盖

void SqListInsert(SqList* ps, int pos, SLDataType x) {
	assert(ps);
	for (int i = ps->_size - 1; i > pos; i--) {
		ps->_data[i] = ps->_data[i];
	}
	ps->_data[pos] = x;
	ps->_size++;
}

2.2.9 顺序表删除pos位置的值

把元素往前挪，从前往后挪：防止元素覆盖

void SqListErase(SqList* ps, int pos) {
	assert(ps);
	for (int i = pos; i < ps->_size - 1; i++) {
		ps->_data[i] = ps->_data[i + 1];
	}
	ps->_size--;
}

2.2.9 顺序表销毁

void SqListDestory(SqList* ps) {
	assert(ps);
	free(ps->_data);
	ps->_data = NULL;
	ps->_capacity = ps->_size = 0;
}

2.2.9 顺序表打印

// 顺序表打印
void SqListPrint(SqList* ps) {
	assert(ps);
	for (int i = 0; i < ps->_size; i++) {
		printf("%d ", ps->_data[i]);
	}
	printf("\n");
}

2.3总代码

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <errno.h>
typedef int SLDataType;
//顺序表定义
typedef struct SqList {
	SLDataType* _data;
	int _size;
	int _capacity;
}SqList;
//顺序表初始化
void SqListInit(SqList* ps);
//
void CheckCapacity(SqList* ps);
//尾插
void SqListPushBack(SqList* ps, SLDataType x);
//尾删
void SqListPopBack(SqList* ps);
//头插
void SqListPushFront(SqList* ps, SLDataType x);
//头删
void SqListPopFront(SqList* ps);
// 顺序表查找(返回下标)
int SqListFind(SqList* ps, SLDataType x);
// 顺序表在pos位置插入x
void SqListInsert(SqList* ps, int pos, SLDataType x);
// 顺序表删除pos位置的值
void SqListErase(SqList* ps, int pos);
// 顺序表销毁
void SqListDestory(SqList* ps);
// 顺序表打印
void SqListPrint(SqList* ps);


#define _CRT_SECURE_NO_WARNINGS 1
#include "SqList.h"


//顺便表初始化
void SqListInit(SqList* ps) {
	assert(ps);
	ps->_capacity = 4;
	ps->_data = (SLDataType*)malloc(sizeof(SLDataType) * ps->_capacity);
	ps->_size = 0;
}

//增容
void CheckCapacity(SqList* ps) {
	assert(ps);
	if (ps->_capacity == ps->_size) {
		ps->_capacity *= 2;
		SLDataType* temp = (SLDataType*)realloc(ps->_data, sizeof(SLDataType) * ps->_capacity);
		if (temp == NULL) {
			perror("realloc\n");
			exit(-1);
		}
		ps->_data = temp;
	}
}

//尾插
void SqListPushBack(SqList* ps, SLDataType x) {
	assert(ps);
	CheckCapacity(ps);
	ps->_data[ps->_size] = x;
	ps->_size++;
	
}

//尾删
void SqListPopBack(SqList* ps) {
	assert(ps && ps->_size > 0);
	ps->_size--;
}

//头插
void SqListPushFront(SqList* ps, SLDataType x) {
	assert(ps);
	CheckCapacity(ps);
	for (int i = ps->_size; i >= 1; i--) {
		ps->_data[i] = ps->_data[i - 1];
	}
	ps->_data[0] = x;
	ps->_size++;
}
//头删
void SqListPopFront(SqList* ps) {
	assert(ps && ps->_size > 0);
	for (int i = 0; i < ps->_size - 1; i++) {
		ps->_data[i] = ps->_data[i + 1];
	}
	ps->_size--;
}

// 顺序表查找(返回下标)
int SqListFind(SqList* ps, SLDataType x) {
	assert(ps);
	for (int i = 0; i < ps->_size; i++) {
		if (ps->_data[i] == x)
			return i;
	}
	return -1;

}
// 顺序表在pos位置插入x
void SqListInsert(SqList* ps, int pos, SLDataType x) {
	assert(ps);
	for (int i = ps->_size - 1; i > pos; i--) {
		ps->_data[i] = ps->_data[i];
	}
	ps->_data[pos] = x;
	ps->_size++;
}
// 顺序表删除pos位置的值
void SqListErase(SqList* ps, int pos) {
	assert(ps);
	for (int i = pos; i < ps->_size - 1; i++) {
		ps->_data[i] = ps->_data[i + 1];
	}
	ps->_size--;
}
// 顺序表销毁
void SqListDestory(SqList* ps) {
	assert(ps);
	free(ps->_data);
	ps->_data = NULL;
	ps->_capacity = ps->_size = 0;
}
// 顺序表打印
void SqListPrint(SqList* ps) {
	assert(ps);
	for (int i = 0; i < ps->_size; i++) {
		printf("%d ", ps->_data[i]);
	}
	printf("\n");
}