VB常用算法——排序

合集下载

计算机考试二级VB常用算法:排序

计算机考试二级VB常用算法:排序

计算机考试二级VB常用算法(9):排序1、算法说明1)初等数学递推法又称为”迭代法”,其基本思想是把一个复杂的计算过程转化为简单过程的多次重复。

每次重复都在旧值的基础上递推出新值,并由新值代替旧值。

问题:猴子吃桃子小猴子有若干桃子,第一天吃掉一半多一个;第二天吃掉剩下的—半多一个••…;如此,到第七天早上要吃时,只剩下一个桃子。

问小猴子一开始共有多少桃子?分析:可以最后一天桃子数推出倒数第二天的桃子数;再从倒数第二天推出倒数第三天桃子数........设第n天桃子数为xn ,前一天桃子数是:xn -1 z则有关系:xn = xn -1/2程序如下:Private Sub Commandl_Click()Dim n%, i%x =「第七天桃子数Print ”第七天桃子数:1只”For i = 6 To 1 Stepx = (x + 1) * 2Print “第“ & i & "天桃子数:” & x & ”只”Next iEnd Sub穷举法又称枚举法,即将所有可能情况一一测试,判断是否满足条件,—般用循环实现。

问题:百元买鸡问题。

假定小鸡每只5角;公鸡每只2元;母鸡每只3元。

现在有100 元,要求买100只鸡,编程列出所有可能的购鸡方案。

分析:设母鸡、公鸡、小鸡分别x、y、z只,则有:x + y+ z = 1003x + 2y + 0.5z = 100程序一:Private Sub Commandl_Click()Dim x%, y%, z%For x = 0 To 100For y = 0 To 100For z = 0 To 100If x + y + z = 100 And 3*x + 2*y + 0.5*z = 100 Then艇锻陆(ix 邸心"uoipunj oi|q n d:XP(S+X乙+ £X)£“二s :乌谥尊相⑹虽崇讎昼(乙qns pugx WNXixaN il P u3 人・x・oOT久'x |uud umq丄001 =(人・x・00l)学FO +人学乙+ x * £ jlOS °1 0 = JOJ ££ o丄0 二xJOJ %人'%x id ()>|oi|3_XP ueujLUO D qns 91SAUJ(刑割)二劄畚qns pugx ixa |\]X|X9|\|ZWNH P u3Z 久'X 1UUJf = x*(x*x + 2) + 5End FunctionPublic Function trapez(ByVal a!, By Vai b!, By Vai n%) AsSingle'b、a分别为积分上下限,n为等分数Dim sum!, h!, x!h = (b ・ a) / nsum = (f(a) + f(b)) / 2For i = 1 To n - 1x = a + i * hsum = sum + f(x)Next itrapez = sum * hEnd Function调用:Private Sub Commandl_Click()Print trapez(l z 3, 30)End Sub数论综合题此类题目比较广泛,必须给以足够重视。

VB常用算法介绍

VB常用算法介绍

VB常用算法介绍在VB程序开发中,常常需要使用各种算法来处理数据和解决问题。

下面将介绍几种常用的VB算法,包括排序算法、算法和图算法等。

1.排序算法排序算法用来将一组数据按照一定的规则进行排列。

常见的排序算法包括冒泡排序、选择排序、插入排序、归并排序和快速排序等。

冒泡排序(Bubble Sort)是一种交换排序算法,通过不断地相邻元素比较和交换,将较大的元素逐渐交换到末尾,从而实现排序。

冒泡排序的时间复杂度为O(n^2)。

选择排序(Selection Sort)是一种排序算法,每次从待排序的数据元素中选择最小(或最大)的一个元素,放到已排序的序列的末尾。

选择排序的时间复杂度为O(n^2)。

插入排序(Insertion Sort)是一种排序算法,将数组元素分为已排序和未排序两部分,每次从未排序的部分中取出一个元素,插入到已排序的部分的适当位置。

插入排序的时间复杂度为O(n^2)。

归并排序(Merge Sort)是一种分治排序算法,将待排序的数据分为两个子序列,然后递归地对子序列进行排序,并将两个已排序的子序列合并成一个有序序列。

归并排序的时间复杂度为O(nlogn)。

快速排序(Quick Sort)是一种分治排序算法,通过一次划分将待排数据分成左右两个子序列,然后递归地对子序列进行排序。

快速排序的时间复杂度为O(nlogn)。

2.算法算法用来在一个数据集合中查找一些元素或满足特定条件的元素。

常见的算法包括线性、二分和深度优先。

线性(Linear Search)是一种简单的算法,从数据集合的第一个元素开始逐个比较,直到找到目标元素或遍历完整个集合。

线性的时间复杂度为O(n)。

二分(Binary Search)是一种在有序数据集合中查找目标元素的算法,通过每次将范围缩小一半来快速定位目标元素。

二分的时间复杂度为O(logn)。

深度优先(Depth-First Search,DFS)是一种用来在图或树结构中遍历所有节点的算法,从一个起始节点开始,先遍历一个邻接节点,然后再递归地遍历该邻接节点的邻接节点。

VB常用算法总结大全

VB常用算法总结大全

VB常用算法总结大全VB(Visual Basic)是一种对初学者友好的编程语言,因其简单易学的特点而受到很多人的喜爱。

在VB中,算法是编程过程中非常重要的一部分,它们用来解决各种问题,从简单的数学计算到复杂的数据处理。

本文将总结一些常用的算法,帮助VB程序员更好地应用于实际项目中。

一、排序算法1.冒泡排序冒泡排序是一种简单的排序算法,它通过不断地交换相邻的元素来对数据进行排序。

它的基本思想是从列表的第一个元素开始,依次比较相邻的两个元素,如果顺序不正确,则交换它们的位置。

重复这个过程,直到整个列表都已经排序。

2.快速排序快速排序是一种高效的排序算法,它通过选择一个基准元素,将列表分为两部分,一部分小于基准元素,一部分大于基准元素。

然后对这两部分分别进行快速排序,最后将它们合并在一起。

3.插入排序插入排序是一种简单直观的排序算法,它将列表分为已排序和未排序两部分,每次选择未排序部分的第一个元素,并插入到已排序部分的适当位置。

重复这个过程,直到整个列表都已经排序。

二、查找算法1.顺序查找顺序查找是一种简单的查找算法,它从列表的第一个元素开始,依次比较每个元素,直到找到目标元素或者遍历完整个列表。

2.二分查找二分查找是一种高效的查找算法,它要求列表已经排序。

它通过比较目标元素与列表中间元素的大小关系来确定要的部分,并缩小范围。

重复这个过程,直到找到目标元素或者确定列表中没有目标元素。

三、图算法1.深度优先(DFS)深度优先是一种用于图遍历的算法,它从一个起始点开始,沿着一个路径尽可能深地访问节点,直到遇到一个没有未访问过的相邻节点为止。

然后回溯到前一个节点,寻找其他路径。

2.广度优先(BFS)广度优先也是一种用于图遍历的算法,它从一个起始点开始,依次访问所有与起始点相邻的节点,然后再依次访问这些节点的相邻节点,直到遍历完图中的所有节点。

四、动态规划动态规划是一种解决多阶段决策问题的方法,它将问题分解为若干个阶段,并定义状态和决策。

VB常用算法总结

VB常用算法总结

VB常用算法总结在VB(Visual Basic)编程中,常用的算法有很多。

下面将对其中一些常见和重要的算法进行总结。

请注意,由于篇幅限制,这只是一个简要总结,无法涵盖所有算法的细节。

1.排序算法:排序算法是计算机科学中最基本和常见的算法之一、在VB中,常用的排序算法包括冒泡排序、插入排序、选择排序、快速排序和归并排序等。

排序算法通过比较和交换来对一组数据进行重新排列,使其按照指定的顺序排列。

2.查找算法:查找算法用于在一个数据集中寻找特定的值或元素。

在VB中,常用的查找算法有二分查找和线性查找等。

二分查找是一种高效的算法,可以在有序数组中快速地找到目标元素。

3.图算法:图算法是用于解决与图相关的问题的算法。

在VB中,常用的图算法包括广度优先(BFS)和深度优先(DFS)等。

这些算法可以用于寻找图中的路径、检测环和遍历图等操作。

4.动态规划:动态规划是一种用于解决最优化问题的算法。

在VB中,常用的动态规划算法有背包问题、最长公共子序列和最短路径等。

动态规划算法通过拆解问题为子问题,并保存子问题的解来避免重复计算,从而提高算法的效率。

5.字符串匹配:字符串匹配算法用于在一个字符串中查找另一个字符串。

在VB中,常用的字符串匹配算法有暴力匹配算法、KMP算法和Boyer-Moore算法等。

这些算法通过比较字符来确定字符串的匹配位置。

6.线性代数:线性代数是数学的一个分支,用于解决线性方程组和向量空间等问题。

在VB中,常用的线性代数算法有矩阵运算、向量运算和线性方程求解等。

这些算法可以应用于计算机图形学、数据分析和机器学习等领域。

7.数学运算:数学运算在VB编程中非常常见。

常用的数学运算算法包括求和、平均值、最大值、最小值和中值等。

这些算法可以通过循环和条件判断来实现。

8.加密与解密:加密和解密算法用于保护数据的安全性。

在VB中,常用的加密算法有对称加密算法(如DES和AES)和非对称加密算法(如RSA和ECC)等。

VB各种排序方法.ppt

VB各种排序方法.ppt
Dim A(10) As Integer, Temp As Integer Dim I As Integer, J As Integer Dim Pointer As Integer Randomize For I = 1 To 10
A(I) = Int(Rnd * (100 - 1)) + 1
Text1 = Text1 & Str(A(I)) Next I For I = 1 To 9
不交交换换
26 4 5 3 62
第一轮比较
6
6
45
5
54
4
3
3
2
2
第二轮比较
第三轮比较
第I用一二三四≠=元轮素P比oAi(较nP较to结einr束te则r)交不去换交比 A换(AI()I)、A、(AP(oPionitnetre)r) 即排交序换结束A(12)和A(63)
6
6
5
5
4
4
3
3
2
2
第四轮比较
筛选法排序
返回
Dim I As Integer, J As Integer
Randomize
For I = 1 To 10
A(I) = Int(Rnd * (100 - 1)) + 1
Text1 = Text1 & Str(A(I))
Next I
For I = 1 To 9
For J = I + 1 To 10
For J = 1 To (N -I
)
If A(J) > A(J + 1) Then
T = A(J)
A(J) = A(J + 1)
A(J + 1) = T

VB常用算法大全

VB常用算法大全

VB常用算法大全在VB中实现常用算法是程序开发中非常常见的任务之一、下面将介绍几个常用的算法以及它们在VB中的实现方式。

1.冒泡排序算法:冒泡排序是一种简单直观的排序算法,它通过交换相邻元素来排序。

具体实现如下:```vbSub BubbleSort(arr( As Integer)Dim i As Integer, j As IntegerDim temp As IntegerFor i = LBound(arr) To UBound(arr) - 1For j = i + 1 To UBound(arr)If arr(j) < arr(i) Thentemp = arr(j)arr(j) = arr(i)arr(i) = tempEnd IfNext jNext iEnd Sub```2.快速排序算法:快速排序是一种高效的排序算法,它通过选择一个基准元素并将数组分为两部分来排序。

具体实现如下:```vbSub QuickSort(arr( As Integer, low As Integer, high As Integer)Dim i As Integer, j As IntegerDim pivot As Integer, temp As Integeri = lowj = highpivot = arr((low + high) / 2)While i <= jWhile arr(i) < pivoti=i+1WendWhile arr(j) > pivotj=j-1WendIf i <= j Thentemp = arr(i)arr(i) = arr(j)arr(j) = tempi=i+1j=j-1End IfWendIf low < j Then QuickSort arr, low, j End IfIf i < high Then QuickSort arr, i, high End IfEnd Sub```3.查找算法之二分查找:二分查找算法是一种在有序数组中查找指定元素的算法。

VB常用算法总结

VB常用算法总结

VB常用算法总结VB是一种基于Visual Basic语言的编程语言,广泛应用于Windows 操作系统环境下的软件开发。

在VB中,算法的选择和使用对于解决问题是至关重要的。

本文将对VB常用算法进行总结,希望能给读者提供一些编程的指导和参考。

一、排序算法排序算法是一类重要的算法,用于将一组无序的数据按照一定的规则进行排序。

VB中常用的排序算法有冒泡排序、选择排序、插入排序、快速排序等。

1.冒泡排序:从序列的第一个元素开始,依次比较相邻的两个元素,如果它们的顺序错误则交换位置,直到序列被完全排序。

2.选择排序:依次选择未排序序列中的最小元素,将其放到已排序序列的末尾。

3.插入排序:将一个记录插入到已排序好的序列中,从而得到一个新的、记录数增1的有序序列。

4.快速排序:通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分小,然后分别对这两部分记录继续进行排序,直到整个序列有序。

二、查找算法查找算法用于在一组有序或无序的数据中寻找指定的元素。

VB中常用的查找算法有线性查找、二分查找、哈希查找等。

1.线性查找:从数据的开头开始,逐个比较每一个元素,直到找到目标元素。

2.二分查找:在有序序列中,每次将待查元素与中间位置的元素比较,如果相等则找到,否则将待查元素与中间位置的元素比较,直到找到目标元素或序列为空。

3.哈希查找:通过哈希函数将关键字映射到一个定长的数组上,当需要查找时,根据关键字计算出哈希地址,从数组中访问对应位置的元素。

三、图算法图算法主要用于解决图结构相关的问题,如最短路径、拓扑排序等。

VB中常用的图算法有深度优先、广度优先、Dijkstra算法等。

1.深度优先:从起始节点开始,递归地访问子节点,直到无法继续访问为止,然后回溯到上一级节点,继续访问其尚未被访问的子节点。

2.广度优先:从起始节点开始,依次访问其所有相邻节点,直到访问到目标节点为止。

3. Dijkstra算法:求解带权有向图中单源最短路径问题,通过使用一个优先队列来实现。

2016年度精品--VB排序算法

2016年度精品--VB排序算法

为什么有这么多的排序算法?首先,在计算机编程中排序是一个经常遇到的问题。

数据只有经过排序后,才更有意义。

其次,排序算法说明了许多重要的算法的技术,例如二进制细分,递归和线性添加。

最后要说明的一点是不同的算法有不同的优缺点,没有一种算法在任何情况下都是最好的算法。

汽泡排序法该算法是专门针对已部分排序的数据进行排序的一种排序算法。

如果在你的数据清单中只有一两个数据是乱序的话,用这种算法就是最快的排序算法。

如果你的数据清单中的数据是随机排列的,那么这种方法就成了最慢的算法了。

因此在使用这种算法之前一定要慎重。

这种算法的核心思想是扫描数据清单,寻找出现乱序的两个相邻的项目。

当找到这两个项目后,交换项目的位置然后继续扫描。

重复上面的操作直到所有的项目都按顺序排好。

图1是对这种算法的说明。

在该例中,数字1的未按顺序排好。

第一次扫描清单时,程序找到4和1是两个相邻的乱序项目,于是交换它们的位置。

以此类推,直到将所有的项目按1234排好。

数字1就象上升的汽泡一样,这就是这一算法名称的由来。

2221331241331444图1.你可以改进该算法,让程序自下而上开始扫描,这样只须一次就能排好顺序了。

下面是用VB代码实现这一算法的例子:' min and max are the minimum and maximum indexes' of the items that might still be out of order.Sub BubbleSort (List() As Long, ByVal min As Integer, _ByVal max As Integer)Dim last_swap As IntegerDim i As IntegerDim j As IntegerDim tmp As Long' Repeat until we are done.Do While min < max' Bubble up.last_swap = min - 1' For i = min + 1 To maxi = min + 1Do While i <= max' Find a bubble.If List(i - 1) > List(i) Then' See where to drop the bubble.tmp = List(i - 1)j = iDoList(j - 1) = List(j)j = j + 1If j > max Then Exit DoLoop While List(j) < tmpList(j - 1) = tmplast_swap = j - 1i = j + 1Elsei = i + 1End IfLoop' Update max.max = last_swap - 1' Bubble down.last_swap = max + 1' For i = max - 1 To min Step -1i = max - 1Do While i >= min' Find a bubble.If List(i + 1) < List(i) Then' See where to drop the bubble.tmp = List(i + 1)j = iDoList(j + 1) = List(j)j = j - 1If j < min Then Exit DoLoop While List(j) > tmpList(j + 1) = tmplast_swap = j + 1i = j - 1Elsei = i - 1End IfLoop' Update min.min = last_swap + 1LoopEnd Sub选择排序法选择排序法是一个很简单的算法。

VB_常用算法总结

VB_常用算法总结

VB_常用算法总结VB是一种使用广泛的编程语言,它有很多常用的算法可以应用到各种实际的问题中。

下面是一些常用的VB算法的总结。

1.排序算法:-冒泡排序:比较相邻的两个元素,如果顺序错误则交换位置,重复该过程直到排序完成。

-插入排序:将一个元素插入到已经排好序的数组中的正确位置。

-选择排序:每次选择数组中最小的元素,放到已排序部分的末尾。

-快速排序:选择一个元素作为基准,将小于它的元素放在它的左边,大于它的元素放在右边,分别对左右两部分进行递归排序。

2.查找算法:-二分查找:将有序数组从中间切分,判断目标元素与中间元素的大小关系,递归查找目标元素所在的半边数组。

-线性查找:逐个比较数组中的元素,直到找到目标元素或遍历完整个数组。

3.图算法:-深度优先(DFS):从起始节点开始,递归地探索图中的每个节点,直到遍历到最深的节点为止。

-广度优先(BFS):从起始节点开始,逐层地探索图中的节点,直到找到目标节点。

- 最短路径(Dijkstra算法):计算从起始节点到所有其他节点的最短路径。

4.动态规划:-背包问题:给定一组物品和一个背包的容量,选择一些物品放入背包中,使得物品的总价值最大。

-最长公共子序列(LCS):两个序列中的最长公共子序列,可以用动态规划的方法求解。

5.图像处理:-图像平滑:使用滤波器(如均值滤波器、高斯滤波器)对图像进行平滑处理,去除图像中的噪声。

- 边缘检测:使用边缘检测算法(如Canny算法、Sobel算法)从图像中检测出物体的边缘。

6.数据压缩:-霍夫曼编码:根据字符出现的频率,构建霍夫曼树,并生成每个字符的编码,实现数据的无损压缩。

- Run-length编码:对连续出现的相同字符进行计数,并将计数值和字符编码压缩存储。

7.数学计算:-求解方程:使用牛顿迭代法、二分法等方法,寻找方程的根。

-矩阵操作:实现矩阵的相加、相乘、转置等操作。

以上只是VB中的一部分常用算法,还有很多其他的算法可以应用到实际问题中。

VB各种排序方法

VB各种排序方法

冒泡排序举例:
对整数序列 8 5 2 4 3 按升序排序


58 5 2 2 2
趟 沉

582 2 4 3 3

逐 渐
284 4 3 4 4
一 个

483 3 5 5 5


38 8 8 8 8
初第 第 第 第
大 的
始一 二 三 四
状趟 趟 趟 趟
程序
态结 结 结 结 果果果果
冒泡法排序一
Option Explicit
For I = 1 To N – 1 For J = I + 1 To N
2.进行每一轮的比较
If A(I) < A(J) then
3.在每一轮比较中,比较两
T = A( I )
个数的大小,根据比较结
A( I ) = A( J )
果决定是否交换两个数
A( J ) = T
End If
Next J Text1 = Text1 & Str(A(I)) Next I
Dim A(10) As Integer, Temp As Integer Dim I As Integer, J As Integer Dim Pointer As Integer Randomize For I = 1 To 10
A(I) = Int(Rnd * (100 - 1)) + 1
Text1 = Text1 & Str(A(I)) Next I For I = 1 To 9
Text1 = Text1 & Str(A(N))
筛选法排序
返回
Dim I As Integer, J As Integer

vb冒泡法排序降序 -回复

vb冒泡法排序降序 -回复

vb冒泡法排序降序-回复VB冒泡法排序降序是一种常见的排序算法,本文将详细介绍该算法的思想和实现过程。

冒泡法排序是一种简单但低效的排序算法,其基本思想是通过相邻元素的比较和交换来逐步将最大的元素冒泡到最后。

本文将一步步回答关于VB冒泡法排序降序的问题,以帮助读者全面理解和掌握这一算法。

第一步:了解冒泡法排序的基本思想冒泡法排序是一种通过多次比较和交换相邻元素来实现排序的算法。

其基本思想是从待排序的数据中依次比较相邻的两个元素,如果顺序不对则交换位置,直到整个序列按照要求排序完成。

在冒泡法排序中,每次都会将当前序列中最大(或最小)的元素移到最后一个位置,并在下一次迭代中不再考虑该位置,因此在每一次迭代中都会使得序列中的一个元素被确定其最终位置。

第二步:编写VB代码实现冒泡法排序冒泡法排序的实现思路如下:1. 从序列的第一个元素开始,比较相邻的两个元素。

2. 如果顺序不对,则交换位置,使得较大的元素移到后面。

3. 继续比较下一对相邻元素,直到整个序列的最后一对元素为止。

4. 重复1-3步骤,直到所有元素都已排序完成。

下面是VB代码实现冒泡法排序的示例:Sub BubbleSortDescending(arr() As Integer)Dim i As Integer, j As Integer, temp As IntegerDim n As Integern = UBound(arr)For i = 0 To n - 1For j = 0 To n - i - 1If arr(j) < arr(j + 1) Thentemp = arr(j)arr(j) = arr(j + 1)arr(j + 1) = tempEnd IfNext jNext iEnd Sub第三步:了解代码实现的过程和原理以上代码实现了对一个由整型数组arr()表示的序列进行冒泡法排序的操作。

冒泡法排序的过程是通过一层循环控制迭代次数,以及内层循环控制每次迭代中相邻元素的比较和交换操作。

vb各种排序算法

vb各种排序算法

vb各种排序算法'此文飞本人原创具体出处未知Option ExplicitDim Sums(9999) As Long, Sumb(9999) As Long '生成数据数量可自己设置Private blnSort As Boolean '排序方向Private Declare Function SendMessageFind Lib "User32" Alias "SendMessageA" (ByVal hWnd As Long, ByVal wmsg As Long, ByVal wparam As Integer, ByVal lparam As String) As Long Private Declare Function timeGetTime Lib "winmm.dll" () As LongDim T As LongPrivate Sub Command1_Click()Dim i As Long, z As Long, j As LongList1.ClearDoEventsList1.Visible = FalseFor i = 0 To UBound(Sums)nn:Randomizez = 99999 * Rnd + 9j = SendMessageFind(List1.hWnd, &H18F, 0, z)If j > -1 ThenGoTo nnElseSums(i) = zSumb(i) = zList1.AddItem Sums(i)End IfNextList1.Visible = TrueMe.Caption = "共产生数据:" & UBound(Sums) + 1 & " 项"End SubPrivate Sub Command2_Click()Dim ti As Integer, i As LongList2.ClearDoEventsFor i = 0 To UBound(Sumb)Sums(i) = Sumb(i)NextblnSort = Option1(0).ValueT = timeGetTimeIf Option2(0).Value = True ThenCall mpsort(Sums) '冒泡排序ti = 0End IfIf Option2(1).Value = True ThenCall insort(Sums) '插入排序ti = 1End IfIf Option2(2).Value = True ThenCall QuickSort(LBound(Sums), UBound(Sums)) '快速排序ti = 2End IfIf Option2(3).Value = True ThenCall selctsort(Sums) '选择排序ti = 3End IfIf Option2(4).Value = True ThenCall hirsort(Sums) '希尔排序ti = 4End IfIf Option2(5).Value = True ThenCall duisort(Sums) '堆排序ti = 5End IfIf Option2(6).Value = True ThenCall nsort(Sums) '打乱次序ti = 6End IfLabel1(ti).Caption = timeGetTime - TList2.Visible = FalseDoEventsFor i = 0 To UBound(Sums)List2.AddItem Sums(i)NextList2.Visible = TrueMe.Caption = "成功对:" & UBound(Sums) + 1 & " 项数据进行了排序,用时: " & Label1(ti).Caption & " 毫秒"Exit SubEnd SubPrivate Sub Command3_Click()List1.ClearList2.ClearMe.Caption = "六种排序"End SubPrivate Sub nsort(ByRef arrtosort() As Long)Dim i As Long, j As Long, tmp As LongFor i = LBound(arrtosort) To UBound(arrtosort)j = (UBound(arrtosort) - i) * Rnd + iIf i <> j Thentmp = arrtosort(i)arrtosort(i) = arrtosort(j)arrtosort(j) = tmpEnd IfNext iEnd SubPrivate Sub mpsort(ByRef arrtosort() As Long) '冒泡排序'经过n-1趟子排序完成的,它的时间复杂度为O(n^2)'优点:1.“编程复杂度”很低,很容易写出代码;2.具有稳定性Dim i As Long, j As Long, M As Long, tmp As LongM = UBound(arrtosort) 'm 等于数组上标Do While M '至m等于数组下标j = M - 1M = 0If blnSort ThenFor i = 0 To jIf arrtosort(i) > arrtosort(i + 1) Then '找到后者大于前者地数tmp = arrtosort(i) '两者互换arrtosort(i) = arrtosort(i + 1)arrtosort(i + 1) = tmpM = i '从该位置开始继续查找End IfNext iElseFor i = 0 To jIf arrtosort(i) < arrtosort(i + 1) Thentmp = arrtosort(i)arrtosort(i) = arrtosort(i + 1)arrtosort(i + 1) = tmpM = iEnd IfNext iEnd IfLoopEnd SubPrivate Sub insort(ByRef arrtosort() As Long) '插入排序'插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据'算法适用于少量数据的排序,时间复杂度为O(n^2)。

VBA排序的十种算法

VBA排序的十种算法

在使用VBA进行写程序时,经常会做排序,下面将会给出一些常用的排序算法的实现,方便大家写程序参考,假设代码中出现了错误,欢送高手指正。

主要算法有:1、〔冒泡排序〕Bubble sort2、〔选择排序〕Selection sort3、〔插入排序〕Insertion sort4、〔快速排序〕Quick sort5、〔合并排序〕Merge sort6、〔堆排序〕Heap sort7、〔组合排序〕Comb Sort8、〔希尔排序〕Shell Sort9、〔基数排序〕Radix Sort10、Shaker Sort第一种〔冒泡排序〕Bubble sortPublic Sub BubbleSort(ByRef lngArray() As Long)Dim iOuter As LongDim iInner As LongDim iLBound As LongDim iUBound As LongDim iTemp As LongiLBound = LBound(lngArray)iUBound = UBound(lngArray)'冒泡排序For iOuter = iLBound To iUBound - 1For iInner = iLBound To iUBound - iOuter - 1'比较相邻项If lngArray(iInner) > lngArray(iInner + 1) Then'交换值iTemp = lngArray(iInner)lngArray(iInner) = lngArray(iInner + 1)lngArray(iInner + 1) = iTempEnd IfNext iInnerNext iOuterEnd Sub2、〔选择排序〕Selection sort1.Public Sub SelectionSort(ByRef lngArray() As Long)2.Dim iOuter As Long3.Dim iInner As Long4.Dim iLBound As Long5.Dim iUBound As Long6.Dim iTemp As Long7.Dim iMax As Long8.9.iLBound = LBound(lngArray)10.iUBound = UBound(lngArray)11.12.'选择排序13.For iOuter = iUBound To iLBound + 1 Step -114.15.iMax = 016.17.'得到最大值得索引18.For iInner = iLBound To iOuter19.If lngArray(iInner) > lngArray(iMax) Then iMax = iInner20.Next iInner21.22.'值交换23.iTemp = lngArray(iMax)24.lngArray(iMax) = lngArray(iOuter)25.lngArray(iOuter) = iTemp26.27.Next iOuter28.End Sub复制代码第三种〔插入排序〕Insertion sort1.Public Sub InsertionSort(ByRef lngArray() As Long)2.Dim iOuter As Long3.Dim iInner As Long4.Dim iLBound As Long5.Dim iUBound As Long6.Dim iTemp As Long7.8.iLBound = LBound(lngArray)9.iUBound = UBound(lngArray)10.11.For iOuter = iLBound + 1 To iUBound12.13.'取得插入值14.iTemp = lngArray(iOuter)15.16.'移动已经排序的值17.For iInner = iOuter - 1 To iLBound Step -118.If lngArray(iInner) <= iTemp Then Exit For19.lngArray(iInner + 1) = lngArray(iInner)20.Next iInner21.22.'插入值23.lngArray(iInner + 1) = iTemp24.Next iOuter25.End Sub复制代码第四种〔快速排序〕Quick sort1.Public Sub QuickSort(ByRef lngArray() As Long)2.Dim iLBound As Long3.Dim iUBound As Long4.Dim iTemp As Long5.Dim iOuter As Long6.Dim iMax As Long7.8.iLBound = LBound(lngArray)9.iUBound = UBound(lngArray)10.11.'假设只有一个值,不排序12.If (iUBound - iLBound) Then13.For iOuter = iLBound To iUBound14.If lngArray(iOuter) > lngArray(iMax) Then iMax = iOuter15.Next iOuter16.17.iTemp = lngArray(iMax)18.lngArray(iMax) = lngArray(iUBound)19.lngArray(iUBound) = iTemp20.21.'开始快速排序22.InnerQuickSort lngArray, iLBound, iUBound23.End If24.End Sub25.26.Private Sub InnerQuickSort(ByRef lngArray() As Long, ByVal iLeftEnd As Long, ByValiRightEnd As Long)27.Dim iLeftCur As Long28.Dim iRightCur As Long29.Dim iPivot As Long30.Dim iTemp As Long31.32.If iLeftEnd >= iRightEnd Then Exit Sub33.34.iLeftCur = iLeftEnd35.iRightCur = iRightEnd + 136.iPivot = lngArray(iLeftEnd)37.38.Do39.Do40.iLeftCur = iLeftCur + 141.Loop While lngArray(iLeftCur) < iPivot42.43.Do44.iRightCur = iRightCur - 145.Loop While lngArray(iRightCur) > iPivot46.47.If iLeftCur >= iRightCur Then Exit Do48.49.'交换值50.iTemp = lngArray(iLeftCur)51.lngArray(iLeftCur) = lngArray(iRightCur)52.lngArray(iRightCur) = iTemp53.Loop54.55.'递归快速排序56.lngArray(iLeftEnd) = lngArray(iRightCur)57.lngArray(iRightCur) = iPivot58.59.InnerQuickSort lngArray, iLeftEnd, iRightCur - 160.InnerQuickSort lngArray, iRightCur + 1, iRightEnd61.End Sub复制代码第五种〔合并排序〕Merge sort1.Public Sub MergeSort(ByRef lngArray() As Long)2.Dim arrTemp() As Long3.Dim iSegSize As Long4.Dim iLBound As Long5.Dim iUBound As Long6.7.iLBound = LBound(lngArray)8.iUBound = UBound(lngArray)9.10.ReDim arrTemp(iLBound To iUBound)11.12.iSegSize = 113.Do While iSegSize < iUBound - iLBound14.15.'合并A到B16.InnerMergePass lngArray, arrTemp, iLBound, iUBound, iSegSize17.iSegSize = iSegSize + iSegSize18.19.'合并B到A20.InnerMergePass arrTemp, lngArray, iLBound, iUBound, iSegSize21.iSegSize = iSegSize + iSegSize22.23.Loop24.End Sub25.26.Private Sub InnerMergePass(ByRef lngSrc() As Long, ByRef lngDest() As Long, ByValiLBound As Long, iUBound As Long, ByVal iSegSize As Long)27.Dim iSegNext As Long28.29.iSegNext = iLBound30.31.Do While iSegNext <= iUBound - (2 * iSegSize)32.'合并33.InnerMerge lngSrc, lngDest, iSegNext, iSegNext + iSegSize - 1, iSegNext + iSegSize+ iSegSize - 134.35.iSegNext = iSegNext + iSegSize + iSegSize36.Loop37.38.If iSegNext + iSegSize <= iUBound Then39.InnerMerge lngSrc, lngDest, iSegNext, iSegNext + iSegSize - 1, iUBound40.Else41.For iSegNext = iSegNext To iUBound42.lngDest(iSegNext) = lngSrc(iSegNext)43.Next iSegNext44.End If45.46.End Sub47.48.Private Sub InnerMerge(ByRef lngSrc() As Long, ByRef lngDest() As Long, ByValiStartFirst As Long, ByVal iEndFirst As Long, ByVal iEndSecond As Long)49.Dim iFirst As Long50.Dim iSecond As Long51.Dim iResult As Long52.Dim iOuter As Long53.54.iFirst = iStartFirst55.iSecond = iEndFirst + 156.iResult = iStartFirst57.58.Do While (iFirst <= iEndFirst) And (iSecond <= iEndSecond)59.60.If lngSrc(iFirst) <= lngSrc(iSecond) Then61.lngDest(iResult) = lngSrc(iFirst)62.iFirst = iFirst + 163.Else64.lngDest(iResult) = lngSrc(iSecond)65.iSecond = iSecond + 166.End If67.68.iResult = iResult + 169.Loop70.71.If iFirst > iEndFirst Then72.For iOuter = iSecond To iEndSecond73.lngDest(iResult) = lngSrc(iOuter)74.iResult = iResult + 175.Next iOuter76.Else77.For iOuter = iFirst To iEndFirst78.lngDest(iResult) = lngSrc(iOuter)79.iResult = iResult + 180.Next iOuter81.End If82.End Sub复制代码第六种〔堆排序〕Heap sort1.Public Sub HeapSort(ByRef lngArray() As Long)2.Dim iLBound As Long3.Dim iUBound As Long4.Dim iArrSize As Long5.Dim iRoot As Long6.Dim iChild As Long7.Dim iElement As Long8.Dim iCurrent As Long9.Dim arrOut() As Long10.11.iLBound = LBound(lngArray)12.iUBound = UBound(lngArray)13.iArrSize = iUBound - iLBound14.15.ReDim arrOut(iLBound To iUBound)16.17.'Initialise the heap18.'Move up the heap from the bottom19.For iRoot = iArrSize \ 2 To 0 Step -120.21.iElement = lngArray(iRoot + iLBound)22.iChild = iRoot + iRoot23.24.'Move down the heap from the current position25.Do While iChild < iArrSize26.27.If iChild < iArrSize Then28.If lngArray(iChild + iLBound) < lngArray(iChild + iLBound + 1) Then29.'Always want largest child30.iChild = iChild + 131.End If32.End If33.34.'Found a slot, stop looking35.If iElement >= lngArray(iChild + iLBound) Then Exit Do36.37.lngArray((iChild \ 2) + iLBound) = lngArray(iChild + iLBound)38.iChild = iChild + iChild39.Loop40.41.'Move the node42.lngArray((iChild \ 2) + iLBound) = iElement43.Next iRoot44.45.'Read of values one by one (store in array starting at the end)46.For iRoot = iUBound To iLBound Step -147.48.'Read the value49.arrOut(iRoot) = lngArray(iLBound)50.'Get the last element51.iElement = lngArray(iArrSize + iLBound)52.53.iArrSize = iArrSize - 154.iCurrent = 055.iChild = 156.57.'Find a place for the last element to go58.Do While iChild <= iArrSize59.60.If iChild < iArrSize Then61.If lngArray(iChild + iLBound) < lngArray(iChild + iLBound + 1) Then62.'Always want the larger child63.iChild = iChild + 164.End If65.End If66.67.'Found a position68.If iElement >= lngArray(iChild + iLBound) Then Exit Do69.70.lngArray(iCurrent + iLBound) = lngArray(iChild + iLBound)71.iCurrent = iChild72.iChild = iChild + iChild73.74.Loop75.76.'Move the node77.lngArray(iCurrent + iLBound) = iElement78.Next iRoot79.80.'Copy from temp array to real array81.For iRoot = iLBound To iUBound82.lngArray(iRoot) = arrOut(iRoot)83.Next iRoot84.End Sub复制代码第七种〔组合排序〕Comb Sort1.Public Sub CombSort(ByRef lngArray() As Long)2.Dim iSpacing As Long3.Dim iOuter As Long4.Dim iInner As Long5.Dim iTemp As Long6.Dim iLBound As Long7.Dim iUBound As Long8.Dim iArrSize As Long9.Dim iFinished As Long10.11.iLBound = LBound(lngArray)12.iUBound = UBound(lngArray)14.'Initialise comb width15.iSpacing = iUBound - iLBound16.17.Do18.If iSpacing > 1 Then19.iSpacing = Int(iSpacing / 1.3)20.21.If iSpacing = 0 Then22.iSpacing = 1 'Dont go lower than 123.ElseIf iSpacing > 8 And iSpacing < 11 Then24.iSpacing = 11 'This is a special number, goes faster than 9 and 1025.End If26.End If27.28.'Always go down to 1 before attempting to exit29.If iSpacing = 1 Then iFinished = 130.31.'Combing pass32.For iOuter = iLBound To iUBound - iSpacing33.iInner = iOuter + iSpacing34.35.If lngArray(iOuter) > lngArray(iInner) Then36.'Swap37.iTemp = lngArray(iOuter)38.lngArray(iOuter) = lngArray(iInner)39.lngArray(iInner) = iTemp40.41.'Not finished42.iFinished = 043.End If44.Next iOuter46.Loop Until iFinished47.End Sub复制代码第八种〔希尔排序〕Shell Sort1.Public Sub ShellSort(ByRef lngArray() As Long)2.Dim iSpacing As Long3.Dim iOuter As Long4.Dim iInner As Long5.Dim iTemp As Long6.Dim iLBound As Long7.Dim iUBound As Long8.Dim iArrSize As Long9.10.iLBound = LBound(lngArray)11.iUBound = UBound(lngArray)12.13.'Calculate initial sort spacing14.iArrSize = (iUBound - iLBound) + 115.iSpacing = 116.17.If iArrSize > 13 Then18.Do While iSpacing < iArrSize19.iSpacing = (3 * iSpacing) + 120.Loop21.22.iSpacing = iSpacing \ 923.End If24.25.'Start sorting26.Do While iSpacing28.For iOuter = iLBound + iSpacing To iUBound29.30.'Get the value to be inserted31.iTemp = lngArray(iOuter)32.33.'Move along the already sorted values shifting along34.For iInner = iOuter - iSpacing To iLBound Step -iSpacing35.'No more shifting needed, we found the right spot!36.If lngArray(iInner) <= iTemp Then Exit For37.38.lngArray(iInner + iSpacing) = lngArray(iInner)39.Next iInner40.41.'Insert value in the slot42.lngArray(iInner + iSpacing) = iTemp43.Next iOuter44.45.'Reduce the sort spacing46.iSpacing = iSpacing \ 347.Loop48.49.End Sub复制代码第九种〔基数排序〕Radix Sort1.Public Sub RadixSort(ByRef lngArray() As Long)2.Dim arrTemp() As Long3.Dim iLBound As Long4.Dim iUBound As Long5.Dim iMax As Long6.Dim iSorts As Long7.Dim iLoop As Long8.9.iLBound = LBound(lngArray)10.iUBound = UBound(lngArray)11.12.'Create swap array13.ReDim arrTemp(iLBound To iUBound)14.15.iMax = &H8000000016.'Find largest17.For iLoop = iLBound To iUBound18.If lngArray(iLoop) > iMax Then iMax = lngArray(iLoop)19.Next iLoop20.21.'Calculate how many sorts are needed22.Do While iMax23.iSorts = iSorts + 124.iMax = iMax \ 25625.Loop26.27.iMax = 128.29.'Do the sorts30.For iLoop = 1 To iSorts31.32.If iLoop And 1 Then33.'Odd sort -> src to dest34.InnerRadixSort lngArray, arrTemp, iLBound, iUBound, iMax35.Else36.'Even sort -> dest to src37.InnerRadixSort arrTemp, lngArray, iLBound, iUBound, iMax38.End If39.40.'Next sort factor41.iMax = iMax * 25642.Next iLoop43.44.'If odd number of sorts we need to swap the arrays45.If (iSorts And 1) Then46.For iLoop = iLBound To iUBound47.lngArray(iLoop) = arrTemp(iLoop)48.Next iLoop49.End If50.End Sub51.52.Private Sub InnerRadixSort(ByRef lngSrc() As Long, ByRef lngDest() As Long, ByValiLBound As Long, ByVal iUBound As Long, ByVal iDivisor As Long)53.Dim arrCounts(255) As Long54.Dim arrOffsets(255) As Long55.Dim iBucket As Long56.Dim iLoop As Long57.58.'Count the items for each bucket59.For iLoop = iLBound To iUBound60.iBucket = (lngSrc(iLoop) \ iDivisor) And 25561.arrCounts(iBucket) = arrCounts(iBucket) + 162.Next iLoop63.64.'Generate offsets65.For iLoop = 1 To 25566.arrOffsets(iLoop) = arrOffsets(iLoop - 1) + arrCounts(iLoop - 1) + iLBound67.Next iLoop68.69.'Fill the buckets70.For iLoop = iLBound To iUBound71.iBucket = (lngSrc(iLoop) \ iDivisor) And 25572.lngDest(arrOffsets(iBucket)) = lngSrc(iLoop)73.arrOffsets(iBucket) = arrOffsets(iBucket) + 174.Next iLoop75.End Sub复制代码第十种 Shaker Sort1.Public Sub ShakerSort(ByRef lngArray() As Long)2.Dim iLower As Long3.Dim iUpper As Long4.Dim iInner As Long5.Dim iLBound As Long6.Dim iUBound As Long7.Dim iTemp As Long8.Dim iMax As Long9.Dim iMin As Long10.11.iLBound = LBound(lngArray)12.iUBound = UBound(lngArray)13.14.iLower = iLBound - 115.iUpper = iUBound + 116.17.Do While iLower < iUpper18.19.iLower = iLower + 120.iUpper = iUpper - 121.22.iMax = iLower23.iMin = iLower24.25.'Find the largest and smallest values in the subarray26.For iInner = iLower To iUpper27.If lngArray(iInner) > lngArray(iMax) Then28.iMax = iInner29.ElseIf lngArray(iInner) < lngArray(iMin) Then30.iMin = iInner31.End If32.Next iInner33.34.'Swap the largest with last slot of the subarray35.iTemp = lngArray(iMax)36.lngArray(iMax) = lngArray(iUpper)37.lngArray(iUpper) = iTemp38.39.'Swap the smallest with the first slot of the subarray40.iTemp = lngArray(iMin)41.lngArray(iMin) = lngArray(iLower)42.lngArray(iLower) = iTemp43.44.Loop45.End Sub复制代码。

VB常用算法总结大全

VB常用算法总结大全

时间复杂度:最好情况下为O(nlogn),最坏情况 下为O(n^2),平均情况下为O(nlogn)。
稳定性:不稳定。
02 查找算法
顺序查找
原理
01
从数据结构的一端开始,顺序扫描,直到找到所查元素为止。
时间复杂度
02
平均时间复杂度和最坏时间复杂度都是O(n),其中n是数据结构
中元素的个数。
适用场景
队列操作
实现入队(enqueue)、出队(dequeue)、 查看队首和队尾元素等基本操作。
3
应用举例
使用栈实现括号匹配检查、表达式求值等;使用 队列实现广度优先搜索(BFS)等算法。
06 文件操作与I/O流处理 算法
文件读写操作
顺序文件读写
使用Open、Input、Output、 Close等语句,按照文件内容的顺 序进行读写操作。
矩阵运算
矩阵加法
将两个矩阵对应元素相加得到新的矩阵。
矩阵乘法
按照矩阵乘法的规则,将两个矩阵相乘得到新的矩阵。
矩阵转置
将矩阵的行和列互换得到新的矩阵。
矩阵求逆
对于可逆矩阵,求解其逆矩阵。
线性方程组求解
高斯消元法
通过消元将线性方程组化为上三角或下三角形式,然后回代求解 。
LU分解法
将系数矩阵分解为一个下三角矩阵和一个上三角矩阵的乘积,然 后分别求解。
链表创建
链表遍历
通过动态分配内存空间,创建链表节点并 连接起来形成链表。
从头节点开始,依次访问链表中的每个节 点。
链表插入
在链表的指定位置插入一个新的节点。
链表删除
删除链表中的指定节点或一系列节点。
栈和队列操作及应用举例
1 2

VB 常考算法

VB  常考算法

1.求因子数Private Sub factor(X As Integer, Fn() As Integer) Dim I As Integer, N As IntegerReDim Fn(1): N = 1: Fn(1) = 1For I = 2 To N / 2If X Mod I = 0 ThenN = N + 1ReDim Preserve Fn(N)Fn(N) = IEnd IfNextEnd Sub2. 求因子数之和Private Function Sum_factor(N As Integer) As Long Dim I As Integer, J As Integer, S As IntegerDo While I < N / 2I = I + 1If N Mod I = 0 ThenS = S + IEnd IfLoopSum_factor = SEnd Function3. 判断数是否为素数Private Function Prime(N As Integer) As Boolean Dim M As IntegerFor M = 2 To Sqr(N)If N Mod M = 0 Then Exit FunctionNextPrime = TrueEnd Function4.求最大公约数Private Function gcd(m As Integer, n As Integer) As Integer If m Mod n = 0 Thengcd = nElsegcd = gcd(n, m Mod n)End IfEnd Function5.求最小公倍数Private Function Lcm(A As Integer, B As Integer) As Long DoLcm = Lcm + AIf Lcm Mod A = 0 And lcm Mod B = 0 ThenExit DoEnd IfLoopEnd Function6.求分数约数Private Sub divisor (Fz As Long, Fm As Long)Dim Min As Integer, K As IntegerIf Fm < Fz Then Min = Fz Else Min = FmFor K = 2 To MinDo While Fz Mod K = 0 And Fm Mod K = 0Fz = Fz / KFm = Fm / KLoopNextEnd Sub7.求阶乘Private Function fact(N As Integer) As Long If N <= 1 Thenfact = 1Elsefact = N * fact(N - 1)End IfEnd Function或Private Function fact(N As Integer) As Long Dim i As Integerfact = 1For i = 1 To Nfact = fact * iNextEnd Function8.一维数组排序(1)选择法排序,结果是从小到大Private Sub choose(a() As Integer)Dim I As Integer, J As Integer, Temp As Integer For I = 1 To UBound(a) - 1For J = I + 1 To UBound(a)If a(I) > a(J) ThenTemp = a(I)a(I) = a(J)a(J) = TempEnd IfNext JNext IEnd Sub(2)冒泡法排序,结果是从小到大Private Sub bubble_up(a() As Integer) Dim I As Integer, J As IntegerDim temp As DoubleDim m As IntegerFor I = LBound(a) To UBound(a) - 1 For J = UBound(a) To I + 1 Step -1If a(J) < a(J - 1) Thentemp = a(J)a(J) = a(J - 1)a(J - 1) = tempEnd IfNext JNext IEnd Sub注:把程序中“>”改成“<”,排序的结果为从大到小。

VB常用算法——排序

VB常用算法——排序

VB常考算法(八)排序:1、算法1)选择法排序算法说明:根据上例中求最小值的思路,我们可以使用如下方法进行从小到大排序:第一轮,以第一个元素逐个跟后面的所有元素比较,如果比后面的元素大就进行交换,经过一轮比较,第一个元素被确定为最小;同样的方法,下一轮以第二个元素跟剩下的所有元素进行比较确定下次小的元素;以此类推…下面我们以图形的形式体现对5个数进行选择排序的过程:第一轮:第二轮:第三轮:从上图可以发现对5个元素进行排序,总共经过了5-1=4轮,而每一轮中比较的次数也不相同,第一轮2、3、4、5号元素参与跟1号元素的比较,共4次,第二轮3、4、5号元素参与跟2号元素的比较,共3次,以次类推,比较次数逐步减少。

经过四轮的比较,利用逐步求最小值的方法将5个数从小到大排好序。

对于这样一个排序的过程,我们可以使用两个循环分别控制比较的轮数和每一轮的次数。

程序代码:Private Sub Command1_Click()Dim n As Integern = InputBox("请输入数组元素的个数:")Dim a() As Integer, i As Integer, j As IntegerPrint "排序前:"ReDim a(n)For i = 1 To na(i) = Int(Rnd * (99 - 10 + 1) + 10)Print a(i);最小值次小值Next iFor i = 1 To n - 1For j = i To nIf a(i) > a(j) Thentemp = a(i) '交换元素a(i) = a(j)a(j) = tempEnd IfNext jNext iPrintPrint "排序后:"For i = 1 To nPrint a(i);Next iEnd Sub2)冒泡法排序算法说明:相邻的元素进行比较,如果前面的元素比后面的元素大,则将它们进行交换,具体思路:设在数组a 中存放n 个元素,第一轮,将a(1)和a(2)进行比较,若a(1)>a(2),则交换这两个元素的值,然后继续用a(2)和a(3)比较,若a(1)>a(2),则交换这两个元素的值,以此类推,直到a(n-1)和a(n)进行比较处理后,a(n)中就存放了n 个数中最大的值;第二轮,用a(1)与a(2),a(2)与a(3),…,a(n-2)与a(n-1)进行比较,处理方法相同,这一轮下来,a(n-1)中存放n 个数中第二大的值;…;第n-1轮,a(1)与a(2)进行比较处理,确保最小值在a(1)中。

vb常用排序法

vb常用排序法

冒泡法:(1) 从第一个元素开始,将相邻的数比较,若为逆序,就交换,比较完一轮,最大的数已沉底,成为数组中的最后一个元素a(n)(2) 对a(1)和a(n-1)的n-1个数进行同(1)的操作,次大的数放入a(n-1)中,完成第二轮排序。

(3) 进行n-1轮排序,所有的数排序完毕。

Dim a%(), i%, j%, n%For i = 1 To n - 1For j = 1 To n - iIf a(j) > a(j + 1) Thent = a(j): a(j) = a(j + 1): a(j + 1) = t End IfNext jNext iPrintFor i = 1 To nPrint a(i);Next i 顺序交换法:(1) 从第一个元素开始,将它和其后的每个元素进行比较,若为逆序,就交换,比较完一轮,a(1)成为数组中的最小的元素。

(2) 对a(2)和a(n)的n-1个数进行同(1)的操作,次小的数放入a(2)中,完成第二轮排序。

(3) 进行n-1轮排序,所有的数排序完毕。

Dim a%(), i%, j%, n%For i = 1 To n - 1For j = i + 1 To nIf a(i) > a(j) Thent = a(i): a(i) = a(j): a(j) = t End IfNext jNext i选择法(1) 从n个数的序列中选出最小的数,与第1个数交换位置;(2) 除第1个数外,其余n-1个数再按(1)的方法选出次小的数,与第2个数交换位置;(3) 重复(1)n-1遍,最后构成递增序列。

Dim a%(), i%, j%, n%For i = 1 To n – 1k=iFor j = i + 1 To nIf a(j) < a(k) Then k=jNext jif k<>i then t=a(i): a(i)=a(k): a(k)=tNext i 插入法:1. 找到插入数在数组中的位置i2. 将从n到i的每个元素向后移动一个位置3. 插入数插入法1:将一个数插入到有序数列,使插入后数列仍然有序Dim a(1 To 10) As IntegerKey = Val(InputBox("输入一个数"))For i=1 to 9If a(i)>Key Then Exit Fornext iFor k = 9 To i Step -1a(k + 1) = a(k)Next ka(i) = Key插入法2:用上面的插入方法将一批数排序(从小到大),设数列中开始只有一个元素。

VB常用算法6排序

VB常用算法6排序

VB常用算法----排序1、选择法排序(1) 利用循环从n个数中选出最小数的下标,结束循环后,将最小数与第一个数交换位置;(2) 除第一个数外,在剩下的n-1个数中再按方法(1)选出次小的数,与第二个数交换位置;(3) 以此类推,最后构成递增序列。

譬如:8 6 9 3 2 7第一轮交换后 2 6 9 3 8 7第二轮交换后 2 3 9 6 8 7第三轮交换后 2 3 6 9 8 7第四轮交换后 2 3 6 7 8 9第五轮无交换 2 3 6 7 8 9程序代码如下:Private Sub xzPaiXu(a() As Double, sheng As Boolean)'a为需要排序的数组,sheng为True则为升序排列,为False,则为降序排列。

Dim i As Integer, j As IntegerDim temp As DoubleDim m As IntegerFor i = LBound(a) To UBound(a) - 1 '进行数组大小-1轮比较m = i '在第i轮比较时,假定第'i个元素为最值元素For j = i + 1 To UBound(a) '在剩下的元素中找出最'值元素的下标并记录在m中If sheng Then '若为升序,则m记录最小元素'下标,否则记录最大元素下标If a(j) < a(m) Then m = jElseIf a(j) > a(m) Then m = jEnd IfNext j '将最值元素与第i个元素交换temp = a(i)a(i) = a(m)a(m) = tempNext iEnd Sub调用该过程示例:Option Base 1Private Sub Command1_Click()Dim b(6) As Doubleb(1) = 8b(2) = 6b(3) = 9b(4) = 3b(5) = 2b(6) = 7Call xzPaiXu(b, True)For i% = 1 To 6Print b(i)NextEnd Sub2、冒泡法排序选择排序法在每一轮排序时寻找最值元素的下标,出了内循环(一轮排序结束时,确定最值下标),再交换最小数的位置;而冒泡法在每一轮排序时将相邻的数比较,当次序不对时就立即..交换..位置,出了内循环,最值数已经冒出。

计算机考试二级VB常用算法(8):排序

计算机考试二级VB常用算法(8):排序

1、算法说明1) 顺序查找逐个元素找,如果有,则记录位置,然后跳出循环;否则,查找失败。

代码如下:Private Sub Search(a(), ByVal Key, Index As Integer)Dim i%For i = LBound(a) To UBound(a)If a(i) = Key Then '找到,将元素下标保存在index中并结束查找Index = iExit SubEnd IfNext iIndex = -1 '若没找到,则index值为-1End Sub2) ⼆分法查找顺序查找效率低下,当数组有序排列时,可以使⽤⼆分法查找提⾼效率。

算法思想:代码如下:Private Sub birSearch(a(), ByVal low%, ByVal high%, ByVal Key, index%) Dim mid As IntegerIf low > high Then '没有查找到index = -1Exit SubEnd Ifmid = (low + high) \ 2 '取查找区间的中点If Key = a(mid) Then '查找到,返回下标index = midExit SubElseIf Key < a(mid) Then '查找区间在上半部分high = mid - 1Elselow = mid + 1 '查找区间在下半部分End IfCall birSearch(a, low, high, Key, index) '递归调⽤查找函数End Sub调⽤⽅法:Private Sub Command1_Click()Dim a(11)a(1) = 5: a(2) = 13: a(3) = 19: a(4) = 21: a(5) = 37a(6) = 56: a(7) = 64: a(8) = 75: a(9) = 80: a(10) = 88: a(11) = 92Dim ind As IntegerCall birSearch(a, LBound(a), UBound(a), 21, ind)Print indEnd Sub。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

VB常考算法(八)排序:
1、算法
1)选择法排序
算法说明:根据上例中求最小值的思路,我们可以使用如下方法进行从小到大排序:第一轮,以第一个元素逐个跟后面的所有元素比较,如果比后面的元素大就进行交换,经过一轮比较,第一个元素被确定为最小;同样的方法,下一轮以第二个元素跟剩下的所有元素进行比较确定下次小的元素;以此类推…
下面我们以图形的形式体现对5个数进行选择排序的过程:
第一轮:
第二轮:
第三轮:
从上图可以发现对5个元素进行排序,总共经过了5-1=4轮,而每一轮中比较的次数也不相同,第一轮2、3、4、5号元素参与跟1号元素的比较,共4次,第二轮3、4、5号元素参与跟2号元素的比较,共3次,以次类推,比较次数逐步减少。

经过四轮的比较,利用逐步求最小值的方法将5个数从小到大排好序。

对于这样一个排序的过程,我们可以使用两个循环分别控制比较的轮数和每一轮的次数。

程序代码:
Private Sub Command1_Click()
Dim n As Integer
n = InputBox("请输入数组元素的个数:")
Dim a() As Integer, i As Integer, j As Integer
Print "排序前:"
ReDim a(n)
For i = 1 To n
a(i) = Int(Rnd * (99 - 10 + 1) + 10)
Print a(i);
最小值
次小值
Next i
For i = 1 To n - 1
For j = i To n
If a(i) > a(j) Then
temp = a(i) '交换元素
a(i) = a(j) a(j) = temp End If Next j Next i Print
Print "排序后:"
For i = 1 To n
Print a(i); Next i End Sub
2)冒泡法排序
算法说明:相邻的元素进行比较,如果前面的元素比后面的元素大,则将它们进行交换,具体思路:设在数组a 中存放n 个元素,第一轮,将
a(1)和a(2)进行比较,若a(1)>a(2),则交换这两个元素的值,然后继续用a(2)和a(3)比较,若a(1)>a(2),则交换这两个元素的值,以此类推,直到a(n-1)和a(n)
进行比较处理后,a(n)中就存放了n 个数中最大的值;第二轮,用a(1)与a(2),a(2)与a(3),…,a(n-2)与a(n-1)进行比较,处理方法相同,这一轮下来,a(n-1)中存放n 个数中第二大的值;…;第n-1轮,a(1)与a(2)进行比较处理,确保最小值在a(1)中。

经过n-1轮比较处理,n 个数已经按从小到大的顺序排列好。

下面我们以图形的形式体现对5个数进行冒泡排序的过程:第一轮:
第三轮:
第四轮:
最大值
程序代码:
Private Sub Command1_Click()
Dim n As Integer
n = InputBox("请输入数组元素的个数:")
Dim a() As Integer, i As Integer, j As Integer
Print "排序前:"
ReDim a(n)
For i = 1 To n
a(i) = Int(Rnd * (99 - 10 + 1) + 10)
Print a(i);
Next i
For i = 1 To n - 1
For j = 1 To n - i
If a(j) > a(j + 1) Then '相邻元素比较
temp = a(j)
a(j) = a(j + 1)
a(j + 1) = temp
End If
Next j
Next i
Print
Print "排序后:"
For i = 1 To n
Print a(i);
Next i
End Sub
2、实战练习
1)填程序一
算法说明:C盘根目录下的数据文件data.txt中有两组数据,第一组数据未排序,并以-1表示该组数据结束;第二组数据按从小到大顺序排列。

下面程序的功能是,单击“读入数据”按钮,将文件中的两组数据,分别读入到A、B数
组中,单击“插入排序”按钮,则把A数组的元素按其大小依次插入到B数组的适当位置,使得B数组中元素仍为从小到大排列。

完善程序,实现以上功能。

n a
Dim a() As Integer, b() As Integer
Private Sub command1_click()
Dim I As Integer, j As Integer, n As Integer, s As String
(1) ‘参考答案:Open "c:\data.txt" For Input As #11
Do
Input #11, n
If n = -1 Then Exit Do
I = I + 1
ReDim Preserve a(I)
a(I) = n
s = s & Str(a(I))
Loop
Text1 = s
s = ""
(2) ‘参考答案:Do While Not EOF(1)
j = j + 1
ReDim Preserve b(j)
Input #11, b(j)
s = s & Str(b(j))
Loop
Text2 = s
Close 11
End Sub
Private Sub command2_click()
Dim I As Integer, j As Integer, s As String
For I = 1 To UBound(a)
If a(I) < b(1) Then
Call change(a(I), 1)
ElseIf a(I) > b(UBound(b)) Then
(3) ‘参考答案:ReDim Preserve b(UBound(b) + 1)
b(UBound(b)) = a(I)
Else
For j = 2 To bound(b)
If (a(I) > b(j - 1)) And a(I) <= b(j) Then Call change(a(I), j)
Next j
End If
Next I
For I = 1 To UBound(b)
s = s & Str(b(I))
Next I
Text3 = s
End Sub
Private Sub change(n As Integer, k As Integer) Dim I As Integer
ReDim Preserve b(UBound(b) + 1)
For I = UBound(b) To k + 1 Step -1
(4) ‘参考答案:b(I) = b(I - 1)
Next I
(5) ‘参考答案:b(k) = n
End Sub
)填程序二
2
Option Base 1
Dim n%, tag_in%
Dim stud(1 To 10) As StudType
Type StudType
Num As String * 6 ' 学号
Name As String * 8 ' 姓名
Average As Single ' 平均分
End Type
Private Sub Command1_Click()
If n < 10 Then
tag_in = 0
n = n + 1
Else
tag_in = 1
MsgBox "输入的学生人数已超过数组声明的个数!"
End If
If tag_in = 0 Then
If Text1 = "" Then
MsgBox "学号不能为空,请重输!"
n = (1)
Else
(2)= Text1
stud(n).Name = Text2
stud(n).Average = Val(Text3)
End If
End If
Text1 = "": Text2 = "": Text3 = ""
End Sub
Private Sub Command2_Click()
Dim t As StudType
Picture1.Cls
For j = 1 To n - 1
For k = (3)To n
If stud(k).Average > stud(j). (4)Then
t = stud(k)
stud(k) = (5)
stud(j) = t
End If
Next k
Next j
For j = 1 To n
Picture1.Print stud(j).Num; stud(j).Name; stud(j).Average Next j
End Sub。

相关文档
最新文档