初阶2 顺序表

本章重点

  1. 线性表
  2. 顺序表

1.线性表

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

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。

请添加图片描述

2.顺序表

2.1 顺序表的概念及结构

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

目标：在数组上完成数据的增删查改。

顺序表一般分为静态顺序表和动态顺序表

  1. 静态顺序表: 使用定长数组储存元素
//静态顺序表
#define MAX 10
typedef int SLDataType;
//给数据类型重命名，以后直接改这里就可以改变全部的数据类型
typedef struct Seqlist
{
	SLDataType arr[MAX];
	int size;//记录存储了多少个有效数据
}sl;//重命名
  1. 动态顺序表: 使用动态内存开辟的数组存储
//动态顺序表
typedef int SLDataType;
typedef struct Seqlist
{
	SLDataType *arr;
	int size;    //记录存储了多少个有效数据
	int capacity;//记录最大存储量
}sl;

2.2 接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。
静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。
所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，

这里重点实现动态的顺序表了：
（两者差别不大，需要静态实现的，可参考动态实现来完成）

#define _CRT_SECURE_NO_WARNINGS
 
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<Windows.h>
//定义/声明：
 
//动态顺序表
typedef int SLDataType;
typedef struct Seqlist
{
	SLDataType* arr;
	int size;//记录存储了多少个有效数据
	int capacity;//记录最大存储量
}SL;//重命名
 
 
void SLInit(SL* ps);//初始化 
void SLDestroy(SL* ps);//销毁
 
void SLprint(SL* ps);//打印
void SLCheckCapacity(SL* ps);//查看容量
 
void SLPushBack(SL* ps, int x);//尾插
//将x插入尾部
void SLPopBack(SL* ps);//尾删
 
void SLPushFront(SL* ps, int x);//头插
void SLPopFront(SL* ps);//头删
 
void SLInsert(SL* ps, int pos, SLDataType x);//中间插入
//在顺序表ps，下标为pos的位置，插入x
void SLEarse(SL* ps, int pos);//中间删除
//删除下表为pos的值
 
int SLFind(SL* ps, SLDataType x);//查找特定值
//返回顺序表ps中的值为x的下标
 
void SLDelete(SL* ps, SLDataType x);//删除特定值
 
 
//实现
//初始化
void SLInit(SL* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->size = 0;
	ps->capacity = 0;
}
//销毁
void SLDestroy(SL* ps)
{
	assert(ps);
 
	free(ps->arr);
	ps->size = 0;
	ps->capacity = 0;
}
//打印
void SLprint(SL* ps)
{
	assert(ps);
 
	for (int i = 0;i < ps->size;i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}
//检查容量
void SLCheckCapacity(SL* ps)
{
	assert(ps);
	//扩容
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
		//realloc在arr为空的时候，作用相当于malloc
		//realloc可能会扩容失败（失败是返回NULL），为了防止原数据丢失，
		//需要用一个临时变量来接收扩容后的地址
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);//0为正常终止，-1为异常终止
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}
//尾插，尾删
void SLPushBack(SL* ps, int x)
{
	/*assert(ps);
	SLCheckCapacity(ps);
	ps->arr[ps->size] = x;
	ps->size++;*/
	SLInsert(ps,ps->size,x);
}
void SLPopBack(SL* ps)
{
	//assert(ps->size);//断言，如果size<0,终止程序
	//ps->size--;
	SLEarse(ps, ps->size);
}
//头插，头删
void SLPushFront(SL* ps, int x)
{
	//assert(ps);
	//SLCheckCapacity(ps);
	挪动数据
	//int end = ps->size-1;
	//while (end >= 0)
	//{
	//	ps->arr[end + 1] = ps->arr[end];
	//	end--;
	//}
	//ps->arr[0] = x;
	//ps->size++;
	SLInsert(ps, 0, x);
}
void SLPopFront(SL* ps)
{
	//assert(ps);
	//assert(ps->size);
	挪动数据
	//int begin = 1;
	//while (begin < ps->size)
	//{
	//	ps->arr[begin-1] = ps->arr[begin];
	//	begin++;
	//}
	//ps->size--;
 
	SLEarse(ps, 0);
}
//中间插，中间删
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	//先要检查一下pos，防止pos选择越界
	// 
	//if (pos < 0 || pos > ps->size)
	//{
	//	printf（“输入的pos不对”）；
	//	exit(-1);
	//	//不想直接结束可以换return；
	//}
	//或者这样写：
	assert(pos >= 0);
	assert(pos <= ps->size);
	//先查看是否扩容
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->arr[end + 1] = ps->arr[end];
		end--;
	}
	ps->arr[pos] = x;
	ps->size++;
}
void SLEarse(SL* ps, int pos)
{
	assert(ps);
	//先要检查一下pos，防止pos选择越界。和中间插一样
	assert(pos >= 0);
	assert(pos <= ps->size );
	
	//挪动数据
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->arr[begin - 1] = ps->arr[begin];
		begin++;
	}
 
	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;
}
//删除特定值
void SLDelete(SL* ps, SLDataType x)
{
	assert(ps);
	if (SLFind(ps, x) == -1)
	{
		printf("%d在顺序表中不存在\n", x);
	}
	else
	{
		int pos = SLFind(ps, x);
		while (pos != -1)
		{
			SLEarse(ps, pos);
			pos = SLFind(ps, x);
		}
	}
 
}
 
//主函数
//测试函数
void text1()
{
	SL s1;
	SLInit(&s1);
	printf("尾插测试：\n");
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 5);
	SLPushBack(&s1, 1);
	SLprint(&s1);
 
	printf("尾删测试：\n");
	SLPopBack(&s1);
	SLprint(&s1);
 
	printf("头插测试：\n");
	SLPushFront(&s1, 4);
	SLPushFront(&s1, 5);
	SLPushFront(&s1, 1);
	SLprint(&s1);
 
	printf("头删测试：\n");
	SLPopFront(&s1);
	SLprint(&s1);
 
 
	printf("中间插入测试：\n");
	SLInsert(&s1, 2, 20);
	SLInsert(&s1, 4, 10);
	SLprint(&s1);
 
	printf("中间删除测试：\n");
	SLEarse(&s1, 3);
	SLprint(&s1);
 
	printf("查找测试：\n");
	printf("查找元素10并返回下标：%d\n", SLFind(&s1, 10));
 
	printf("删除元素为1的值，测试：\n");
	SLDelete(&s1, 1);
	SLprint(&s1);
 
	printf("删除元素为5的值，测试：\n");
	SLDelete(&s1, 5);
	SLprint(&s1);
 
	SLDestroy(&s1);
}
 
void mune()
{
	printf("1.尾插\n");
	printf("2.尾删\n");
	printf("3.头插\n");
	printf("4.头删\n");
	printf("5.中间插\n");
	printf("6.中间删\n");
	printf("7.查找特定值\n");
	printf("8.删除特定值\n");
	printf("9.打印数据\n");
	printf("0.退出\n");
}
void text2()
{
	int option = 1;
	SL s2;
	SLInit(&s2);
 
	SLPushBack(&s2, 1);
	SLPushBack(&s2, 5);
	SLPushBack(&s2, 1);
	SLPushBack(&s2, 2);
	SLPushFront(&s2, 4);
	SLPushFront(&s2, 5);
	SLPushFront(&s2, 1);
 
	while (option)
	{
		mune();
		printf("请输入：");
		scanf("%d", &option);
		SLDataType a = 0;
		SLDataType b = 0;
 
		switch(option)
		{
		case 1:
			printf("请依次输入你要尾插的数据，以-1结束：");
			scanf("%d", &a);
			while (a != -1)
			{
				SLPushBack(&s2, a);
				scanf("%d", &a);
			}
			system("cls");
 
			printf("插入成功！\n");
			break;
		case 2:
			SLPopBack(&s2);
			system("cls");
 
			printf("尾删成功！\n");
			break;
		case 3:
			printf("请输入你要头插的数据：");
			scanf("%d", &a);
			SLPushFront(&s2, a);
			system("cls");
 
			printf("头插成功！\n");
			break;
		case 4:
			SLPopFront(&s2);
 
			system("cls");
			printf("头删成功！\n");
			break;
		case 5:
			printf("请输入要插入的位置下标：");
			scanf("%d", &b);
			printf("请输入要插入的数：");
			scanf("%d", &a);
			SLInsert(&s2, b, a);
 
			system("cls");
			printf("中间插入成功！\n");
			break;
		case 6:
			printf("请输入要删除的位置下标：");
			scanf("%d", &b);
			SLEarse(&s2, b);
 
			system("cls");
			printf("中间删除成功！\n");
			break;
		case 7:
		{
			SL s;
			SLInit(&s);
			for (int i = 0;i < s2.size; i++)
			{
				SLCheckCapacity(&s);
				s.arr[i] = s2.arr[i];
				s.size++;
			}
			system("cls");
			printf("请输入要查找的数：");
			scanf("%d", &a);
			printf("查找元素：%d\n返回下标:", a);
			while (SLFind(&s, a) != -1)
			{
				printf("%d  ", SLFind(&s, a));
				SLEarse(&s, SLFind(&s, a));
				if (SLFind(&s, a) != -1)
				{
					SLInsert(&s, SLFind(&s, a), 0);
				}
			}
			printf("\n");
			SLDestroy(&s);
		}
			break;
		case 8:
			printf("请输入要删除的数：");
			scanf("%d", &a);
			SLDelete(&s2, a);
 
			system("cls");
			printf("删除成功！\n");
			break;
		case 9:
			system("cls");
 
			SLprint(&s2);
			printf("\n");
 
			break;
		case 0:
			SLDestroy(&s2);
			break;
		default:
			system("cls");
			printf("选择错误！请重选：\n");
			break;
		}
	}
}
int main()
{
	//text1();
	//菜单函数，建议先用text1调试成功后，再写菜单
	text2();
	return 0;
}

2.3 顺序表相关面试题

  1. 原地移除数组中所有的元素val，要求时间复杂度为O(N)，空间复杂度为O(1)。
    移除元素 - 力扣（LeetCode）

  2. 删除排序数组中的重复项。
    删除有序数组中的重复项 - 力扣（LeetCode）

  3. 合并两个有序数组。
    合并两个有序数组 - 力扣（LeetCode）

2.3.1 移除元素

思路一：查一次，删一次，
最容易想到的，时间复杂度为O(N^2)，空间复杂度：O(1)

int removeElement(int* nums, int numsSize, int val) 
{
	int n = 0;
	for (int i = 0;i < numsSize;i++)
	{
		if (nums[i] == val)
		{
			for (int j = i;j < numsSize - i+1;j++)
			{
				nums[j] = nums[j + 1];
			}
			numsSize--;
		}
	}
	return numsSize;
}
int main()
{
	int arr[] = { 1,4,1,2,1 };
	int v = 0;
	scanf("%d", &v);
	int sz = sizeof(arr) / sizeof(arr[0]);
	int len = removeElement(arr, sz, v);
	for (int i = 0;i < len;i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

思路二：建一个临时数组，利用双指针，以空间换时间
时间复杂度：O(N)，空间复杂度：O(N)

就不写了，可以直接看思路三的代码

思路三：双指针，直接在原数组中操作

时间复杂度：O(N)，空间复杂度：O(1)

int removeElement(int* nums, int numsSize, int val)
{
	int* b1 = nums;
	int* b2 = nums;
	int n = numsSize;
	for (int i = 0;i < numsSize;i++)
	{
		if (*b1 == val)
		{
			b1++;
			n--;
		}
		else
		{
			*b2++ = *b1++;
		}
	}
	return n;
}
int main()
{
	int arr[] = { 5,4,1,2,1 };
	int v = 0;
	scanf("%d", &v);
	int sz = sizeof(arr) / sizeof(arr[0]);
	int len = removeElement(arr, sz, v);
	for (int i = 0;i < len;i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

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

方法：双指针：和上一题类似

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

或

int removeDuplicates(int* nums, int numsSize) 
{
   int pos=0;
   for(int i=1;i<numsSize;i++)
   {
       if(nums[i]!=nums[pos])
       {
           nums[++pos]=nums[i];
       }
   }
   return pos+1;
}

2.3.3 合并两个有序数组

方法：双指针，一个指向nums1，一个指向nums2

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) 
{
	int i1 = m - 1, i2 = n - 1;
	int j = m + n - 1;
	while (i1 >= 0 && i2 >= 0)
	{
		if (nums1[i1] > nums2[i2])
		{
			nums1[j--] = nums1[i1--];
		}
		else
		{
			nums1[j--] = nums2[i2--];
		}
	}
	while (i2 >= 0)//如果nums1先结束的，那么还要把nums2里面的值赋给nums1
	{
		nums1[j--] = nums2[i2--];
	}
}

或

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) 
{
   int dst1=m,dst2=n,dst_new=nums1Size;
   while(dst1&&dst2)
   {
       if(nums1[dst1-1]>nums2[dst2-1])
       {
           nums1[--dst_new]=nums1[--dst1];
       }
       else
           nums1[--dst_new]=nums2[--dst2];
   }
   while(dst2)
       nums1[--dst_new]=nums2[--dst2];
}

2.4 顺序表自身性能的问题

问题：

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

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

破局沉寂的区块链市场：未来之路与战略思考

破局沉寂的区块链市场：未来之路与战略思考

近年来&#xff0c;区块链行业经历了高速增长、泡沫破裂和市场低谷。如今&#xff0c;尽管技术发展仍在持续&#xff0c;市场热度却明显降温。无论是公链项目、去中心化金融&#xff08;DeFi&#xff09;&#xff0c;还是NFT和GameFi&#xff0c;许多领域都陷入了创新瓶颈和用户…
阅读更多...
leetcode-289.生命游戏-day3

leetcode-289.生命游戏-day3

时间复杂度O(Mn) public void gameOfLife(int[][] board){if(board.length 0 || board[0].length0) return;int m board.length, n board[0].length;int[] neighbor {0, 1, -1};for(int i 0; i < m; i)for(int j 0; j < n; j)if(board[i][j] % 10 1)for(int k 0…
阅读更多...
SYN6288语音合成模块使用说明(MicroPython、STM32、Arduino)

SYN6288语音合成模块使用说明(MicroPython、STM32、Arduino)

模块介绍 SYN6288中文语音合成模块是北京宇音天下科技有限公司推出的语音合成模块。该模块通过串口接收主控传来的语音编码后&#xff0c;可自动进行自然流畅的中文语音播报。 注&#xff1a;SYN6288模块无法播报英文单词和句子&#xff0c;只能按字母播报英文 &#xff1b;而…
阅读更多...
JS API事件流

JS API事件流

事件流两个阶段说明 目标&#xff1a;能够说出事件流经过的2个阶段 事件流指的是事件完整执行过程的流动路径 说明&#xff1a;假设页面里有个div&#xff0c;当触发事件时&#xff0c;会经历两个阶段&#xff0c;分别是捕获阶段、冒泡阶段 简单来说&#xff1a;捕获阶段是 …
阅读更多...
15.Java 网络编程（网络相关概念、InetAddress、NetworkInterface、TCP 网络通信、UDP 网络通信、超时中断）

15.Java 网络编程（网络相关概念、InetAddress、NetworkInterface、TCP 网络通信、UDP 网络通信、超时中断）

一、网络相关概念 1、网络通信 网络通信指两台设备之间通过网络实现数据传输&#xff0c;将数据通过网络从一台设备传输到另一台设备 java.net 包下提供了一系列的类和接口用于完成网络通信 2、网络 两台以上设备通过一定物理设备连接构成网络&#xff0c;根据网络的覆盖范…
阅读更多...
Moretl轻量化日志采集工具

Moretl轻量化日志采集工具

永久免费: 至Gitee下载 使用教程: Moretl使用说明 用途 定时全量或增量采集工控机,电脑文件或日志. 优势 开箱即用: 解压直接运行.不需额外下载.管理设备: 后台统一管理客户端.无人值守: 客户端自启动,自更新.稳定安全: 架构简单,兼容性好,通过授权控制访问. 架构 技术架…
阅读更多...
Spring Security6.3 自定义AuthorizationManager问题

Spring Security6.3 自定义AuthorizationManager问题

项目环境&#xff1a; Springboot3.3.5, 对应的SpringFrameWork6.1&#xff0c;Security为6.3 问题&#xff1a;我想自定义AuthorizationManager接口实现类&#xff0c;在里面判断如果角色为amdin则放行请求&#xff1b; 在AdminAuthorizationManager类的check()方法中pass变量…
阅读更多...
【一本通】Beads

【一本通】Beads

【一本通】Beads &#x1f490;The Begin&#x1f490;点点关注&#xff0c;收藏不迷路&#x1f490; Zxl 有一次决定制造一条项链&#xff0c;她以非常便宜的价格买了一长条鲜艳的珊瑚珠子&#xff0c;她现在也有一个机器&#xff0c;能把这条珠子切成很多块&#xff08;子串&…
阅读更多...
开放词汇的航拍对象检测

开放词汇的航拍对象检测

&#x1f3e1;作者主页&#xff1a;点击&#xff01; &#x1f916;编程探索专栏&#xff1a;点击&#xff01; ⏰️创作时间&#xff1a;2024年12月11日18点20分 神秘男子影, 秘而不宣藏。 泣意深不见, 男子自持重, 子夜独自沉。 论文链接 点击开启你的论文编程之旅…
阅读更多...
【PyQt5教程 四】Qt Designer 样式表（styleSheet）实现基本小部件的自定义动态效果和资源浏览器背景添加方法

【PyQt5教程 四】Qt Designer 样式表（styleSheet）实现基本小部件的自定义动态效果和资源浏览器背景添加方法

目录 一、成果演示&#xff1a; 二、样式表的使用方法: &#xff08;1&#xff09;样式表语法和属性&#xff1a; &#xff08;2&#xff09;样式表代码示例&#xff1a; &#xff08;3&#xff09;伪类和状态&#xff1a; &#xff08;4&#xff09;复合选择器&#xff…
阅读更多...
2024小迪安全基础入门第十二课

2024小迪安全基础入门第十二课

目录 一、请求头&返回包-方法&头修改&状态码等 二、 数据包分析-红队攻击手法&蓝队流量研判 三、数据包构造-Reqable自定义添加修改请求 一、Reqable概述 二、数据包构造基本步骤 三、Reqable常见用法示例 四、使用 Reqable 进行安全测试 一、请求头&am…
阅读更多...
Springboot3 Mybatis-plus 3.5.9

Springboot3 Mybatis-plus 3.5.9

1. Mybatis-plus 官网&#xff1a;链接 1. 依赖 <dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-spring-boot3-starter</artifactId><version>3.5.9</version> </dependency>2. 注解配置表名、字段…
阅读更多...
android——录制屏幕

android——录制屏幕

录制屏幕 1、界面 2、核心代码 import android.app.NotificationChannel import android.app.NotificationManager import android.app.PendingIntent import android.app.Service import android.content.Context import android.content.Intent import android.graphics.Bi…
阅读更多...
js面试题|[2024-12-10]

js面试题|[2024-12-10]

1.延迟加载JS有哪些方式&#xff1f; 延迟加载&#xff1a;async、defer 例如&#xff1a;<script defer type"text/javascript" srcscript.js></script> defer&#xff1a;等html全部解析完毕&#xff0c;才会执行js代码&#xff0c;顺次执行js脚本 asy…
阅读更多...
【数据结构——查找】顺序查找（头歌实践教学平台习题）【合集】

【数据结构——查找】顺序查找（头歌实践教学平台习题）【合集】

目录&#x1f60b; 任务描述 相关知识 测试说明 我的通关代码: 测试结果&#xff1a; 任务描述 本关任务&#xff1a;实现顺序查找的算法。 相关知识 为了完成本关任务&#xff0c;你需要掌握&#xff1a;1.根据输入数据建立顺序表&#xff0c;2.顺序表的输出&#xff0c;…
阅读更多...
基于微信小程序+Springboot+Vue社区超市管理系统的分析与设计（源码+lw+讲解部署等）

基于微信小程序+Springboot+Vue社区超市管理系统的分析与设计（源码+lw+讲解部署等）

&#x1f497; 博主介绍✌ 3Dex&#xff08;全栈开发工程师&#xff09;&#xff0c;专注于4smile等项目的建设与优化&#xff0c;在软件开发与技术实现方面积累了丰富的经验。专注于Java、小程序、前端、Python等技术领域毕业项目实战&#xff0c;以及程序定制化开发。✌ 擅长…
阅读更多...
自然语言处理：从入门到精通全指引

自然语言处理：从入门到精通全指引

一、引言 自然语言处理&#xff08;NLP&#xff09;作为人工智能领域的关键分支&#xff0c;旨在让计算机理解、生成和处理人类语言&#xff0c;近年来取得了令人瞩目的成就&#xff0c;在智能客服、机器翻译、文本分析、语音助手等众多领域发挥着重要作用。从入门到精通自然语…
阅读更多...
[leetcode100] 101. 对称二叉树

[leetcode100] 101. 对称二叉树

https://leetcode.cn/problems/symmetric-tree/description/?envTypestudy-plan-v2&envIdtop-100-liked 心血来潮&#xff0c;突然感觉很久没做leetcode&#xff0c;刷一题。 看到“简单”&#xff0c;哦吼&#xff0c;应该很快吧。 结果真是《简单》 题目描述 给你一个…
阅读更多...
GPIO在ZYNQ7000中的结构和相关寄存器解析

GPIO在ZYNQ7000中的结构和相关寄存器解析

GPIO MASK DATA LSW和 MASK DATA MSW LSW和MSW分别是LSW (Least Significant Word)和MSW (Most Significant Word)。 因为DATA是u32,所以如果寄存器的基址是XGPIOPS_DATA_LSW_OFFSET&#xff0c;那么32位就能同时让高16位的MASK DATA MSW]31:16和 MASK DATA LSW的bit7同时为…
阅读更多...
设计模式-装饰器模式(结构型)与责任链模式(行为型)对比，以及链式设计

设计模式-装饰器模式(结构型)与责任链模式(行为型)对比，以及链式设计

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言1.装饰器模式1.1概念1.2作用1.3应用场景1.4特点1.5类与对象关系1.6实现 2责任链模式2.1概念2.2作用2.3应用场景2.4特点2.5类与对象关系2.6实现 3.对比总结 前言…
阅读更多...
最新文章

Copyright @ 2022~2023