排序是数据处理中十分常见的基本算法，本文介绍三种简单的排序算法：遍历排序、冒泡排序及优化后的冒泡排序。

1、三种排序算法

1.1、遍历排序

function y = easy_sort(x)

% 遍历排序法

% 1）从第一个数开始, 将其与剩下的数依次对比, 若比其小, 则两数交换位置, 得到最小数保存到x(1)的位置

% 2）再从第二个数开始, 将其与剩下的数依次对比, 若比其小, 则两数交换位置, 得到次小数保存到x(2)的位置

% 3）以此类推, 进行比较

x_len = length(x);

for i = 1:1:x_len

for j = i:1:x_len

if (x(i) > x(j))

[x(i), x(j)] = swap(x(i), x(j));

end

end

disp([num2str(i), '. Sort: x = ', num2str(x)]);

end

y = x;

end

1.2、冒泡排序

function y = bubble_sort(x)

% 冒泡排序法

% 1）第一次循环, 确定第一个数: 从最后一个数开始, 比较相邻两数, 将较小者往前排, 依次向前两两比较, 最后，第一个数为最小值

% 2) 第二次循环, 确定第二个数: 再从最后一个数开始，依次向前两两比较，直到第二个数, 则第二个数为次小值

% 3）依次进行, 直到确定倒数第二个数

x_len = length(x);

for i = 1:1:(x_len-1)

for j = x_len:-1:(i+1)

if (x(j) < x(j-1))

[x(j), x(j-1)] = swap(x(j), x(j-1));

end

end

disp([num2str(i), '. Sort: x = ', num2str(x)]);

end

y = x;

end

1.3、冒泡排序优化

function y = bubble_sort_optim(x)

% 优化后的冒泡排序法

% 1）第一次循环, 确定第一个数: 从最后一个数开始, 比较相邻两数, 将较小者往前排, 依次向前两两比较, 最后，第一个数为最小值

% 2) 第二次循环, 确定第二个数: 再从最后一个数开始，依次向前两两比较，直到第二个数, 则第二个数为次小值

% 3）依次进行, 当某次循环不再冒泡, 即不再有交换时, 停止循环

x_len = length(x);

flag = 1;

for i = 1:1:(x_len-1)

if flag

flag = 0; %若flag为0则代表已经排好序了, 不用继续循环

for j = x_len:-1:(i+1)

if (x(j) < x(j-1))

[x(j), x(j-1)] = swap(x(j), x(j-1));

flag = 1; %有交换, 说明还需要继续循环

end

end

disp([num2str(i), '. Sort: x = ', num2str(x)]);

end

end

y = x;

end

1.4、两数交换

function [a, b] = swap(x, y)

% 两数交换

a = y;

b = x;

end

2、调用三种排序算法

% main.m

clc;

clear;

x = randperm(9); %随机排序1~9

disp(['Before Sort: x = ', num2str(x)]);

%% 1. 遍历排序

disp('------------------------------');

y = easy_sort(x);

disp(['Easy Sort: x = ', num2str(y)]);

%% 2. 冒泡排序

disp('------------------------------');

y = bubble_sort(x);

disp(['Bubble Sort: x = ', num2str(y)]);

%% 3. 冒泡排序优化

disp('------------------------------');

y = bubble_sort_optim(x);

disp(['Bubble Sort Optim: x = ', num2str(y)]);

3、排序结果对比

Before Sort: x = 2 1 3 4 6 8 5 7 9

------------------------------

遍历排序，循环8次，第7次得到结果：

1. Sort: x = 1 2 3 4 6 8 5 7 9

2. Sort: x = 1 2 3 4 6 8 5 7 9

3. Sort: x = 1 2 3 4 6 8 5 7 9

4. Sort: x = 1 2 3 4 6 8 5 7 9

5. Sort: x = 1 2 3 4 5 8 6 7 9

6. Sort: x = 1 2 3 4 5 6 8 7 9

7. Sort: x = 1 2 3 4 5 6 7 8 9

8. Sort: x = 1 2 3 4 5 6 7 8 9

Easy Sort: x = 1 2 3 4 5 6 7 8 9

------------------------------

冒泡排序，循环8次，第2次得到结果：

1. Sort: x = 1 2 3 4 5 6 8 7 9

2. Sort: x = 1 2 3 4 5 6 7 8 9

3. Sort: x = 1 2 3 4 5 6 7 8 9

4. Sort: x = 1 2 3 4 5 6 7 8 9

5. Sort: x = 1 2 3 4 5 6 7 8 9

6. Sort: x = 1 2 3 4 5 6 7 8 9

7. Sort: x = 1 2 3 4 5 6 7 8 9

8. Sort: x = 1 2 3 4 5 6 7 8 9

Bubble Sort: x = 1 2 3 4 5 6 7 8 9

------------------------------

冒泡排序优化，循环3次，第2次得到结果：

1. Sort: x = 1 2 3 4 5 6 8 7 9

2. Sort: x = 1 2 3 4 5 6 7 8 9

3. Sort: x = 1 2 3 4 5 6 7 8 9

Bubble Sort Optim: x = 1 2 3 4 5 6 7 8 9