Bootstrap

【初阶数据结构】2.顺序表

文章目录

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。

逻辑上：线性

物理上：不一定线性

2.顺序表

逻辑上：线性

物理上：线性（因为底层是数组）

2.1 概念与结构

概念：顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。

在这里插入图片描述

顺序表和数组的区别？

顺序表的底层结构是数组，对数组的封装，实现了常用的增删改查等接口

在这里插入图片描述

2.2 分类

2.2.1 静态顺序表

概念：使用定长数组存储元素

//定义前知道数组的大小
int arr[3] = { 1,2,3 };

struct SeqList {
	int arr[1000];//定长数组
	int size;//记录当前顺序表中有效数据的个数

};

2.2.2 动态顺序表

//定义前不知道数组的大小------动态内存管理
int* arr1;

struct SeqList {
	int* arr;
	int capacity;//顺序表空间大小
	int size;//记录当前顺序表中有效数据的个数
};

2.3 动态顺序表的实现

尾插：

  1. 空间充足：将数据插入到size指向的位置，size++

    在这里插入图片描述

  2. 空间不足：先增容，再插入在这里插入图片描述

头插：

原数据依次往后移动一位，然后把数据插到第一位

增容：

  1. 连续空间足够，直接增容

  2. 连续空间不够：

    1）：重新找一块地址，分配足够的内存

    2）：拷贝数据到新的地址

    3）：销毁旧地址

增容一般是成倍数的增加，比如2->4->8->16

为什么不一个一个增加呢?

因为增容的操作本身就有一定的程序性能的消耗，若频繁的增容会导致程序效率低下。

SeqList.h

#pragma once
#include <stdio.h>
//定义顺序表结构，声明要提供的操作

//定义动态顺序表结构
typedef int SLDatatype;

typedef struct SeqList {
	SLDatatype* arr;
	int capacity;//空间大小
	int size;//有效数据大小
}SL;

//typedef struct SeqList SL;//两种方式都可以


//顺序表的初始化
void SLInit(SL* ps);

//顺序表的销毁操作
void SLDestory(SL* ps);

//插入数据
//尾插
void SLPushBack(SL* ps, SLDatatype x);
//头插
void SLPushFront(SL* ps, SLDatatype x);

//删除
//尾删
void SLPopBack(SL* ps);
//头删
void SLPopFront(SL* ps);

//指定位置之前插入数据
void SLInsert(SL* ps, SLDatatype x, int pos);
//删除指定位置的数据
void SLErase(SL* ps, int pos);

//顺序表的查找
int SLFind(SL* ps, SLDatatype x);

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "SeqList.h"

//具体实现各种操作

//初始化
void SLInit(SL* ps) {
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

//销毁
void SLDestory(SL* ps) {
	if (ps->arr)//相当于ps->arr!=NULL
	{
		free(ps->arr);
	}
	ps->arr == NULL;
	ps->size = ps->capacity = 0;
}

void SLCheckCapcity(SL* ps) {
	//判断空间是否充足
	if (ps->size == ps->capacity) {
		//增容
		//若capacity为0，给个默认值，否则乘2倍
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;//乘号
		SLDatatype* tmp = (SLDatatype*)realloc(ps->arr, newCapacity * sizeof(SLDatatype));
		if (tmp == NULL) {
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}

//插入数据
//尾插
//时间复杂度O(1)
void SLPushBack(SL* ps, SLDatatype x) {
	温柔的解决方式
	//if (ps == NULL) {
	//	return;
	//}

	//粗暴的解决方式
	assert(ps);//等价于assert(ps!=NULL)
	//判断空间是否充足
	SLCheckCapcity(ps);
	ps->arr[ps->size++] = x;//x插到最后
}
//头插
//时间复杂度O(n)
//原数据依次往后移动一位，然后把数据插到第一位
void SLPushFront(SL* ps, SLDatatype x) {
	assert(ps);
	//判断空间是否足够
	SLCheckCapcity(ps);

	//数据整体后移一位
	for (int i = ps->size; i > 0; i--) {
		ps->arr[i] = ps->arr[i - 1];
	}
	//下标为0的位置空出来了
	ps->arr[0] = x;//x插到最前面

	ps->size++;//增加了一个数据，size要加1个空间
	//之所以不在之前++,是因为size指的是有效数据大小，例如size=3，那么就有3个元素arr[0]~arr[size-1]，假设arr里面放了1 2 3，要插入4
	// 后来我们使用arr[0]~arr[size]，一共4个元素，刚好四个元素，四个位置。4 1 2 3
	//那为什么要++呢？如果按照上面的例子，size一开始是指向第3个元素末尾的位置，也就是说原来没有arr[size]，只有arr[size-1]里面存的是3
	// 因为挪动元素，原来的第3个元素到了后面一个位置。arr[size]里面存的就是3了
	// size指向的位置不变，我们通过size++来使得size重新指向第4个元素末尾的位置，防止后续调用元素产生误判，误以为还是只有arr[0]~arr[size-1]个元素
}

//打印
void SLPrint(SL* ps) {
	for (int i = 0; i < ps->size; i++) {
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

//删除
//尾删
//时间复杂度O(1)
void SLPopBack(SL* ps) {
	assert(ps);
	assert(ps->size);//顺序表为空不可以删
	
	//ps->arr[ps->size - 1] = -1;//多余了
	ps->size--;//少了一个元素自然size--

}

//头删
//时间复杂度O(n)
//将第一个数据往后的数据整体往前挪一位
void SLPopFront(SL* ps){
	assert(ps);
	assert(ps->size);//顺序表为空不可以删

	for (int i = 0; i < ps->size-1; i++) {
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;//少了一个元素自然size--
}

//指定位置之前插入数据(空间足够才能直接插入数据）
void SLInsert(SL* ps, SLDatatype x, int pos) {//x是插入的数据，pos是插入的位置
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);//前半部分头插，后半部分尾插
	//首先pos肯定是在0~size之间的，pos=0的时候，就相当于头插，pos=size的时候，就相当于尾插

	//检查空间够不够
	SLCheckCapcity(ps);

	//pos及之后的数据整体向后移动一位
	for (int i = ps->size; i > pos; i--) {
		ps->arr[i] = ps->arr[i - 1];

	}
	ps->arr[pos] = x;//插入x
	ps->size++;//多了一个元素自然size++
}

//删除指定位置的数据
void SLErase(SL* ps, int pos) {
	assert(ps);
	assert(pos >= 0 && pos < ps->size);//前半部分头删，后半部分尾删
	//首先pos肯定是在0~size之间的，pos=0的时候，就相当于头删，pos=size的时候，就相当于尾删

	for (int i = pos; i < ps->size - 1; i++) {
		ps->arr[i] = ps->arr[i + 1];

	}
	ps->size--;//少了一个元素自然size--
}

//顺序表的查找
int SLFind(SL* ps, SLDatatype x) {
	assert(ps);
	for (int i = 0; i < ps->size; i++) {
		if (ps->arr[i] == x) {
			return i;
		}
	}
	//没有找到返回一个无效的下标
	return -1;
}

test.c

//测试程序
#include "SeqList.h"

void SLtest01() {
	SL s;
	SLInit(&s);

	//尾插
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 5);
	
	//SLPushBack(NULL, 1);//不行，会报错

	//头插
	/*SLPushFront(&s, 1);
	SLPushFront(&s, 2);
	SLPushFront(&s, 3);
	SLPushFront(&s, 4);

	SLPrint(&s);*/

	//SLPopBack(&s);//尾删
	//SLPopFront(&s);//头删

	//SLInsert(&s, 11, 0);//指定位置插入
	//SLPrint(&s);
	//SLInsert(&s, 22, s.size);//指定位置插入
	/*SLPrint(&s);*/

	/*SLPrint(&s);*/

	//SLErase(&s, 0);//指定位置删除
	//SLPrint(&s);
	//SLErase(&s, s.size-1);//指定位置删除
	//SLPrint(&s);

	SLPrint(&s);
	int find = SLFind(&s, 222);
	if (find < 0) {
		printf("没有找到！\n");
	}
	else {
		printf("找到了！\n");
	}
	
	SLDestory(&s);
}

int main() {
	SLtest01();
	return 0;
}

编写代码过程中要勤测试，避免写出大量代码后再测试而导致出现问题，问题定位无从下手。

2.4 顺序表算法题

2.4.1 移除元素

在这里插入图片描述

思路：定义两个变量指向数组第一个位置，判断nums[src]是否等于val

  1. 相等，src++
  2. 不相等，nums[dst] = nums[src],src++,dst++

在这里插入图片描述

int removeElement(int* nums, int numsSize, int val) {
    int src = 0,dst = 0;
    while(src < numsSize){
        if(nums[src] == val){
            src++;
        }
        else{
            nums[dst] = nums[src];
            dst++;
            src++;
        }
    }
    //此时dst指向的位置就是要返回的有效个数
    return dst;
}

2.4.2 删除有序数组中的重复项

在这里插入图片描述

思路：定义两个指针变量。dst指向数组第一个位置，src指向数组第二个位置。判断nums[dst]是否等于nums[src]

  1. 相等，src++
  2. 不相等，dst++,nums[dst] = nums[src],src++

在这里插入图片描述

int removeDuplicates(int* nums, int numsSize) {
    int dst = 0,src = dst + 1;
    while(src < numsSize){
        if(nums[dst] != nums[src] && ++dst != src){
            nums[dst] = nums[src];
        }
        src++;
    }
    return dst+1;
}

2.4.3 合并两个有序数组

在这里插入图片描述

思路：定义三个指针变量。L1指向nums1数组第一个位置，L2指向nums2数组第一个位置,L3指向nums1数组最后一个位置。

比较L1和L2位置的数据，谁大，谁就往L3位置放数据。

结束条件：要么L1<0，要么L2<0

  1. L1<0：要处理nums2中的数据，循环放到nums1中
  2. L2<0：不需要处理，因为nums2中的数据已经有序的放到nums1中了。

在这里插入图片描述

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
	int L1 = m - 1;
	int L2 = n - 1;
	int L3 = m + n - 1;

	//L1>=0 L2>=0
	while (L1 >= 0 && L2 >= 0) {
		if (nums1[L1] > nums2[L2]) {
			nums1[L3--] = nums1[L1--];
		}
		else {
			//L2> = L1
			nums1[L3--] = nums2[L2--];
		}
	}
	//跳出while循环有两种情况：要么L1<0（需要处理），要么L2<0（不需要处理）
	while (L2 >= 0) {
		nums1[L3--] = nums2[L2--];
	}
}

2.5 顺序表问题与思考

  • 中间/头部的插入删除，时间复杂度为O(N)

  • 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

  • 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们 再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
Spring Boot洗衣店订单系统：简化工作流程
迅为RK3568开发板Buildroot 系统设置屏幕旋转
《白话机器学习的数学》第4章——评估
掌握Go语言中的异常控制：panic、recover和defer的深度解析
网络安全（补充）
js的定时器
系统架构师软考案例分析总结
exo项目目录架构
Win7升级Win10出现0x80072f8f-0x20000错误解决办法
seattle language school & on-line degree
;