###### 排序 Swap(0, i) 最小次数

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">	</span><span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">最近在上数据结构和算法基础， 有一个附加题。要求如下：</span>
5-1 Sort with Swap(0, i)   (25分)

Given any permutation of the numbers {0, 1, 2,..., N1}, it is easy to sort them in increasing order. But what if Swap(0, *) is the ONLY operation that is allowed to use? For example, to sort {4, 0, 2, 1, 3} we may apply the swap operations in the following way:

Swap(0, 1) => {4, 1, 2, 0, 3}
Swap(0, 3) => {4, 1, 2, 3, 0}
Swap(0, 4) => {0, 1, 2, 3, 4}


Now you are asked to find the minimum number of swaps need to sort the given permutation of the first N nonnegative integers.

### Input Specification:

Each input file contains one test case, which gives a positive N (105) followed by a permutation sequence of {0, 1, ..., N1}. All the numbers in a line are separated by a space.

### Output Specification:

For each case, simply print in a line the minimum number of swaps need to sort the given permutation.

### Sample Input:

10
3 5 7 2 6 4 9 0 8 1


### Sample Output:

9

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

int *Array, NumNotPos, NumSwap;
void Swap(int a, int b, int N);
void Sort(int N);

int main(int argc, char const *argv[])
{
int N;
scanf("%d", &N);
Sort(N);
printf("%d\n", NumSwap);
system("pause");
return 0;
}

{
Array = (int *)malloc(N * sizeof(int));
int i = 0;
while (i < N)
{
scanf("%d", &Array[i]);
i++;
}
/*
Array[0] = 3;
Array[1] = 5;
Array[2] = 7;
Array[3] = 2;
Array[4] = 6;
Array[5] = 4;
Array[6] = 9;
Array[7] = 0;
Array[8] = 8;
Array[9] = 1;
*/
}

void Sort(int N)
{
int i = 0;
while (i < N)
{
if (Array[i] != i)
NumNotPos++;
i++;
}

do
{
if (Array[0] == 0 && NumNotPos != 0)
{
int j = 1;
while(Array[j] == j && j < N)
{
j++;
}
Swap(0, j, N);
NumNotPos++;
}

if (NumNotPos != 0)
{
int j = 0;
while (Array[j] != 0 && j < N)
j++;
Swap(0, j, N);
NumNotPos--;
if (Array[0] == 0)
NumNotPos--;
}
} while (NumNotPos > 0);
}

void Swap(int a, int b, int N)
{
NumSwap++;
int i, temp, FirIndex, SecIndex;
i = FirIndex = SecIndex = 0;
while (i < N)
{
if (Array[i] == a)
FirIndex = i;
if (Array[i] == b)
SecIndex = i;
if (FirIndex && SecIndex)
break;
i++;
}

temp = Array[FirIndex];
Array[FirIndex] = Array[SecIndex];
Array[SecIndex] = temp;
}

http://blog.csdn.net/xyt8023y/article/details/47210245

#include <stdio.h>

int findNotOK(int* arr,int begin,int end)   //从begin开始往后寻找未到位的数
{
for(int i=begin;i<end;i++)
{
if(arr[i]!=i)return i;
}
return 0;
}

int main()
{
int n;
scanf("%d",&n);
int* arr = new int[n];
int i,t;

for(i=0;i<n;i++)
{
scanf("%d",&t);
arr[t]=i;
}
int tmp = 0;
int count=0;
int firstPos = 1;
firstPos = findNotOK(arr,firstPos,n);

while(firstPos)     //还有未到位的数字
{
if(arr[0]==0)       //如果0到位了，则与未到位的firstPos交换
{
arr[0] = arr[firstPos];
arr[firstPos] = 0;
count++;
}

while(arr[0]!=0)    //如果0不到位，则循环与自己所指向的值交换
{
tmp = arr[0];
arr[0] = arr[tmp];
arr[tmp] = tmp;
count++;
}
firstPos = findNotOK(arr,firstPos,n);       //此时0归位了，找到下一个未到位的数字
}
printf("%d\n",count);

return 0;
}  

1、排序是否完成

2、若没完成，Array[0] == 0 时0 的交换对象。

#### 浙大PAT-Sort with Swap(0, i)

2016-07-21 13:59:23

#### 10-排序6 Sort with Swap(0, i) (25分)

2016-11-10 23:08:43

#### 排序算法（二）Sort with Swap(0,*)

2015-01-25 17:09:44

#### 10-排序6 Sort with Swap(0, i)

2015-10-02 17:03:39

#### 10-排序6 Sort with Swap(0, i)   (25分)

2017-05-16 20:16:18

#### PTA 10-排序6 Sort with Swap(0, i)（25 分）

2018-05-14 12:57:53

#### 只含0、1的串进行排序，可任意交换位置，最小交换次数

2015-09-04 23:59:53

#### Sort with Swap(0, i)

2017-05-03 18:23:49

#### 关于一个求最小交换次数的算法的一个严格证明，是严格证明，不是想当然

2015-01-06 10:33:21

#### 交换任意两个元素进行排序进行的最小交换次数

2018-03-22 00:09:06