3*3的方格里有1-8八个数字和一个空格，通过移动可以使其按时针排序。这种游戏的vb代码应怎么写

Question

移动数字排序
1．算法说明
在3*3的9个方格中，空出中间的格，其余八个格上任意填入数字1到8（注意：每个数字仅能填入一个点，不能重复）；1的位置固定不动，然后移动其余的数字，直至数字1到8按照顺时针从小到大排好序为止。
移动的规则是：只能将数字沿线移向空白的点。
3．功能要求
启动程序后，在“输入原始数字”下方的各文本框中任意输入数字1到8（空出中间的点）。单击“确定”按钮，开始按照自行设计的算法自动移动数字（注意：数字1的位置固定不动），直至按照要求排好序停止。
（1）在“数字移动过程”下方的列表框中显示每次移动后数字的排列情况，其中0表示空位（注意：只能将数字沿线移向空白的点）。
（2）移动完成后的结果显示在“移动后的结果”下方的个文本框中。
（3）移动次数显示在“移动次数”文本框中。

Answer 1

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#include<iostream>
#include<iomanip>
#include<ctime>//调用时间种子
using namespace std;

#define M 1000 //数值范围
#define N 20 //待排序记录的个数

int R[N+1];
int i,j;
/*
typedef struct
{
int key; //关键字
AnyType other; //记录的其他数据域
}RecType;
RecType R[N+1]; //R[0]不存放记录，留作它用
*/
/********* 输出函数***********/
void display()
{
for(i=1;i<=N;i++)
{
printf("%6d",R[i]);
if(0==i%10)
cout<<endl;
}
cout<<endl;
}
/*****************************************************/
//①------------直接插入排序--------------------
void StrInsSort(int R[],int n)
{
//本算法利用监视哨对R[]进行直接插入排序
int i,j;
for (i=2;i<=n;i++)//假定第一个有序
{
R[0]=R[i];//将待排序元素放进监视哨
j=i-1;//从后向前查找插入位置，同时后移以已记录数据
while (R[0]<R[j])
{
R[j+1]=R[j];//记录后移
j--;
}
R[j+1]=R[0];//将待排序插入合适位置
}
}
/*****************************************************///②------------折半查找排序--------------------
void BinSort(int R[],int n)
{
int i,j,low,high,m;
for (i=2;i<=n;i++) //假定第一个记录有序
{
R[0]=R[i]; //将待记录项暂存到R[0]中
low=1;high=i-1; //设置折半查找的位置
//在R[low,high]中折半查找
while (low<=high)
{
m=(low+high)/2; //折半
if(R[0]<R[m])
high=m-1; //插入点在低半区
else
low=m+1; //插入点在高半区
}
for(j=i-1;j>=high+1;j--)//记录后移
R[j+1]=R[j];
R[high+1]=R[0];//插入
}
}
/*****************************************************/
//③-------------希尔排序--------------------------
void ShellSort(int R[], int n)
{
int i,j,d;
//以步长Di/2分组的希尔排序，第一个步长取n/2，最后取
for (d=n/2;d>=1;d=d/2)
for (i=1+d;i<=n;i++) //将R[i]插入到合适的位置去
{
R[0]=R[i];
j=i-d;
while (j>0 && R[0]<R[j])
{
R[j+d]=R[j];
j=j-d;
}
R[j+d]=R[0]; //将第i个元素插在合适位置
}
}// end of ShellSort
/*****************************************************/
//④----------冒泡排序------------------
void BubbleSort(int R[],int n)
{
int i,j,lastexchange;
//i指示无序序列最后一个记录的位置
for(i=1;i<n;i++)
{
lastexchange=1;
for (j=1;j<=n-i;j++)
if (R[j]>R[j+1])
{
R[0]=R[j];
R[j]=R[j+1];
R[j+1]=R[0];
lastexchange=0;
}
if(lastexchange)
break;
}
}
/*****************************************************/
//⑤--------------选择排序------------------
void SelectSort(int R[],int n)
{
int i,j,k;
for (i=1;i<n;i++)//选择第i小的数，并交换到位
{
k=i;//假定第i个因素最小
for(j=i+1;j<n;j++)
if (R[j]<R[k])
k=j;
if (i!=k)//交换
{
R[0]=R[i];
R[i]=R[k];
R[k]=R[0];
}
}
}
/*****************************************************/
//--------堆的调整技术(筛选)----------
void Shift(int R[],int i,int m)
{
// 已知R[i..m]中记录的关键字除R[i] 之外均满足堆的特征，
// 本函数自上而下调整R[i],使R[i..m] 也成为一个大顶堆
int j;
R[0]=R[i]; // 暂存“根”记录R[s]
for (j=i*2;j<=m;j*=2)
{
if(j<m&&R[j]<R[j+1])// 左/右“子树根”之间先进行相互比较
j++; // j 为关键字较大孩子记录的位置
if(R[0]<R[j])
{ // 再做“根”和“子树根”之间的比较
R[i]=R[j]; // 双亲小,将R[j]调整到其双亲位置i
i=j; // 尚需继续往下调整,指针后移
} // j最终指向需与堆顶交换的结点的位置
else break; // 否则说明已找到堆顶记录R[0]的插入位置i,退出for循环
}
R[i]=R[0]; // 将调整前的堆顶记录放入正确位置i
}

//⑥------------堆排序---------------------
void HeapSort(int R[],int n)
{ //对记录R[1..n] 进行堆排序
int i;
for (i=n/2;i>0;i--) //把R[1..n]初始建成大顶堆
Shift(R,i,n);
for (i=n;i>1;i--)
{
R[0]=R[1]; //将堆顶记录和当前未经排序子序列
R[1]=R[i]; //R[1..i]中最后一个记录相互交换
R[i]=R[0];
Shift(R,1,i-1); //对R[1..i-1]进行筛选重新调整为大顶堆
}
}
/*****************************************************/
//------将两个有序子序列归并成一个较大的有序序列-------
void Merge(int R[],int R1[],int l,int m,int h)
{
//将有序序列R[l..m]R[m+1..h]归并成有序序列R[l..h]

int i,j,k,t;
for (i=l,j=m+1,k=l; i<=m && j<=h; k++)
//l为R[i..m]的位序,j为R[m+1..h]位序,k为R1[i..h]的位序
//将R中的记录从小到大并入R1
if(R[i]<=R[j])
R1[k]=R[i++];
else R1[k]=R[j++];

if(i<=m)
for(t=k;t<=h;t++)//将剩余的R[i..m]并入R1
R1[t]=R[i++];
if(j<=h)
for(t=k;t<=h;t++)//将剩余的R[j..h]并入R1
R1[t]=R[j++];

for(t=l;t<=h;t++) //R[l..h]=R1[l..h]
R[t]=R1[t];
}
//⑦--------------二路归并排序----------------
void MSort(int R[],int R1[],int s,int t)
{ //将R[s..t]进行二路归并排序为R[s..t]
int m;
if(s<t)

{
m=(s+t)/2;//将R[s..t]平均分为R[s..m]和R[m+1..t]两段
MSort(R,R1,s,m); //递归归并排序R[s..m]
MSort(R,R1,m+1,t);//递归归并排序R[m+1..t]
Merge(R,R1,s,m,t);
}
// return;
}
void MergeSort(int R[],int n)
{
MSort(R,R,1,n);
}
/*****************************************************/
//⑧----------递归选择排序------------------
void RecursiveSelectSort(int R[],int n)
{ int j,t,max,maxi;
if(n!=1)
{ max=R[1];maxi=1;
for(j=2;j<=n;j++)
if (R[j]>max) {max=R[j];maxi=j;}
// if (maxi!=n) {t=R[n];R[n]=R[maxi];R[maxi]=t;}
if (maxi!=n) {R[maxi]=R[n];R[n]=max;}
RecursiveSelectSort(R,n-1);
// cout<<"!! k="<<k<<" !!"<<endl;
}
}
/*****************************************************/
//⑨----------递归冒泡排序------------------
void RecursiveBubbleSort(int R[],int n)
{ int j,t;
if(n!=1)
{ for(j=1;j<n;j++)
if (R[j]>R[j+1]) {t=R[j];R[j]=R[j+1];R[j+1]=t;}
RecursiveBubbleSort(R,n-1);
// cout<<"!! k="<<k<<" !!"<<endl;
}
}
/*****************************************************/
//⑩-------------递归直接插入排序-------------------
void RecursiveInsSort(int R[],int n)
{ int j,t;
if(n!=1)
{ RecursiveInsSort(R,n-1);
t=R[n];
for(j=n-1;j>=1;j--)
if (t<R[j]) R[j+1]=R[j];
else break;
R[j+1]=t;
// cout<<"!! k="<<k<<" !!"<<endl;
}
}
/*****************************************************/
//--------------- 一次划分---------------
int Partition(int R[],int l,int h)
{
//交换记录子序列R[l...h]的记录，使枢轴记录到位，并返回其位置
//此时，在他之前的记录均不大于他
int i=l,j=h,x;//记录待排序的记录的首尾位置
R[0]=R[i];//以字表的第一个记录为枢轴，将其暂时存在R[0]中
x=R[i];
while (i<j)
{
//从表两端交替的向中间扫描
while (i<j && R[j]>=x)
j--;
R[i]=R[j];//将比枢轴小的移到低端
while(i<j && R[i]<=x)
i++;
R[j]=R[i];//将比枢轴大的移到高端
}
R[i]=R[0];
return i;//返回枢轴位置
}
//(11)-------------快速排序-------------------
void QuickSort(int R[],int s,int t)
{
//对记录序列R[s...t]进行快速排序
int k;
if(s<t)
{
k=Partition(R,s,t);
QuickSort(R,s,k-1);
QuickSort(R,k+1,t);
}
}

/***************** 主函数******************/
int main()
{
int select;
srand((unsigned)time(NULL)); //使用时间种子，让每次产生的随机数不相同
for(i=1;i<=N;i++)
R[i]=(rand()%M); //产生一组随机数

cout<<"【1】直接插入排序"<<endl;
cout<<"【2】折半查找排序"<<endl;
cout<<"【3】希尔排序"<<endl;
cout<<"【4】冒泡排序"<<endl;
cout<<"【5】选择排序"<<endl;
cout<<"【6】堆排序"<<endl;
cout<<"【7】二路归并排序"<<endl;
cout<<"【8】递归选择排序"<<endl;
cout<<"【9】快速冒泡排序"<<endl;
cout<<"【10】递归直接插入排序"<<endl;
cout<<"【11】快速排序"<<endl;
cout<<"================================"<<endl;
//cout<<"请选择：";
//cin>>select;
cout<<endl;
for(select=1;select<=8;select++)
{
switch(select)
{
case 1:
StrInsSort(R,N);
cout<<"【1】直接插入排序："<<endl;
display();
break;
case 2:
BinSort(R,N);
cout<<"【2】折半查找排序："<<endl;
display();
break;
case 3:
ShellSort(R,N);
cout<<"【3】希尔排序："<<endl;
display();
break;
case 4:
BubbleSort(R,N);
cout<<"【4】冒泡排序："<<endl;
display();
break;
case 5:
SelectSort(R,N);
cout<<"【5】选择排序："<<endl;
display();
break;
case 6:
HeapSort(R,N);
cout<<"【6】堆排序："<<endl;
display();
break;
case 7:
MergeSort(R,N);
cout<<"【7】二路归并排序："<<endl;
display();
break;
case 8:
RecursiveSelectSort(R,N);
cout<<"【8】递归选择排序："<<endl;
display();
case 9:
RecursiveBubbleSort(R,N);
cout<<"【9】快速冒泡排序："<<endl;
display();
case 10:
RecursiveInsSort(R,N);
cout<<"【10】递归直接插入排序："<<endl;
display();
case 11:
QuickSort(R,1,N);
cout<<"【11】快速排序："<<endl;
display();
}
}
return 0;
}本回答被提问者和网友采纳

Answer 2

25