交换瓶子-JavaA

有N个瓶子，编号 1 ~ N，放在架子上。

比如有5个瓶子：
2 1 3 5 4

要求每次拿起2个瓶子，交换它们的位置。
经过若干次后，使得瓶子的序号为：
1 2 3 4 5

对于这么简单的情况，显然，至少需要交换2次就可以复位。

如果瓶子更多呢？你可以通过编程来解决。

输入格式为两行：
第一行: 一个正整数N（N<10000）, 表示瓶子的数目
第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。

输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。

例如，输入：
5
3 1 2 5 4

程序应该输出：
3

再例如，输入：
5
5 4 3 2 1

程序应该输出：
2

**思路：**一开始分析最少次数的交换过程，有点像一个排序，但自身将快排和选择排序记混了导致一开始用递归很沙比的做了一下，实际上要实现最小次数交换，按照选择排序的思想交换就是最小次数

---

代码：

import java.util.HashMap;
import java.util.Scanner;

public class ad2 {
    static int N;
    static int[]arr;
    static int right;//右
    static int left=1;
    private static int  ans;
    public static void main(String[] args) {//十分类似选择排序
        Scanner scanner=new Scanner(System.in);
        N=scanner.nextInt();
        arr = new int[N+1];
        right=arr.length-1;
        for (int i = 1; i < arr.length; i++) {
            arr[i]=scanner.nextInt();
        }
        while (left<=N){
            int maxindex=0;
            for (int i = left+1; i < arr.length; i++) {
                if (arr[i]<arr[left]){
                    maxindex=Math.max(maxindex,i);
                }
            }
            if (maxindex!=0) {
                swap(maxindex, left);
            }
            left++;
        }
        System.out.println(ans);
        for (int i = 1; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }

    private static void swap(int i,int k) {
        int temp=arr[i];
        arr[i]=arr[k];
        arr[k]=temp;
        ans++;
    }
}

---

下面是第一次做的sb代码：我真的要笑死我自己了，递归学的还行（晕了@@@@）
有点像深搜：时间复杂度直接指数级别

import java.util.Scanner;

public class ad {
    static int N;
    static int[]arr;
    static int right;//右
    static int left=1;
    private static int  ans;
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Scanner scanner=new Scanner(System.in);
        N=scanner.nextInt();
        arr = new int[N+1];
        right=arr.length-1;
        for (int i = 1; i < arr.length; i++) {
            arr[i]=scanner.nextInt();
        }
        int core=arr[1];
        swapnum(core,"l");
        System.out.println(ans);
        System.out.println("--------------");
        for (int i = 1; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }

    private static void  swapnum(int core,String flag) {
        // TODO 自动生成的方法存根
        //k为下标//先左后右，找不到就固定
        if (left>right) {
            return ;
        }
        if (flag=="l") {//从左开始
            for (int i = left+1; i < arr.length; i++) {
                if (left>right) {
                    return ;
                }
                if (arr[i]>core&&arr[i-1]<core&&i!=arr.length-1) {//找到比core值大的
                    swap(i-1, left);
                    swapnum(arr[right],"r");
                }else if (arr[i]>core&&i==arr.length-1){
                    left++;
                    swapnum(arr[right],"r");
                }else if (arr[i]<core&&i==arr.length-1){//从左向右变量需要考虑找不到比首元素大的特殊情况
                    swap(i, left);
                    swapnum(arr[right], "r");
                }
            }
        }
        if (flag=="r") {//从右开始
            //这时候right是left
            for (int i = right-1; i >=1; i--) {
                if (left>right) {
                    return ;
                }
                if (arr[i]<core&&arr[i+1]>core) {//找到比core小的，没找到，不用换
                    swap(right, i+1);
                    swapnum(arr[left],"l");
                }else if (arr[i]<core&&i==1){
                    right--;
                    swapnum(arr[left],"l");
                }
           }

        }
    }
    private static void swap(int i, int k) {
        // TODO 自动生成的方法存根
        int temp=arr[i];
        arr[i]=arr[k];
        arr[k]=temp;
        ans++;
    }
}