提示：用陣列值作為下標

分析：

       對於一般陣列的排序顯然 O(n) 是無法完成的。

      既然題目這樣要求，肯定原先的陣列有一定的規律，讓人們去尋找一種機會。

例如：原始陣列：

          a = [ 10, 6,9, 5,2, 8,4,7,1,3 ]

        如果把它們從小到大排序且應該是

         b = [1,2,3,4,5,6,7,8,9,10 ]  

        也就是說： 如果我們觀察 a --> b 的對映關係是：

                    a[ i ] 在 b 中的位置是 b[ a[i] - 1]

答案一：

#include<iostream.h>
int main()
{
 int a[]={10,6,9,5,2,8,4,1,7,3};
 int len=sizeof(a)/sizeof(int);
 int temp;
 for(int i=0;i<len;)
 {
  temp=a[a[i]-1];
  a[a[i]-1]=a[i];
  a[i]=temp;
  if(a[i]==i+1)
   i++;
 }
 for(int j=0;j<len;j++)
  cout<<a[j]<<",";
 return 0;
}

此題值得注意的就是：在for迴圈裡for（i=0；i<len;;）說明只有當for迴圈裡面的東西滿足條件以後才會開始下一個i++的迴圈，這個地方很巧，否則把i++加到for迴圈裡面就錯了

--------------------------------------------------------------

有1,2,....一直到n的無序陣列，求排序演算法，並且要求時間複雜度為O(n)，空間複雜度O(1)，使用交換，而且一次只能交換兩個數.（華為）

分析：陣列的特點是值和下標滿足一定的關係，以此作為交換的終止條件。

但這個演算法的時間複雜度如何證明是O(n)呢？

void sortOnorder1(int array[], int len)
{
        int temp;
 
        for(int i = 0; i < len; )
        {
                if ( array[i] != i + 1)//下標和值不滿足對應關係
                {
                       temp = array[array[i] - 1];        //不相等的話就把array[i]交換到與索引相應的位置
                       array[array[i] - 1] = array[i];
                       array[i] = temp;
                }
                else
                       i++; // 儲存，以後此值不會再動了
        }
 
}
 
void sortOnorder2(int array[], int len)
{
        int temp;
        int i = 0;
 
        for(i = 0; i < len; i++)
        {
       //不相等的話就把array[i]交換到與索引相應的位置，若相等，其實本次迴圈沒有任何意義，其不會對現有的資料產生任何影響
                temp = array[array[i] - 1];       
                array[array[i] - 1] = array[i];
                array[i] = temp;
        }
 
        for(i = 0; i < len; i++)
        {
                temp = array[array[i] - 1];        //不相等的話就把array[i]交換到與索引相應的位置
                array[array[i] - 1] = array[i];
                array[i] = temp;
        }
}
 
int main()
{
        int a[] = {10,6,9,5,2,8,4,7,1,3};
        int b[] = {4,6,9,3,2,8,10,7,1,5};
 
        int lena = sizeof(a) / sizeof(int);
        int lenb = sizeof(b) / sizeof(int);
 
 
        //sortOnorder1(a,lena);
        sortOnorder2(a,lena);
 
        for (int j = 0; j < lena; j++)
        cout<<a[j]<<",";
        cout<<"/n";
 
        //sortOnorder1(b,lenb);
        sortOnorder2(b,lenb);
 
        for (int k = 0; k < lenb; k++)
        cout<<b[k]<<",";
 
        return 0;
}