第五周day5

最新推荐文章于 2024-11-04 21:43:20 发布
最新推荐文章于 2024-11-04 21:43:20 发布
阅读量48 收藏
点赞数
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56569448/article/details/129883921
版权
本文介绍了数据结构中的基本概念，包括逻辑结构（集合、线性结构、树型结构、图型结构）和物理结构（顺序结构、链式结构）。特别讨论了线性表的两种实现——顺序表和链表，以及如何在C语言中封装单链表，提供了添加、删除、修改等操作。此外，还提到了静态链表和循环链表，以及双向循环链表的特点和操作方法。
摘要由CSDN通过智能技术生成

复习：

    《大话数据结构》

1、什么是数据结构

    专门研究数据之间关系和操作的学科，而非计算方法

    数据结构+算法=程序

2、逻辑结构和物理结构

    逻辑结构：

        集合：      除了同属一个集合之外，数据之间没有任何关系

        线性结构：  数据之间具有一对一的关系

        树型结构：  数据之间具有一对多的关系

        图型结构：  数据之间具有多对多的关系

    物理结构：

        顺序结构：数据存在连续的内存中，使用数据之间相对位置表示数据之间的关系

        链式结构：数据存储在不确定位置的内存中，数据项中有一块指针域，用来表示数据之间的关系

3、线性表结构：

    顺序表：数组

    链式表：链表

    常见的面试题：数组和链表的优缺点

4、功能受限的表结构

    栈：只有一个出入口、先进后出

        有四种顺序栈名称：

            空增栈：

                top初值：0 先入栈，再top++

            空减栈：

                top初值：cal-1 先入栈，再top--

            满增栈：

                top初值：-1 先top++，再入栈

            满减栈：

                top初值：cal 先top--，再入栈

    队列：有两个出入口，队尾进，对头出，先进先出


 

封装链表：

    1、单链表

        之前的没封装过的单链表，尾添加效率低、非法位置的判断效率低

        节点：

            数据域

            指针域

        单链表结构：

            头指针 (带头节点)

            尾指针

            节点数量

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define TYPE int

//封装带头节点的单链表
typedef struct  Node
{
	TYPE data;
	struct Node* next;
}Node;


Node* creat_node(TYPE data)
{
	Node* node= malloc(sizeof(Node));
	node->next=NULL;
	node->data=data;
	return node;
}

typedef struct List
{
	Node* head;		//头指针
	Node* tail;		//尾指针
	size_t size;	//数量
}List;

//创建链表
List* creat_list(void)
{
	List* list = malloc(sizeof(List));
	list->head = creat_node(0);		//带头节点
	list->tail = NULL;
	list->size = 0;
	return list;
}

//头添加
void add_head_list(List* list,TYPE data)
{
	Node*  node = creat_node(data);
	if(list->size == 0)
	{
		list->head->next= node;
		list->tail = node;
	}
	else
	{
		node->next = list->head->next;
		list->head->next = node;
	}
	list->size++;
}

//尾添加
void add_tail_list(List* list,TYPE data)
{
	Node* node = creat_node(data);
	if(0 == list->size)
	{
		list->head->next = node;
		list->tail = node;
	}
	else
	{
		list->tail->next = node;
		list->tail = node;
	}
	list->size++;
}
//头删除
bool del_head_list(List* list)
{
	if(0 == list->size) return false;
	Node* temp = list->head->next;
	list->head->next = temp->next;
	free(temp);
	if(0 == list->size) list->tail == NULL;
	return true;
}
//尾删除
bool del_tail_list(List* list)
{
	if(0 == list->size) return false;
	free(list->tail);
	if(1 == list->size)
	{
		list->head->next=NULL;
		list->tail = NULL;
	}
	else
	{
		Node* prev = list->head->next;
		while(prev->next != list->tail) prev=prev->next;
		prev->next = NULL;
		list->tail = prev;
	}
	list->size--;
	return true;

}
//插入
bool insert_list(List* list,size_t index,TYPE data)
{
	if(index >= list->size) return false;
	Node* node = creat_node(data);
	Node* prev = list->head;
	for(int i =0; i<index; i++)
	{
		prev = prev->next;
	}
	node->next = prev->next;
	prev->next = node;
	list->size++;
	return true;
}
//按值删除
bool del_val_list(List* list,TYPE data)
{
	if(0 == list->size) return false;
	if(data == list->head->next->data) return del_head_list(list);
	if(data == list->tail->data) return del_tail_list(list);
	for(Node* n = list->head->next; n->next; n=n->next)
	{
		if(n->next->data == data)
		{
			Node* temp = n->next;
			n->next = temp->next;
			free(temp);
			return true;
		}
	}
	return false;
}
//按位置删除
bool del_index_list(List* list,size_t index)
{
	if(index >= list->size) return false;
	if(0 == index) return del_head_list(list);
	if(list->size-1 == index) return del_tail_list(list);

	Node* prev = list->head->next;
	for(int i=1;i<index;i++)
	{
		prev=prev->next;
	}
	Node* node = prev->next;
	prev->next= node->next;
	free(node);
	list->size--;
	return true;
}
//按值修改
bool modify_val_list(List* list, TYPE old, TYPE val)
{
	bool flag=false;
	for(Node* n=list->head->next;n;n=n->next)
	{
		if(n->data==old)
		{
			n->data=val;
			flag=true;
		}
	}
	return flag;
}
//按位置修改
bool modify_index_list(List* list,int index,TYPE val)
{
	if(index>=list->size)	return false;
	Node* n=list->head->next;
	for(int i =0;i<index;i++)
	{
		n=n->next;
	}
	n->data = val;
	return true;
}
//查询
int query_list(List* list ,TYPE val)
{
	int i=0;
	for(Node* n=list->head->next;n;n=n->next)
	{
		if(n->data == val)
		{
			return i;
		}
		else
		{
			i++;
		}
	}
	return -1;
}
//访问
bool access_list(List* list,int index,TYPE* val)
{
	if(index>=list->size)	return false;
	Node* n=list->head->next;
	for(int i =0;i<index;i++)
	{
		n=n->next;
	}
	*val = n->data;
	return true;

}
//排序
void sort_list(List* list)
{
	for(Node* n1=list->head->next;n1->next!=NULL;n1=n1->next)
	{
		for(Node* n2=n1->next;n2!=NULL;n2=n2->next)
		{
			if(n1->data < n2->data)
			{
				TYPE temp=n1->data;
				n1->data=n2->data;
				n2->data=temp;
			}
		}
	}
}
//遍历
void show_list(List* list)
{
	for(Node* n=list->head->next; n; n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}
//清空
void clean_list(List* list)
{
	//while(list->size) del_tail_list(list);
	while(list->head->next)
	{
		Node* temp = list->head->next;
		list->head->next = temp->next;
		free(temp);
	}
	list->tail = NULL;
	list->size = 0;

}
//销毁
void destroy_list(List* list)
{
	clean_list(list);
	free(list->head);
	free(list);
}
int main(int argc,const char* argv[])
{
	List* list=creat_list();
	for(int i=0; i<10; i++)
	{
		add_tail_list(list,i+1);
	}
	show_list(list);
	int i=query_list(list,10);
	printf("%d\n",i);
	int num=-10;
	access_list(list,10,&num);
	printf("%d\n",num);
	show_list(list);
	sort_list(list);
	show_list(list);
}

    2、静态链表

        节点：

            数据域

            游标

        静态链表的节点存储在连续的内存中，通过游标来访问下一个节点

        这种链表没有指针域，需要在插入或删除时，通过修改游标的值完成，而不需要动态申请、释放内存，但是也可以实现链式的效果

        但是它牺牲了随机访问的功能，而且也缺少真正链式表的全部优点

    3、循环链表

        让链表的最后一个节点的next不再指向NULL，而是指向头节点，这种链表统称为单向循环链表，简称循环链表，它的优点是可以通过任意节点遍历整个链表

    4、双向循环链表

        节点：

            前驱指针

            数据

            后继指针

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

// 演示双向链表特点
typedef struct Node
{
	struct Node* prev;	//前驱
	TYPE data;
	struct Node* next;	//后继
}Node;

Node* creat_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->prev =node;
	node->next=node;
	return node;
}

void _add_list(Node* n1,Node*n2,TYPE data)
{
	Node* node = creat_node(data);
	node->prev = n1;
	node->next = n2;
	n1->next = node;
	n2->prev = node;
}

void _del_list(Node* node)
{
	node->prev->next=node->next;
	node->next->prev=node->prev;
	free(node);
}
//头添加
void add_head_list(Node* head,TYPE data)
{
	_add_list(head,head->next,data);
}
//尾添加
void add_tail_list(Node* head,TYPE data)
{
	_add_list(head->prev,head,data);
}

//按位置删除
bool del_index_list(Node* head,int index)
{
	Node* n=head->next;
	for(int i=0;i<index;i++)
	{
		n=n->next;
		if(n == head) return false;
	}
	_del_list(n);
	return true;
}

//按值删除
bool del_val_list(Node* head,TYPE val)
{
	for(Node* n=head->next;n!=head;n=n->next)
	{
		if(n->data==val)
		{
			_del_list(n);
			return true;
		}
	}
	return false;
}
//插入
bool insert_list(Node* head,size_t index,TYPE data)
{
	Node* n=head->next;
	for(int i=0;i<index;i++)
	{
		n=n->next;
		if(n==head) return false;
	}
	_add_list(n->prev,n,data);
	return true;
}

//遍历
void show_list(Node* head)
{
	for(Node* n=head->next;n!=head;n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}

int main(int argc,const char* argv[])
{
	Node* head=creat_node(0); //带头节点
	for(int i =0;i<10;i++)
	{
		add_head_list(head,i+1);
	}
	show_list(head);
//	insert_list(head,5,88);
//	del_index_list(head,9);
	del_val_list(head,5);
	show_list(head);
}

一根葱230
关注
一周掌握 FPGA VHDL Day 5
06-23 302
今天给大侠带来的是一周掌握 FPGA VHDL Day 5，今天开启第五天，带来常用电路的VHDL程序。下面咱们废话就不多说了，一起来看看吧。每日十分钟，坚持下去，量变成质变。 VHDL语言 五、常用电路的VHDL程序 计数器： 比较器： 奇数倍分频： 8位奇偶校验电路： LIBRARY IEEE;USE IEEE.STD_LOGIC_1164.ALL;ENTITY p_check IS PORT (a: ...
android 时间为第几周,计算当前天是第几周的算法以及小技巧
weixin_39797393的博客
05-30 1045
public static int getWeekOfYear(Stringdate){try{SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");Calendar cal = Calendar.getInstance();//这一句必须要设置，否则美国认为第一天是周日，而我国认为是周一，对计算当期日期是第几周会有错误cal.setFi...
第五周day03总结
hongqixiaozi的博客
08-22 148
第五周day01总结
hongqixiaozi的博客
08-19 132
第五周day06总结（lambda表达式）
hongqixiaozi的博客
08-24 100
第五周day04总结（JS，DOM）
hongqixiaozi的博客
08-23 390
JS计算今天在本月第几周
start_sea的博客
07-20 2471
计算某月某日是在某月的第几周； a = d = 当前日期 b = 6 - w = 当前周的还有几天过完(不算今天) a + b 的和在除以7 就是当天是当前月份的第几周*/ date是需要计算的日期。 通过new Date() 方法获取时间戳 var date = new Date(date), 通过getDay()方法获取到date是星期几 week = date.getDay(), 通过getDate()方法返回date是几日 day = date.getDate(); if( week == 0)
第十五周-day59-63@Zabbix监控day01-day05
linux丶晨星
07-15 230
day01PDF链接:：https://pan.baidu.com/s/18enCwGWZiw1iyJQc1uJO1Q 提取码: 6rvf day02PDF链接： https://pan.baidu.com/s/1WUXRMqCzQn18h219dF2pfQ 提取码: jf3r day03PDF链接：https://pan.baidu.com/s/1QFFb3rWOEnVcJ6qbFE...
sql server 取当天所在第几周
08-29 2596
declare @datetime datetime;; set @datetime=getdate(); select dateadd(day,1-(datepart(weekday,@datetime)),@datetime) as dStartDate, ----取本周开始日期 dateadd(day,1-(datepart(weekday,@datetime))+6,@datetime) as dEndDate,----取本周截至日期 datepart(year,dateadd(day,...
php计算第几周,PHP计算某时间段内有几个周及某时间为今年第几周 - end
weixin_39669701的博客
03-11 568
...6个月)时，必须满足以下业务要求： 如果end_at早于当前时间，则设置start_at为当前时间，end_at为当前时间加上续买的月数 如果end_at等于或晚于当前时间，则设置end_at=end_at+续买的月数 续买...PHP计算某时间段内有几个周及某时间为今年第几周函数date_default_timezone_set('PRC');function count_wee...
day-planner:GTBC第5周作业
03-16
标题 "day-planner:GTBC第5周作业" 暗示这是一项关于日程计划器的编程作业，可能是某个在线课程（如Google Tech Bootcamp Challenge，GTBC）的第五周任务。作业可能要求学生使用HTML来创建一个交互式或静态的日程...
05-day-planner:第5周的作业
03-26
第五周的作业。 该应用程序使用moment.js拉出一个日期，并将其显示在巨型样式标头中。 标头下方有一个标准工作日的小时段。 用户可以在文本输入中输入特定时间的项目。 如果用户随后单击右侧的“保存”图标，则该...
HTML5大前端学习过程第二周（Day10）
01-08
2020年2月21日 四级出成绩了，考了4次终于过了，哈哈。今天没学什么新知识，主要是练习昨天学习的定位。 一. 本节课学习目标。 掌握定位的应用。 重点 二. 定位练习1-小米官网1。 ... 家电 插线板 >
Python实现获取某天是某个月中的第几周
09-22
运行上述代码，我们可以得到2015年1月份的第4天、第5天、第15天和第18天分别是这个月的第几周。这样的计算方法可以广泛应用于需要根据日期计算周数的各种场景。 需要注意的是，这里我们实现的方法是基于通用的西方...
week3day5
03-13
"week3day5"这样的标记可能表示一个特定的学习计划或课程安排，其中"week3"代表学习的第三周，"day5"则指的是该周内的第五天。在这一天的学习中，可能会涵盖一个或多个关键的IT主题。尽管没有具体的标签来指示详细的...
数据结构之树
x6886_57的博客
11-03 606
树的定义，树的逻辑表示方法，树的基本术语，树的性质，树的存储结构
数据结构---链表实现栈
最新发布
Dragonlongbo的博客
11-04 253
/用链表作为底层数据结构实现-栈。
插入排序和希尔排序
b123321888的博客
11-04 545
定义：插入排序是一种简单且直观的排序算法，适用于小规模数据的排序。基本思想：通过构建有序序列，对于未排序的数据，在已排序序列中从后向前扫描，找到相应位置并插入。实现特点：使用双层循环，外层循环遍历每个元素，内层循环负责将当前元素插入到正确的位置。定义：希尔排序是一种基于插入排序的排序算法，但它通过将原始列表分割成多个子列表来改进性能，每个子列表使用插入排序进行排序。基本思想：通过比较相距一定间隔的元素来进行排序，逐步减少间隔，直到间隔为1，此时整个列表基本有序，最后进行一次插入排序。
数据结构---链表实现双端队列
Dragonlongbo的博客
11-04 273
/链表实现双端队列。
postgresql 判断日期是月份的第几周
05-26
可以使用 PostgreSQL 内置的 `date_trunc()` 和 `extract()` 函数来判断日期是月份的第几周。 具体步骤如下： 1. 使用 `date_trunc()` 函数将日期截断到月份的第一...因此，'2022-05-15' 是 2022 年 5 月的第 3 周。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值