手撕顺序表

已于 2024-08-25 23:38:55 修改
阅读量759 收藏 15
点赞数 7
分类专栏： 数据结构 文章标签： 数据结构 c++ c语言
于 2024-08-25 23:38:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_72224727/article/details/141505857
版权

顺序表

分类
顺序表
静态
数组
动态
结构体
STL
vector

概念

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。

接口声明
接口
结构体本身
初始化
销毁
打印
扩容
尾插
头插
尾删
头删
插入
查找
删除 
#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 SLInit(SL* psl);//初始化
void SLDestroy(SL* psl); //销毁

void SLPrint(SL* psl);//打印
void SLCheckCapacity(SL* psl);//扩容

void SLPushBack(SL* psl, SLDataType x);//尾插
void SLPushFront(SL* psl, SLDataType x);//头插

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

int SLFind(SL* psl, SLDataType x);//找到第一个和x相等的下标
void SLInsert(SL* psl, int pos, SLDataType x);//插入
void SLErase(SL* psl, int pos);//删除

接口实现

#include"SeqList.h"

void SLInit(SL* psl) {
	assert(psl);

	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}

void SLDestroy(SL* psl) {
	assert(psl);

	if (psl->a != NULL) {
		free(psl->a);
		psl->a = NULL;
		psl->size = 0;
		psl->capacity = 0;
	}
}

void SLPrint(SL* psl) {
	assert(psl);

	for (int i = 0; i < psl->size; i++) {
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

void SLCheckCapacity(SL* psl) {
	assert(psl);

	if (psl->size == psl->capacity) {//有效数据等于空间容量时需要扩容
		size_t NewCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;//二倍扩容

		SLDataType* tmp = (SLDataType*)realloc(psl->a, sizeof(SLDataType) * NewCapacity);
		if (tmp == NULL) {
			perror("realloc fail");
			return;
		}

		psl->a = tmp;
		psl->capacity = NewCapacity;
	}
}

void SLPushBack(SL* psl, SLDataType x) {
	assert(psl);

	SLCheckCapacity(psl);

	psl->a[psl->size ++] = x;
}

void SLPushFront(SL* psl, SLDataType x) {
	assert(psl);

	SLCheckCapacity(psl);

	 ++ psl->size;
	 for (size_t i = psl->size - 1; i > 0; i--) {
		 psl->a[i] = psl->a[i - 1];
	 }

	 psl->a[0] = x;
}

void SLPopBack(SL* psl) {
	assert(psl);
	assert(psl->size > 0);

	psl->size--;
}

void SLPopFront(SL* psl) {
	assert(psl);
	assert(psl->size > 0);

	for (int i = 0; i < psl->size - 1; i++) {
		psl->a[i] = psl->a[i + 1];
	}

	psl->size--;
}

int SLFind(SL* psl, SLDataType x) {
	assert(psl);

	for (int i = 0; i < psl->size; i++) {
		if (psl->a[i] == x) {
			return i;
		}
	}

	return -1;
}

void SLInsert(SL* psl, int pos, SLDataType x) {
	assert(psl);
	assert(pos >= 0&& pos < psl->size);

	SLCheckCapacity(psl);

	psl->size++;
	for (size_t i = psl->size - 1; i > pos;i --) {
		psl->a[i] = psl->a[i - 1];
	}

	psl->a[pos] = x;
}

void SLErase(SL* psl, int pos) {
	assert(psl);
	assert(pos >= 0 && pos < psl->size);

	for (int i = pos; i < psl->size - 1; i++) {
		psl->a[i] = psl->a[i + 1];
	}

	psl->size --;
}

接口测试

#include"SeqList.h"

void test1() {
	SL p;
	SLInit(&p);

	SLPushBack(&p, 1);
	SLPushBack(&p, 3);
	SLPushBack(&p, 1);
	SLPushBack(&p, 4);

	SLPushFront(&p, 0);
	SLPushFront(&p, 2);
	SLPushFront(&p, 5);

	SLPrint(&p);

	SLDestroy(&p);
}

void test2() {
	SL p;
	SLInit(&p);

	SLPushBack(&p, 1);
	SLPushBack(&p, 3);
	SLPushBack(&p, 1);
	SLPushBack(&p, 4);

	SLPushFront(&p, 0);
	SLPushFront(&p, 2);
	SLPushFront(&p, 5);

	SLPrint(&p);

	SLPopBack(&p);
	SLPopBack(&p);

	SLPrint(&p);

	SLPopFront(&p);
	SLPopFront(&p);

	SLPrint(&p);

	SLDestroy(&p);
}

void test3() {
	SL p;
	SLInit(&p);

	SLPushBack(&p, 1);
	SLPushBack(&p, 3);
	SLPushBack(&p, 1);
	SLPushBack(&p, 4);

	SLPushFront(&p, 0);
	SLPushFront(&p, 2);
	SLPushFront(&p, 5);

	SLPrint(&p);

	int pos = SLFind(&p, 2);
	if(pos >= 0) SLErase(&p, pos);
	pos = SLFind(&p, 8);
	if (pos >= 0) SLErase(&p, pos);
	SLPrint(&p);

	SLInsert(&p, 4, 10);
	SLPrint(&p);

	SLInsert(&p, 2, 16);
	SLPrint(&p);

	SLDestroy(&p);
}

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

vector

vector 为C++ STL中封装的一个类，它的功能类似于动态的顺序表，接下来我们进行实现一下。
在这里插入图片描述

封装实现

#pragma once
#include<assert.h>
#include<initializer_list>

namespace yxw {
	template<class T>
	class vector {
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		//迭代器
		iterator begin() {
			return start;
		}

		iterator end() {
			return finish;
		}

		const_iterator begin() const {
			return start;
		}

		const_iterator end() const {
			return finish;
		}

		//构造函数
		vector() : start(nullptr), finish(nullptr), end_of_storage(nullptr) {}

		vector(const vector<T>& v) {
			reverse(v.capacity());
			for (auto& e : v) {//加引用防止浅拷贝
				push_back(e);
			}
		}

		//应对 vector<int> a = { 0， 1， 2， 3， 4}
		vector(std::initializer_list<T> v) {
			reverse(v.size());
			for (auto& e : v) {
				push_back(e);
			}
		}

		template<class InputIterator>
		vector(InputIterator first, InputIterator last) {
			while (first != last) {
				push_back(*first);
				++first;
			}
		}

		vector(size_t n, const T& val = T()) {
			reverse(n);
			for (size_t i = 0; i < n;i ++) {
				push_back(val);
			}
		}

		vector(int n, const T& val = T()) {//防止与上面模板发生冲突
			reverse(n);
			for (size_t i = 0; i < n; i++) {
				push_back(val);
			}
		}

		//主函数
		size_t size() const{ //有效数据大小
			return finish - start;
		}

		size_t capacity() const { //空间容量
			return end_of_storage - start;
		}

		bool empty() {
			return start == finish;
		}

		T& operator[](size_t pos) {
			assert(pos < size());
			return start[pos];
		}

		const T& operator[](size_t pos) const{
			assert(pos < size());
			return start[pos];
		}

		void swap(vector<T>& v) {
			std::swap(start, v.start);
			std::swap(finish, v.finish);
			std::swap(end_of_storage, v.end_of_storage);
		}

		vector<T>& operator=(vector<T> v) {
			swap(v);
			return *this;
		}

		void reverse(size_t n) {
			if (n > capacity()) {
				T* tmp = new T[n];
				size_t old_size = size();
				for (size_t i = 0; i < size(); i++) {
					tmp[i] = start[i];
				}
				delete[]start;

				start = tmp;
				finish = tmp + old_size;
				end_of_storage = tmp + n;
			}
		}

		void resize(size_t n, const T& val = T()) {
			if (n > size()) {
				reverse(n);
				for (iterator it = finish; it != start + n; it++) {
					*it = val;
				}
				finish = start + n;
			}
			else {
				finish = start + n;
			}
		}

		//尾插
		void push_back(const T& val) {
			insert(end(), val);
		}

		//插入
		void insert(iterator pos, const T& val) {

			assert(pos >= start);
			assert(pos <= finish);

			if (finish == end_of_storage) {
				size_t len = pos - start;
				reverse(capacity() == 0 ? 4 : capacity() * 2);
				pos = start + len;//防止迭代器失效
			}

			++ finish;
			for (iterator it = finish - 1; it > pos; it --) {
				*it = *(it - 1);
			}

			*pos = val;
		}

		//尾删
		void pop_back() {
			erase(end() - 1);
		}

		//删除
		iterator erase(iterator pos) {
			
			assert(pos >= start);
			assert(pos < finish);

			--finish;
			for (iterator it = pos; it != finish; it++) {
				*it = *(it + 1);
			}

			return pos;
		}

		//析构函数
		~vector() {
			delete[] start;
			start = finish = end_of_storage = nullptr;
		}

	private:
		iterator start = nullptr;
		iterator finish = nullptr;
		iterator end_of_storage = nullptr;
	};
}

封装测试

#include<iostream>
#include<cstdio>
#include<vector>
#include"vector.h"

void test1() {
   yxw::vector<int> a;
   a.push_back(1);
   a.push_back(3);
   a.push_back(1);
   a.push_back(4);

   a.insert(a.begin(), 0);
   a.insert(a.begin(), 2);
   a.insert(a.begin(), 5);

   for (int i = 0; i < a.size(); i++) {
   	std::cout << a[i] << " ";
   }
   std::cout << "\n";

   for (yxw::vector<int>::iterator it = a.begin(); it != a.end(); it++) {
   	std::cout << *it << " ";
   }
   std::cout << "\n";

   for (auto e : a) {
   	std::cout << e << " ";
   }
   std::cout << "\n";
}

void test2() {
   yxw::vector<int> a;
   a.push_back(1);
   a.push_back(3);
   a.push_back(1);
   a.push_back(4);

   a.insert(a.begin(), 0);
   a.insert(a.begin(), 2);
   a.insert(a.begin(), 5);

   for (auto e : a) {
   	std::cout << e << " ";
   }
   std::cout << "\n";

   a.pop_back();
   a.pop_back();

   for (auto e : a) {
   	std::cout << e << " ";
   }
   std::cout << "\n";

   a.erase(a.begin());

   for (auto e : a) {
   	std::cout << e << " ";
   }
   std::cout << "\n";
}

void test3() {
   std::vector<int> a;
   a.push_back(2);
   a.push_back(3);
   a.push_back(4);
   a.push_back(5);

   for (auto e : a) {
   	std::cout << e << " ";
   }
   std::cout << "\n";

   a.resize(10, 1);


   for (auto e : a) {
   	std::cout << e << " ";
   }
   std::cout << "\n";

   yxw::vector<int> b;
   b.push_back(1);
   b.push_back(2);
   b.push_back(3);
   b.push_back(4);
   b.push_back(5);

   for (auto e : b) {
   	std::cout << e << " ";
   }
   std::cout << "\n";

   b.resize(10, 1);


   for (auto e : b) {
   	std::cout << e << " ";
   }
   std::cout << "\n";
}

void test4() {
   yxw::vector<int> a(10, 1);

   for (auto e : a) {
   	std::cout << e << " ";
   }
   std::cout << "\n";
}

void test5() {
   yxw::vector<std::string> a = { "yixuan", "shajdh", "jsdhkf", "kdshkf"};

   for (auto e : a) {
   	std::cout << e << " ";
   }
   std::cout << "\n";

}

void test6() {
   yxw::vector<int> a(10, 1);
   yxw::vector<int> b(a.begin(), a.end());

   for (auto e : b) {
   	std::cout << e << " ";
   }
   std::cout << "\n";
}

void test7() {
   yxw::vector<int> a;
   a.push_back(1);
   a.push_back(3);
   a.push_back(1);
   a.push_back(4);

   a.insert(a.begin(), 0);
   a.insert(a.begin(), 2);
   a.insert(a.begin(), 5);

   yxw::vector<int>::iterator it = a.begin();

   while (it != a.end()) {
   	if (*it % 2 == 0) {
   		it = a.erase(it);//用完erase或者insert原来的迭代器可能会失效记得更新
   	}
   	else {
   		++it;
   	}
   }

   for (auto e : a) {
   	std::cout << e << " ";
   }
   std::cout << "\n";
}

int main() {

   test7();

   return 0;
}
Ldawn_AI
关注
专栏目录
Python手撕算法Recursion
12-25
Python手撕算法Recursion
【数据结构】手撕顺序表
yangzaiiscute的博客
11-08 263
头插尾插头删尾删？头都大了！！！看我直接手撕它
Python手撕算法RadixSort
12-25
Python手撕算法RadixSort
Python手撕算法QuickSort
12-25
Python手撕算法QuickSort
Python手撕算法Queue
12-25
Python手撕算法Queue
Python手撕算法mysingleton
12-25
Python手撕算法mysingleton
【数据结构】双向链表（Doubly Linked List）
2301_77727857的博客
10-05 357
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
【笔记】数据结构12
m0_52024881的博客
09-29 517
看到的社区的一个知识总结，这里记录一下。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1112
本文介绍了数据结构中的AVL树，给出了C++的代码实现
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 371
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1233
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 1229
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
深入理解 C# 中的集合与数据结构
qq_45728381的博客
10-02 1270
在日常开发中，集合与数据结构是处理数据的基础工具。C# 提供了一系列强大而灵活的集合类型，帮助我们存储、访问和管理数据。这篇文章将带你了解 C# 中常用的数组、列表、字典、队列、栈、集合和链表的特性和用法。
数据结构之图（6）
2301_76246515的博客
10-05 550
图G有顶点集V和边集E组成，记为G=(V,E),其中V（G）表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系（边）集合。若V={v1,v2,…，vn}，则用|V|表示图G中顶点的个数。也称为图G的阶E={（u,v)|u ∈​​​V},用|E|表示图G中边的条数图不可以是空，V一定是非空集E是无向边（简称边）的有限集合E是有向边（弧）的有限集合弧是顶点的有序对，记为<v,w>,v为弧尾，w为弧头不存在重复边不存在顶点到自身的边。
数据结构篇（绪论）
最新发布
wlcass zhengge blog
10-05 423
字符类型：char布尔类型：boolean数值类型：byte、short、int、long、float、double。如果系统自定义的数据类型不够，可以自定义数据类型。例如：Person、Animal、. . .算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令。算法代表着用系统的方法描述解决问题的策略机制。
【数据结构】红黑树相关知识详细梳理
fulufulucode的博客
10-03 704
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或 Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路 径会比其他路径长出俩倍，因而是接近平衡的。 例如： 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个节点是红色的，则它的两个孩子结点是黑色的 4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点
18年408数据结构
weixin_62182040的博客
09-28 1014
如图所示：因为只存上三角部分的元素（包含对角线元素），经分析可知第一层存12个元素，第二层存11个元素，第三层存10个元素，第四层存9个元素，第五层存8个元素，接着第6层只存m6,6，一共是12+11+10+9+8+1=51.A.1出队并输出，2出队并输出，345存入栈中，5出栈并输出，6出队并输出，4出栈并输出，3出栈并输出，A正确。B.1出队入栈，2出队并输出，3出队并输出，4出队并输出，5出队并输出，6出队并输出,1出栈并输出。此时储存在数组中的序列是：6,9,7,1,8,4,5，排除D。
数据结构--绪论
2301_81591020的博客
09-30 855
程序=数据结构+算法（1）时间复杂度T(n)：运行完程序所需要的时间。（2）空间复杂度S(n):运行完一个程序所需要的临时内存的大小。
【初阶数据结构】排序——选择排序
2301_77112794的博客
09-28 436
本文主要讲了选择排序，分别是直接选择排序和堆排序
手撕list链表底层
11-16
手撕List链表底层涉及到一些计算机科学和数据结构的知识，包括链表、节点、内存管理等。下面是对手撕List链表底层的一些基本介绍： 1. 链表结构：链表是由一系列节点组成的数据结构，每个节点包含数据和指向下一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值