DataStructure 排序 源码实现

本篇博客实现了 1.冒泡排序 2.冒泡排序的一种优化(当某次冒泡没有进行交换时，退出循环) 3.选择排序 4.归并排序 5.快速排序。

主要是源码的实现，并将自己在敲的过程中所遇到的一些问题记录下来。

全局定义与相关声明：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

int num[100005];            //存储数组

void swap1(int i, int j)    //交换函数swap
{
    int t = num[i];
    num[i] = num[j];
    num[j] = t;
}

/*Printnum 输出*/

void Printnum(int n)        //输出排序完成的数组
{
    for (int i = 1; i <= n; i++) {
        cout << num[i] << " ";
    }
    
    cout << endl;
}

1.冒泡排序

/*Bubble_Sort 冒泡排序*/

void Bubble_Sort(int n)
{
    int i, j;
    
    for (i = 1; i <= n; i++)                //遍历n次
    {
        for (j = 1; j <= n-i; j++)          //每次都把最大数往后排，缩小范围
        {
            if (num[j] > num[j+1])
            {
                swap1(j, j+1);
            }
        }
    }
}

冒泡的思想：不断把范围中的最大数往后排，排完之后缩小范围；以上过程执行n次。

个人小结：思想很简单，但是太久不碰真的会忘记。

2.冒泡排序的优化

void Bubble_Sort_Better(int n)
{
    int i, j;
    
    for (i = 1; i <= n; i++)
    {
        bool flag = true;
        
        for (j = 1; j <= n-i; j++)
        {
            if (num[j] > num[j+1])
            {
                flag = false;
                
                swap1(j, j+1);
            }
        }
        
        if (flag) break;                    //某一次遍历没有发生交换时，结束
    }
}

优化的思想：当某一次冒泡没有交换任何数时，则说明当前范围内序列有序，结束循环。

3.选择排序

/*Selection_Sort 选择排序*/

void Selection_Sort(int n)
{
    int i, j;
    
    int rcd;
    
    for (i = 1; i <= n; i++)
    {
        rcd = i;
        
        for (j = i+1; j <= n; j++)
        {
            if (num[j] < num[rcd])          //找出i+1=>n范围内的最小元并前移
            {
                rcd = j;
            }
        }
        
        swap1(i, rcd);
    }
}

思想：找出范围i => n内最小的数，用rcd(初始化为i)记录其位置，之后与寻找范围内的第一个数num[i]进行交换，保证i+1 => n的所有数均大于num[i]。

4.归并排序：

/*Merge_Sort 归并排序*/

int temp[100005];

void Merge_Array(int l1, int r1, int l2, int r2)
{
    int p1 = l1;
    int p2 = l2;
    
    int i = 1;
    
    memset(temp, 0, sizeof(temp));
    
    for (i = l1; i <= r2; i++)
    {
        if (p1 > r1)
        {
            temp[i] = num[p2++];
            
            continue;
        }
        
        if (p2 > r2)
        {
            temp[i] = num[p1++];
            
            continue;
        }
        
        if (num[p1] < num[p2])
        {
            temp[i] = num[p1++];
            
            continue;
        }
        
        else
        {
            temp[i] = num[p2++];
            
            continue;
        }
    }
    
    for (i = l1; i <= r2; i++)
    {
        num[i] = temp[i];
    }
    
}

void Merge_Sort(int l, int r)
{
    if (l < r)
    {
        int mid = (l+r)/2;
        
        Merge_Sort(l, mid);             //l => mid
        Merge_Sort(mid+1, r);           //mid+1 => r
        
        Merge_Array(l, mid, mid+1, r);  //l => mid => mid+1 => r
    }
}

思想可以参考：白话经典算法系列之五 归并排序的实现

大概的思路是，先并后归，将范围二分，分别递归排序之后再进行合并(利用一个额外的数组temp)。

个人小结：

1.看似简单，实现起来总是会出问题；动手吧。

2.一定要注意：递归选取的范围，取了mid = (l+r)/2之后，左边的一半范围为[l => mid]，右边的一半范围为[mid+1 => r]。原因可以考虑以下情况：两个数3 1进行排序，mid = 1，如果选取的范围为[l => mid-1]和[mid => r](这里是[1 => 1]和[1 => 2])，则会出现死循环。

5.QuickSort快速排序

int Quick_Sort_Adjust(int l, int r)
{
    int key = l;               //选取第一个元素为基准值
    
    int a, b;
    
    a = l+1;
    
    b = r;
    
    while (a < b)
    {
        bool out_bound = false;
        
        while (1)
        {
            if (num[a] > num[key]) break;
            
            a++;
            
            if (a > r)
            {
                out_bound = true;
                
                break;
            }
        }
        
        while (1)
        {
            if (num[b] < num[key]) break;
            
            b--;
            
            if (b < l)
            {
                out_bound = true;
                
                break;
            }
        }
        
        if (out_bound || a >= b) break;         //如果出现越界或a>=b直接结束
        
        swap1(a, b);
        
        a++;
        b--;
    }
    
    swap1(key, a-1);
    
    return a-1;
}

void Quick_Sort(int l, int r)
{
    if (l < r)
    {
        int mid = Quick_Sort_Adjust(l, r);
        
        Quick_Sort(l, mid-1);               //l => mid-1
        Quick_Sort(mid+1, r);               //mid+1 => r
    }
}

思想可以参考：白话经典算法系列之六 快速排序 快速搞定

思路上文讲的很清楚了，建议在纸上模拟以下四种情况：

1.n = 7
1 3 1 2 -1 8 9

2.n = 7
1 1 1 1 1 1 1

3.n = 7
7 6 5 4 3 2 1

4.n = 7
7 1 1 1 1 1 1

个人小结：

1.同样的，自己敲一遍能够发现一堆问题。

2.一定要注意，当出现以下两种情况时：(1)i>j(这里的代码是a>b) (2)i、j越界 应该立即退出循环。

3.递归范围的选择，在基准值num[key]和num[mid]交换之后，接下来的递归范围应该为[l => mid-1]和[mid+1 => r]，因为[l => mid-1]范围内的所有值都小于num[mid]，[mid+1 => r]内的所有值都大于num[mid]；如果选取范围对mid取等，会出现上文中两个数(如 3 1)的死循环。

4.这里选择的基准是第一个数，快速排序还有很多改进版本，如随机选择基准数，区间内数据较少时直接用别的方法排序以减小递归深度。

完整代码如下：

//
//  main.cpp
//  Sort
//
//  Created by wasdns on 16/12/25.
//  Copyright © 2016年 wasdns. All rights reserved.
//

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

/*存储数组定义*/

int num[100005];

void swap1(int i, int j)
{
    int t = num[i];
    num[i] = num[j];
    num[j] = t;
}

/*Printnum 输出*/

void Printnum(int n)
{
    for (int i = 1; i <= n; i++) {
        cout << num[i] << " ";
    }
    
    cout << endl;
}

/*Bubble_Sort 冒泡排序*/

void Bubble_Sort(int n)
{
    int i, j;
    
    for (i = 1; i <= n; i++)                //遍历n次
    {
        for (j = 1; j <= n-i; j++)          //每次都把最大数往后排，缩小范围
        {
            if (num[j] > num[j+1])
            {
                swap1(j, j+1);
            }
        }
    }
}

void Bubble_Sort_Better(int n)
{
    int i, j;
    
    for (i = 1; i <= n; i++)
    {
        bool flag = true;
        
        for (j = 1; j <= n-i; j++)
        {
            if (num[j] > num[j+1])
            {
                flag = false;
                
                swap1(j, j+1);
            }
        }
        
        if (flag) break;                    //某一次遍历没有发生交换时，结束
    }
}

/*Selection_Sort 选择排序*/

void Selection_Sort(int n)
{
    int i, j;
    
    int rcd;
    
    for (i = 1; i <= n; i++)
    {
        rcd = i;
        
        for (j = i+1; j <= n; j++)
        {
            if (num[j] < num[rcd])          //找出i+1=>n范围内的最小元并前移
            {
                rcd = j;
            }
        }
        
        swap1(i, rcd);
    }
}

/*Merge_Sort 归并排序*/

int temp[100005];

void Merge_Array(int l1, int r1, int l2, int r2)
{
    int p1 = l1;
    int p2 = l2;
    
    int i = 1;
    
    memset(temp, 0, sizeof(temp));
    
    for (i = l1; i <= r2; i++)
    {
        if (p1 > r1)
        {
            temp[i] = num[p2++];
            
            continue;
        }
        
        if (p2 > r2)
        {
            temp[i] = num[p1++];
            
            continue;
        }
        
        if (num[p1] < num[p2])
        {
            temp[i] = num[p1++];
            
            continue;
        }
        
        else
        {
            temp[i] = num[p2++];
            
            continue;
        }
    }
    
    for (i = l1; i <= r2; i++)
    {
        num[i] = temp[i];
    }
    
}

void Merge_Sort(int l, int r)
{
    if (l < r)
    {
        int mid = (l+r)/2;
        
        Merge_Sort(l, mid);             //l => mid
        Merge_Sort(mid+1, r);           //mid+1 => r
        
        Merge_Array(l, mid, mid+1, r);  //l => mid => mid+1 => r
    }
}

/*Quick_Sort 快速排序*/

int Quick_Sort_Adjust(int l, int r)
{
    int key = l;               //选取第一个元素为基准值
    
    int a, b;
    
    a = l+1;
    
    b = r;
    
    while (a < b)
    {
        bool out_bound = false;
        
        while (1)
        {
            if (num[a] > num[key]) break;
            
            a++;
            
            if (a > r)
            {
                out_bound = true;
                
                break;
            }
        }
        
        while (1)
        {
            if (num[b] < num[key]) break;
            
            b--;
            
            if (b < l)
            {
                out_bound = true;
                
                break;
            }
        }
        
        if (out_bound || a >= b) break;         //如果出现越界或a>=b直接结束
        
        swap1(a, b);
        
        a++;
        b--;
    }
    
    swap1(key, a-1);
    
    return a-1;
}

void Quick_Sort(int l, int r)
{
    if (l < r)
    {
        int mid = Quick_Sort_Adjust(l, r);
        
        Quick_Sort(l, mid-1);               //l => mid-1
        Quick_Sort(mid+1, r);               //mid+1 => r
    }
}

int main()
{
    int n;
    
    cin >> n;
    
    for (int i = 1; i <= n; i++)
    {
        cin >> num[i];
    }
    
    int option;
    
    cin >> option;
    
    if (option == 1)
    {
        cout << "Bubble_Sort" << endl;
        
        Bubble_Sort(n);
    }
    
    else if (option == 2)
    {
        cout << "Bubble_Sort_Better" << endl;
        
        Bubble_Sort_Better(n);
    }
    
    else if (option == 3)
    {
        cout << "Selection_Sort" << endl;
        
        Selection_Sort(n);
    }
    
    else if (option == 4)
    {
        cout << "Merge_Sort" << endl;
        
        Merge_Sort(1, n);
    }
    
    else if (option == 5)
    {
        cout << "Quick_Sort" << endl;
        
        Quick_Sort(1, n);
    }
    
    Printnum(n);
    
    return 0;
}

2016/12/26