BasicSort 之 SelectSort

一、选择排序

核心:不断地选择剩余元素中的最小者。

  1. 找到数组中最小元素并将其和数组第一个元素交换位置。
  2. 在剩下的元素中找到最小元素并将其与数组第二个元素交换,直至整个数组排序。

性质:

  • 比较次数=(N-1)+(N-2)+(N-3)+...+2+1~N^2/2
  • 交换次数=N
  • 运行时间与输入无关
  • 数据移动最少

二、实现

  实现方式一:

package sort;

public class SelectSort {
	/**
	 *  选择排序: 不断地选择剩余元素中的最小者。
	 *  1、找到数组中最小元素并将其和数组第一个元素交换位置。
		2、在剩下的元素中找到最小元素并将其与数组第二个元素交换,直至整个数组排序。
		复杂度分析: n^2/2 交换N次  ,  运行时间与输入无关,数据移动最少
	 */
	public static void main(String[] args) {
		int[] unsortedArray = new int[]{8, 5, 2, 6, 9, 3, 1, 4, 0, 7} ;
		selectSort(unsortedArray) ;
		System.out.println("After sort: ");
		for (int item : unsortedArray) {
			System.out.print(item + " ");
		}
	}

	public static void selectSort(int[] array){
		int len = array.length ;
		for (int i = 0; i < len; i++) {
			for (int item : array) {
				System.out.print(item + " ");
			}
			System.out.println();
			int min_index = i ;
			for (int j = i+1; j < len; j++) {
				if (array[j] < array[min_index]) {
					min_index = j ;
				}
			}
			int temp = array[min_index] ;
			array[min_index] = array[i];
			array[i] = temp ;
		}
	}

}

  实现方式二:

  定义一个类,进行存储元素和排序、显示等操作。

package selectSort;

public class ArraySel
{
	private long[] a ;				// ref to Array a
	private int nElems ;			// number of data items

	public ArraySel(int max){		// constructor
		a = new long[max] ;			// create the array
		nElems = 0 ;				// no items yet
	}

	public void insert(long value){	// put element into array
		a[nElems] = value ;			// insert it
		nElems++ ;					// increment size
	}

	public void display(){			// display array contents
		for (int i = 0; i < nElems; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}

	public void selectSort(){
		int out , in , min;
		for (out = 0; out < nElems-1; out++) {// outer loop
			min = out ;						  // minimum
			for(in = out+1; in < nElems; in++){	  // inner loop
				if(a[in] < a[min]){
					min = in ;				  // we have a new min
				}
			}
			swap(out,min);			  // swap them
		}
	}

	private void swap(int one, int two) {
		long temp = a[one] ;
		a[one] = a[two] ;
		a[two] = temp ;
	}
}

  定义主函数入口main函数。

package selectSort;

public class SelectSort
{
	public static void main(String[] args) {
		int maxSize = 100 ;
		ArraySel arr ;
		arr = new ArraySel(maxSize) ;

		arr.insert(0);
		arr.insert(6);
		arr.insert(5);
		arr.insert(3);
		arr.insert(1);
		arr.insert(8);
		arr.insert(7);
		arr.insert(2);
		arr.insert(4);
		arr.insert(9);

		arr.display();

		arr.selectSort();

		arr.display();
	}
}

  注意:下标在小于或等于out的位i置的元素总是有序的。

  部分内容参考Github。https://algorithm.yuanbin.me/zh-hans/basics_sorting/selection_sort.html

时间: 2024-08-07 08:37:17

BasicSort 之 SelectSort的相关文章

selectSort

function selectSort(arr) { var len = arr.length; for (var i = 0; i < len -1; i++) { for (var j = i + 1; j < len; j++) { if (arr[i] > arr[j]) { var temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } } return arr; } var arr = [1, 3, 2, 5, 4]; conso

排序--SelectSort优化

SelectSort:(以升序为例) 选择排序的基本思想:初始时,有序区为0,每一趟在无序区中选出一个关键字最小的元素,然后与无序区第一个元素交换,然后无序区减1,有序区加1,直到记录全部排完. 直接选择排序:第一趟排序在R[0..n]中选出一个关键字最小的与R[0]交换,第二趟在R[1..n]中选择一个最小的与R[1]进行交换,以此类推直到无序区的记录只剩一个时排序完成. 要知道"比较"与"移位"相比,移位更花费时间,所以直接选择排序相比于插入排序来说,能更好一点

排序算法ONE:选择排序SelectSort

1 /** 2 *选择排序: 3 * 对冒泡排序的一个改进 4 * 进行一趟排序时,不用每一次都交换,只需要把最大的标示记下 5 * 然后再进行一次交换 6 */ 7 public class SelectSort 8 { 9 /** 10 *选择排序主方法 11 * 12 */ 13 public static void selectSort(int[] resouceArr) 14 { 15 for(int i = resouceArr.length - 1 ; i >= 0 ; i-- )

数据结构基础(1) --Swap &amp; Bubble-Sort &amp; Select-Sort

Swap的简单实现 //C语言方式(by-pointer): template <typename Type> bool swapByPointer(Type *pointer1, Type *pointer2) { //确保两个指针不会指向同一个对象 if (pointer1 == NULL || pointer2 == NULL) { return false; } if (pointer1 != pointer2) { Type tmp = *pointer1; *pointer1 =

选择排序SelectSort

/** * * @author Administrator * 功能:选择排序法 */ package com.test1; import java.util.Calendar; public class SelectSort { public static void main(String[] args) { // TODO Auto-generated method stub //int[] arr = { 1, 6, 0, -1, 9, -100, -90 }; int[] arr = n

简单选择排序SelectSort

package com.cc.dataconsttuct.com; /*** * 简单选择排序:令A[0,n-1]有n个数据元素的数组,将数组A排列为一个非降序的有序数组: * 算法:首先在n个元素中找到最小元素,将其放在A[0]中,然后将剩下的n-1个元素中找到最小的放在A[1]中,这个过程不断进行下去.... * @author caocx * */public class SelectSort { public static void main(String[] args) { // TO

SelectSort 选择排序

# SelectSort选择排序_Python实现 def select_sort(li): for i in range(len(li)): min_index = i # 此处确定刚刚所排序好的最小值的次序 for j in range(i+1, len(li) ): # 此处range最大值为index最高位数+1, 因为遍历是从i+1开始和i对比. if li[j] < li[min_index]: min_index = j li[i], li[min_index] = li[min_

BasicSort — InsertionSort

一.插入排序 核心:通过构建有序序列,对于未排序序列,在已排序序列中从后向前扫描(对于单向链表则只能从前往后遍历),找到相应位置并插入.实现上通常使用in-place排序(需用到O(1)的额外空间) 从第一个元素开始,该元素可认为已排序 取下一个元素,对已排序数组从后往前扫描 若从排序数组中取出的元素大于新元素,则移至下一位置 重复步骤3,直至找到已排序元素小于或等于新元素的位置 插入新元素至该位置 重复2~5 性质: 交换操作和数组中倒置的数量相同 比较次数>=倒置数量,<=倒置的数量加上数

Android中的算法

算法是思想的体现形式,常见的算法做一些总结 算法简介 算法-Algorithm 解题方案的准确而完整的描述,是一系列解决问题的清晰指令 特征 有穷性,确切性,输入项,输出项,可行性 算法运算要素 算术运算:加减乘除等运算 逻辑运算:或.且.非等运算 关系运算:大于.小于.等于.不等于等运算 数据传输:输入.输出.赋值等运算 算法优劣评定 时间复杂度,空间复杂度,正确性,可读性,健壮性 LogN 二分法查找最坏的情况:对于N个元素的数组,第一次查找未找到则舍弃 N/2 个元素,剩下 N/2,同理第