编程之美笔记2 一摞烙饼的排序问题

 一摞烙饼的排序问题

1.

自己写的.cpp

  #include <iostream>
  using namespace std;
  
  int getMax(int data[],int n)
  {
       int max=0;
        int pos=0;
        for(int i=0;i<n;i++)
        {
               if(data[i]>max)
               { 
                      max=data[i];
                     pos=i+1;
               }
        }
        return pos;
  }


  void reverse(int data[],int n)
  {
         for(int i=0;i<n/2;i++)
        {
               int temp=data[n-i-1];
               data[n-i-1]=data[i];
               data[i]=temp;
       }
  }
  
  void Sort(int data[],int n)
  {
         int pos=getMax(data,n);

        if(pos!=n && pos>0)  
        { 
       reverse(data,pos); //翻转
       for(int i=0;i<8;++i)
               cout <<data[i]<<" ";
       cout <<endl;
       reverse(data,n);   //翻转
       for(int i=0;i<8;++i) 
              cout <<data[i]<<" ";
       cout <<endl;
      } 

       if(n>0)
          Sort(data,n-1);
  }
    
 int main()
 {
       int data[]={1,5,4,3,2,8,6,7};
       int n=sizeof(data)/sizeof(int);
       Sort(data,n);
    
     return 0;
 }

2.不懂

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  


static int nCakeNum;  
static int nMaxSwap;  
int *TempCakeArray;     /* current cake sort */  
  
int *LeastReverseArray; /* store the reverse step */  
int *TempReverseArray;  /* store the temp reverse step */  


int FindUpperBound(int nCakeCnt)  
{  
    return 2*(nCakeCnt - 1);  
}  
  
int FindLowerBound(int *pCakeArray, int nCakeCnt)  
{  
    int i, temp;  
    int ret = 0;  
    for(i = 1; i < nCakeCnt; i++)  
    {  
        temp = pCakeArray[i] - pCakeArray[i-1];  
        if((temp != 1) && (temp != -1))  //不相邻
        {  
            ret++;  
        }  
    }  
    return ret;  
}  
  
/* check if the cakes are sorted */  
#define CAKE_NOT_SORTED 0  
#define CAKE_SORTED     1  
int IsSorted(int *pCakeArray, int nCakeCnt)  
{  
    int i;  
    for(i = 1; i < nCakeCnt; i++)  
    {  
        if(pCakeArray[i] < pCakeArray[i - 1])  
            return CAKE_NOT_SORTED;  
    }  
    return CAKE_SORTED;  
}  
  
/* swap cake */  
void Reverse(int nBegin, int nEnd)  
{  
    int i, j;  
    int temp;  
/*  ASSERT(nBegin < nEnd);    remember to check the value all the time */  
    for(i = nBegin, j = nEnd; i < j; i++, j--)  
    {  
        temp = TempCakeArray[i];  
        TempCakeArray[i] = TempCakeArray[j];  
        TempCakeArray[j] = temp;  
    }  

}  
  


void Search(int step)  
{  
    int i;  
    int nEstimate;  
  
    nEstimate = FindLowerBound(TempCakeArray, nCakeNum);  
    if(nEstimate + step > nMaxSwap)  
        return;  
  
    if(IsSorted(TempCakeArray, nCakeNum) == CAKE_SORTED)  
    {  

        if(step < nMaxSwap)  
        {  
            nMaxSwap = step;    /* minimize the upper bound */  
            for(i = 0; i < nMaxSwap; i++)  
                LeastReverseArray[i] = TempReverseArray[i];  
        }  
        return;  
    }  



  
    for(i = 0; i < nCakeNum; i++)  
    {     


        Reverse(0, i);  
TempReverseArray[step] = i;
Search(step + 1);  
        Reverse(0, i); 

    }  
 
}  
  
/* print the result */  
void PrintSortSteps()  
{  
    int i;  
    printf("The least swap steps is %d.\nThe details:\n", nMaxSwap);  
    for(i = 0; i < nMaxSwap; i++)  
        printf("%d\t", LeastReverseArray[i]);  
    printf("\n");  
    return;  
}  
  
int main()  
{  
    int i;  
    int CakeArray[] = {3, 2, 1, 6, 5, 4, 9, 8, 7, 0};  
  
    nCakeNum = sizeof(CakeArray)/sizeof(int);  
    TempCakeArray = (int*) malloc(nCakeNum * sizeof(int));  
    if(TempCakeArray == NULL)  
        return -1;  
    for(i = 0; i < nCakeNum; i++)  
        TempCakeArray[i] = CakeArray[i];  
  
    nMaxSwap = FindUpperBound(nCakeNum);  
    TempReverseArray =(int*)  malloc(nMaxSwap * sizeof(int));  
    if(TempReverseArray == NULL)  
        return -1;  
    memset(TempReverseArray, 0, nMaxSwap * sizeof(int));  
    LeastReverseArray =(int*)  malloc(nMaxSwap * sizeof(int));  
    if(LeastReverseArray == NULL)  
        return -1;  
    memset(LeastReverseArray, 0, nMaxSwap * sizeof(int));  
  
    Search(0);  
    PrintSortSteps(); 


printf("%d\t",count);
  
    return 0;  
}