• 关于 GAP 的搜索结果

回答

#include <stdio.h> #include <stdlib.h> #include <time.h> #define MAX 100 #define SWAP(x,y) {int t; t = x; x = y; y = t;} void shellsort(int[]); int main(void) { int number[MAX] = {0}; int i; srand(time(NULL)); printf("排序前:"); for(i = 0; i < MAX; i++) { number[i] = rand() % 100; printf("%d ", number[i]); } printf("\n"); shellsort(number); return 0; } void shellsort(int number[]) { int i, j, k, gap, t; gap = MAX / 2; while(gap > 0) { for(k = 0; k < gap; k++) { for(i = k+gap; i < MAX; i+=gap) { for(j = i - gap; j >= k; j-=gap) { if(number[j] > number[j+gap]) { SWAP(number[j], number[j+gap]); } else break; } } } printf("\ngap = %d:", gap); for(i = 0; i < MAX; i++) printf("%d ", number[i]); printf("\n"); gap /= 2; } }

沉默术士 2019-12-02 01:18:40 0 浏览量 回答数 0

回答

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

游客ejnn55cgkof5g 2020-02-14 19:41:37 0 浏览量 回答数 0

回答

简单的insert会在insert的行对应的索引记录上加一个排它锁,这是一个record lock,并没有gap,所以并不会阻塞其他session在gap间隙里插入记录。不过在insert操作之前,还会加一种锁,官方文档称它为insertion intention gap lock,也就是意向的gap锁。这个意向gap锁的作用就是预示着当多事务并发插入相同的gap空隙时,只要插入的记录不是gap间隙中的相同位置,则无需等待其他session就可完成,这样就使得insert操作无须加真正的gap lock。假设有一个记录索引包含键值4和7,不同的事务分别插入5和6,每个事务都会产生一个加在4-7之间的插入意向锁,获取在插入行上的排它锁,但是不会被互相锁住,因为数据行并不冲突。假设发生了一个唯一键冲突错误,那么将会在重复的索引记录上加读锁。当有多个session同时插入相同的行记录时,如果另外一个session已经获得该行的排它锁,那么将会导致死锁。

hiekay 2019-12-02 01:42:08 0 浏览量 回答数 0

云原生Knative训练营

免费开通产品,还有CNCF指尖陀螺等你拿哦~

回答

//About_C团队解答 //VC6.0环境下编译通过,希望满意(因为你没要求语言,所以我就用C++了) //任何问题,追问我哦 ^_^ #include<iostream> #include<fstream> using namespace std; #define N 5 typedef struct node{ int key; char data; }Node; void ShellSort( Node data[], int n){ Node tmp; int gap; gap = n / 2; while( gap > 0){ for( int i = gap; i < n; i++){ tmp = data[i]; for( int j = i - gap; j >= 0; j -= gap){ if( data[j].key > tmp.key){ data[j+gap] = data[j]; }else{ break; } } data[j+gap] = tmp; } gap /= 2; } } int main(){ Node data[N] = { 5, 'a', 4, 'b', 3, 'c', 2, 'b', 1, 'a'}; ShellSort( data, N); for( int i = 0; i < N; i++){ cout << data[i].key << ":" << data[i].data<< "\t"; } cout << endl; return 0; }

寒凝雪 2019-12-02 01:19:13 0 浏览量 回答数 0

问题

请问在mysql innodb 下read-committed存在gap lock吗?

落地花开啦 2019-12-01 19:46:47 1756 浏览量 回答数 1

回答

以下版本适用于任何大小的表格(不仅限于100行): SELECT (t1.id + 1) as gap_starts_at, (SELECT MIN(t3.id) -1 FROM arrc_vouchers t3 WHERE t3.id > t1.id) as gap_ends_at FROM arrc_vouchers t1 WHERE NOT EXISTS (SELECT t2.id FROM arrc_vouchers t2 WHERE t2.id = t1.id + 1) HAVING gap_ends_at IS NOT NULL gap_starts_at -当前差距的第一个ID gap_ends_at -当前间隙中的最后一个ID来源:stack overflow

保持可爱mmm 2020-05-11 11:03:39 0 浏览量 回答数 0

回答

参考mysql官方文档的说明 http://dev.mysql.com/doc/refman/5.5/en/innodb-record-level-locks.htmlread-committed隔离级别,gap Lock不生效。官网说的,应该不会有错,可以做实验测试下。Gap locking can be disabled explicitly. This occurs if you change the transaction isolation level to READ COMMITTED or enable the innodb_locks_unsafe_for_binlog system variable. Under these circumstances, gap locking is disabled for searches and index scans and is used only for foreign-key constraint checking and duplicate-key checking.

扛雷来了 2019-12-02 01:41:26 0 浏览量 回答数 0

回答

对于高并发数据库访问所需要采取的架构措施1 java 事务尽量减短,禁止在事务里调用远程接口2 建议数据库事务级别为,read commitd. 如果使用read repeated,会数据库多产生一个gap锁,gap锁主要防治幻读, mysql 默认tx锁是对已经存在的数据,比如update delete. 但是insert 的数据是无法判断的,因为是未来发生的事情,为了保证事务读取事务刚开始的数据,mysql提供了gap锁. 这个也是产生死锁的原因.3 使用分布式锁,同样的数据同一时候只有一个请求在做事情

1210119897362579 2019-12-02 00:22:25 0 浏览量 回答数 0

回答

Sub shellsort(ByRef a() As Single) '希尔排序算法,对数组a进行排序         Dim i, j, gap As Integer         Dim k, x, n As Integer         n = UBound(a)         gap = Int(n / 2)         While gap > 0             For i = gap + 1 To n                 j = i - gap                 While j > 0                     If a(j) < a(j + gap) Then                         x = a(j)                         a(j) = a(j + gap)                         a(j + gap) = x                         j = j - gap                     Else                         j = 0                     End If                 End While             Next i             gap = Int(gap / 2)         End While     End Sub

寒凝雪 2019-12-02 01:19:11 0 浏览量 回答数 0

回答

Record lock:单个行记录上的锁Gap lock:间隙锁,锁定一个范围,不包括记录本身Next-key lock:record+gap 锁定一个范围,包含记录本身

剑曼红尘 2020-03-31 11:02:21 0 浏览量 回答数 0

回答

MyISAM和InnoDB存储引擎使用的锁: MyISAM 采用表级锁(table-level locking)。 InnoDB 支持行级锁(row-level locking)和表级锁,默认为行级锁 表级锁和行级锁对比: 表级锁: Mysql中锁定粒度最大的一种锁,对当前操作的整张表加锁,实现简单,资源消耗也比较少,加锁快,不会出现死锁。其锁定粒度最大,触发锁冲突的概率最高,并发度最低,MyISAM和 InnoDB引擎都支持表级锁。 行级锁: Mysql中锁定粒度最小的一种锁,只针对当前操作的行进行加锁。行级锁能大大减少数据库操作的冲突。其加锁粒度最小,并发度高,但加锁的开销也最大,加锁慢,会出现死锁。 InnoDB存储引擎的锁的算法有三种: Record lock:单个行记录上的锁 Gap lock:间隙锁,锁定一个范围,不包括记录本身 Next-key lock:record+gap 锁定一个范围,包含记录本身 相关知识点: innodb对于行的查询使用next-key lock Next-locking keying为了解决Phantom Problem幻读问题 当查询的索引含有唯一属性时,将next-key lock降级为record key Gap锁设计的目的是为了阻止多个事务将记录插入到同一范围内,而这会导致幻读问题的产生 有两种方式显式关闭gap锁:(除了外键约束和唯一性检查外,其余情况仅使用record lock) A. 将事务隔离级别设置为RC B. 将参数innodb_locks_unsafe_for_binlog设置为1

pandacats 2019-12-23 10:36:32 0 浏览量 回答数 0

回答

我近期做练习的时候专门为排序做了一个c程序,你看看怎么样,包括了很多排序方法 #include<stdio.h> #include<stdlib.h> #include<time.h> #define LEN 10 //初始化数组 void init(int *arr,int len); //打印数组元素 void print(int *arr,int len); //打印堆元素 void printH(int *arr,int len); //交换两个整数的值 void swap(int &a,int &b); //简单插入排序 void inserts(int *arr,int len); //冒泡排序 void bubbles1(int *arr,int len); //简单选择排序 void selects(int *arr,int len); //快速排序 void quicks(int *arr,int low,int high); //希尔排序 void shells(int *arr,int len); //归并 void merge(int *a,int len1,int *b,int len2,int *c); int main() { int arr[LEN],brr[LEN],crr[2*LEN]; srand((unsigned)time(NULL)); init(arr,LEN); print(arr,LEN); bubbles1(arr,LEN); print(arr,LEN); init(arr,LEN); print(arr,LEN); selects(arr,LEN); print(arr,LEN); init(arr,LEN); print(arr,LEN); inserts(arr,LEN); print(arr,LEN); init(arr,LEN); print(arr,LEN); quicks(arr,0,LEN); print(arr,LEN); init(arr,LEN); init(brr,LEN); print(arr,LEN); print(brr,LEN); shells(arr,LEN); shells(brr,LEN); merge(arr,LEN,brr,LEN,crr); print(crr,2*LEN); return 0; } //初始化数组 void init(int *arr,int len) { int i; for(i=0;i<len;i++) { arr[i]=rand()%1000; } } //打印数组元素 void print(int *arr,int len) { int i; printf("\n"); for(i=0;i<len;i++) printf("%4d ",arr[i]); printf("\n"); } //打印堆元素 void printH(int *arr,int len) { int i; printf("\n"); for(i=0;i<len;i++) printf("%4d ",arr[i]); printf("\n"); } //交换两个整数的值,^功能为异或,相同0,相异1 void swap(int &a,int &b) { a=a^b; b=a^b; a=a^b; } //插入排序 void inserts(int *arr,int len) { int i,j,temp; for(i=1;i<len;i++) { temp=arr[i]; for(j=i-1;j>=0&&arr[j]>temp;j--) arr[j+1]=arr[j]; arr[j+1]=temp; } } //冒泡排序 void bubbles1(int *arr,int len) { int i,j,exchange; exchange=0; for(i=0;i<len-1;i++) { for(j=0;j<len-i-1;j++) { if(arr[j]>arr[j+1]) { swap(arr[j],arr[j+1]); exchange=1; } } if(!exchange) break; } } //简单选择排序 void selects(int *arr,int len) { int i,j,temp; for(i=0;i<len-1;i++) { temp=i; for(j=i+1;j<len;j++) { if(arr[j]<arr[temp]) { temp=j; } } if(temp!=i) { swap(arr[temp],arr[i]); } } } //快速排序 void quicks(int *arr,int low,int high) { int temp,l,r; if(low<high) { l=low; r=high; temp=arr[low]; while(low<high) { while(low<high&&arr[high]>=temp) high--; if(low<high) arr[low]=arr[high]; while(low<high&&arr[low]<=temp) low++; if(low<high) arr[high]=arr[low]; } arr[low]=temp; quicks(arr,l,low-1); quicks(arr,low+1,r); } } //希尔排序 void shells(int *arr,int len) { int i,j,gap; for(gap=len/2;gap>0;gap/=2) //步长 for(i=gap;i<len;i++) for(j=i-gap;j>=0&&arr[j]>arr[j+gap];j-=gap) swap(arr[j],arr[j+gap]); } //两有序数组合并 void merge(int *a,int len1,int *b,int len2,int *c) { int i=0,j=0,k=0; while(i<len1&&j<len2) { if(a[i]<=b[j]) { c[k]=a[i]; k++; i++; } else { c[k]=b[j]; k++; j++; } } if(i<len1) c[k++]=a[i++]; else if(j<len2) c[k++]=b[j++]; }

美人迟暮 2019-12-02 01:17:27 0 浏览量 回答数 0

问题

GAP锁为什么要锁住索引间的区间,而不是直接锁住值相等的就行了? 400 报错

爱吃鱼的程序员 2020-05-30 22:27:23 0 浏览量 回答数 1

问题

mysql 死锁

paulzhu8597 2019-12-01 19:43:51 865 浏览量 回答数 0

回答

隔离级别RR开的有点高,一般开RC就够了。mysql的RR不是完全基于mvcc的Snapshot Isolation,而是mvcc+lock混合实现的,比如有范围查询,mysql会上gap lock,如果有unindexed row update,即使只有一个row行匹配,RR模式下update也会持有多个lock,直到事务结束。“还有mysql默认是自动提交,如果不加事务的话,每个select sql都会自动的开启事务和提交事务,开销是不是要比都放在一个事务里要高?” 这个问题要看具体情况,定性的分析下如果pure read,RR或者RC,那么多个select一起提交跟每个select提交一次,性能相差不会太大,每个事物申请txID的时候在mysql内部会有并发冲突,但这个时间跟sql解析,查询优化,磁盘IO跟,可以忽略;读写混合场景,如果多个select放一个事务,要看这个batch读事务,跟包含写操作的事务之间有没有锁冲突;假如是RR(不要以为MVCC了就没有锁冲突,范围查询也有gap lock),冲突的可能性比较大,那最好每个select单独提交,如果RC应该区别不大。

小六码奴 2019-12-02 02:02:10 0 浏览量 回答数 0

回答

个人见解,MVCC多版本并发控制,不能解决幻读。 幻读, 默认的事务隔离级别是REPEATABLE READ。采用Next-Key Locking的算法。 Next-Key Locking( Record Lock + Gap Lock ) 锁定一个范围,并且锁定记录本身 。 主键Id加record锁,是锁定记录本身,如果解决幻读不能直接加 Gap Lock  ######可重复度的事务隔离级别好像不能解决幻读吧,但是next-key确实可以解决幻读。###### 有意思 到底能不能啊######我也不知道,这个问题提出来后,总说纷纭,我还去stackoverflow上提问了,也没人回答,然后只好去看看了看官方文档,官方文档关于幻读得解决只提到了next-key。应该没有解决的吧。

kun坤 2020-06-08 15:04:06 0 浏览量 回答数 0

问题

将要就读的硕士可以报名吗?

陈键飞 2019-12-01 21:43:28 4443 浏览量 回答数 2

回答

参考答案: 我们可以使用两个指针而不是一个指针。第一个指针从列表的开头向前移动 n+1 步,而第二个指针将从列表的开头出发。现在,这两个指针被 n 个结点分开。我们通过同时移动两个指针向前来保持这个恒定的间隔,直到第一个指针到达最后一个结点。此时第二个指针将指向从最后一个结点数起的第 n 个结点。我们重新链接第二个指针所引用的结点的 next 指针指向该结点的下下个结点。 参考代码: { ListNode dummy = new ListNode(0); dummy.next = head; ListNode first = dummy; ListNode second = dummy; // Advances first pointer so that the gap between first and second is n nodes apart for (int i = 1; i <= n + 1; i++) { first = first.next; } // Move first to the end, maintaining the gap while (first != null) { first = first.next; second = second.next; } second.next = second.next.next; return dummy.next; } 复杂度分析: 时间复杂度:O(L),该算法对含有 L 个结点的列表进行了一次遍历。因此时间复杂度为 O(L)。 空间复杂度:O(1),我们只用了常量级的额外空间。

Runt 2020-04-14 18:27:34 0 浏览量 回答数 0

回答

这个next-key就是RR级别下才会出现的一个锁。虽然你指定where字句里面有id=2。貌似只要锁定一行记录就行了。其实RR的事务级别就要求不出现幻读。就是要避免你在id=2和id=3之间再插入其他的id=2的记录。所以他就会锁住id=2的next key中间的gap不知道我这么说是否清楚。

五月华斩 2019-12-01 23:40:18 0 浏览量 回答数 0

回答

InnoDB存储引擎的锁有两种,一种是表锁(table-level locking),一种是行锁(row-level locking),默认是行锁,你说的三种算法是指行锁算法: 1) Record Lock:单个行记录上的锁 2) Gap Lock:间隙锁,锁定一个范围,但不包含记录本身 3) Next-Key Lock:Gap Lock+Record Lock,锁定一个范围,并且锁定记录本身。 这个可以参考这篇文档 https://www.jianshu.com/p/f3868e608c8c 而表锁的算法则不同,分为写锁和读锁, 写锁的实现机制是,如果在表上没有锁(读锁或写锁),则在表上加一个写锁,否则就把写锁请求放在写锁队列中。 读锁的实现机制是,如果在表上没有写锁,把一个读锁定放在它上面,否则就把读锁请求放在读锁定队列中。 当一个锁被释放时,写锁队列中的线程会优先获取写锁,读锁队列中的线程则是后获取锁,这意味着,如果一个表上有许多更新,SELECT语句将一直等待,知道没有新的写请求。

豪三 2020-03-31 15:22:09 0 浏览量 回答数 0

问题

tensorflow LSTM时间序列预测问题?报错

爱吃鱼的程序员 2020-06-08 13:26:46 0 浏览量 回答数 1

回答

#include<stdio.h> #include<stdlib.h> #include <math.h> #define L 8 //排序元素个数 #define FALSE 0 #define TRUE 1 typedef struct { int key; char otherinfo; }RecType; typedef RecType Seqlist[L+1]; int num; //定义排序趟数的全局变量 Seqlist R; //直接插入排序 void Insertsort() { int i,j,k,m=0; printf("\n\t\t原始数据为(按回车键开始排序):\n\t\t"); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); for(i=2;i<=L;i++) { if(R[i].key<R[i-1].key) { R[0]=R[i]; j=i-1; while(R[0].key<R[j].key) { R[j+1]=R[j]; j--; } R[j+1]=R[0]; } m++; printf("\t\t第%d趟排序结果为(按回车键继续):\n\t\t",m); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); } printf("\n\t\t排序的最终结果是:\n\t\t"); for(i=1;i<=L;i++) { printf("%5d",R[i].key); } printf("\n"); } //希尔排序 void Shellsort() { int i,j,gap,x,m=0,k; printf("\n\t\t原始数据为(按回车键开始排序):\n\t\t"); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); gap=L/2; while(gap>0) { for(i=gap+1;i<=L;i++) { j=i-gap; while(j>0) { if(R[j].key>R[j+gap].key) { x=R[j].key; R[j].key=R[j+gap].key; R[j+gap].key=x; j=j-gap; } else { j=0; } } } gap=gap/2; m++; printf("\t\t第%d趟排序结果为(按回车键开始排序):\n\t\t",m); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); } printf("\n\t\t排序的最终结果是:\n\t\t"); for(i=1;i<=L;i++) { printf("%5d",R[i].key); } printf("\n"); } //冒泡排序 void Bubblesort() { int i,j,k; int exchange; printf("\n\t\t原始数据为(按回车键开始排序):\n\t\t"); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); for(i=1;i<L;i++) { exchange=FALSE; for(j=L;j>=i+1;j--) { if(R[j].key<R[j-1].key) { R[0].key=R[j].key; R[j].key=R[j-1].key; R[j-1].key=R[0].key; exchange=TRUE; } } if(exchange) { printf("\t\t第%d趟排序结果为(按回车键开始排序):\n\t\t",i); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); } } printf("\n\t\t排序的最终结果是:\n\t\t"); for(i=1;i<=L;i++) { printf("%5d",R[i].key); } printf("\n"); } int Partition(int i,int j) //i和j为形式参数,分别代表low和high { RecType pirot=R[i]; while(i<j) { while(i<j&&R[j].key>=pirot.key) { j--; } if(i<j) { R[i++]=R[j]; } while(i<j&&R[j].key<=pirot.key) { i++; } if(i<j) { R[j--]=R[i]; } } R[i]=pirot; return i; } //递归形式为快速排序 void Quicksort(int low,int high) { int pirotpos,k; if(low<high) { pirotpos=Partition(low,high); num++; printf("\t\t第%d趟排序结果为(按回车键开始排序):\n\t\t",num); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); Quicksort(low,pirotpos-1); Quicksort(pirotpos+1,high); } } //选择排序 void Selectsort() { int i,j,k,h; printf("\n\t\t原始数据为(按回车键开始排序):\n\t\t"); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); for(i=1;i<L;i++) { h=i; for(j=i+1;j<=L;j++) { if(R[j].key<R[h].key) { h=j; } } if(h!=j) { R[0]=R[i]; R[i]=R[h]; R[h]=R[0]; } printf("\t\t第%d趟排序结果为(按回车键开始排序):\n\t\t",i); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); } printf("\n\t\t排序的最终结果是:\n\t\t"); for(i=1;i<=L;i++) { printf("%5d",R[i].key); } printf("\n"); } void Merge(int low,int mm,int high) { int i=low,j=mm+1,p=0; RecType *R1; R1=new RecType[high-low+1]; if(!R1) { printf("内存容量不够。"); } while(i<=mm&&j<=high) { R1[p++]=(R[i].key<=R[j].key)?R[i++]:R[j++]; } while(i<=mm) { R1[p++]=R[i++]; } while(j<=high) { R1[p++]=R[j++]; } for(p=0,i=low;i<=high;p++,i++) { R[i]=R1[p]; } } void MergePass(int length) { int i; for(i=1;i+2*length-1<=L;i=i+2*length) { Merge(i,i+length-1,i+2*length-1); } if(i+length-1<L) { Merge(i,i+length-1,L); } } //归并排序 void Mergesort() { int length,k,m=0,i; printf("\n\t\t原始数据为(按回车键开始排序):\n\t\t"); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); for(length=1;length<L;length*=2) { MergePass(length); m++; printf("\t\t第%d趟排序结果为(按回车键开始排序):\n\t\t",m); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); } printf("\n\t\t排序的最终结果是:\n\t\t"); for(i=1;i<=L;i++) { printf("%5d",R[i].key); } printf("\n"); } //堆建 void CreateHeap(int root,int index) { int j,temp,finish; j=2*root; temp=R[root].key; finish=0; while(j<=index&&finish==0) { if(j<index) { if(R[j].key<R[j+1].key) { j++; } } if(temp>=R[j].key) { finish=1; } else { R[j/2].key=R[j].key; j=j*2; } } R[j/2].key=temp; }//堆排序 void Heapsort() { int i,j,temp,k; for(i=(L/2);i>=1;i--) { CreateHeap(i,L); } for(i=L-1,k=1;i>=1;i--,k++) { temp=R[i+1].key; R[i+1].key=R[1].key; R[1].key=temp; CreateHeap(1,i); printf("\t\t第%d趟排序结果为(按回车键开始排序):\n\t\t",k); for(j=1;j<=L;j++) { printf("%5d",R[j].key); } getchar(); printf("\n"); } } void Heap() { int i; printf("\n\t\t原始数据为(按回车键开始排序):\n\t\t"); for(i=1;i<=L;i++) { printf("%5d",R[i].key); } getchar(); printf("\n"); Heapsort(); printf("\n\t\t排序的最终结果是:\n\t\t"); for(i=1;i<=L;i++) { printf("%5d",R[i].key); } printf("\n"); } main() { Seqlist S; int i,k; char ch1,ch2,q; printf("\n\t\t1000个随机数产生:\n\t\t"); for(i=1;i<=1000;i++) { S[i].key = rand() % 999 + 1; //产生1-1000的随机数 //printf("%d\n", number); // 去掉注释显示随机数的输出} printf("\n\t\t排序数据已经输入完毕。"); ch1='y'; while(ch1=='y'||ch1=='Y') { printf("\n"); printf("\n\t\t 排 序 子 系 统 \n"); printf("\n\t\t*******************************************\n"); printf("\n\t\t* 1--------更新排序数据 *\n"); printf("\n\t\t* 2--------直接插入排序 *\n"); printf("\n\t\t* 3--------希 尔 排 序 *\n"); printf("\n\t\t* 4--------冒 泡 排 序 *\n"); printf("\n\t\t* 5--------快 速 排 序 *\n"); printf("\n\t\t* 6--------选 择 排 序 *\n"); printf("\n\t\t* 7--------归 并 排 序 *\n"); printf("\n\t\t* 8--------堆 排 序 *\n"); printf("\n\t\t* 0--------返 回 *\n"); printf("\n\t\t*******************************************\n"); printf("\n\t\t 请选择菜单号(0--8):"); scanf("%c",&ch2); getchar(); for(i=1;i<=L;i++) { R[i].key=S[i].key; } switch(ch2) { case '1': printf("\n\t\t请输入%d个待排序数据(按回车键分隔):\n\t\t",L); for(i=1;i<=L;i++) { scanf("%d",&S[i].key); getchar(); printf("\t\t"); } printf("\n\t\t排序数据已经输入完毕。"); break; case '2': Insertsort(); break; case '3': Shellsort(); break; case '4': Bubblesort(); break; case '5': printf("\n\t\t原始数据为(按回车键开始排序):\n\t\t"); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } getchar(); printf("\n"); num=0; Quicksort(1,L); printf("\n\t\t排序的最终结果是:\n\t\t"); for(k=1;k<=L;k++) { printf("%5d",R[k].key); } printf("\n"); break; case '6': Selectsort(); break; case '7': Mergesort(); break; case '8': Heap(); break; case '0': ch1='n'; break; default: system("cls"); printf("\n\t\t 对不起,您的输入有误,请重新输入。\n"); break; } if(ch2!='0') { if(ch2=='2'||ch2=='3'||ch2=='4'||ch2=='5'||ch2=='6'||ch2=='7'||ch2=='8') { printf("\n\n\t\t排序输出完毕。"); printf("\n\t\t按回车键返回。"); q=getchar(); if(q!='\xA') { getchar(); ch1='n'; } } } } }

沉默术士 2019-12-02 01:18:58 0 浏览量 回答数 0

回答

选择排序 #include <iostream> using namespace std; void select_sort(int arr[], int num); void output_array(int arr[], int num); int main() {     int a[10];     for(int i=0; i<10; i++)     {         cin>>a[i];     }     select_sort(a,10);     output_array(a,10);     return 0; } void select_sort(int array[],int n) //形参array是数组名 {     int i,j,k,t;     for(i=0; i<n-1; i++)     {         k=i;  //先设第i个就为最小         for(j=i+1; j<n; j++)             if(array[j]<array[k])                 k=j;   //通过循环,得到k为最小         t=array[k];    //交换a[i]和a[k]         array[k]=array[i];         array[i]=t;     }     return; } void output_array(int arr[], int num) {     int i;     for(i=0; i<num; i++)     {         cout<<arr[i];         cout<<endl;     }     return; } 2.冒泡排序 #include<stdio.h> int main() { int i,j,a[10],t; for(i=0;i<10;i++) scanf("%d",&a[i]); for(i=0;i<10;i++) for(j=i+1;j<10;j++) if(a[i]>a[j]) { t=a[j]; a[j]=a[i]; a[i]=t; } for(i=0;i<10;i++) printf("%d ",a[i]); return 0; } 3.堆排序 #include<iostream> using namespace std; void  paidui(int a[20],int i,int m) { int k,t;     t=a[i];  k=2*i+1;     while (k<m)     {         if ((k<m-1)&&(a[k]<a[k+1]))  k++;    if (t<a[k])  { a[i]=a[k];  i=k;  k=2*i+1; }         else break;  }     a[i]=t; } void duipai(int a[20], int n)   { int i,k;  for (i=n/2-1;i>=0;i--)  paidui(a,i,n);      for (i=n-1; i>=1; i--)     {   k=a[0];  a[0]=a[i];  a[i]=k;   paidui(a,0,i);     }} int main()  {   int a[10],i;  for(i=0;i<10;i++)   cin>>a[i]; duipai(a,10);  for(i=0;i<10;i++) cout<<a[i]<<endl; } 4.快速排序 #include<iostream> using namespace std; void Quicksort(int a[],int low,int high) {     if(low>=high)     {         return;     }     int first=low;     int last=high;     int key=a[first];     while(first<last)     { while(first<last&&a[last]>=key)             --last;         a[first]=a[last];         while(first<last&&a[first]<=key)             ++first;         a[last]=a[first]; }     a[first]=key;     Quicksort(a,low,first-1);     Quicksort(a,last+1,high); } int main() {     int i,a[100],x,n=0; while(cin>>x) { a[n]=x; n++; } n--; Quicksort(a,0,n); for(i=0;i<=n;i++) cout<<a[i]<<" "; cout<<endl;     return 0; } 5. 基数排序 #include <stdio.h> #include <stdlib.h> int main(){ int data[10]={73,22,93,43,55,14,82,65,39,81};        //对十个数进行排序 int temp[10][10]={0};        //构造一个临时二维数组,其值为0 int order[10]={0};        //构造一维数组,其值为0 int i,j,k,n,lsd; k=0;n=1; for (i=0;i<10;i++) printf("%d ",data[i]);         //在排序前,对这10个数打印一遍 putchar('\n'); while (n<=10){ for (i=0;i<10;i++){ lsd=((data[i]/n)%10);         //lsd先对个位取余,然后再对十位取余,注意循环 temp[lsd][order[lsd]]=data[i];        //temp[3][0]=73,temp[2][0]=22,temp[3][1]=93,temp[3][2]=43,⋯⋯ order[lsd]++;        //需要区分的是lsd和order[lsd],这两个不是一样的概念嗷 } printf("\n重新排列: "); for (i=0;i<10;i++){ if(order[i]!=0) for (j=0;j<order[i];j++){ data[k]=temp[i][j]; printf("%d ",data[k]); k++; } order[i]=0; } n*=10; //第二次用十位 k=0; } putchar('\n'); printf("\n排序后: "); for (i=0;i<10;i++) printf("%d ",data[i]); return 0; } 6.希尔排序 #include<iostream> using namespace std; void shell_sort(int a[],int n); int main() {     int n,a[10000];     cin>>n;     for(int y=0;y<n;y++)         cin>>a[y];     shell_sort(a, n);       for(int i=0; i<n; i++)           cout<<a[i]<<" ";       cout<<endl; } void shell_sort(int a[], int n) {     int gap,k,temp;//定义增量;     for(gap = 3; gap >0; gap--)//设置初始增量,递减;     {         for(int i=0; i<gap; i++)//按增量分组;         {             for(int j = i+gap; j<n; j=j+gap)//每组分别比较大小;             {                 if(a[j]<a[j-gap])                 {                     temp = a[j];                     k = j-gap; while(k>=0&&a[k]>temp)                     {                         a[k+gap] = a[k];                         k = k-gap;                     }                     a[k+gap] = temp;                 }             }         }     } } 7.归并排序 #include<iostream> using namespace std; void MergeSort(int p[],int s,int m,int t) {      int q[100];                        //q[100]用来存放排好的序列  int i=s;  int j=m+1;  int k=s; while(i<=m&&j<=t)  {  if(p[i]<=p[j])  q[k++]=p[i++];  else  q[k++]=p[j++];  }  if(i<=m)  while(i<=m)  q[k++]=p[i++];  else while(j<=t)  q[k++]=p[j++];  for(int n=s;n<=t;n++)              p[n]=q[n]; }  void Merge(int p[],int s,int t)  {  if(s<t)  {  int m=(s+t)/2;  //将数组分成两半  Merge(p,s,m);//递归拆分左数组  Merge(p,m+1,t);//递归拆分右数组  MergeSort(p,s,m,t);//合并数组      }  }  int main()  {      int n;  int p[100];  cin>>n;   for(int i=0; i<n; i++)          cin>>p[i];  Merge(p,0,n-1);  for(int j=0;j<n;j++)  cout<<p[j]<<" ";  cout<<endl;  return 0;  } 排序方法基本就这些,还有双向冒泡这种拓展的排序方法,还有直接排序如桶排序

祁同伟 2019-12-02 01:17:24 0 浏览量 回答数 0

问题

阿里二面之MVCC能不能解决幻读?:报错

kun坤 2020-06-08 11:05:39 2 浏览量 回答数 1

问题

阿里二面之MVCC能不能解决幻读?

因为相信,所以看见。 2020-05-22 21:38:44 3 浏览量 回答数 1

回答

innodb在rr级别上的gap锁是为了解决幻读的问题 你说的相等值,其实就是rc级别的行级锁,只能避免不可重复读######回复 @bboo:嗯,理解,确实是,谢了!######回复 @爱吃大肉包:我的意思是对于你这100030这数据的话,锁住一行就可以了.但是显然,只锁住一行是解决不了幻读的问题的,就如我刚才举的例子,删除一个不存在的索引举无法锁住一行.间隙锁是在性能和并发之间做一个取舍######回复 @bboo:不知道我理解是否有问题,我理解的插入引起的幻读就是updateusersetname='tt'whereuserId='100030';影响行数就是1行,第二次2行。如果改成select...forupdate,就是每次查出的记录都是一样的。所以我才得出,只要锁住单条记录就行了。你列举的'8888888'好像并没影响我的执行结果######回复 @bboo:索引直接不存在,更不用谈加锁了,解决幻读只能通过间隙锁住100040-正无穷来控制8888888这个索引字段的插入.而rc级别下就会通过行锁保证可重复读innodb通过这些配置实际上隔离级别高了一个标准######回复 @爱吃大肉包:你考虑下删除的情况,比如你删除88888888的时候,这条数据不存在.

优选2 2020-06-09 16:03:39 0 浏览量 回答数 0

回答

innodb在rr级别上的gap锁是为了解决幻读的问题 你说的相等值,其实就是rc级别的行级锁,只能避免不可重复读######回复 @bboo : 嗯, 理解,确实是,谢了!######回复 @爱吃大肉包 : 我的意思是对于你这100030这数据的话,锁住一行就可以了.但是显然,只锁住一行是解决不了幻读的问题的,就如我刚才举的例子,删除一个不存在的索引举无法锁住一行.间隙锁是在性能和并发之间做一个取舍######回复 @bboo : 不知道我理解是否有问题,我理解的插入引起的幻读就是 update user set name ='tt' where userId='100030';影响行数就是1行,第二次2行。 如果改成select ...for update, 就是每次查出的记录都是一样的。 所以我才得出,只要锁住单条记录就行了。 你列举的 '8888888' 好像并没影响我的执行结果######回复 @bboo : 索引直接不存在,更不用谈加锁了,解决幻读只能通过间隙锁住 100040-正无穷 来控制8888888这个索引字段的插入. 而rc级别下就会通过行锁保证可重复读 innodb通过这些配置实际上隔离级别高了一个标准######回复 @爱吃大肉包 : 你考虑下删除的情况,比如你删除88888888的时候,这条数据不存在.

爱吃鱼的程序员 2020-05-30 22:27:23 0 浏览量 回答数 0

问题

支付宝当面付接口,官方的demo无法正常请求,返回“无效签名” : 配置报错 

kun坤 2020-06-04 13:15:32 3 浏览量 回答数 1

问题

十大经典排序算法最强总结(内含代码实现)

游客pklijor6gytpx 2020-01-09 14:44:55 1240 浏览量 回答数 2

问题

POI 4.1.0 Line-Chart Y系列显示错误的图例

小六码奴 2019-12-01 21:48:50 12 浏览量 回答数 1
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 云栖号物联网 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站 云栖号弹性计算 阿里云云栖号 云栖号案例 云栖号直播