gap

【Python数据结构与算法笔记day30】6.5. 希尔排序

由 ℡╲_俬逩灬. 提交于 2020-02-01 22:24:33
文章目录 6.5. 希尔排序 希尔排序 希尔排序过程 希尔排序的分析 时间复杂度 希尔排序演示 6.5. 希尔排序 希尔排序 希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。 希尔排序过程 希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。 例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样(竖着的元素是步长组成)： 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 然后我们对每列进行排序： 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45

希尔排序

由 核能气质少年 提交于 2020-01-31 14:37:43
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。 希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。 def shellSort(arr): n = len(arr) gap = int(n/2) while gap > 0: for i in range(gap,n): temp = arr[i] j = i while j >= gap and arr[j-gap] >temp: arr[j] = arr[j-gap] j -= gap arr[j] = temp gap = int(gap/2) arr = [ 12, 34, 54, 2, 3] n = len(arr) print ("排序前:") for i in range(n): print(arr[i]), shellSort(arr) print ("\n排序后:") for i in range(n): print(arr[i]) 执行以上代码输出结果为： 排序前: 12 34 54 2 3 排序后: 2 3 12 34 54 参考https://www.runoob.com/python3/python3-examples.html 来源： https:/

my39_InnoDB锁机制之Gap Lock、Next-Key Lock、Record Lock解析

由 自古美人都是妖i 提交于 2020-01-26 21:22:16
MySQL InnoDB支持三种行锁定方式： 行锁（Record Lock）:锁直接加在索引记录上面，锁住的是key。 间隙锁（Gap Lock）: 锁定索引记录间隙，确保索引记录的间隙不变。间隙锁是针对事务隔离级别为可重复读或以上级别而已的。 Next-Key Lock ：行锁和间隙锁组合起来就叫Next-Key Lock。 默认情况下，InnoDB工作在可重复读隔离级别下，并且会以Next-Key Lock的方式对数据行进行加锁，这样可以有效防止幻读的发生。 Next-Key Lock是行锁和间隙锁的组合，当InnoDB扫描索引记录的时候，会首先对索引记录加上行锁（Record Lock），再对索引记录两 边的间隙加上间隙锁（Gap Lock）。加上间隙锁之后，其他事务就不能在这个间隙修改或者插入记录。 Gap Lock在InnoDB的唯一作用就是防止其他事务的插入操作，以此防止幻读的发生。 行锁（Record Lock） 行锁锁定的是索引记录，而不是行数据，也就是说锁定的是key。 间隙锁（Gap Lock） 例如： create table test(id int,v1 int,v2 int,primary key(id),key `idx_v1`(`v1`))Engine=InnoDB DEFAULT CHARSET=UTF8; insert into test

2020 新年倒计时

由 |▌冷眼眸甩不掉的悲伤 提交于 2020-01-26 09:20:46
效果显示 <!DOCTYPE html> < html lang = " en " > < head > < meta charset = " UTF-8 " > < meta name = " viewport " content = " width=device-width, initial-scale=1.0 " > < meta http-equiv = " X-UA-Compatible " content = " ie=edge " > < title > Document </ title > < style > * { margin : 0 ; padding : 0 ; } h1 { margin : 200px auto ; text-align : center ; } span { color : purple ; } </ style > </ head > < body > < h1 style =" color : pink " > 2020新年倒计时： < span > </ span > 天 < span > </ span > 小时 < span > </ span > 分 < span > </ span > 秒 </ h1 > < script > var goalDate = new Date ( 2020 , 0 , 24 ) ; var

深入了解mysql--gap locks,Next-Key Locks

由 时光毁灭记忆、已成空白 提交于 2020-01-25 22:47:42
Next-Key Locks Next-Key Locks是在存储引擎innodb、事务级别在 可重复读 的情况下使用的数据库锁，官网上有介绍，Next-Key Locks是行锁和gap锁的组合。行锁是什么我们都很清楚，这篇文章主要简单分析一下mysql中的gap锁是什么。innodb默认的锁就是Next-Key locks。 GAP锁 gap锁，又称为间隙锁。存在的主要目的就是为了防止在 可重复读 的事务级别下，出现幻读问题。 在可重复读的事务级别下面，普通的select读的是快照，不存在幻读情况，但是如果加上for update的话，读取是已提交事务数据，gap锁保证for update情况下，不出现幻读。 那么gap锁到底是如何加锁的呢？ 假如是for update级别操作，先看看几条总结的何时加锁的规则。 唯一索引 精确等值检索，Next-Key Locks就退化为记录锁，不会加gap锁 范围检索，会锁住where条件中相应的范围，范围中的记录以及间隙，换言之就是加上记录锁和gap 锁（至于区间是多大稍后讨论）。 不走索引检索，全表间隙加gap锁、全表记录加记录锁 非唯一索引 精确等值检索，Next-Key Locks会对间隙加gap锁（至于区间是多大稍后讨论），以及对应检索到的记录加记录锁。 范围检索，会锁住where条件中相应的范围，范围中的记录以及间隙

希尔排序

由 試著忘記壹切 提交于 2020-01-24 14:54:15
希尔排序 **时间复杂度：**最好 O(N) 最坏 O(n ^ 2) 稳定性： 比较时加了" = "，则不稳定，否则稳定 实现： 组内直接插入排序，最后看成一组，进行插入排序。 思想与直接插入排序类似，不过增量变成了组的差值（这是因为在进行组内排序） 分组-》组内插入排序-》最后看成一组 代码示例： public static void shell ( int [ ] array , int gap ) { for ( int i = gap ; i < array . length ; i ++ ) { int tmp = array [ i ] ; int j = i - gap ; for ( ; j >= 0 ; j -= gap ) { if ( array [ j ] > tmp ) { array [ j + gap ] = array [ j ] ; } else { break ; } } array [ j + gap ] = tmp ; } } public static void shellSort ( int [ ] array ) { //这里先分为5组，再分为3组，之后看成一组 int [ ] drr = { 5 , 3 , 1 } ; for ( int i = 0 ; i < drr . length ; i ++ ) { shellSort (

Algorithm01-八大排序

由 。_饼干妹妹 提交于 2020-01-22 05:42:06
1.八大排序 2.冒泡排序 static void bubbling ( int [ ] arr ) { final int length = arr . length ; for ( int i = 0 ; i < length - 1 ; i ++ ) { for ( int j = 0 ; j < length - i - 1 ; j ++ ) { if ( arr [ j ] > arr [ j + 1 ] ) { int t = arr [ j ] ; arr [ j ] = arr [ j + 1 ] ; arr [ j + 1 ] = t ; } } } } 3.插入排序 static void insertion ( int [ ] arr ) { final int length = arr . length ; for ( int i = 1 ; i < length ; i ++ ) { //&& arr[j] < arr[j - 1]，排序过后前面的数已经有序 //arr[j] < arr[j - 1]，前面已经有序，所以前面肯定没有比arr[j]大的数 //这样减少内层循环 for ( int j = i ; j > 0 && arr [ j ] < arr [ j - 1 ] ; j -- ) { if ( arr [ j ] < arr [ j - 1

处理Dataguard日志传输gap一例

由 梦想的初衷 提交于 2020-01-22 01:00:43
文章目录 制造gap 从主库进行增量SCN的备份 在备库上恢复 后续检查 制造gap 在主库上停止向备库传输日志 SQL> alter system set log_archive_dest_state_2=defer scope=memory; System altered. 在主库进行几次日志切换，并将切换的日志删除，在错误备库的错误日志中可以看到： Archived Log entry 20 added for thread 1 sequence 123 rlc 913820033 ID 0x55ec8100 dest 2: Tue Jan 21 10:58:49 2020 Fetching gap sequence in thread 1, gap sequence 120-121 Tue Jan 21 11:00:40 2020 FAL[client]: Failed to request gap sequence GAP - thread 1 sequence 120-121 DBID 1441600768 branch 913820033 FAL[client]: All defined FAL servers have been attempted. ----------------------------------------------------------

数据结构与算法之排序算法

由 橙三吉。 提交于 2020-01-21 15:03:38
排序 内部排序 插入排序 直接插入排序 希尔排序 选择排序 简单选择排序 堆排序 交换排序 冒泡排序 快速排序 归并排序 基数排序 外部排序 内部排序 插入排序 直接插入排序 是对于欲排序的元素以插入的方式找寻元素的适当位置，以达到排序的目的 思路: 插入排序（Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。 如上图，我们所说的有序表是前面有括号包着的表，后面是无序表。我们每一次都把无序表的第一个元素插入到有序表中，并与有序表的最后一个元素比较，如果比它大就查到后面去，如果比它小，就一个一个往前比较，直到找到位置位置。 代码实现 // 插入排序 public static void insertSort ( int [ ] arr ) { // 使用逐步推导的方式来讲解，便于理解 // 从最后一个开始 遍历到最后一个 for ( int i = 1 ; i < arr . length ; i ++ ) { // 定义待插入的数 int insertVal = arr [ i ] ; int insertIndex = i - 1 ; /

【数据结构22】希尔排序

由 梦想与她 提交于 2020-01-18 08:17:38
1. 希尔排序介绍 2. 希尔排序思路 3. 代码实现 3.1 交换法 希尔排序推导过程： public class ShellSort { public static void main ( String [ ] args ) { int [ ] arr = { 8 , 9 , 1 , 7 , 2 , 3 , 5 , 4 , 6 , 0 } ; System . out . println ( "排序前：" + Arrays . toString ( arr ) ) ; shellSort ( arr ) ; } public static void shellSort ( int [ ] arr ) { int temp = 0 ; //第一轮排序:将10个数据分成5组 for ( int i = 5 ; i < arr . length ; i ++ ) { //如果当前元素大于步长后面的那个元素，说明交换 for ( int j = i - 5 ; j >= 0 ; j -= 5 ) { if ( arr [ j ] > arr [ j + 5 ] ) { temp = arr [ j ] ; arr [ j ] = arr [ j + 5 ] ; arr [ j + 5 ] = temp ; } } } System . out . println ( "第1轮：" )
订阅 gap