非稳定排序--选择排序和快速排序

        问世间何为非稳定排序？

        答曰:不稳定排序算法可能会在相等的键值中改变纪录的相对次序。

讲人话，就是在一个数组中，有两个相同的数据，排序过程中，会改变两者的相对位置，就是不稳定排序。相反的，两者的相对位置不改变，则为稳定排序。

                                 

非稳定排序就有两个儿子，分别是选择排序和快速排序，都是大名鼎鼎啊。

一. 选择排序

选择排序一般是按照从小到大的顺序排列

1.排序思想：

1）将排序数组分为已排序区和未排序区。

2）每轮排序从待排序区中找出最小元素并于已排序区的后一位（待排序区的首位）交换。

        例如，未排序区中，最小值为4，则使其与5交换位置，则完成了一轮排序，以此类推。

3）直到未排序区元素数量为1，只剩下最大值，无须再排一次。

2.代码演示

void select_sort(int* arr, int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        int index = i;
        for (int j = i + 1; j < n; j++)
        {
            if (arr[index] > arr[j])
                index = j;
        }
        swap(arr[index], arr[i]);
    }
    return;
}

ps：swap为定义的一个宏，用来交换两者的值。

二. 快速排序

1.排序思想

1）选取一个基准值，一般选取首元素为基准值，保存其值，并认为首位为空。

2）设置两个指针，分别指向首和尾，若首指针指向大于基准值的元素，则将其值赋给尾指针指向部位，并认为首指针所处为空，并将尾指针向前移动，若尾指针指向小于基准值的元素，则将其值赋给首指针指向部位，并认为尾指针所处为空，将首指针向后移动一位。

3）直至首尾指针相遇，再将基准值赋给此处。

4）递归处理前后两部分，以此类推。

2.具体步骤

1）设置基准值并保存，看为空。

2）先处理右指针，right指向9，大于基准值，符合要求，向前移动，直到不符合要求的元素3；

  3）将3赋值到左指针位置，并将其看为空，左指针向后移动一位；

4）再去操作左指针，左指针指向8，大于基准值，不符合要求，将8复制到右指针位置，并将右指针向前移动一位；

 5）以此类推，直到左右指针指向同一位置，再将基准值赋到此位置。

 

6）到此，前边的都比基准值小，后边的都比基准值大，然后以递归的方法处理前后两段 。

3.代码演示

void quick_sort(int* arr, int l, int r)
{
    if (r <= l)
        return;
    int x = l;
    int y = r;
    int z = arr[l];
    while (x < y)
    {
        while (x<y && arr[y]>=z)
        {
            y--;
        }
        if (arr[y] < z)
        {
            arr[x] = arr[y];
            x++;
        }
        while (x < y && arr[x] <= z)
        {
            x++;
        }
        if (arr[x] > z)
        {
            arr[y] = arr[x];
            x++;
        }
    }
    arr[x] = z;
    quick_sort(arr,l, x);
    quick_sort(arr,x + 1, r);
     
    return;
}

 最后的最后，再呈上可以跑起来的代码。

                                       

Skip to content
Search or jump to…
Pull requests
Issues
Marketplace
Explore
 
@Xavier2077 
Xavier2077
/
Data-structures-and-algorithms
Public
Code
Issues
Pull requests
Actions
Projects
Wiki
Security
Insights
Settings
Data-structures-and-algorithms/排序与查找/不稳定排序(选择，快速）
@Xavier2077
Xavier2077 Create 不稳定排序(选择，快速）
…
Latest commit 7fdde1c 3 hours ago
 History
 1 contributor
77 lines (76 sloc)  1.38 KB
   
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define MAX_OP 20
#define swap(a, b) {int t=a;a=b;b=t;}
void select_sort(int* arr, int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        int index = i;
        for (int j = i + 1; j < n; j++)
        {
            if (arr[index] > arr[j])
                index = j;
        }
        swap(arr[index], arr[i]);
    }
    return;
}
void quick_sort(int* arr, int l, int r)
{
    if (r <= l)
        return;
    int x = l;
    int y = r;
    int z = arr[l];
    while (x < y)
    {
        while (x<y && arr[y]>=z)
        {
            y--;
        }
        if (arr[y] < z)
        {
            arr[x] = arr[y];
            x++;
        }
        while (x < y && arr[x] <= z)
        {
            x++;
        }
        if (arr[x] > z)
        {
            arr[y] = arr[x];
            x++;
        }
    }
    arr[x] = z;
    quick_sort(arr,l, x);
    quick_sort(arr,x + 1, r);
     
    return;
}
void output(int* arr, int n)
{
    printf("[");
    for (int i = 0; i < n; ++i)
    {
        printf(" %d", arr[i]);
    }
    printf(" ]\n");
}
int main() 
{
    srand(time(0));
    int* p = (int*)malloc(sizeof(int) * MAX_OP);
    for (int i = 0; i < MAX_OP; ++i)
    {
        p[i] = rand() % 100;
    }
    //select_sort(p, MAX_OP);
    //output(p, MAX_OP);
    quick_sort(p, 0, MAX_OP - 1);
    output(p, MAX_OP);
    return 0;
}