数据结构与抽象之选择排序递归实现

最近在看排序算法，了解到递归思想，于是就想拿递归实现选择排序。选择排序的时间复杂度是O(n^2)

选择排序的思路：

1.找出数组内最小的数

2.交换最小数和数组第一位的位置

3.然后再找刚才排序完以外最小的数，排在其后面

...

以此类推

拿迭代写很简单，但是刚接触到递归写起来还是有一点费劲。

步骤：

一、遍历数组，找出最小数的下标

代码：

   /**
     * 
     * @param a 需要查找的数组
     * @param first 查找的开始下标
     * @param last  查找的结束下标
     * @return
     */
    public int getIndexOfMin(int[] a,int first,int last){
        int indexOfMin;
        if(first>=last){
            return first;
        }else{
            indexOfMin=getIndexOfMin(a,first+1,last);
            int min=a[indexOfMin];
            if(min>a[first]){
                min=a[first];
                indexOfMin=first;
            }
        }
        return indexOfMin;
    }

跟踪一下这段代码：

初始值：int[] a={2,4,3,6},int first=0,int last=a.length-1=3;查找数组a从下标0到a.length-1里面的最小值的下标

1.第一层，进入判断，0>=3不成立因此进入else

indexOfMin=getIndexOfMin(a,0+1,3);//在这里第一层停止运算进入第二层

2.第二层，进入判断，1>=3不成立因此进入else,first=1,last=3

indexOfMin=getIndexOfMin(a,1+1,3);//第二层停止，进入第三层

3.第三层，进入判断，2>=3不成立，进入else，first=2;

indexOfMin=getIndexOfMin(a,2+1,3);//第三层停止，进入第四层

4.第四层，进入判断，3>=3成立，返回3，回到第三层

4.第三层接收到第四层返回来的最小值的的下标3，继续运行

indexOfMin=3;

int min=a[indexOfMin]=6;

比较a[3]和a[2]的值，返回2，回到第二层

5.第二层接收到第三层返回来的最小值的下标2，继续运行

indexOfMin=2;

int min=a[2]=3;

比较a[2]和a[1]的大小，返回2，回到第一层

6.第一层接收到第二层返回的最小值的下标2，继续运行

indexOfMin=2;

int min=a[2]=3;

比较a[2]和a[0]的大小，返回2结束运行

二、交换最小值和第一位的位置

    /**
     * 交换数组a内i和j数字的位置
     * @param a
     * @param i
     * @param j
     */
    public void swap(int[] a,int i,int j){
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }

三、进行排序

    /**
     * 递归选择排序
     * @param a
     * @param first 排序的开始下标
     * @param last 排序结束的下标
     */
    public void selectionSort(int[] a,int first,int last){
        if(first>=last){
            return;
        }else{
            //得到最小值的下标
            int indexOfMin=getIndexOfMin(a,first,last);
            //交换最小值和第一位的位置
            swap(a,first,indexOfMin);
            //递归
            selectionSort(a,first+1,last);
        }
    }

四、测试

    @Test
    public void method3(){
        int[] a={1,2,3,444,111,666,77};
        selectionSort(a,0,a.length-1);
        for (int i=0;i<a.length;i++){
            System.out.print(a[i]+"\t");
        }
    }

五、结果

1 2 3 77 111 444 666

六、所有代码

import org.junit.Test;

public class Sort {
    /**
     * 递归选择排序
     *
     * @param a
     * @param first 排序的开始下标
     * @param last  排序结束的下标
     */
    public void selectionSort(int[] a, int first, int last) {
        if (first >= last) {
            return;
        } else {
            //得到最小值的下标
            int indexOfMin = getIndexOfMin(a, first, last);
            //交换最小值和第一位的位置
            swap(a, first, indexOfMin);
            //递归
            selectionSort(a, first + 1, last);
        }
    }

    /**
     * 交换数组a内i和j数字的位置
     *
     * @param a
     * @param i
     * @param j
     */
    public void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    /**
     * @param a     需要查找的数组
     * @param first 查找的开始下标
     * @param last  查找的结束下标
     * @return
     */
    public int getIndexOfMin(int[] a, int first, int last) {
        int indexOfMin;
        if (first >= last) {
            return first;
        } else {
            indexOfMin = getIndexOfMin(a, first + 1, last);
            int min = a[indexOfMin];
            if (min > a[first]) {
                min = a[first];
                indexOfMin = first;
            }
        }
        return indexOfMin;
    }

    @Test
    public void method3() {
        int[] a = {1, 2, 3, 444, 111, 666, 77};
        selectionSort(a, 0, a.length - 1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "\t");
        }
    }
}