挑战数组腾挪大法

samhoo

下面几个贴子将整理参与该题目，且已给出的可编译执行代码的解答。
可以编译执行的有：samhoo, 离了水的蛤蟆, beggar
wwjxjtu和(fake)aegis的代码无法编译通过，暂无法整理

samhoo

samhoo的解答。

一)算法说明
  left = 0&#59; right = n - 1&#59;
1)比较L[left]和X, 如果小于X, left加1, 重复本步骤&#59; 如果等于X跳到步骤2&#59; 如果大于X, 跳到步骤3.
2)比较L[left]以右的数, 如果小于X,交换之, left加1, 重复本步骤&#59; 如果等于X, left加1, 重复本步骤&#59; 如果大于X, 跳到步骤3.
3)做法与步骤1相似, right向左移动.
4)做法与步骤2相似, right向左移动.
5)交换L[left], L[right]&#59;跳到步骤1）
上述步骤都会对边界进行检查。

二）编译器/运行平台，机器类型
cc/sco OpenServer 5.05, intel 1.2GMhz

三）Partition函数代码
/*
* L：输入数组
* n：数组大小
* X：X元素
* 返回X在数组中的下标
*/
int  Partition(long *L, int n, long X)
{

   int left = 0, left_ep = 0, right = n -1, right_ep = n - 1&#59;

   /* 大数:大于X的数&#59; 小数:小于X的数 */
   while(left < right){
       /* 找到左边用于交换的大数 */
       while( (L[left] <= X) &amp;&amp; (left < right) ){
           if (L[left] < X){ /* 如果是小数,向右移动 */
               left++&#59;
               left_ep++&#59;
           }
           else{
               while((L[left] == X) &amp;&amp; (left <= right)) left++&#59;

               if (left >; right)
                   break&#59;

               SWAP(L, left, left_ep)&#59;
               if (L[left] < X){
                   left++&#59;
                   left_ep++&#59;
               }
               else
                   left = left_ep&#59;
           }
       }
   
       /* 找到右边用于交换的小数 */
       while( (L[right] >;= X) &amp;&amp; (left < right) ){
           if (L[right] >; X){  /* 如果是大数,向左移动 */
               right--&#59;
               right_ep--&#59;
           }
           else{
               while((L[right] == X) &amp;&amp; (left <= right)) right--&#59;

               if (left >; right) break&#59;

               SWAP(L, right, right_ep)&#59;

               if (L[right] >; X){
                   right--&#59;
                   right_ep--&#59;
               }
               else
                   right = right_ep&#59;
           }
       }

       /* 交换 */
       if (left < right){
           SWAP(L, left, right)&#59;
           left++&#59;
           left_ep++&#59;
           right--&#59;
           right_ep--&#59;
       }
   }
   return left_ep&#59;
}


long *CreateList(int n)
/* Allocates memory for an array of n longs */
{
  long *L&#59;

  L = (long *) malloc( n * sizeof(long) )&#59;
  if( L == NULL) { /* Exit program if memory cannot be allocated */
     printf(&quot;\nCannot allocate enough memory for list.\n&quot&#59;
     exit(0)&#59;
  }

  return (L)&#59;
}

long *MakeRandomList(int *num)
{
  long *L&#59;               /* pointer to List */
  unsigned int seed&#59;     /* seed for random number generator */
  int i&#59;                 /* index of for loop */

  printf(&quot;\nNumber of elements to sort=>;&quot&#59;
  scanf(&quot;%d&quot;,num)&#59;

  printf(&quot;Seed for random number generator (integer)=>;&quot&#59;
  scanf(&quot;%d&quot;,&amp;seed)&#59;
  srand(seed)&#59;

  /* Allocate memory for # of elements. If memory cannot be allocated,
     display message and terminate program. Read in the elements. */
  L = CreateList(*num)&#59;
  if (L == NULL) {
     printf(&quot;\nCannot allocate enough memory for number list.\n&quot&#59;
     exit(0)&#59;
  }
  for (i = 0&#59; i < *num&#59; ++i)
     L = rand()&#59;

  return(L)&#59;           /* Return the List */
}

int Check(long *L, int num, int X, int position)
{
  int i, lpos = -1, rpos = -1&#59;
  
  for (i = 0&#59; i < num&#59; i++)
    if (L == X){
      lpos = i&#59;
      break&#59;
    }
    else if (L >; X)
      return -1&#59;

  for (i = num - 1&#59; i >;= 0&#59; i--)
    if (L == X){
      rpos = i&#59;
      break&#59;
    }
    else if (L < X)
      return -1&#59;
            
  if ((lpos == -1) || (rpos == -1) || (position < lpos) || (position >;rpos))
    return -1&#59;

  for (i = lpos&#59; i <=rpos&#59; i++)
    if (L != X)
      return -1&#59;

  return 0&#59;
}

int SWAP(long *L, int a, int b)
{
  long temp&#59;

  temp = L[a]&#59;
  L[a] = L&#59;
  L = temp&#59;
  return 0&#59;
}


四）至少给出前4组测试数据的结果
   i  )L[]={5,5,5,5,5,5,7,1,6,8}&#59; n=10&#59; X=5&#59; （在main函数提供，注释掉其中一些语句即可）
X=5
L[]=5 5 5 5 5 5 7 1 6 8
-----------------------------------------------------------------
Check :correct.
Time  : 0.000 seconds.
-----------------------------------------------------------------
position=1
L[]=1 5 5 5 5 5 5 7 6 8


   
   ii )n=10的随机数组
Number of elements to sort=>;10
Seed for random number generator (integer)=>;1
X=31051
L[]=16838 5758 10113 17515 31051 5627 23010 7419 16212 4086
-----------------------------------------------------------------
Check :correct.
Time  : 0.000 seconds.
-----------------------------------------------------------------
position=9
L[]=16838 5758 10113 17515 5627 23010 7419 16212 4086 31051


   
   iii)n=10,000,000的随机数组
Number of elements to sort=>;10000000
Seed for random number generator (integer)=>;1
X=5500
L[]=16838 5758 10113 17515 31051 5627 23010 7419 16212 4086 2749 12767 9084 1206
0 32225 17543 25089 21183 25137 25566 26966 ...(too much number, ignore)
-----------------------------------------------------------------
Check :correct.
Time  : 2.440 seconds.
-----------------------------------------------------------------
position=1678846
L[]=2266 2127 2110 1762 626 1023 4566 2197 572 4086 2749 4060 1120 2206 2836 293
5 3375 3800 3392 4703 2069 ...(too much number, ignore)


   iv )n=50,000,000随机数组
Number of elements to sort=>;50000000
Seed for random number generator (integer)=>;1
X=16413
L[]=16838 5758 10113 17515 31051 5627 23010 7419 16212 4086 2749 12767 9084 1206
0 32225 17543 25089 21183 25137 25566 26966 ...(too much number, ignore)
-----------------------------------------------------------------
Check :correct.
Time  : 38.350 seconds.
-----------------------------------------------------------------
position=25052130
L[]=3827 5758 10113 7067 1970 5627 10035 7419 16212 4086 2749 12767 9084 12060 6
42 4478 5374 2400 10405 7411 10487 ...(too much number, ignore)



   v  ）其他自己认为具有“边界”特性的数组。
   none

samhoo

经整理的“离开水的蛤蟆”的解答，仍有部分数组未能应付。
（如果有理解错误的地方，请指正）


一）算法说明
两头向中间找不属于那个位置的数据，从左边开始找到的是大于目标数据（X）的位置，从右边开始找到的是小于X的位置，把他们互换。
如果遇到等于X的数，找出其后最后一个顺序适合的数，将他们进行互换。
这样向中间逼近，就能吧X放到合适的位置上。

二）编译运行平台，机器类型/主频
cc/sco OpenServer 5.05, intel 1.2GMhz

三）Partition函数代码
/*
* L：输入数组
* n：数组大小
* X：X元素
* 返回X在数组中的下标
*/
int  Partition(long *L, int n, long X)
{
int   MAX_SIZE = n&#59;
long  OBJECT_NUMBER = X&#59;
long  *my_array = L&#59;
int   last_less_room, last_more_room,
object_current_room, temp_room&#59;

for (last_less_room = 0, last_more_room = MAX_SIZE -1 &#59;
last_less_room < last_more_room&#59
  {
    while (my_array[last_less_room] < OBJECT_NUMBER) last_less_room ++&#59;
    while (my_array[last_more_room] >; OBJECT_NUMBER) last_more_room --&#59;
    if (last_less_room >;= last_more_room)
{
break&#59;
}

    if (my_array[last_less_room] == my_array[last_more_room])
      {
for (temp_room = last_less_room+1&#59;
(temp_room<(last_more_room-1))
&amp;&amp; (my_array[temp_room] == OBJECT_NUMBER)&#59; temp_room++)&#59;
if (my_array[temp_room] == OBJECT_NUMBER)
  {
    break&#59;
  }
else if (my_array[temp_room] >; OBJECT_NUMBER)
  {
    //INT_EXCHANGE (temp_room, last_less_room)&#59;
    SWAP (L, temp_room, last_more_room)&#59;
  }
else if (my_array[temp_room] < OBJECT_NUMBER)
  {
    //INT_EXCHANGE (temp_room, last_less_room)&#59;
    SWAP (L, temp_room, last_less_room)&#59;
  }

continue&#59;
      }

    if (my_array[last_less_room] == OBJECT_NUMBER)
      {
        object_current_room = last_less_room&#59;
        while (((last_less_room + 1) < (MAX_SIZE - 1))
              &amp;&amp; (my_array[last_less_room + 1] < OBJECT_NUMBER))
          {
            last_less_room ++&#59;
          }
        //INT_EXCHANGE (temp_room, last_less_room)&#59;
        SWAP (L, last_less_room, object_current_room)&#59;
        if (((last_less_room + 1) < MAX_SIZE)
              &amp;&amp; (my_array[last_more_room] < OBJECT_NUMBER))
          {
            //INT_EXCHANGE (temp_room, last_less_room)&#59;
            SWAP (L, last_less_room + 1, last_more_room)&#59;
          }
      }
    if (my_array[last_more_room] == OBJECT_NUMBER)
      {
        object_current_room = last_more_room&#59;
        while (((last_more_room - 1) >; 0)
              &amp;&amp; (my_array[last_more_room - 1] >; OBJECT_NUMBER))
          {
            last_more_room --&#59;
          }

        //INT_EXCHANGE (temp_room, last_less_room)&#59;
        SWAP (L, last_more_room, object_current_room)&#59;
        if ((last_more_room >; 0)
              &amp;&amp; (my_array[last_less_room] >; OBJECT_NUMBER))

          {
            //INT_EXCHANGE (temp_room, last_less_room)&#59;
            SWAP (L, last_more_room - 1, last_less_room)&#59;
          }
      }

  }
}

四）至少给出前4组测试数据的结果
   i  )L[]={5,5,5,5,5,5,7,1,6,8}&#59; n=10&#59; X=5&#59; （在main函数提供，注释掉其中一些语句即可）
X=5
L[]=5 5 5 5 5 5 7 1 6 8
-----------------------------------------------------------------
Check :correct.
Time  : 0.000 seconds.
-----------------------------------------------------------------
position=5
L[]=1 5 5 5 5 5 5 7 6 8

   ii )n=10的随机数组
Number of elements to sort=>;10
Seed for random number generator (integer)=>;1
X=31051
L[]=16838 5758 10113 17515 31051 5627 23010 7419 16212 4086
-----------------------------------------------------------------
等了许久，未见结果，相信有些边界条件判断失败，而陷入循环

   iii)n=10,000,000的随机数组
＜未测试＞
   iv )n=50,000,000的随机数组(小心，别影响别人工作)
＜未测试＞
   v  ）其他自己认为具有“边界”特性的数组。
X=7
L[]=3 5 7 1 8 7 6 7 2 0
-----------------------------------------------------------------
Check :correct.
Time  : 0.000 seconds.
-----------------------------------------------------------------
position=7
L[]=3 5 1 0 2 6 7 7 7 8

samhoo

经整理的baggar的解答.
（如果有理解错误的地方，请指正）
baggar的算法性能相当不错，但是在某种情况下（Ｘ为数组的最大值）返回Ｘ的下标的时候仍有点小bug.


一）算法说明
程序先把原始数据分成三部分,用下标将这三部分分开.
[ 比X小的 ] [ 比X大的 ] [ X ]

再将第三部分移到第二部分之前,完成处理.
[ 比X小的 ] [ X ] [ 比X大的 ]

二）编译运行平台，机器类型/主频
cc/sco OpenServer 5.05, intel 1.2GMhz
三）Partition函数代码
/*
* L：输入数组
* n：数组大小
* X：X元素
* 返回X在数组中的下标
*/
int  Partition(long *L, int n, long X)
{
  //在这里插入你的代码
int DATA_LEN = n&#59;

int loop,loopstart,looplen,tmp,found_loc&#59;
//int big_count,equ_count,big_loc,equ_loc,test_num&#59;

int big_count,equ_count,big_loc,equ_loc,test_num = X&#59;
//int ori_data[DATA_LEN]={56,6,56,678,45,546,88,56,345,577}&#59;

long *ori_data = L&#59;
looplen=DATA_LEN&#59; //e.g: 1000 numbers
//test_num=56&#59;
loopstart=big_count=equ_count=big_loc=0&#59;
for(loop=loopstart&#59;loop<looplen&#59;loop++){
if(test_num>;ori_data[loop]){
if(big_count!=0){
//exchange small to big locate.
tmp=ori_data[big_loc]&#59;
ori_data[big_loc]=ori_data[loop]&#59;
ori_data[loop]=tmp&#59;
}
big_loc++&#59;
continue&#59;
}

if(test_num<ori_data[loop]){
big_count++&#59;
continue&#59;
}
if(test_num==ori_data[loop]){
tmp=ori_data[loop]&#59;
ori_data[loop]=ori_data[looplen-1]&#59;
ori_data[looplen-1]=tmp&#59;
equ_count++&#59;
looplen--&#59;
loop--&#59;
}
}

if(equ_count==0){
printf(&quot;ERROR:test number not found.\n&quot&#59;
exit(1)&#59;
}else{
found_loc=big_loc+1&#59;
equ_loc=DATA_LEN-equ_count&#59;
if(equ_count<big_count){
looplen=DATA_LEN&#59;
tmp=equ_loc&#59;

loopstart=big_loc&#59;
}else{
looplen=big_loc+big_count&#59;
tmp=big_loc&#59;
loopstart=DATA_LEN-big_count&#59;
}
for(loop=tmp&#59;loop<looplen&#59;loop++){
tmp=ori_data[loop]&#59;
ori_data[loop]=ori_data[loopstart]&#59;
ori_data[loopstart]=tmp&#59;
loopstart++&#59;
}
}
return found_loc&#59;

}

四）至少给出前4组测试数据的结果
   i  )L[]={5,5,5,5,5,5,7,1,6,8}&#59; n=10&#59; X=5&#59; （在main函数提供，注释掉其中一些语句即可）
X=5
L[]=5 5 5 5 5 5 7 1 6 8
-----------------------------------------------------------------
Check :correct.
Time  : 0.000 seconds.
-----------------------------------------------------------------
position=2
L[]=1 5 5 5 5 5 5 6 8 7

   ii )n=10的随机数组
X=31051
L[]=16838 5758 10113 17515 31051 5627 23010 7419 16212 4086
-----------------------------------------------------------------
Check :incorrect.
Time  : 0.000 seconds.
-----------------------------------------------------------------
position=10
L[]=16838 5758 10113 17515 4086 5627 23010 7419 16212 31051


   iii)n=10,000,000的随机数组
Number of elements to sort=>;10000000
Seed for random number generator (integer)=>;1
X=5500
L[]=16838 5758 10113 17515 31051 5627 23010 7419 16212 4086 2749 12767 9084 1206
0 32225 17543 25089 21183 25137 25566 26966 ...(too much number, ignore)
-----------------------------------------------------------------
Check :correct.
Time  : 0.110 seconds.
-----------------------------------------------------------------
position=1678847
L[]=4086 2749 4978 4143 920 1422 1945 3894 1414 5262 3181 1201 5202 4434 4586 41
66 2582 5000 3214 4697 3123 ...(too much number, ignore)

   iv )n=50,000,000的随机数组(小心，别影响别人工作)
Number of elements to sort=>;50000000
Seed for random number generator (integer)=>;1
X=16413
L[]=16838 5758 10113 17515 31051 5627 23010 7419 16212 4086 2749 12767 9084 1206
0 32225 17543 25089 21183 25137 25566 26966 ...(too much number, ignore)
-----------------------------------------------------------------
Check :correct.
Time  : 0.800 seconds.
-----------------------------------------------------------------
position=25052131
L[]=5758 10113 5627 7419 16212 4086 2749 12767 9084 12060 4978 10311 11367 13145
12754 11653 6561 13628 15188 4143 6967 ...(too much number, ignore)

   v  ）其他自己认为具有“边界”特性的数组。
X=56
L[]=56 6 56 678 45 546 88 56 345 577
-----------------------------------------------------------------
Check :correct.
Time  : 0.000 seconds.
-----------------------------------------------------------------
position=3
L[]=6 45 56 56 56 546 88 345 678 577

beggar

[这个贴子最后由beggar在 2002/10/28 01:26pm 编辑]

samhoo你好.
以下是输出结果

===ori data===
16838 5758 10113 17515 31051 5627 23010 7419 16212 4086
===Total===
find data:31051 location:10 foundtimes:1 total exchage:1
ok
===Last array===
16838 5758 10113 17515 4086 5627 23010 7419 16212 31051

返回下标是排序后的易读位置值(下标+1) 以这儿就是(9+1).可能这让你误以为下标错误.在此澄清.

离了水的蛤蟆

samhoo:
我检查的程序，问题的确出在边界上，那组测试数据中，X是最大的数（就是这么村），如果X是最小的数，也会出现同样问题，我进行了修改，将两个if 语句改成：

     if (my_array[last_less_room] == OBJECT_NUMBER)
       {
         object_current_room = last_less_room&#59;
         while ((last_less_room < (MAX_SIZE - 1))    /* ！！！！！！ */
               &amp;&amp; (my_array[last_less_room + 1] < OBJECT_NUMBER))
           {
             last_less_room ++&#59;
           }
         INT_EXCHANGE (last_less_room, object_current_room)&#59;
         if (((last_less_room + 1) < MAX_SIZE)
               &amp;&amp; (my_array[last_more_room] < OBJECT_NUMBER))
           {
             INT_EXCHANGE (last_less_room + 1, last_more_room)&#59;
           }
       }
     else if (my_array[last_more_room] == OBJECT_NUMBER)
       {
         object_current_room = last_more_room&#59;
         while ((last_more_room >; 0)              /* ！！！！！！ */
               &amp;&amp; (my_array[last_more_room - 1] >; OBJECT_NUMBER))
           {
             last_more_room --&#59;
           }

         INT_EXCHANGE (last_more_room, object_current_room)&#59;
         if ((last_more_room >; 0)
               &amp;&amp; (my_array[last_less_room] >; OBJECT_NUMBER))
           {
             INT_EXCHANGE (last_more_room - 1, last_less_room)&#59;
           }
       }
     else
       {
         INT_EXCHANGE (last_less_room, last_more_room)&#59;
       }

加惊叹号的地方是出错的地方。
请帮忙再测试一下。
我自己的测试结果是，如果目标数据没有包含在数组中，也会出现错误的结果，我修改了两个while语句：

     while ((my_array[last_less_room] < OBJECT_NUMBER)
                &amp;&amp; (last_less_room < MAX_SIZE)) last_less_room ++&#59;
     while ((my_array[last_more_room] >; OBJECT_NUMBER)
                &amp;&amp; (last_more_room >; 0)) last_more_room --&#59;

     if ((last_less_room >;= MAX_SIZE) || (last_more_room < 0))
       {
         break&#59;
       }

另外，在最后打印last_less_room和last_more_room应该就是X的位置

aegis

1） 看来 beggar 应该去当律师，善于无中生有
2） 诚如 chinajiji 所说，原题目可理解为 重复的 X 可以放在左边或右边，不用
    挪到一起。那样 f_aegis 的第二个程序也是正确的
3） 如果讨论本题，我认为满足原题要求就可以了，可按 x 挪到一起的要求来讨论
    至于程序的效率，1000 个数满足时间复杂度 O(N) 的各种算法我想差别不大
    如果要详细讨论，建议 samboo 另开新贴子，并规定回复格式，这样比较整齐
    建议最好大家先写 思路，再写 程序。如果对时间要求很高的话，建议由
    samboo 用同一环境进行测试，再把结果公布，这样结果比较可信。
4） 我想，解决问题主要是能有独立的想法。同类的算法当然可以精益求精地改进，
    如果性能差别不是太大，这里就不必那么详细了。至于我上次提出的 2 pass
    的方法，主要是从另一个角度出发来满足题目要求，在 1000 的长度范围也基本
    适用。它算法简单，并且 O(n) 显而易见, 并不用来做 time score 的。

beggar

[这个贴子最后由beggar在 2002/10/28 04:40pm 编辑]

我想samhoo的测试已经说得很清楚了.我想你应试去看一看本题所有回贴.学点东西才是
到现在你还认为你的理解是正确的话我也无话可说.只能说你理解能力太差或是有神经质.
你的根本代码无法编译或是根本没有提供源代码.我只能认为纸上谈兵确有其人.
在这个问题上我不想再和你讨论了.
从time test已经看得出结果了.你还嘴硬吗?如果你用你那种算法能够比我的算法用更少的时间,以后你在此出现的话我就退避以示我怕你...
拿你的那个算法的程式码来看啊.如果不行的话请你以后就不要鬼扯了.想清楚再回贴
我每次测试一个程序就重启测试下一个怎么样?

samhoo

我前面的帖子已经给出了解答的“八股”，各位可参照解之。

总结2：
1）baggar的程序修改后，经测试没有发现问题。
2）离开水的蛤蟆在修改后，在测试如下数据时依然有陷入循环：
X=4086
L[]=16838 5758 10113 17515 31051 5627 23010 7419 16212 4086 2749 12767 9084 1206
0 32225 17543 25089 21183 25137 25566

请baggar和离开水的蛤蟆以及Chinajiji自己整理一下自己的“八股”，举手之劳即可让大家顺畅沟通，何乐而不为？

至于aegis呢，如果没有可运行的代码，让大家去“品味”你的思路以及代码，恐怕是困难的。

测试我倒是可以为各位服务，计算一下time score。

beggar

#include <sys/types.h>;
#include <stdio.h>;

#define DATA_LEN 10

main()
{//a num used for temport value.
int total_mov_time=0&#59;//记录下总共交换的次数.作测试用.
int loop,loopstart,looplen,tmp,found_loc&#59;
int big_count,equ_count,big_loc,equ_loc,test_num&#59;
int ori_data[DATA_LEN]={16838,5758,10113,17515,31051,5627,23010,7419,16212,4086}&#59;
looplen=DATA_LEN&#59; // 数组总长度
test_num=31051&#59;//假设找31051
printf(&quot;===ori data===\n&quot&#59;
for(loop=0&#59;loop<looplen&#59;loop++)
printf(&quot;%d &quot;,ori_data[loop])&#59;
printf(&quot;\n&quot&#59; //输入出原始数据

loopstart=big_count=equ_count=big_loc=0&#59;
for(loop=loopstart&#59;loop<looplen&#59;loop++){            //从第一个无素开始循环
if(test_num>;ori_data[loop]){          //如果小于X
if(big_count!=0){             //看它前面是否有大于X的数
//把他与第一个大于X的数交换,就成为了在小于X的部分的最后一个数
tmp=ori_data[big_loc]&#59;
ori_data[big_loc]=ori_data[loop]&#59;
ori_data[loop]=tmp&#59;
total_mov_time++&#59;
}
big_loc++&#59; //第二部分的起始位置后移1个数
continue&#59;  //退出本循环
}
if(test_num<ori_data[loop]){ //如果大于X
big_count++&#59;  //将第二部分的元素个数+1
continue&#59; //退出循环
}
if(test_num==ori_data[loop]){  //如果等于X
tmp=ori_data[loop]&#59; //将第三部分前一个数与当前数交换
ori_data[loop]=ori_data[looplen-1]&#59;
ori_data[looplen-1]=tmp&#59;
equ_count++&#59;  //第三部分元素个数+1
looplen--&#59; //第三部分不再参于比较
loop--&#59;  //再次进行本次循环,因为把最后一个数换过来了
total_mov_time++&#59;  
}
}

if(equ_count==0){
printf(&quot;ERROR:test number not found.\n&quot&#59;
exit(1)&#59;
}else{//以下代码要所第二部分及第三部分的长度决定移动哪部分.
found_loc=big_loc+1&#59;
equ_loc=DATA_LEN-equ_count&#59;
if(equ_count<big_count){
looplen=DATA_LEN&#59;
tmp=equ_loc&#59;
loopstart=big_loc&#59;
}else{
looplen=big_loc+big_count&#59;
tmp=big_loc&#59;
loopstart=DATA_LEN-big_count&#59;
}
for(loop=tmp&#59;loop<looplen&#59;loop++){
tmp=ori_data[loop]&#59;
ori_data[loop]=ori_data[loopstart]&#59;
ori_data[loopstart]=tmp&#59;
loopstart++&#59;
total_mov_time++&#59;
}
}
printf(&quot;\n===Total===\n&quot&#59; //输出统计信息
printf(&quot;find data:%d location:%d foundtimes:%d total exchage:%d\nok\n&quot;,
test_num,found_loc,equ_count,total_mov_time)&#59;
printf(&quot;\n===Last array===\n&quot&#59;//输出整理后的数组
for(loop=0&#59;loop<DATA_LEN&#59;loop++)
printf(&quot;%d &quot;,ori_data[loop])&#59;
printf(&quot;\n&quot&#59;
exit(0)&#59;
}