插入排序,选择排序

1.插入排序

4 2 5 1 6 3

选定4, [0,0]这个区间是已处理的有序区间
现在遍历[1,5]这个区间,逐渐插入已处理的有序区间

把2拿出来 与[4]比较,发现<4 ,把4挪到它后面的位置处

_ 4 5 1 6 3

考察之前的4所在的位置0位是不是应该插入的地,2与这个预插入位置之前的元素比较,发现已经到头
所以0位是2正确插入的位置 插入后

2 4 5 1 6 3

然后考察5 把5挖出来,看下5是否能放在2这个位置,需要和2位置前面的元素比较
发现5>前面的元素4,所以5 放进2这个位置

2 4 5 1 6 3

继续考察1,把1挖出来,看下1是否能放在3个位置

与之前的2号元素比较,发现1<5,2号元素往后移动

2 4 5 6 3

2号位置空出来,考察2号之前的元素,发现4>1 ,说明2号位置不是最终插入位置
需要把2号之前的元素往后移动

2 4 5 6 3

1号位置空出来后,考察1号位置是不是最终插入位置,发现1<1号之前的元素2
所以1号位置不是最终插入位置
继续把1号前一位元素移动到1号

_ 2 4 5 6 3

此时考察0号位是不是最终插入位置,发现要比较的位置为-1号 超出范围
所以要比较的号位+1位即0号位时最终插入位置

1 2 4 5 6 3

6的插入和之前的5一样

1 2 4 5 6 3

把5号位的3挖出来,看下5号位是不是最终插入位置
3与5号位前一位4号位的6比较,发现小于6,所以需要把4号位的6移动到5号位

1 2 4 5 6

预插入4号位,拿3与4号位前的3号位比较 发现3<5
把3号位往后移动

1 2 4 5 6

预插入3号位 ,与2号位比较 3<4
2号位后移

1 2 _ 4 5 6

预插入2号位,与2号位前位1号位的2比较,发现3>2

终于找到了此次预插入的位即为最终插入位,over

1 2 3 4 5 6

code

insertSort(int arr[],int size){
    int i,j;

    for(i=1;i<size;i++){
        int tmp=arr[i];
        for (j=i-1;j>=0;j--){
            if(arr[j]>tmp){
                arr[j+1]=arr[j];
            } else{
                break;
            }
        }
        arr[j+1]=tmp;
    }
}

选择排序

4 2 5 1 6 3

minindex=0,要考察位0

逐个考察每个元素把相应位置放入相应的元素

第一轮,找到4元素位置应该放的元素,从待考察集合里找到最小的元素的元素与4交换

  • 选定第一个待考察的元素 4,把4挖出来,认为这个位置的元素是最小的,minindex=0
  • 逐个遍历待考察元素之后的元素,发现2<4,所以 暂时认定2是最小元素,minindex=1
  • 继续考察5,发现2<5 ,minindex不变
  • 继续考察1 发现 1<2 minindex=3
  • 继续考察6 发现 1<6 minindex不变
  • 继续考察3 发现 1<3 minindex不变
  • 此轮考察完毕,找到minindex=3

    4 2 5 1 6 3

    交换

    1 2 5 4 6 3

第二轮:找到索引为1位置应该存放的元素,从其下一位开始考察

minindex=1,要考察位1

  • 考察5,2<5 ,minindex不变
  • 考察4 发现2<4 minindex不变
  • 考察6 发现2<6 minindex不变
  • 考察3 发现 2<3 minindex不变
  • 发现minindex与初始的一样,无需交换

    1 2 5 4 6 3

依次考察后续位最终数组排序完成
code

void selectSort(int arr[],int size){
    int i,j;
    for(i=0;i<size;i++){
        int minIndex=i;
        for(j=i+1;j<size;j++){
            if(arr[j]<arr[minIndex]){
                minIndex=j;
            }
        }
        if(minIndex!=i){
            int tmp=arr[minIndex];
            arr[minIndex]=arr[i];
            arr[i]=tmp;
        }
    }
}

code

原文地址:https://www.cnblogs.com/HKUI/p/11185142.html

时间: 2025-01-17 20:12:02

插入排序,选择排序的相关文章

数组排序-冒泡排序-插入排序-选择排序-Java实现

package org.lyk.entities; public class SortHelper { public static void BubbleSort(int[] array) { for(int i = array.length-1; i >= 1 ; i--) { for(int j = 0; j < i ; j++) { if(array[j] > array[j+1]) { int temp = array[j]; array[j] = array[j+1]; arr

冒泡排序,插入排序,选择排序

""" 遍历数组 交换旗帜变量 = 假 (False) 从 i = 1 到 最后一个没有排序过元素的指数 如果 左边元素 > 右边元素 交换(左边元素,右边元素) 交换旗帜变量 = 真(True) """ def bubble_sort(arr): for i in range(len(arr)): flag = False for j in range(len(arr)-i-1): if arr[j] > arr[j+1]: arr

算法 排序lowB三人组 冒泡排序 选择排序 插入排序

参考博客:基于python的七种经典排序算法   [经典排序算法][集锦]     经典排序算法及python实现 首先明确,算法的实质 是 列表排序.具体就是操作的列表,将无序列表变成有序列表! 一.排序的基本概念和分类 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法. 排序的稳定性: 经过某种排序后,如果两个记录序号同等,且两者在原无序记录中的先后秩序依然保持不变,则称所使用的排序方法是稳定的,反之是不稳定

基本排序算法(冒泡排序 选择排序 插入排序 快速排序 归并排序 基数排序 希尔排序)

冒泡排序 public static void bubbleSort(int[] arr){ int lgn = arr.length; for (int i = 0; i < lgn - 1; i++) { for (int j = 0; j < lgn - 1 - i; j++) { if(arr[j] > arr[j + 1]){ int temp = arr[j + 1]; arr[j + 1] = arr[j]; arr[j] = temp; } } } } 选择排序 publ

Python排序-冒泡排序、选择排序、插入排序

''' 冒泡排序 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成. 这个算法的名字由来是因为越大的元素会经由交换慢慢"浮"到数列的顶端 ''' data_set = [12,45,2,48,66,2,1,56,36,90,5,10,503] for i in range(len(data_set)): ##控制相邻比较的轮数 for j in range(len(data_set

选择排序和插入排序

选择排序思想是:假设一组混乱数组中一个数字是排好序的,然后对其他数字逐个排序,注意他与插入排序本质区别是,选择排序没有提前退出一说,也就是说必须要全部遍历完的,而插入排序可以提前退出循环 下面选择排序代码: let select = (arr) => { for (var i = 0; i < arr.length;i++) { for (var j = i+1; j< arr.length;j++) { if (arr[j] < arr[i]) { swap(arr, j, i)

python开发之路Day17-算法设计(冒泡排序、选择排序、插入排序、二叉树)

s12-20160514-day17 *:first-child { margin-top: 0 !important; } body>*:last-child { margin-bottom: 0 !important; } /* BLOCKS =============================================================================*/ p, blockquote, ul, ol, dl, table, pre { margin

Java学习 (七)、数组,查找算法,二分查找法,冒泡排序,选择排序,插入排序

一.常用数组查找算法 工作原理:它又称为顺序查找,在一列给定的值中进行搜索,从一端的开始逐一检查每个元素,知道找到所需元素的过程. 例1:查找指定的数在数组中出现的位置,找到返回下标,找不到返回-1 1 import java.util.Scanner; 2 public class LinearSearch{ 3 public static void main(String []argas) 4 { 5 int [] array={10,100,90,65,80,92}; 6 System.o

插入排序 | 冒泡排序 | 希尔排序 | 堆排序 | 快速排序 | 选择排序 | 归并排序

以下是最近学习各种算法的代码实现: #include <stdlib.h> #include <stdio.h> #include <time.h> #include <limits.h> typedef int EleType; typedef int (*CompFunc)(void *,void *); int IntComp(void * a,void *b) { if(*(int *)a > *(int *)b) return 1; if(*