内部排序之交换排序

目录

1. 快速交换排序简介及其代码
2. 冒泡交换排序及其代码
3. 交换排序总结

---

快速排序简介及其代码

我们知道假如一个已排好序的数组,假如是从小到大升序排列,则随便取其中一个数N,则N左边所有数都小于或等于N,右边的都大于或等于N.

那反向思维下,我们先随便取数组第一个数为基准X,然后将所有小于它的数交换到左边,大于它的数交换到右边.最后X可能就被交换到中间某个位置.以X为分界线,数组被分成两部分.接着再对两部分重复同样的操作.这里用到了递归的思想.

快速排序里面的元素交换又叫填坑,首先取出一个值做标准值basic,则该值所在的位置i变成一个坑,从后面开始遍历碰到大于X的值(假如下标是j)就把该值交换到位置i,这样位置j就多出一个坑,从前面遍历,碰到大于basic的值(假如位置是i)则把该值交换到位置j.这样i又多出一个坑. 这样不停的从后到前遍历,从前到后遍历,i与j值不断的变.最后i == j时停止.而此时位置i肯定是空着的,于是把值basic移到这里来.这样basic左边的值都小于它,右边的都大于它了.

所以整个操作分三步.

1.取一个数作为基准值(可以随意取一个,不过一般情况取第一个)

2.不停的比较交换数据,使最终基准值左边的都小于它,右边的都大于它

3.以步骤2中基准值的位置为中点,把待排序数组分为两部分,再分别重复步骤2(这里用了递归的思想)

s=0,t=9;r[s]=6,r[t]=5;并把s赋给i，把t赋给j；取一般的标准值tmp,即第一个元素。，tmp=r[s];
此时先看r[j]=5,5小于6，应该在6的右边，所以把r[9]赋值给r[0],因为r[9]的元素被挪走了所以此时r[9]为一个坑，需要一个元素来填坑。要填坑，就要从i的下标里面找，此时r[0]已经是5了。5<6,符合条件i++,r[1]为8，大于6，需要移动，于是把r[j]=r[i],刚好填了r[9]的空。
依此类推，从j下标开始的，如果元素大于等于标准元素，j–,进行下一次比较，否则进行移动。
从i下标开始的，如果元素小于等于标准元素，i++进行下一次比较，否则进行移动。
最后i==j时，r[i]=tmp。
代码：

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
typedef int KeyType;
typedef struct
{
    KeyType key;
    int data;
}RecType;
void QuickSort(RecType R[],int s,int t)
{
    int i = s, j = t;
    RecType tmp;
    if (s < t)
    {
        tmp = R[s];
        while (i != j)
        {
            while (j > i && R[j].key >= tmp.key)
            {
                j--;
            }
            R[i] = R[j];
            while (i < j && R[i].key <= tmp.key)
            {
                i++;
            }
            R[j] = R[i];
        }
        R[i] = tmp;
        QuickSort(R, s, i - 1);
        QuickSort(R, i + 1, t);
    }
}
int main(void)
{
    RecType R[MAXSIZE];
    KeyType a[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
    int i,n = 10;
    for (i = 0; i < n; i++)
    {
        R[i].key = a[i];
    }
    printf("排序前");
    for (i = 0; i < n; i++)
    {
        printf("%d ", R[i].key);
    }
    printf("\n");
    QuickSort(R, 0, n-1);
    printf("排序后");
    for (i = 0; i < n; i++)
    {
        printf("%d ", R[i].key);
    }
    printf("\n");
    system("pause");
    return 0;
}

---

冒牌排序的简介及其代码

代码：

#include<stdio.h>
#include<assert.h>
#include<stdlib.h.h>
//从头向尾遍历
//相邻两数进行比较
//将最大数(相对)沉入尾部(相对)
void BubbleSort1(int *arr,int sz){
    int i = 0;
    int j = 0;
    assert(arr);
    for(i=0;i<sz-1;i++){
        for(j=0;j<sz-i-1;j++){
            if(arr[j]>arr[j+1]){
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
}
//从尾向头遍历
//相邻两数进行比较
//将最小数(相对)冒泡到头部(相对)
void BubbleSort2(int *arr,int sz){
    int i = 0;
    int j = 0;
    assert(arr);
    for(i=0;i<sz-1;i++){
        for(j=sz;j>i;j--){
            if(arr[j]>arr[j-1]){
                int tmp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = tmp;
            }
        }
    }
}
//测试函数
//为了方便起见,将参数设定为一个函数指针
void TestBubbleSort(void (*BubbleSort)(int *arr,int sz)){
    int arr[]={1,3,5,7,9,2,4,6,8,0};
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    BubbleSort(arr,sz);
    for(i=0; i<sz; i++){
        printf("%d ",arr[i]);
    }
    printf("\n");
}
int main(){
    TestBubbleSort(BubbleSort1);
    TestBubbleSort(BubbleSort2);
    system("pause");
    return 0;

测试结果：