向已是升序排列的数组a中加入一个数x，使该数组仍保持升序排列的程序段如下。 Dim j%, n%, i% n = ___

选B，主要关键字必须指定。

首先你 应该 自己 去 debug 、 、 、才更明白 、、
for (int i = 0; i < shu.length-1; i++) {
for (int j = 0; j shu[j+1]){
int tem = shu[j];
shu[j] = shu[j + 1];
shu[j + 1] = tem;
}
} //这就是冒泡排序的 .、 二重循环 、 、 、 、
}
首先 其实原理就是、
它是一个二重循环 、 、 外层循环控制比较多少轮、内层控制比较的次数、、
int j = 0; j

假设数据0-9在A列,那么在B1-B10输入公式=COUNTIF(A:A,"0")记得将公式后面双引号里面的数字改为0-9,然后将B列进行升序排列就行了

struct student* sx(struct student * head)
{ // 用递归，每次找出原链表中学号最小的元素，插入到新链表的后面。
struct student *cursor, *first, *prev, *min;
first = NULL;

if (head == NULL)
return NULL;

for (cursor = min = head; cursor->next != NULL; cursor = cursor->next)
{
if (cursor->next->num < min->num)
{
prev = cursor;
min = cursor->next;
}
}

first = min;

if (min == head)
head = head->next;
else
prev->next = min->next;

first->next = sx(head);

return first;
}

这条公式
=INDEX($A$1:$A$100,MATCH(LARGE($B$1:$B$100-ROW($B$1:$B$100)/10^4,ROW(1:1)),$B$1:$B$100-ROW($B$1:$B$100)/10^4,),)
试试看

merge sort的一个子程序(假设两个数列是由小到大的)
void merge(int arr1[],int arr2[],int arr3[],int len1,int len2){
//arr1,arr2表示两个数组.arr3是新数组,且长度足够
//len1:arr1的长度 len2同理
int i=0,j=0,pos=0;
for(;i

D
冒泡排序算法的运作如下：（从后往前）
比较相邻的元素.如果第一个比第二个大,就交换他们两个.
对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数.
针对所有的元素重复以上的步骤,除了最后一个.
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较.

3次.先把58和46调换,再把11和34调换,最后调换11和23.

这个分为4个函数写吧 第一个用stdlib库函数产生四位整数然后,然后构成一个链表,在传递链表的头指针给素数选出函数,判断链表节点是否为素数,留下素数.然后构成了一个新的链表,但是头指针依然没变,在把头指针用在排序函数.最后输出链表时控制格式.主要用的知识点就是1怎样产生4位整数,2链表的基本操作,3排序的方法有哪些,4顺序控制.

C语言源代码：
#include "stdio.h"
/* 对数组startIndex位置起,长度为length的元素进行逆序排列 */
void sort(int arr[],int startIndex,int length)
{
int i,j,k;
int temp;
for(i=0; i

每次以第一个为轴
3,2,3,9,8,7,4,6
2,3,3,9,8,7,4,6
2,3,3,6,8,7,4,9
2,3,3,4,6,7,8,9

请贴出具体的表结构
一般是这样的
select * from tableA order by col1 desc,col2 asc;
先按col1降序,相同则按col2 升序

冒泡和快速排序的区别在于：冒泡算法，每次比较如果发现较小的元素在后面，就交换两个相邻的元素。将待排序的元素看作是竖着排列的"气泡"，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个"气泡"序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即"轻"的元素在下面，就交换它们的位置。显然，处理一遍之后，"最轻"的元素就浮到了最高位置；处理二遍之后，"次轻"的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是"最轻"元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。而选择排序算法的改进在于：先并不急于调换位置，先从A[1]开始逐个检查，看哪个数最小就记下该数所在的位置P，等一躺扫描完毕，再把A[P]和A[1]对调，这时A[1]到A[10]中最小的数据就换到了最前面的位置。 所以，选择排序每扫描一遍数组，只需要一次真正的交换，而冒泡可能需要很多次。比较的次数是一样的。 其实看你声明的变量的个数就知道了。选择的要比冒泡的多声明一个，用来存储最小（或最大的）元素的下标。而冒泡的比较后直接换。

1.17,18,20,60,32,70,65,25,73
2.17,18,20,32,60,65,25,70,73
3.17,18,20,32,60,25,65,70,73
4.17,18,20,32,25,60,65,70,73
5.17,18,20,25,32,60,65,70,73
6.17,18,20,25,32,60,65,70,73

C

你没说用什么编啊,我是vb编的
一
Private Sub Command1_Click()
Dim c() As Single
al = LBound(a)
ae = UBound(a)
bl = LBound(b)
be = UBound(b) - bl
ReDim c(ae - al + 1 + be)
cl = 0
Do
If al > ae Then
c(cl) = b(bl)
cl = cl + 1
bl = bl + 1
ElseIf bl > be Then
c(cl) = a(al)
cl = cl + 1
al = al + 1
ElseIf a(al) < b(bl) Then
c(cl) = a(al)
cl = cl + 1
al = al + 1
Else
c(cl) = b(bl)
cl = cl + 1
bl = bl + 1
End If
Loop Until al > ae And bl > be
end sub
二
Private Sub Command1_Click()
Dim a(1 To 100) As Integer
Dim b() As Integer
List1.Clear
List2.Clear
For i = 1 To 100
a(i) = Rnd() * 21
List1.AddItem a(i)
If a(i) 0 Then
bn = bn + 1
ReDim Preserve b(bn)
b(bn) = a(i)
List2.AddItem a(i)
End If
Next i
Label1 = "共产生了" & 100 - bn & "个零."
End Su

简单选择排序：13,40,63,83,84,35,96
直接插入：40,83,63,13,84,35,96
希尔排序,增量未知,下面是按照增量3作为第一趟的结果：
13,40,35,83,84,63,96
冒泡排序,用大数下沉的结果：
40,63,13,83,35,84,96
快速排序,以最左元素作为基准：
35,40,63,13,83,84,96
二路归并排序：40,83,13,63,35,84,96

2 2 6

从1到2n的连续自然数选n个数出来,他们的大小关系就唯一确定了
于是只要考虑从1到2n的连续自然数中选出n个数有多少种就是了
就是C（2n,n)种

例如把12345678任选4个就有C（8,4）=8*7*6*5/(4*3*2*1)=70种

2,6,8,9,3,7,4,3
2,3,8,9,6,7,4,3
2,3,3,9,6,7,4,8
2,3,3,4,6,7,9,8
2,3,3,4,6,7,9,8
2,3,3,4,6,7,9,8
2,3,3,4,6,7,8,9

第一趟:(35),78,12,26,90,41,66,58 第二趟:(35,78),12,26,90,41,66,58 第三趟:(12,35,78),26,90,41,66,58 第四趟:(12,26,35,78),90,41,66,58

index on 1000-语文 to aa
在前面加上负号(或用一个数来减)就是降序

不知是否是将具有同样分数的记录达到2条或以上的记录检索出来？如果是这样，实现代码如下:
select * from CJB,
(select 分数 from CJB
group by 分数 having count(分数)>1)t
where CJB.分数=t.分数
order by CJB.分数;
如果我的理解有误差，请追问。

堆作为满二叉树,应该是用数组来实现的那么root作为大根堆的最大元素位于data【0】,其他的元素不管此时做堆排序,删除root,保存在tmp变量中调整堆,那么原来的堆的大小减一,数组最后一位空出赋以tmp那么最大元素位于数组尾部以此类推. 查看原帖

合并两个序列后,排序,则[L/2]处的数就是中位数了!

order by 升序字段 asc,降序字段 desc

人家要插入排序,你用冒泡排序,真晕阿

一23,19,30,45,19,12
二12,19,30,45,19,23
三12,19,23,45,19,30
四12,19,19,45,23,30
五12,19,19,23,45,30
六12,19,19,23,30,45
ok

C n 3 分之 1 就行了
你只要在N个数中随即选三个数字出来 那三个数字看做是自动排列 加上分之一 使之作为分母 就可以了
n!/(6(n-3)!)

我的算法是：对该二维数组排序,排成从小到大的有序二维数组,比如a[3][3]={{1,5,2},{2,3,9{,{0,4,8}},那么排序后就是a[3][3] = {{0,1,2},{2,3,4},{5,8,9}},就满足要求了.

因为作者虽然天资有限,但是对于求学求知一直抱着坚持不懈的态度,遇到问题一定向更有学问的人请教,靠自己谦虚的学习态度和后天的不懈的努力,所以增长了自己的知识.

Dim a(100) As Integer,num As Integer
Private Sub Command1_Click()
Dim k As Integer
Open App.Path & "in4.dat" For Input As #1
For k = 1 To 60
Input #1,a(k)
Text1 = Text1 + Str(a(k)) + Space(2)
Next k
Close #1
End Sub
Private Sub Command2_Click()
num = InputBox("请输入一个数")
End Sub
Private Sub Command3_Click()
For i = 1 To 60
'If num < a(i) Then exit for
Next i
For j = 60 To i step=-1
a(j + 1) =a(j)
Next j
a(i)= num
Text1 = ""
'以下程序段将插入后的数组A重新显示在Text1中
'For k = 1 To 61
Text1 = Text1 + Str(a(k)) + Space(2)
Next k
End Sub
这段程序其实有点问题,它不能实现连续插入数字,只能插入一个数字.

Private Sub Form_Click() Dim arr(1 To 20), brr(), i, j, n, s Cls For i = 1 To UBound(arr) s = InputBox("输入一个正整数", i) arr(i) = s If Val(s) Mod 2 = 0 Then ...

其实就是大于、小于、小于等于、大于等于的意思
用例子来说的话,设数列{an}
若符合a(n+1)>an,则数列的递增的,也是升序的
若符合a(n+1)

polynomal.h--
#include
#include
#include"math.h"
struct Term
{
x05float coef;
x05int exp;
x05Term *link;
x05Term(float c,int e,Term *next=NULL)
x05{
x05x05coef=c;
x05x05exp=e;
x05x05link=next;
x05}
x05Term *InsertAfter(float c,int e);
x05friend ostream& operatorcoef,q->exp);
x05q=q->link;
x05p=p->link;
}
return *this;
}
istream& operator >> (istream& in,Polynomal& x)
{
x05 Term *rear = x.first;x05
float c;
int e,a;
x05 int size=0;
x05 couta) break;x05
x05 size++;
x05x05rear = rear->InsertAfter(c,e);x05
x05 }
x05 return in;
};
ostream& operator link;
x05 out coef;x05x05x05 x05
x05x05 x05 if ( fabs(temp) > 0.001)
x05x05 pc = pc->InsertAfter(temp,pa->exp);
x05x05 pa = pa->link; pb = pb->link;
x05x05x05 }
x05 else
x05x05 x05 if (pa->exp < pb->exp)
x05x05x05 {
x05x05x05 pc = pc->InsertAfter(pa->coef,pa->exp);
x05x05x05 pa = pa->link;x05x05x05x05x05
x05x05x05 }
x05x05 else
x05x05x05 {x05 x05
x05x05x05 pc = pc->InsertAfter(pb->coef,pb->exp);
x05x05x05 pb = pb->link;x05x05x05x05x05
x05x05x05 }x05
x05x05x05 }
p = (pa != NULL)?pa :pb;
while (p != NULL)
x05x05 {
x05x05 pc = pc->InsertAfter(p->coef,p->exp);
x05x05 p = p->link;
x05x05 }
x05x05x05 return C;
};
Polynomal operator *(Polynomal& A,Polynomal& B)
{
Term *pa,*pb,*pc;
int AL,BL,k,maxExp;
Polynomal C;
pc=C.getHead();
AL=A.maxOrder();
BL=B.maxOrder();
if(AL!=-1||BL!=-1)
{
x05 maxExp=AL+BL;
float *result=new float[maxExp+1];
for(int i=0;ilink ;
x05 while(pa!=NULL)
x05 {
x05x05 pb=B.getHead()->link ;
x05x05 while(pb!=NULL)
x05x05 {
x05x05x05 k=pa->exp+pb->exp ;
x05x05x05 result[k]=result[k]+(pa->coef)*(pb->coef) ;
x05x05x05 pb=pb->link ;
x05x05 }
x05x05 pa=pa->link ;
x05 }
x05 for(i=0;i0.001)
x05x05x05 pc=pc->InsertAfter (result[i],i);
x05 }
x05x05 delete []result;
}
pc->link =NULL;
return C;
};
polynomal.cpp--
#include"polynomal.h"
#include
void main()
{
x05Polynomal p1;
x05cin>>p1;
x05cout

H55的公式用整列引用,如=SUM(C:C)

template
void merge(SeqList& A, SeqList& B, SeqList& C)
{
int a=0,b=0,c=0, Alength=A.length(),Blength=B.length(),Adata,Bdata;
while(a

旁边空白列输入
=rand()
填充到底
选中这两列,以rand那列为主要关键字排序

意思就是如果有2047个数，二分查找定位一个数最多需要11次（2^11-1=2047，2的11次幂减1是2047），同理在4096个数中定位一个数最多需要12次（2^12是12个2相乘）。因为2047

修改一下你的数据所在的列的单元格格式.将其改为数值型后再排序就好了.

/D表示降序
/A表示升序(不写/A也表示升序）

A. 保持原始次序

Sub Macro1()

With ActiveSheet.UsedRange
.Replace what:="A", Replacement:="10", LookAt:=xlWhole, _
SearchOrder:=xlByRows, MatchCase:=False, SearchFormat:=False, _
ReplaceFormat:=False

.Sort Key1:=Range("C2"), Order1:=xlAscending, Key2:=Range("B2") _
, Order2:=xlAscending, Header:=xlGuess, OrderCustom:=1, MatchCase:= _
False, Orientation:=xlTopToBottom, SortMethod:=xlPinYin, DataOption1:= _
xlSortNormal, DataOption2:=xlSortNormal

.Replace what:="10", Replacement:="A", LookAt:=xlWhole, _
SearchOrder:=xlByRows, MatchCase:=False, SearchFormat:=False, _
ReplaceFormat:=False

End With

End Su

//hipi亲自测试通过，供参考。时间优化已经做到。

//输入 0 0 退出

#include
#include
using namespace std;
long a[100],b[1000001],num;
int main()
{
int n,m,i,j,left,right,mid,flag;
while(scanf("%d %d",&n,&m)!=EOF)
{
if(!n&&!m) break;
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
for(i=1;i<=m;i++)
scanf("%d",&b[i]);
for(i=0;i{
num=b[i+1];
left=1;right=n;
flag=0;mid=0;
while(left<=right)
{
mid=(right+left)/2;
if(a[mid]>num) right=mid-1;
else if(a[mid] else if(a[mid]==num) {flag=1;break;}
}
if(flag)
printf("yesn");
else printf("non");
}
}
return 0;
}

排序之后是1 5 5 7 8 21 23 45 87,8是第五个

出这个题的人弱智.
冒泡可以从左到右遍历,也可以从右到左遍历.这个想怎么实现都可以,出题人说选c就是从右到左的遍历结果,a是从左到右的遍历结果.题目又没说采用什么方式,如果这是考试题目的话,这样出题就是弱智.除非这个教材上的习题,他的冒泡流程在正文讲的,这样才可以.