数据结构 排序(选择排序)

//排序--选择排序法
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>

/*
选择排序(Selection sort)是一种简单直观的排序算法。
它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,
存放在序列的起始位置,直到全部待排序的数据元素排完。
选择排序是不稳定的排序方法(比如序列[5, 5, 3]第一次就将第一个[5]与[3]交换,导致第一个5挪动到第二个5后面)。

选择排序 创建一个有序数组A,
第一步:找出无序数组B中的最小的元素  把他放置在有序数组A的第一个位置,从无序数组B中将该元素删除
第二步:继续找出无序数组B中的最小的元素  把他放置在有序数组A的第二个位置,从无序数组B中将该元素删除

选择排序&冒泡排序&插入排序:

选择排序每一轮都会遍历无序数组一遍,
插入排序每一轮都会遍历有序数组一遍,
冒泡排序不存在有序数组和无序数组的概念,只是通过相邻元素的交换 将最值元素放到数组的一端
*/

//选择法排序
void SelectionSort(int * arr, int num){
    if (arr==NULL)
    {
        printf("传入参数不可以为空!\n");
        return;
    }
    int i = 0, j = 0,k=0,temp=0;
    for (i = 0; i < num; i++)
    {
        //假设k是最小元素的下标
        k = i;
        for (j = i+1; j < num; j++)
        {
            //k初始化为0  当j=1是 正好是arr[0] vs arr[1]  没有漏掉任何一个元素
            if (arr[j]<arr[k])
            {
                //发现比下标为k的元素 更小的元素  改变k的值
                //改变之后  k这个下标的元素现在是最小的了
                k = j;
            }
        }
        //交换最小元素和第0个元素的值---一轮循环完了再进行交换
        if (k != i)
        {
            temp = arr[i];
            arr[i] = arr[k];
            arr[k] = temp;
        }
    }
}

//打印数组
void Print(int * arr,int num){
    if (arr == NULL)
    {
        printf("传入参数不可以为空!\n");
        return;
    }
    int i = 0;
    for (int i = 0; i < num; i++)
    {
        printf("%5d", *(arr + i));
    }
    printf("\n");
}

void Test(){
    int i = 0;
    int arr[10] = { 0 };
    //定义时间类型变量
    time_t ts;
    //生成随机数种子
    srand((unsigned int)time(&ts));
    for (i = 0; i < 10; i++)
    {
        arr[i] = (int)(rand() % 100);
    }
    //打印数组
    printf("\n原始数据----\n");
    Print(arr, 10);
    //选择法排序
    printf("选择法排序之后的数据\n");
    SelectionSort(arr, 10);
    Print(arr, 10);
}

void main(){
    Test();
    system("pause");
}

时间: 2024-08-03 13:41:57

数据结构 排序(选择排序)的相关文章

数据结构 - 简单选择排序(simple selection sort) 详解 及 代码(C++)

数据结构 - 简单选择排序(simple selection sort) 本文地址: http://blog.csdn.net/caroline_wendy/article/details/28601965 选择排序(selection sort) : 每一趟在n-i+1个记录中选取关键字最小的记录作为有序序列中第i个记录. 简单选择排序(simple selection sort) : 通过n-i次关键字之间的比较, 从n-i+1个记录中选出关键字最小的记录, 并和第i个记录交换. 选择排序需

算法大神之路----排序(选择排序法)

选择排序法,顾名思义,就是把特定的数据选择出来进行排序. 选择排序法有两种方式 在所有的数据中,当由大到小排序,那么就将最大值放到第一个位置 如果由小到大排序,那么就将最小值放到第一个位置 以由小到大排序举例,当排序时候,扫描整个数据,拿第一个依次与其他做比较,如果其他数据比第一个大,或者相等,那么就不交换,如果其他数据比第一个数小,那么就交换二者的位置,扫描结束后,则从第二个数开始,依次扫描. 方法分析 无论是最坏还是最好情况,甚至是平均情况下,都需要对全部数据进行扫描,找到最大或最小值,因此

01. Java的经典排序--选择排序--冒泡排序--折半查找(二分查找)

Java的经典排序--选择排序--冒泡排序--折半查找 选择排序 选择排序 3 2 1 5 8 0 1 3 2 5 8 1 1 2 3 5 8 2 1 2 3 5 8 3 1 2 3 5 8 public static void main(String[] args) { int[] arr={3,2,1,5,8}; selectSort(arr); for(int i = 0 ; i < arr.length ; i ++){ System.out.println(arr[i]) ; } }

数据结构之——选择排序

选择排序的基本思想为:每一趟(例如第i趟)在后面的n-i+1(i=1,2,3,…...,n-1)个待排序元素中选取关键字最小的元素,作为有序序列的第i个元素,直到n-1趟做完,待排序元素只剩下一个,就不用选了,序列也排序完毕.选择排序主要有简单选择排序和堆排序,下面分别就这两种排序算法进行讨论. 1.简单选择排序 从上面选择排序的思想中可以很直观的得出简单选择排序的算法思想:假设排序列表为L[1……n],第i趟排序从L[i……n]中选择关键字最小的元素与L(i)交换,每一趟排序可以确定一个元素的

数据结构之选择排序--简单选择排序

排序思路:在要排序的一组数中,选出最小的一个数与第一个位置的数交换:然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环.算法实现: public static void selectSort(int arr[]){ int temp; for(int i = 0;i < arr.length-1; i ++){//有N个元素只需比较N-1次 int min = i;//记住初始位置 for(int j = i+1; j < arr.length; j ++){//在 [i+1,arr.

数据结构排序-选择排序

选择排序中的两个经典算法:简单选择排序,堆排序. 简单选排:通过n-1次数据元素的比较,从n-i+1个记录中选择最小的数据,并与第i个数据进行交换,它的时间复杂度是O(n^2). 堆排序:利用堆的特征进行排序,复杂度为O(n*logn). 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 int n; 5 6 /* 7 * 选择排序 8 */ 9 void SelectSort(int *array) 10 { 11 int i, j,

数据结构——排序——选择排序算法

选择排序(Selection sort)是一种简单直观的排序算法.它的工作原理如下.首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾.以此类推,直到所有元素均排序完毕. 选择排序的主要优点与数据移动有关.如果某个元素位于正确的最终位置上,则它不会被移动.选择排序每次交换一对元素,它们当中至少有一个将被移到其最终位置上,因此对n个元素的表进行排序总共进行至多n-1次交换.在所有的完全依靠交换去移动元素的排序方

算法与数据结构之选择排序(C语言)

1 #include<stdio.h> 2 #include<stdlib.h> 3 void SelectSort(int *a,int n);//预声明要调用的函数 4 int main(void) 5 { 6 int k; 7 int x[10]={2,4,6,8,0,1,3,5,7,9}; 8 for(k=0;k<10;k++) 9 printf("%d",x[k]); 10 printf("\n"); 11 SelectSor

【数据结构】选择排序算法示例

基本选择排序编辑 排序算法即解决以下问题的算法: 输入 n个数的序列<a1,a2,a3,...,an>. 输出 原序列的一个重排<a1*,a2*,a3*,...,an*>:,使得a1*<=a2*<=a3*<=...<=an* 排序算法有很多,包括插入排序,冒泡排序,堆排序,归并排序,选择排序,计数排序,基数排序,桶排序,快速排序等.插入排序,堆排序,选择排序,归并排序和快速排序,冒泡排序都是比较排序,它们通过对数组中的元素进行比较来实现排序,其他排序算法则是

大话数据结构——简单选择排序

在学了冒泡排序后,会发觉这种算法就是不断比较交换.虽简单直接,显然给人一种繁琐的感觉.那有没有更好一点的算法呢?这当然有啦,没有就糟糕透了 :-P 这篇文章介绍一种较冒泡要好的排序算法:简单选择排序 看到“选择”这两字估计也猜到一二了.没错,这种算法的思想就是:待找到了最适合的那位数的位置我才选择与它进行交换 这样做,我们大大省下了很多不必要的交换.因为在代码编写中,交换函数是经常使用,所以一般将其封装成一个函数进行调用.如果存在非常多不必要的交换操作,这就产生了非常多不必要的函数调用.要知道,