数据结构拾遗——排序(时间复杂度O(n^2))

复习完数据结构后，决定挑选重要的部分总结一下，顺序暂定从后向前

所以一开始是排序

不多说直接上代码

swap.h

1 #pragma once　　//编译一次
2 #include <vector>　　//数据结构决定简单的使用向量
3 
4 template <typename T>　　//模板编程适用变量更多
5 void swapLHW(vector<T> &v, int i, int j) {　　//单纯的交换向量中的两个元素
6     T tmp = v[i];
7     v[i] = v[j];
8     v[j] = tmp;
9 }

c++自带了swap，不过还是定义了一个自己的

BubbleSort.h

 1 #pragma once
 2 #include <vector>
 3 #include "swap.h"
 4 template <typename T>
 5 void BubbleSort0 (vector<T> &v) {
 6     for (auto i = 0; i < v.size(); i++)
 7         for (auto j = i + 1; j < v.size(); j++)
 8             if (v[i] > v[j])
 9                 swapLHW(v, i, j);
10 }
11 
12 template <typename T>
13 void BubbleSort1(vector<T> &v) {
14     for (auto i = 0; i <v.size(); i++)
15         for (auto j = v.size() - 1; j > i; j--)
16             if (v[j] < v[j - 1])
17                 swapLHW(v, j, j - 1);
18 }
19 
20 template <typename T>
21 void BubbleSort3(vector<T> &v) {
22     bool flag = true;
23     for (auto i = 0; i < v.size() && flag; i++)
24     {
25         flag = false;
26         for (auto j = v.size() - 1; j > i; j--) 
27         {
28             if (v[j] < v[j - 1]) 
29             {
30                 swapLHW(v, j, j - 1);
31                 flag = true;
32             }
33         }
34     }
35 }

0是简易的冒泡，每次只比较固定的v[i]和递增的v[j]

事实上v[i]如果是最小了，后面的比较久没有意义

1是普通的冒泡，每次比较v[j-1]和v[j]，两个都是递减的

如果较小的在后面，可以不断上浮

如果被更小的截止，更小的可以接着上浮

2只是简单的判断了一下一次循环有没有交换元素

如果没有，说明已经排序好，跳出循环

SelectSort.h

 1 #pragma once
 2 #include "swap.h"
 3 #include <vector>
 4 template <typename T>
 5 void SelectSort(vector<T> &v) {
 6     for (auto i = 0; i < v.size(); i++)
 7     {
 8         int pos = i;
 9         for (auto j = i + 1; j < v.size(); j++)
10         {
11             if (v[j] < v[pos])
12             {
13                 pos = j;
14             }
15         }
16         if (pos != i)
17         {
18             swapLHW(v, i, pos);
19         }
20     }
21 }

选择排序

简单的想法，每次扫描未排序好的部分

选择最小的放前面

StraightInsertSort.h

 1 #pragma once
 2 #include "swap.h"
 3 #include <vector>
 4 using namespace std;
 5 template <class T>
 6 void StraightIS(vector<T> &v) {
 7     T tmp;
 8     for (auto i = 1; i < v.size(); i++)
 9     {
10         tmp = v[i];
11         if (v[i] < v[i - 1])
12         {
13             int j = i - 1;
14             for (; j >= 0 && v[j] > tmp; j--)
15             {
16                 v[j + 1] = v[j];
17             }
18             v[j + 1] = tmp;
19         }
20         
21     }
22 }

直接插入排序

从第二个开始，依次取第二、三……个元素

插入到前面的位置

比这个元素大的元素，向后移动一个位置

 

posted @ 2017-04-16 21:03  r088r088  阅读(221)  评论(1)  编辑  收藏  举报