算法基础之----二元选择排序

假设有一个序列，元素个数为n，要对该序列进行排序。（升序为例）

在要排序的这一组数中，找到一个最小元素，与第1个位置（下标为0）的元素进行交换；与此同时，找到一个最大的元素，与最后一个位置的元素

（下标为n-1）进行交换。然后，再进行如上操作，从除第一个元素和最后一个元素之外的所有元素中，分别找到最大和最小的元素，分别与第二个位置（下标为1）、倒数第二个位置（下标为n-2）处的元素进行交换；

以此类推，直到第n-1个元素和第n个元素比较为止。

例如：

元素序列：  5 8 1 2 6 0 4 3 9 7

   下标：      0 1 2 3 4 5 6 7 8 9

第一次         0 8 1 2 6 5 4 3 1 9

第二次         0 1 7 2 6 5 4 3 8 9

….                     ….

第n/2次     0 1 2 3 4 5 6 7 8 9

手工过程：（假设一个数组array的长度为n）

第0趟：找出array中下标为0~n-1中最小的元素minValue，与array[0]交换；找到最大的元素maxValue，与array[n-1]交换。

第1趟：找出array中下标为1~n-2中最小的元素minValue，与array[1]交换；找到最大的元素maxValue，与array[n-2]交换

….

第i趟：找出array中下标为i~n-1-i中最小（或最大）的元素minValue，与array[i]交换；找到最大的元素maxValue，与array[n-1-i]交换

…..

第(n/2)-1趟：将array中下表为n/2和下标为n/2-1的元素比较，找到合适的位置，进行交换。

如此过程就完成了排序。

代码实现：（此处数组的生成采用一个随机函数生成一个无序数组）

C语言：

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

void initData(int *data, int size, int minValue, int maxValue);
void showData(int *data, int size);
void selectSort(int *data, int size);

void selectSort(int *data, int size) {
	int i;
	int j;
	int minIndex = 0;		//标记处最小的元素的下标
	int maxIndex = size-1;		
	int minValue;		//用来交换的中间变量
	int maxValue;

	for(i = 0; i < size/2; i++) {
		int minIndex = i;
		int maxIndex = size-i-1;
	
		for(j = i; j < size-i-1; j++) {
			if(data[minIndex] > data[j]) {
				minIndex = j;
			}

			if(data[maxIndex] < data[j]) {
				maxIndex = j;
			}
		}

		minValue = data[minIndex];
		maxValue = data[maxIndex];

		data[minIndex] = data[i];
		data[maxIndex] = data[size-i-1];

		data[i] = minValue;
		data[size-i-1] = maxValue;

	}
}

void showData(int *data, int size) {
	int i;
	for(i = 0; i < size; i++) {
		printf(i == 0 ? "%d" : ", %d", data[i]);
	}
	printf("\n");
}

void initData(int *data, int size, int minValue, int maxValue) {
	int i;
	int value = maxValue-minValue+1;

	srand(time(0));
	for(i = 0; i < size; i++) {
		data[i] = minValue+rand()%value;
	}
}


int main(void) {
	int *arr;

	arr = (int *)calloc(sizeof(int), 20/*maxSize*/);

	initData(arr, 20/*maxSize*/, 1/*minValue*/, 100/*maxValue*/);
	showData(arr, 20);
	selectSort(arr, 20);
	showData(arr, 20);

	return 0;
}

import java.util.Arrays;

public class 二元SelectSort {
	public static void main(String[] args) {
		int[] array = new int[20];
		
		initData(array, 100/*maxValue*/);
		showData(array);
		
		selectSort(array);
		showData(array);
	}
	
	private static void selectSort(int[] array) {
		int len = array.length;
		if(len == 0) {
			throw new RuntimeException("array length is 0");
		}
		
		for(int i = 0; i < len/2; i++) {
			int minIndex = i;
			int maxIndex = len-1-i;
			
			for(int j = i; j < len-1-i; j++) {
				if(array[minIndex] > array[j]) {
					minIndex = j;
				}
				
				if(array[maxIndex] < array[j]) {
					maxIndex = j;
				}
			}
			
			int minValue = array[minIndex];
			int maxValue = array[maxIndex];
			
			array[minIndex] = array[i];
			array[maxIndex] = array[len-1-i];
			
			array[i] = minValue;
			array[len-1-i] = maxValue;
		}
	}

	/**
	 *显示数组
	 * @param array
	 */
	private static void showData(int[] array) {
		System.out.println(Arrays.toString(array));
	}

	/**
	 * 初始化一个数组，元素随机产生
	 * @param array		要初始化的数组
	 * @param maxValue	数组元素的最大值
	 */
	private static void initData(int[] array, int maxValue) {
		for(int i = 0; i < array.length; i++) {
			array[i] = (int)(Math.random()*maxValue);
		}
	}
}