【王道数据结构】第八章 | 排序

news2024/9/9 3:54:40

目录

8.1. 排序的基本概念

8.2. 插入排序 

8.2.1. 直接插入排序

8.2.2. 折半插入排序

8.2.3. 希尔排序 

8.3. 交换排序 

8.3.1. 冒泡排序

8.3.2. 快速排序 

8.4. 选择排序 

8.4.1. 简单选择排序 

8.4.2. 堆排序

8.5. 归并排序和基数排序

8.5.2. 基数排序

8.1. 排序的基本概念

  • 排序：重新排列表中的元素，使表中元素满足按关键字有序的过程。
  • 输入：n个记录 \small R_{1},R_{2},...,R_{n}，对应的关键字为 \small R_{1},R_{2},...,R_{n} 。     
  • 输出:：输入序列的一个重排\small R_{1}^{'},R_{2}^{'},...,R_{n}^{'} ，使得\small k_{1}^{'}\leq k_{2}^{'}\leq ...\leq k_{n}^{'} 。
  • 算法的稳定性：若待排序表中有两个元素\small R_{1}和\small R_{2}，其对应的关键字相同即\small key_{i} = \small key_{j}  ，且在排序前\small R_{1}在\small R_{2}的前面，若使用某一排序算法排序后，\small R_{1}仍然在\small R_{2}的前面，则称这个排序算法是稳定的，否则称排序算法是不稳定的。
  • 排序算法的评价指标：时间复杂度、空间复杂度、稳定性。
    • 排序算法的分类：
      内部排序： 排序期间元素都在内存中——关注如何使时间、空间复杂度更低。
      外部排序： 排序期间元素无法全部同时存在内存中，必须在排序的过程中根据要求不断地在内、外存之间移动——关注如何使时间、空间复杂度更低，如何使读/写磁盘次数更少。

8.2. 插入排序 

8.2.1. 直接插入排序

  • 算法思想：每次将一个待排序的记录按其关键字大小，插入到前面已经排好序的子序列中，直到全部记录插入完成。

代码实现（不带哨兵）: 

// 对A[]数组中共n个元素进行插入排序
void InsertSort(int A[],int n){
    int i,j,temp;
    for(i=1; i<n; i++){
        if(A[i]<A[i-1]){    	//如果A[i]关键字小于前驱
            temp=A[i];  
            for(j=i-1; j>=0 && A[j]>temp; --j)
                A[j+1]=A[j];    //所有大于temp的元素都向后挪
            A[j+1]=temp;
        }
    }
}

代码实现（带哨兵）：

// 对A[]数组中共n个元素进行插入排序
void InsertSort(int A[], int n){
    int i,j;
    for(i=2; i<=n; i++){
        if(A[i]<A[i-1]){
            A[0]=A[i];     	//复制为哨兵，A[0]不放元素
            for(j=i-1; A[0]<A[j]; --j)
                A[j+1]=A[j];
            A[j+1]=A[0];
        }
    }
}
  • 算法效率分析：
    • 时间复杂度：最好情况 O(n)，最差情况O(n^{2})，平均情况 O(n^{2})。
    • 空间复杂度：O(1)。
    • 算法稳定性：稳定。
    • 适用性：适用于顺序存储和链式存储的线性表。

对链表进行插入排序代码实现：

//对链表L进行插入排序
void InsertSort(LinkList &L){
    LNode *p=L->next, *pre;
    LNode *r=p->next;
    p->next=NULL;
    p=r;
    while(p!=NULL){
        r=p->next;
        pre=L;
        while(pre->next!=NULL && pre->next->data<p->data)
            pre=pre->next;
        p->next=pre->next;
        pre->next=p;
        p=r;
    }
}

8.2.2. 折半插入排序

  • 算法思路： 每次将一个待排序的记录按其关键字大小，使用折半查找找到前面子序列中应该插入的位置并插入，直到全部记录插入完成。
  • 注意：为了保证稳定性，当查找到和插入元素关键字一样的元素时，应该在这个元素的右半部分继续查找以确认位置。即当 A[mid] == A[0] 时，应继续在mid所指位置右边寻找插入位置。

代码实现：

//对A[]数组中共n个元素进行折半插入排序
void InsertSort(int A[], int n){ 
    int i,j,low,high,mid;
    for(i=2; i<=n; i++){
        A[0]=A[i];    		     	 //将A[i]暂存到A[0]
            low=1; high=i-1;
        while(low<=high){            //折半查找
            mid=(low+high)/2;
            if(A[mid]>A[0])
                high=mid-1;
            else
                low=mid+1;
        }
        for(j=i-1; j>high+1; --j)
            A[j+1]=A[j];
        A[high+1]=A[0];
    }
}
  • 与直接插入排序相比，比较关键字的次数减少了，但是移动元素的次数没有变。时间复杂度仍为 O(n²)。

8.2.3. 希尔排序 

 

  • 算法思路：先追求表中元素的部分有序，再逐渐逼近全局有序，以减小插入排序算法的时间复杂度。
  • 具体实施：希尔排序:先将待排序表分割成若干形如 L[i,i+d,i+ed,...,i+kd] 的“特殊”子表，对各个子表分别进行直接插入排序。缩小增量d，重复上述过程，直到d=1为止。

希尔排序代码实现： 

// 对A[]数组共n个元素进行希尔排序
void ShellSort(ElemType A[], int n){
    int d,i,j;
    for(d=n/2; d>=1; d=d/2){  	//步长d递减
        for(i=d+1; i<=n; ++i){
            if(A[i]<A[i-d]){
                A[0]=A[i];		//A[0]做暂存单元，不是哨兵
                for(j=i-d; j>0 && A[0]<A[j]; j-=d)
                    A[j+d]=A[j];
                A[j+d]=A[0];
            }
		}
    }
}
  • 算法效率分析：
    • 时间复杂度：希尔排序时间复杂度依赖于增量序列的函数。最差情况O(n^{2})，n在某个特顶范围时可达O(n^{1.3}) 。
    • 空间复杂度：O(1)
    • 算法稳定性：不稳定。

8.3. 交换排序 

8.3.1. 冒泡排序

 

  • 算法思路：从后往前（或从前往后）两两比较相邻元素的值，若为逆序（即 A [ i − 1 ] > A [ i ]) ，则交换它们，直到序列比较完。如此重复最多 n-1 次冒泡就能将所有元素排好序。为保证稳定性，关键字相同的元素不交换。

冒泡排序代码实现：

// 交换a和b的值
void swap(int &a, int &b){
    int temp=a;
    a=b;
    b=temp;
}

// 对A[]数组共n个元素进行冒泡排序
void BubbleSort(int A[], int n){
    for(int i=0; i<n-1; i++){
        bool flag = false; 			//标识本趟冒泡是否发生交换
        for(int j=n-1; j>i; j--){
            if(A[j-1]>A[j]){
                swap(A[j-1],A[j]);
                flag=true;
            }
        }
        if(flag==false)
            return;       //若本趟遍历没有发生交换，说明已经有序
    }
}
  • 算法效率分析：
    • 时间复杂度：最好情况O(n) ，最差情况O(n^{2})，平均情况O(n^{2})。
    • 空间复杂度：O(1)。
    • 稳定性：稳定。
    • 适用性：冒泡排序可以用于顺序表、链表。

8.3.2. 快速排序 

 

  • 算法思路：在待排序表 L [ 1... n ] 中任选一个元素 pivot 作为枢轴（通常取首元素），通过一趟排序将待排序表分为独立的两部分 L [ 1... k − 1 ] 和 L [ k − 1... n ] 。使得 L [ 1... k − 1 ] 中的所有元素小于 pivot，L [ k − 1... n ]中的所有元素大于等于 pivot，则 pivot 放在了其最终位置 L [ k ]上。重复此过程直到每部分内只有一个元素或空为止。
  • 快速排序是所有内部排序算法中性能最优的排序算法。
  • 在快速排序算法中每一趟都会将枢轴元素放到其最终位置上。（可用来判断进行了几趟快速排序）
  • 快速排序可以看作数组中n个元素组织成二叉树，每趟处理的枢轴是二叉树的根节点，递归调用的层数是二叉树的层数。

快速排序代码实现：

// 用第一个元素将数组A[]划分为两个部分
int Partition(int A[], int low, int high){
    int pivot = A[low];
    while(low<high){
        while(low<high && A[high]>=pivot)
            --high;
        A[low] = A[high];
        while(low<high && A[low]<=pivot) 
            ++low;
        A[high] = A[low];
    }
    A[low] = pivot;
    return low;
} 

// 对A[]数组的low到high进行快速排序
void QuickSort(int A[], int low, int high){
    if(low<high){
        int pivotpos = Partition(A, low, high);  //划分
        QuickSort(A, low, pivotpos - 1);
        QuickSort(A, pivotpos + 1, high);
    }
}
  • 算法效率分析：
    • 时间复杂度：快速排序的时间复杂度 = O ( n × 递 归 调 用 的 层 数 ) 。最好情况 O(nlog_{2}n),最差情况 O(n^{2}) ，平均情况O(n^{2})。
    • 空间复杂度：快速排序的空间复杂度 = O ( 递 归 调 用 的 层 数 ) O(递归调用的层数)O(递归调用的层数)。最好情况O(nlog_{2}n)，最差情况 O(n)，平均情况 O(n^{2})。

8.4. 选择排序 

  • 选择排序思想： 每一趟在待排序元素中选取关键字最小（或最大）的元素加入有序子序列。

8.4.1. 简单选择排序 

  • 算法思路：每一趟在待排序元素中选取关键字最小的元素与待排序元素中的第一个元素交换位置。

简单选择排序代码实现：

// 交换a和b的值
void swap(int &a, int &b){
    int temp = a;
    a = b;
    b = temp;
}

// 对A[]数组共n个元素进行选择排序
void SelectSort(int A[], int n){
    for(int i=0; i<n-1; i++){          	//一共进行n-1趟，i指向待排序序列中第一个元素
        int min = i;
        for(int j=i+1; j<n; j++){		//在A[i...n-1]中选择最小的元素
            if(A[j]<A[min])
                min = j;
        }
        if(min!=i)                     
            swap(A[i], A[min]);
    }
}
  • 算法效率分析：
    • 时间复杂度：无论待排序序列有序、逆序还是乱序，都需要进行 n-1 次处理，总共需要对比关键字(n−1)+(n−2)+. . .+1=n( n−1) /2 次，因此时间复杂度始终是O(n^{2}) 。
    • 空间复杂度：O(1) 。
    • 稳定性：不稳定。
    • 适用性：适用于顺序存储和链式存储的线性表。
       

对链表进行简单选择排序：

void selectSort(LinkList &L){
    LNode *h=L,*p,*q,*r,*s;
    L=NULL;
    while(h!=NULL){
        p=s=h; q=r=NULL;
        while(p!=NULL){
            if(p->data>s->data){
                s=p; r=q;
            }
            q=p; p=p->next;
        }
        if(s==h)
            h=h->next;
        else
            r->next=s->next;
        s->next=L; L=s;
    }
}

8.4.2. 堆排序

 

  • 算法思路：首先将存放在 L [ 1... n ] 中的n个元素建成初始堆，由于堆本身的特点，堆顶元素就是最大值。将堆顶元素与堆底元素交换，这样待排序列的最大元素已经找到了排序后的位置。此时剩下的元素已不满足大根堆的性质，堆被破坏，将堆顶元素下坠使其继续保持大根堆的性质，如此重复直到堆中仅剩一个元素为止。
  • 在顺序存储的完全二叉树中：
    • 非终端结点的编号 ：i ≤ [ n / 2 ]
    • i 的左右孩子 ：2i 和 2i+1
    • i 的父节点：[ i / 2 ]

堆排序代码实现：

// 对初始序列建立大根堆
void BuildMaxHeap(int A[], int len){
    for(int i=len/2; i>0; i--) 		//从后往前调整所有非终端结点
        HeadAdjust(A, i, len);
}

// 将以k为根的子树调整为大根堆
void HeadAdjust(int A[], int k, int len){
    A[0] = A[k];
    for(int i=2*k; i<=len; i*=2){	//沿k较大的子结点向下调整
        if(i<len && A[i]<A[i+1])	
            i++;
        if(A[0] >= A[i])
            break;
        else{
            A[k] = A[i];			//将A[i]调整至双亲结点上
            k=i;					//修改k值，以便继续向下筛选
        }
    }
    A[k] = A[0]
}

// 交换a和b的值
void swap(int &a, int &b){
    int temp = a;
    a = b;
    b = temp;
}

// 对长为len的数组A[]进行堆排序
void HeapSort(int A[], int len){
    BuildMaxHeap(A, len);         	//初始建立大根堆
    for(int i=len; i>1; i--){      	//n-1趟的交换和建堆过程
        swap(A[i], A[1]);
        HeadAdjust(A,1,i-1);
    }
}
  • 算法效率分析：
    • 时间复杂度：O(n\log_{2}n)。建堆时间 O(n) ，之后进行 n-1 次向下调整操作，每次调整时间复杂度为O(\log_{2}n)。
    • 空间复杂度：O(1)。
    • 稳定性：不稳定。
       

  • 堆的插入：对于大（或小）根堆，要插入的元素放到表尾，然后与父节点对比，若新元素比父节点更大（或小），则将二者互换。新元素就这样一路==“上升”==，直到无法继续上升为止。

  • 堆的删除：被删除的元素用堆底元素替换，然后让该元素不断==“下坠”==，直到无法下坠为止。

8.5. 归并排序和基数排序

  •  归并（Merge）：把两个或多个已经有序的序列合并成一个新的有序表。k路归并每选出一个元素，需对比关键字k-1次。
  • 算法思想：把待排序表看作 n 个有序的长度为1的子表，然后两两合并，得到 ⌈ n / 2 ⌉ 个长度为2或1的有序表……如此重复直到合并成一个长度为n的有序表为止。

代码实现：

// 辅助数组B
int *B=(int *)malloc(n*sizeof(int));

// A[low,...,mid]，A[mid+1,...,high]各自有序，将这两个部分归并
void Merge(int A[], int low, int mid, int high){
    int i,j,k;
    for(k=low; k<=high; k++)
        B[k]=A[k];
    for(i=low, j=mid+1, k=i; i<=mid && j<= high; k++){
        if(B[i]<=B[j])
            A[k]=B[i++];
        else
            A[k]=B[j++];
    }
    while(i<=mid)
        A[k++]=B[i++];
    while(j<=high) 
        A[k++]=B[j++];
}

// 递归操作
void MergeSort(int A[], int low, int high){
    if(low<high){
        int mid = (low+high)/2;
        MergeSort(A, low, mid);
        MergeSort(A, mid+1, high);
        Merge(A,low,mid,high);     //归并
    }
}

8.5.2. 基数排序

  • 算法思想：把整个关键字拆分为d位，按照各个关键字位递增的次序（比如：个、十、百），做d趟“分配”和“收集”，若当前处理关键字位可能取得r个值，则需要建立r个队列。
  • 分配：顺序扫描各个元素，根据当前处理的关键字位，将元素插入相应的队列。一趟分配耗时O ( n ) O(n)O(n)。
  • 收集：把各个队列中的结点依次出队并链接。一趟收集耗时O ( r ) O(r)O(r)。
     
  • 基数排序擅长处理的问题：
    1. 数据元素的关键字可以方便地拆分为d组，且d较小。
    2. 每组关键字的取值范围不大，即r较小。
    3. 数据元素个数n较大。
  • 算法效率分析：算法效率分析：
    1. 时间复杂度：一共进行d趟分配收集，一趟分配需要 O ( n )，一趟收集需要 O(r) ，时间复杂度为 O[ d ( n + r ) ] ，且与序列的初始状态无关.
    2. 空间复杂度：O(r)，其中r为辅助队列数量。
    3. 稳定性：稳定。

未完待续
 

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

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

相关文章

3-track网络预测蛋白质结构和相互作用

3-track网络预测蛋白质结构和相互作用

目录引言网络架构发展直接生成蛋白-蛋白复合物DeepMind在最近的CASP14上展示了非常准确的预测。作者探索了融合相关思想的网络架构&#xff0c;并通过对一维序列级、二维距离图级&#xff08;distance map&#xff09;和三维坐标级&#xff08;coordinate&#xff09;的信息依次…
阅读更多...
机械设备管理软件如何选择？机械设备管理软件哪家好？

机械设备管理软件如何选择？机械设备管理软件哪家好？

随着信息化技术的进步与智能制造的发展趋势&#xff0c;很多机械设备制造企业也在一直探寻适合自己的数字化管理转型之路&#xff0c;而企业上ERP管理软件又是实现数字化管理的前提&#xff0c;机械设备管理软件对于企业来说就是关键一环。机械设备管理软件如何选择&#xff1f…
阅读更多...
IPV4地址的原理和配置

IPV4地址的原理和配置

第三章&#xff1a;IP地址的配置 IPv4&#xff08;Internet Protocol Version 4&#xff09;协议族是TCP/IP协议族中最为核心的协议族。它工作在TCP/IP协议栈的网络层&#xff0c;该层与OSI参考模型的网络层相对应。网络层提供了无连接数据传输服务&#xff0c;即网络在发送分…
阅读更多...
【GD32F427开发板试用】7. 移植LVGL到GD32F427V

【GD32F427开发板试用】7. 移植LVGL到GD32F427V

本篇文章来自极术社区与兆易创新组织的GD32F427开发板评测活动&#xff0c;更多开发板试用活动请关注极术社区网站。作者&#xff1a;hehung 之前发帖 【GD32F427开发板试用】1. 串口实现scanf输入控制LED 【GD32F427开发板试用】2. RT-Thread标准版移植 【GD32F427开发板试用…
阅读更多...
TypeScript快速入门———（一）TypeScript 介绍以及初体验

TypeScript快速入门———（一）TypeScript 介绍以及初体验

文章目录1. TypeScript 介绍1.1 TypeScript 是什么1.2 TypeScript 为什么要为 JS 添加类型支持&#xff1f;1.3 TypeScript 相比 JS 的优势2. TypeScript 初体验2.1 安装编译 TS 的工具包2.2 编译并运行 TS 代码2.3 简化运行 TS 的步骤1. TypeScript 介绍 1.1 TypeScript 是什…
阅读更多...
[python入门㊺] - 异常中的finally

[python入门㊺] - 异常中的finally

目录 ❤ finally的作用 ❤ try、except、finally的执行顺序是什么 ❤ 案列 finally 中不带return finally中有return ❤ finally的作用 finally内的代码不管有无异常发生&#xff0c;都会执行。具体来说&#xff1a; 无论是否发生了异常&#xff0c;一定会执行 fi…
阅读更多...
若依-pro使用

若依-pro使用

前言 最近开始搞一个项目&#xff0c;使用的框架是若依-pro。新手上路&#xff0c;多多指教。 首先了解一下什么是若依&#xff0c;其实他就是将很多项目共同的代码进行了抽取&#xff0c;方便我们可以快速开发的一个javaweb项目&#xff08;若依是一个项目&#xff0c;一个p…
阅读更多...
中睿天下Coremail联合发布《2022年第四季度企业邮箱安全报告》(附下载）

中睿天下Coremail联合发布《2022年第四季度企业邮箱安全报告》(附下载）

近日&#xff0c;中睿天下联合CAC邮件安全大数据中心&#xff08;以下简称CAC中心&#xff09;发布《2022年第四季度企业邮箱安全报告》&#xff0c;对当前企业邮箱的应用状况和安全风险进行了分析。1.垃圾邮件同比下降22.16%日前&#xff0c;CAC&#xff08;Coremail Anti Spa…
阅读更多...
test3

test3

数据链路层故障分析 一、网桥故障 a.主要用途简述 网桥作为一种桥接器&#xff0c;可以连接两个局域网。工作在数据链路层&#xff0c;是早期的两端口二层网络设备。可将一个大的VLAN分割为多个网段&#xff0c;或者将两个以上的LAN互联为一个逻辑LAN&#xff0c;使得LAN上的…
阅读更多...
互联网舆情监测系统困境及措施，TOOM舆情监控平台应对及处置?

互联网舆情监测系统困境及措施，TOOM舆情监控平台应对及处置?

互联网舆情监测系统帮助政府、企业、媒体等机构了解公众的需求和诉求&#xff0c;及时发现和解决问题&#xff0c;防范和化解不良舆情&#xff0c;提高公众满意度和信任度。互联网舆情监测的技术手段包括爬虫、文本挖掘、情感分析、网络图谱等&#xff0c;互联网舆情监测系统困…
阅读更多...
UE4 使用AE跟踪相机数据，演算任意视频的相机运动数据

UE4 使用AE跟踪相机数据，演算任意视频的相机运动数据

参考链接 ae 3dsmax 摄像机互导 aehj 虚幻引擎5使用AE跟踪相机数据 一、软件版本&#xff1a;试过好几个版本&#xff0c;目前只有两组版本成功过 3dmax2016 AE2014 3dmax2020 AE2022 二、程序安装&#xff08;执行exe和手动拷贝是相同的&#xff09; 参考链接 重启AE后如…
阅读更多...
工作记录------PostMan自测文件导入、导出功能

工作记录------PostMan自测文件导入、导出功能

工作记录------PostMan自测文件导入、导出功能 测试文件导出 背景&#xff1a;写了一个文件下载功能&#xff0c;是数据写到excel中&#xff0c;下载&#xff0c;使用PostMan点击send后&#xff0c;返回报文是乱码。 解决办法&#xff1a; 点击send下面的 send and Downlo…
阅读更多...
python学习之pandas库的使用总结

python学习之pandas库的使用总结

【1】读取CSV并进行透视 我们的原始数据格式&#xff1a; ① 读取数据 pd.read_csv 会读取csv表格并使用names指定读取后的列名称。 import pandas as pdreleaseNumOfYear pd.read_csv("data/releaseNumOfYear.csv", headerNone, names[Year, Genre, ReleaseNum]…
阅读更多...
各种音频接口比较

各种音频接口比较

时间 参考&#xff1a;https://www.bilibili.com/video/BV1SL4y1q7GZ/?spm_id_from333.337.search-card.all.click&vd_source00bd76f9d6dc090461cddd9f0deb2d51&#xff0c; https://blog.csdn.net/weixin_43794311/article/details/128941346 接口名字时间公司支持格式…
阅读更多...
springcloud - 2021.0.3版本 - （一）服务注册nacos+feign

springcloud - 2021.0.3版本 - （一）服务注册nacos+feign

一&#xff0c;注册中心 最新版使用的是nacos&#xff0c;可替换为eureka&#xff0c;zookeeper&#xff0c;使用方式大同小异&#xff0c;这里不做扩展。 下载安装&#xff1a;&#xff08;有机会重装时再补上&#xff09; 管理页面&#xff1a;http://localhost:8848/naco…
阅读更多...
RabbitMQ详解（二）：Docker安装RabbitMQ

RabbitMQ详解（二）：Docker安装RabbitMQ

在Docker上安装部署RabbitMQ方便快捷&#xff0c;不需要额外安装Erlang环境&#xff0c;所以写该篇文章先来介绍如何在Docker上部署RabbitMQ。 一、安装并运行 (1)、在docker hub 中查找rabbitmq镜像 docker search rabbitmq:3.9.12-management带有“mangement”的版本&…
阅读更多...
Python将脚本程序转变为可执行程序

Python将脚本程序转变为可执行程序

Python将脚本程序转变为可执行程序 类似Java打包操作&#xff0c;若不想让人看到Python程序内部逻辑&#xff0c;也可将其转换为exe可执行文件 首先自己写一个Python程序&#xff0c;如下&#xff1a; print("start running...")listTest ["I","a…
阅读更多...
网渗透(二十二)之Windows协议认证和密码抓取-Silver Ticket白银票据制作原理及利用方式

网渗透(二十二)之Windows协议认证和密码抓取-Silver Ticket白银票据制作原理及利用方式

系列文章第一章节之基础知识篇 内网渗透(一)之基础知识-内网渗透介绍和概述 内网渗透(二)之基础知识-工作组介绍 内网渗透(三)之基础知识-域环境的介绍和优点 内网渗透(四)之基础知识-搭建域环境 内网渗透(五)之基础知识-Active Directory活动目录介绍和使用 内网渗透(六)之基…
阅读更多...
知识图谱业务落地技术推荐之国内知识图谱平台汇总(竞品)[阿里、腾讯、华为等】

知识图谱业务落地技术推荐之国内知识图谱平台汇总(竞品)[阿里、腾讯、华为等】

各位可以参考国内知识图谱平台产品进行对技术链路搭建和产品参考提供借鉴。
阅读更多...
2.4G-WiFi连接路由器过程

2.4G-WiFi连接路由器过程

一、概述 WiFi的数据通信基于802.11协议进行&#xff0c;无线AP在工作时会定时向空中发送beacon数据包&#xff0c;基站&#xff08;STA&#xff09;从beacon中解析出AP的名称、加密方式等信息&#xff0c;从而发起连接。 二、WiFi连接路由器的详细过程 WiFi连接过程主要可以…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023