数据结构-＞链表分类与oj（题），带你提升代码好感

news2024/10/7 20:36:17

✅作者简介：大家好，我是橘橙黄又青，一个想要与大家共同进步的男人😉😉

🍎个人主页：橘橙黄又青-CSDN博客

1.🍎链表的分类

前面我们学过顺序表，顺序表问题：

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

这些问题，链表给出了相应的答案。

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

 比如说我们前面学习的单链表就是如此。

单链表是单向不循环不带头链表

 

实际中要实现的链表的结构非常多样，以下情况组合起来就有8种链表结构：

  • 1. 单向、双向
  • 2. 带头、不带头
  • 3. 循环、非循环

又称2x2x2 

图解：

 

  • 1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结 构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
  • 2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都 是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带 来很多优势，实现反而简单了，后面我们代码实现了就知道了。 

2.🍎链表相关基础oj

题目链接
设计链表. - 力扣（LeetCode）
两数相加. - 力扣（LeetCode）
合并两个有序链表. - 力扣（LeetCode）
两两交换链表中的节点. - 力扣（LeetCode）
删除排序链表中的重复元素. - 力扣（LeetCode）
删除排序链表中的重复元素II. - 力扣（LeetCode）
相交链表. - 力扣（LeetCode）
移除链表元素. - 力扣（LeetCode）
回文链表. - 力扣（LeetCode）
奇偶链表. - 力扣（LeetCode）
链表的中间结点. - 力扣（LeetCode）
链表最大孪生和. - 力扣（LeetCode）
两两交换链表中的节点404: This page could not be found

合并两个链表中，可以安排一个哨兵（头）可以减少判断空的代码。

哨兵位的申请：

这些都是比较好的题目，

接下来我们分析几道题目

题目链接
反转链表. - 力扣（LeetCode）
反转链表II. - 力扣（LeetCode）
链表中间节点问题. - 力扣（LeetCode）
环形链表的约瑟夫问题环形链表的约瑟夫问题_牛客题霸_牛客网

2.1🍎第一个反转链表

第一种：头插法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 //头插术
typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {
    ListNode* returnHead = NULL;
    ListNode* ListLt = head;
    while(ListLt != NULL){
        //保存下一个节点
        ListNode* temp = ListLt -> next;
        //换头手术
        ListLt -> next = returnHead;
        returnHead = ListLt;
        //迭代
        ListLt = temp;

    }
    return returnHead;
}

这里说一个错误代码：

输出结果为1，为什么来：

 

所以temp要保存下一个节点。 

第二种解法：

三指针法：

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {
    if(head == NULL){
        return head;
    }
    ListNode* n1 = NULL;
    ListNode* n2 = head;
    ListNode* n3 = head -> next;
    ListNode* pcur = head;
    while(n2){
        n2-> next = n1;
        n1 = n2;
        n2 = n3;
        if(n3){//这里防止n3为空，如果为空就无next
            n3 = n3 -> next; 
        }
    }
    return n1;
}

图解：

链表II与这个差不多，思路更为复杂。 

2.2🍎链表中间节点问题

可以遍历链表计数除2，也可以使用双指针法

双指针法：

思路：

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head) {
    ListNode* slow,*fast;
    slow = fast = head;
    while(fast && fast -> next){
        slow = slow -> next;
        fast = fast -> next -> next;
    }
    return slow;
}

值得注意的是循环条件不能写成 fast -> next &&fast ，原因是计算机编译器是从左往右编译的，如果fast为空，就没有fast -> next。

快慢指针法以后会经常使用务必理解.

2.3.环形链表的约瑟夫问题 

题目:

这里我们输入Li 它就有暗示，说明已经有结构体结构了

解题代码：

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param n int整型 
 * @param m int整型 
 * @return int整型
 */
 typedef struct ListNode ListNode;
//申请一个节点
 ListNode* BuyNode(int x){
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode -> val = x;
    newNode -> next = NULL;
    return newNode;

 }
 ListNode* creteList(int n){
    ListNode* phead = BuyNode(1);
    ListNode* ptail = phead;
    //创建链表和标号
    for (int i = 2; i <= n; i++) {
        ptail -> next = BuyNode(i);
        ptail = ptail -> next;
    }
    //链表首尾链接
    ptail -> next = phead;
    return phead;
 }
#include <stdio.h>
int ysf(int n, int m ) {
    //逢m删除节点
    ListNode* head = creteList(n);
    ListNode* pcur = head;
    //前驱节点
    ListNode* prev = NULL;
    
    int conut = 1;
    while (pcur ->next != pcur) {
        if(conut == m){
            //删除当前节点
            prev -> next = pcur ->next;
            free(pcur);
            //删除节点后往后走，让pcur走到新的位置，conut为初始值
            pcur = prev -> next;
            conut = 1;
        }
        else{
            //pcur往后走
            prev = pcur;
            pcur =  pcur -> next;
            conut++;
        }
    }
    //此时pcur节点就是活下来的节点
    return pcur -> val;
}

3.🍎上节链表代码建议重复观看

SList.c文件：

 SList.h文件

 test.c文件测试代码： 

 test.c文件代码

#include"SList.h"

//void SlistTest01() {
// 
//	链表的打印
//	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
//	node1->data = 1;
//	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
//	node2->data = 2;
//	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
//	node3->data = 3;
//	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
//	node4->data = 4;
//
//	node1->next = node2;
//	node2->next = node3;
//	node3->next = node4;
//	node4->next = NULL;
//
//	SLTNode* plist = node1;
//	SLTPrint(plist);
//}
void SlistTest02() {
	//尾插测试
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist); //1->2->3->4->NULL
	//头插测试
	//SLTPushFront(&plist, 5);
	//SLTPrint(plist);          //5->1->2->3->4->NULL
	//SLTPushFront(&plist, 6);
	//SLTPrint(plist);         //6->5->1->2->3->4->NULL
	//SLTPushFront(&plist, 7);
	//SLTPrint(plist);         //7-6->5->1->2->3->4->NULL

	SLTPopBack(&plist);
	SLTPrint(plist);//1->2->3->NULL
	SLTPopBack(&plist);
	SLTPrint(plist);//1->2->3->NULL
	SLTPopBack(&plist);
	SLTPrint(plist);//1->2->3->NULL
	SLTPopBack(&plist);
	SLTPrint(plist);//1->2->3->NULL
	SLTPopBack(&plist);
	SLTPrint(plist);//1->2->3->NULL
}

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

	SListDesTroy(&plist);


	头删
	//SLTPopFront(&plist);
	//SLTPrint(plist);    //2->3->4->NULL
	//SLTPopFront(&plist);
	//SLTPrint(plist);    //3->4->NULL
	//SLTPopFront(&plist);
	//SLTPrint(plist);    //4->NULL
	//SLTPopFront(&plist);
	//SLTPrint(plist);    //NULL
	//SLTPopFront(&plist);
	//SLTPrint(plist);    //assert
	
	//查找测试
	//SLTNode* FindRet = SLTFind(&plist, 3);
	//if (FindRet) {
	//	printf("找到了！\n");
	//}
	//else {
	//	printf("未找到！\n");
	//}
	//SLTInsert(&plist, FindRet, 100);
	//SLTInsertAfter(FindRet, 100);
	
	//删除指定位置的节点测试
	//SLTErase(&plist, FindRet);
	//SLTPrint(plist); //1->2->3->NULL
}
int main() {
	//SlistTest01();
	//SlistTest02();
	SlistTest03();
	return 0;
}

SList.c文件代码：

#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* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL) {
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}
//
void SLTPushBack(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	//开辟空间
	SLTNode* newnode = SLTBuyNode(x);

	//链表为空，新节点作为phead
	if (*pphead == NULL) {
		*pphead = newnode;
		return;
	}
	//链表不为空，找尾节点
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//ptail就是尾节点
	ptail->next = newnode;
}
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);

	//newnode *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}
//尾删
void SLTPopBack(SLTNode** pphead) {
	assert(pphead);
	//链表不能为空
	assert(*pphead);

	//链表不为空
	//链表只有一个节点，有多个节点
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	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);
	//链表不能为空
	assert(*pphead);

	//让第二个节点成为新的头
	//把旧的头结点释放掉
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}
//查找
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x) {
	assert(pphead);

	//遍历链表
	SLTNode* pcur = *pphead;
	while (pcur) //等价于pcur != NULL
	{
		if (pcur->data == x) {
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}
//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) {
	assert(pphead);
	assert(pos);
	//要加上链表不能为空
	assert(*pphead);

	SLTNode* newnode = SLTBuyNode(x);
	//pos刚好是头结点
	if (pos == *pphead) {
		//头插
		SLTPushFront(pphead, x);
		return;
	}

	//pos不是头结点的情况
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//prev -> newnode -> pos
	prev->next = newnode;
	newnode->next = pos;
}
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x) {
	assert(pos);

	SLTNode* newnode = SLTBuyNode(x);

	//pos newnode pos->next
	newnode->next = pos->next;
	pos->next = newnode;
}
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos) {
	assert(pphead);
	assert(*pphead);
	assert(pos);

	//pos刚好是头结点，没有前驱节点，执行头删
	if (*pphead == pos) {
		//头删
		SLTPopFront(pphead);
		return;
	}

	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//prev pos pos->next
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos) {
	assert(pos);
	//pos->next不能为空
	assert(pos->next);

	//pos  pos->next  pos->next->next
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}
//销毁链表
void SListDesTroy(SLTNode** pphead) {
	assert(pphead);
	assert(*pphead);

	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

SList.h文件代码：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLTDataType;
//链表是由节点组成
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

//typedef struct SListNode SLTNode;
//打印链表
void SLTPrint(SLTNode* phead);

//链表的头插、尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
void SLTPushFront(SLTNode** pphead, SLTDataType x);

//链表的头删、尾删
void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

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

//在指定位置之前插入数据
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 SListDesT

今天就到这里了，都看到这里了，点一个赞吧，感谢观看。

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

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

相关文章

基于springboot实现的幼儿园管理系统

基于springboot实现的幼儿园管理系统

一、系统架构 前端&#xff1a;html | layui | jquery | css 后端&#xff1a;springboot | mybatis 环境&#xff1a;jdk1.8 | mysql | maven 二、代码及数据库 三、功能介绍 01. 登录页 02. 系统管理-用户管理 03. 系统管理-页面管理 04. 系统管理-角色管…
阅读更多...
喜报｜3DCAT成为国内首批适配Vision Pro内容开发者

喜报｜3DCAT成为国内首批适配Vision Pro内容开发者

近日&#xff0c;苹果在上海总部举办了国内首场 Apple Vision Pro 开发者实验室活动&#xff0c;3DCAT作为国内领先的实时渲染云平台参与了此次活动&#xff0c;成为国内首批适配 Vision Pro 的内容开发者之一。 Vision Pro是苹果于2023年6月发布的首个空间计算设备&#xff0…
阅读更多...
【C++STL详解 —— string类】

【C++STL详解 —— string类】

【CSTL详解 —— string类】 CSTL详解 —— sring类一、string的定义方式二、string的插入三、string的拼接四、string的删除五、string的查找六、string的比较七、string的替换八、string的交换九、string的大小和容量十、string中元素的访问十一、string中运算符的使用十二、…
阅读更多...
鸿蒙NEXT开发实战：【视频文件裁剪】

鸿蒙NEXT开发实战：【视频文件裁剪】

使用OpenHarmony系统提供的ffmpeg三方库的能力在系统中实现了音视频文件裁剪的功能&#xff0c;并通过NAPI提供给上层应用调用。 基础信息 视频文件裁剪 简介 在OpenHarmony系统整个框架中有很多子系统&#xff0c;其中多媒体子系统是OpenHarmony比较重要的一个子系统&#…
阅读更多...
Java+SpringBoot+Vue+MySQL：农业管理新篇章

Java+SpringBoot+Vue+MySQL：农业管理新篇章

✍✍计算机毕业编程指导师 ⭐⭐个人介绍&#xff1a;自己非常喜欢研究技术问题&#xff01;专业做Java、Python、微信小程序、安卓、大数据、爬虫、Golang、大屏等实战项目。 ⛽⛽实战项目&#xff1a;有源码或者技术上的问题欢迎在评论区一起讨论交流&#xff01; ⚡⚡ Java、…
阅读更多...
软件测试实战，Web项目网页bug定位详细分析总结（详全）

软件测试实战，Web项目网页bug定位详细分析总结（详全）

目录&#xff1a;导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09; 前言 1、前置条件 1&a…
阅读更多...
9、Linux-安装JDK、Tomcat和MySql

9、Linux-安装JDK、Tomcat和MySql

目录 一、安装JDK 1、传输JDK文件&#xff08;.tar.gz&#xff09; 2、解压 3、备份环境变量 4、配置环境变量 5、重新加载环境变量 6、验证&#xff08;java -version&#xff09; 二、安装Tomcat 1、传输文件&#xff0c;解压到/usr/local 2、进入Tomcat的bin目录 …
阅读更多...
数据库-ER图教程

数据库-ER图教程

一.什么是E-R图 E-R图全称&#xff1a;“Entity-Relationship Approach”&#xff0c;是一种“实体-联系”方法。 E-R图的优点&#xff1a; 1.自然地描述现实世界。 2.图形结构简单。 3.设计者和用户易理解。 4.是数据库设计的中间步骤&#xff0c;易于向数据模型转换。 …
阅读更多...
44、网络编程/数据库相关操作练习20240306

44、网络编程/数据库相关操作练习20240306

一、代码实现数据库的创建&#xff08;员工信息表&#xff09;&#xff0c;并存储员工信息&#xff08;工号、姓名、薪资&#xff09;&#xff0c;能实现增加人员信息、删除人员信息、修改人员薪资操作。 代码&#xff1a; #include<myhead.h>int do_update(sqlite3 *p…
阅读更多...
作业1-32 P1059 [NOIP2006 普及组] 明明的随机数

作业1-32 P1059 [NOIP2006 普及组] 明明的随机数

题目 思路 根据题意&#xff0c;需要将读入的数据排序&#xff0c;去重。 参考代码 #include<bits/stdc.h> using namespace std; int n,a[5000],k;int main() {while(cin>>n){//读入数据for(int i0;i<n;i)cin>>a[i];sort(a,an);//排序int b[5000];in…
阅读更多...
chrome浏览器离线安装及历史版本的下载

chrome浏览器离线安装及历史版本的下载

背景&#xff1a;测试web功能在浏览器各版本的兼容性&#xff0c;需要用到旧版本的浏览器&#xff0c;当用户环境无法访问到互联网&#xff0c;需要下载离线版本安装&#xff1b; 1、在线版本安装 需要当前环境能正常使用互联网&#xff1a; 目前能访问的官网地址&#xff1…
阅读更多...
【刷题】双指针入门

【刷题】双指针入门

双指针入门 双指针283.移动零1089. 复写零202. 快乐数11. 盛最多水的容器Thanks♪(&#xff65;ω&#xff65;)&#xff89;谢谢阅读&#xff01;&#xff01;&#xff01;下一篇文章见&#xff01;&#xff01;&#xff01; 双指针 双指针是非常经典的算法&#xff0c;包括但…
阅读更多...
6. Gin集成redis

6. Gin集成redis

文章目录 一&#xff1a;连接Redis二&#xff1a;基本使用三&#xff1a;字符串四&#xff1a;列表五&#xff1a;哈希六&#xff1a;Set七&#xff1a;管道八、事务九&#xff1a;示例 代码地址&#xff1a;https://gitee.com/lymgoforIT/golang-trick/tree/master/14-go-redi…
阅读更多...
Cookie 探秘：了解 Web 浏览器中的小甜饼

Cookie 探秘：了解 Web 浏览器中的小甜饼

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…
阅读更多...
java开发工程师面试题，996页阿里Java面试真题解析火爆全网

java开发工程师面试题，996页阿里Java面试真题解析火爆全网

开头 消息队列 RocketMQ 是阿里巴巴集团基于高可用分布式集群技术&#xff0c;自主研发的云正式商用的专业消息中间件&#xff0c;既可为分布式应用系统提供异步解耦和削峰填谷的能力&#xff0c;同时也具备互联网应用所需的海量消息堆积、高吞吐、可靠重试等特性&#xff0c;…
阅读更多...
b站小土堆pytorch学习记录—— P18-P22 神经网络+小实战

b站小土堆pytorch学习记录—— P18-P22 神经网络+小实战

文章目录 一、卷积层 P181.卷积操作2.代码 二、池化层 P191.池化层简单介绍2.代码&#xff08;1&#xff09;池化操作中数字的变化&#xff08;2&#xff09;池化操作对图片的影响 三、非线性激活 P201.简要介绍2.代码 四、线性层及其他层介绍 P211.线性层2.代码 五、搭建小实战…
阅读更多...
C++初阶：初识C++

C++初阶：初识C++

目录 1. 前言&#xff1a;C 与 C语言2. C对于C语言语法的完善与补充2.1 命名冲突与命名空间2.1.1 命名空间的定义2.1.2 调用方式 2.3 补充&#xff1a;流的概念2.4 缺省参数2.4.1 缺省参数的使用 2.5 函数重载2.5.1 什么是函数重载2.5.2 函数重载的使用2.5.3 特殊情况&#xff…
阅读更多...
七、链表问题（上）

七、链表问题（上）

160、相交链表&#xff08;简单&#xff09; 题目描述 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个…
阅读更多...
如何采集京东搜索页面商品的销量、价格数据？

如何采集京东搜索页面商品的销量、价格数据？

这段Python代码旨在从京东网站上获取商品信息&#xff0c;包括评论数量和评论的关键词&#xff0c;以便进行进一步的分析。该程序分析并模拟了京东的JavaScript请求&#xff0c;以获取动态加载的评论数据。 代码都测试验证过都能正常跑通&#xff0c;实现效果&#xff0c;由于…
阅读更多...
图像处理与视觉感知---期末复习重点（1）

图像处理与视觉感知---期末复习重点（1）

文章目录 一、概述二、图像处理基础2.1 视觉感知要素2.2 像素间的一些基本关系2.2.1 相邻像素2.2.2 连通性2.2.3 距离度量 2.3 基本坐标变换2.4 空间变换与灰度值 一、概述 1. 图像的概念及分类。  图像是用各种观测系统以不同形式和手段观测客观世界而获得的、可以直接或间接…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023