初阶数据结构的实现1 顺序表和链表

news2024/11/15 17:33:30

顺序表和链表

  • 1.线性表
    • 1.1顺序表
      • 1.1.1静态顺序表（不去实现）
      • 1.1.2动态顺序表
        • 1.1.2.1 定义程序目标
        • 1.1.2.2 设计程序
        • 1.1.2.3编写代码
        • 1.1.2.3测试和调试代码
      • 1.1.2 顺序表的问题与思考
    • 1.2链表
      • 1.2.1链表的概念及结构
        • 1.2.1.1 定义程序目标
        • 1.2.1.2 设计程序
        • 1.2.1.3编写代码
        • 1.1.2.3测试和调试代码

1.线性表

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

相同特性
逻辑结构：人为想象出来的数据的组织形式
物理结构：数据在想象出来的数据的组织形式。

1.1顺序表

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

1.1.1静态顺序表（不去实现）

#define N 5
typedef int SLdatatype;
typedef struct SeqList {
	SLdatatype array [N];
	int size;
};

1.1.2动态顺序表

typedef int SLdatatype;
typedef struct SeqList {
	SLdatatype *arr;
	int capacity;//容量
	int size;//有效数据个数
}SL
1.1.2.1 定义程序目标
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef struct SeqList {
	SLDatatype *arr;
	int capacity;//容量
	int size;//有效数据个数
}SL;

//初始化
void SLInitialize(SL*s);

//销毁
void SLDestroy(SL*s );

//打印顺序表
void SLPrint(SL* ps);


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

//头插
void SLPushFront(SL*s, SLDatatype x);

//尾删
void SLPopBack(SL* s);

//头删
void SLPopFront(SL* s);

//在指定位置插入数据
void SLInsert(SL* s, SLDatatype x, int pos);

//在指定位置删除数据
void SLErase(SL* s,int pos);

//查找数据
int SLFind(SL* s, SLDatatype x);
1.1.2.2 设计程序

面向程序员自身的，能实现包括顺序表的结构定义、初始化、插入、删除、查找、遍历、排序等操作

1.1.2.3编写代码
void SLInitialize(SL* ps)
{
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

void SLDestroy(SL* ps)
{
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

void SLCheckCapacity(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;
	}
}

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

void SLPushBack(SL*ps, SLDatatype x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->arr[ps->size++] = x;
}

void SLPushFront(SL* ps, SLDatatype x)
{
	assert(ps);
	SLCheckCapacity(ps);
	//数据整体后移
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i-1];
	}
	ps->arr[0] = x;
	ps->size++;
}


void SLPopBack(SL* ps)
{
	assert(ps && ps->size);
	ps->size--;
}
void SLPopFront(SL* ps)
{
	assert(ps && ps->size);
	for (int i = 0; i < ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

void SLInsert(SL* ps, SLDatatype x, int pos)
{
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	for (int i = ps->size; i >pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[ps->size] = x;
	ps->size++;

}

void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size&& ps->size);
	for (int i=pos; i < ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i+1];
	}
	ps->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;
}
1.1.2.3测试和调试代码
#include"Seqlist.h"
void SLtest01()
{
	SL s;
	SLInitialize(&s);

	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 5);
	SLPushBack(&s, 6);
	/*SLPushBack(NULL , 6);*/

	SLPushFront(&s, 1);
	SLPushFront(&s, 2);
	SLPushFront(&s, 3);
	SLPushFront(&s, 4);
	SLPrint(&s); //4 3 2 1

	SLPopBack(&s);
	SLPrint(&s);
	SLPopBack(&s);
	SLPrint(&s);
	SLPopBack(&s);
	SLPrint(&s);
	SLPopBack(&s);
	SLPrint(&s);
	
	SLPopFront(&s);
	SLPrint(&s);
	SLPopFront(&s);
	SLPrint(&s);
	SLPopFront(&s);
	SLPrint(&s);
	SLPopFront(&s);
	SLPrint(&s);
	SLPopFront(&s);
	SLPrint(&s);

	SLInsert(&s, 11, 0);
	SLPrint(&s);
	SLInsert(&s, 22, s.size);
	SLPrint(&s);
	SLInsert(&s, 33, 1);
	SLPrint(&s);

	SLDestroy(&s);
}

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

在这里插入图片描述

1.1.2 顺序表的问题与思考

  1. 中间/头部的插入删除，时间复杂度为O(N)
  2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们
    再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
    思考：如何解决以上问题呢？下面给出了链表的结构来看看。

1.2链表

1.2.1链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链
接次序实现的 。

1.2.1.1 定义程序目标

实现

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

typedef int SLTDataType;

//定义结点结构;
typedef struct SListNode {
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

//链表的打印
void SLTPrint(SLTNode*);
//申请新结点
SLTNode* SLTBuyNode(SLTDataType);
//尾插
void SLTPushBack(SLTNode**, SLTDataType);
//头插
void SLTPushFront(SLTNode** , SLTDataType );

//删除

//尾删
void SLTPopBack(SLTNode**);
//头删
void SLTPopFront(SLTNode**);

//查找
SLTNode* SLTFind(SLTNode*, SLTDataType);

//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

//在指定位置之后插⼊数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos);

//删除pos之后的结点
void SLTEraseAfter(SLTNode* pos);

//销毁链表
void SListDestroy(SLTNode** pphead);
1.2.1.2 设计程序

面向程序员自身的，能实现包括链表的结构定义、初始化、插入、删除、查找、遍历、排序等操作

1.2.1.3编写代码
#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	node->data = x;
	node->next = NULL;

	return node;
}

void SLTPushBack(SLTNode**pphead, SLTDataType x)
{
	//申请新结点
	SLTNode*NewNode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = NewNode;
	}
	//尾结点->新结点
	//找尾结点
	else
	{
		SLTNode* pcur = *pphead;
		while (pcur->next)
		{
			pcur = pcur->next;
		}
		pcur->next = NewNode;
	}
}

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//申请新结点
	SLTNode* NewNode = SLTBuyNode(x);
	//进行头插
	NewNode->next = *pphead;
	*pphead = NewNode;
}

void SLTPopBack(SLTNode** pphead)
{
	//链表为空不可以删除
	assert(pphead && *pphead);
	//处理链表只有一个结点的情况
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//找prev和ptail
		SLTNode* ptail = *pphead;
		SLTNode* prev = NULL;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}

void SLTPopFront(SLTNode** pphead)
{
	//链表为空不可以删除
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = NULL;
	*pphead = next;
}

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		else
		{
			pcur = pcur->next;
		}
	}
	return NULL;
}

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
		SLTPushBack(pphead, x);
	else
	{
		SLTNode* prev = *pphead;
		SLTNode* NewNode = SLTBuyNode(x);
			while (prev->next != pos)
			{
				prev = prev->next;
			}
		prev->next = NewNode;
		NewNode->next = pos;
	}
}

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* NewNode = SLTBuyNode(x);
	NewNode->next = pos->next;
	pos->next = NewNode;
}

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead&&*pphead);
	assert(pos);
	if (*pphead = pos)
		SLTPopBack(pphead);
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

void SListDestroy(SLTNode** pphead)
{
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}
1.1.2.3测试和调试代码
#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

void SListTest01()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);//1->2->3->4->NULL

	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist); //4->3->2->1->NULL

	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);

	SLTNode* find = SLTFind(plist, 4);
	if (find == NULL)
	{
		printf("未找到！\n");
	}
	else
	{
		printf("找到了！\n");
	}
	SLTInsert(&plist, plist, 11);//4->3->2->11->1->NULL
	SLTInsertAfter(plist, 11);
	SLTPrint(plist);1->11->2->3->4->NULL

	SLTErase(&plist, plist);// 1->2->3->NULL
	SLTEraseAfter(plist);

	SLTPrint(plist);
	SListDestroy(&plist);
	SLTPrint(plist);
}
int main()
{
	SListTest01();
	return 0;
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1940033.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

51单片机嵌入式开发：15、STC89C52RC操作蜂鸣器实现一个music音乐播放器的音乐盒

51单片机嵌入式开发：15、STC89C52RC操作蜂鸣器实现一个music音乐播放器的音乐盒

STC89C52RC操作蜂鸣器实现一个music音乐播放器的音乐盒 1 概述2 蜂鸣器操作方法3 蜂鸣器发出音声4 硬件电路5 软件实现6 整体工程&#xff1a;7 总结 1 概述 要实现一个基于STC89C52RC单片机的音乐盒&#xff0c;可以按照以下步骤进行&#xff1a; &#xff08;1&#xff09;硬…
阅读更多...
Golang | Leetcode Golang题解之第274题H指数

Golang | Leetcode Golang题解之第274题H指数

题目&#xff1a; 题解&#xff1a; func hIndex(citations []int) int {// 答案最多只能到数组长度left,right:0,len(citations)var mid intfor left<right{// 1 防止死循环mid(leftright1)>>1cnt:0for _,v:range citations{if v>mid{cnt}}if cnt>mid{// 要找…
阅读更多...
ISO 14001：企业环境管理的黄金标准

ISO 14001：企业环境管理的黄金标准

在全球可持续发展潮流中&#xff0c;企业的环境责任愈发重要。ISO 14001环境管理体系&#xff0c;为各类企业提供了一条优化环境绩效的明路。无论企业规模大小&#xff0c;业务类型如何&#xff0c;ISO 14001都能帮助企业有效管理环境影响&#xff0c;实现绿色发展。 ISO 14001…
阅读更多...
QT样式美化 之 qss入门

QT样式美化 之 qss入门

样例一 *{font-size:13px;color:white;font-family:"宋体"; }CallWidget QLineEdit#telEdt {font-size:24px;}QMainWindow,QDialog{background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,stop: 0 #1B2534, stop: 0.4 #010101,stop: 0.5 #000101, stop: 1.0 #1F2B…
阅读更多...
【LeetCode】day17：654 - 最大二叉树, 617 - 合并二叉树, 700 - 二叉树搜索树中的搜索, 98 - 验证二叉搜索树

【LeetCode】day17：654 - 最大二叉树, 617 - 合并二叉树, 700 - 二叉树搜索树中的搜索, 98 - 验证二叉搜索树

LeetCode 代码随想录跟练 Day17 654.最大二叉树617.合并二叉树700.二叉搜索树中的搜索98.验证二叉搜索树 654.最大二叉树 题目描述&#xff1a; 给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建: 创建一个根节点&#xff0c;其值为 nums 中的…
阅读更多...
PyCharm创建一个空的python项目

PyCharm创建一个空的python项目

1.设置项目路径 2.配置python解释器 右下角可以选择always
阅读更多...
提交(git-add git-commit git-push)

提交(git-add git-commit git-push)

当修改好一个功能的时候&#xff0c;可以提交到远程仓库&#xff0c;这样就等于更新了一次版本&#xff0c;那么下次改修了文件的话&#xff0c;是跟这个版本做对比的 git status&#xff0c; 查看文件修改情况&#xff0c;git add 假如你只想提交1个文件&#xff0c;那么直接…
阅读更多...
Python入门基础教程（非常详细）

Python入门基础教程（非常详细）

现在找工作真的越来越难了&#xff01;今年更是难上加难 前几天在网上刷到这样一条热搜&#xff1a; #23岁找工作因年龄大被HR拒绝了# 是这个世界疯了还是我疯了&#xff1f; 合着只想要有20年以上工作经验的应届毕业生是吧 这好像就是现在的就业市场现状&#xff1a;“35岁…
阅读更多...
【leetcode】二分查找本质

【leetcode】二分查找本质

标题&#xff1a;【leetcode】二分查找本质 水墨不写bug 正文开始&#xff1a;&#xff08;点击题目标题转跳到OJ&#xff09; 目录 &#xff08;O&#xff09;前言* &#xff08;一&#xff09; 在排序数组中查找元素的第一个和最后一个位置 思路详解&#xff1a; 参考代…
阅读更多...
cocos2d-x安装和项目

cocos2d-x安装和项目

首先多方查找资料发现教程很简洁&#xff0c;发现对自己的操作方面没多大帮助&#xff0c;后来干脆去官网&#xff0c;好像也很简洁。基于这样一个原因&#xff0c;加上我首次碰cocos2d-x&#xff0c;决定记录一下整个流程&#xff0c;解决实际操作上的疑惑。 涉及的方面&…
阅读更多...
数模·时间序列

数模·时间序列

时间序列思维导图 时间序列分析的方法 聚焦于趋势和季节变化 时间序列预测模型 时间序列平稳性 时间序列的平稳性是时间序列分析中的一个重要概念。一个时间序列如果是平稳的&#xff0c;意味着其统计性质&#xff08;如均值、方差、自相关等&#xff09;不随时间变化。 平稳性…
阅读更多...
[计网04] 传输层和应用层 笔记 总结 万字详解

[计网04] 传输层和应用层 笔记 总结 万字详解

目录 传输层概述和功能 URL 和URI 端口号划分 套接字Socket UDP&#xff08;User Datagram Protocol&#xff09; UDP首部 UDP伪首部 TCP 三报文握手和四报文挥手 TCP&#xff08;Transmission Control Protocol&#xff09; TCP首部报文格式 TCP流量控制 cwnd&…
阅读更多...
如何在 C# ASP.NET MVC 项目中实现 Memcached？

如何在 C# ASP.NET MVC 项目中实现 Memcached？

一.介绍 在现代 Web 应用程序中&#xff0c;性能和可扩展性至关重要。提高性能的有效方法之一是使用缓存。Memcached 是一种开源、高性能、分布式内存缓存系统&#xff0c;被广泛使用。本文将引导您在 C# ASP.NET MVC 项目中实现 Memcached。 二.什么是 Memcached&#xff1f;…
阅读更多...
SpringBoot面试高频总结01

SpringBoot面试高频总结01

1. 什么是SpringBoot&#xff1f; SpringBoot是一个基于Spring框架的快速开发框架&#xff0c;它采用约定大于配置&#xff0c;自动装配的方式&#xff0c;可以快速地创建独立的&#xff0c;生产级别的&#xff0c;基于Spring的应用程序。 相比于传统的Spring框架&#xff0c;S…
阅读更多...
真实测评，霍尼韦尔、希喂、352宠物空气净化器性能对比

真实测评，霍尼韦尔、希喂、352宠物空气净化器性能对比

在快节奏的社会生活中&#xff0c;人们越来越注重精神需要&#xff0c;许多年轻人纷纷选择拥抱宠物&#xff0c;作为生活中的温馨伴侣。宠物们治愈心灵的同时也要付出一定“代价”&#xff0c;日常养护&#xff0c;如清理猫毛、管理气味以及保持宠物环境的清洁&#xff0c;都是…
阅读更多...
Agent类型解析：AIGC在不同领域的应用与影响

Agent类型解析：AIGC在不同领域的应用与影响

目录 引言 垂直智能体&#xff08;Vertical Agent&#xff09; 水平智能体&#xff08;Horizontal Agent&#xff09; 混合智能体&#xff08;Hybrid Agent&#xff09; 结论 引言 在人工智能&#xff08;AI&#xff09;领域&#xff0c;智能体&#xff08;Agent&#xf…
阅读更多...
更加深入Mysql-04-MySQL 多表查询与事务的操作

更加深入Mysql-04-MySQL 多表查询与事务的操作

文章目录 多表查询内连接隐式内连接显示内连接 外连接左外连接右外连接 子查询 事务事务隔离级别 多表查询 有时我们不仅需要一个表的数据&#xff0c;数据可能关联到俩个表或者三个表&#xff0c;这时我们就要进行夺标查询了。 数据准备&#xff1a; 创建一个部门表并且插入…
阅读更多...
JavaWeb day01-HTML入门

JavaWeb day01-HTML入门

Web前端 课程安排 HTML、CSS简介 HTML快速入门 实现标题排版 新闻标题样式
阅读更多...
Docker核心技术：Docker的基本使用

Docker核心技术：Docker的基本使用

云原生学习路线导航页&#xff08;持续更新中&#xff09; 本文是 Docker核心技术 系列文章&#xff1a;Docker的基本使用&#xff0c;其他文章快捷链接如下&#xff1a; 应用架构演进容器技术要解决哪些问题Docker的基本使用&#xff08;本文&#xff09;Docker是如何实现的 3…
阅读更多...
Spark调优特殊case- Task倾斜

Spark调优特殊case- Task倾斜

首先我们观察下上面的stage5, Task MaxTime2.4Min, 但是stage5的整体耗时竟然可以达到55Min, 其实分区1000&#xff0c; 300个executor&#xff0c; 按照最大的TaskTime2.4Min来估算所有Task运行完成时间, 那么时间应该是- 2.4Min * 3 2.4Min 9.6Min 也就是最慢也就跑10分钟就…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023