/*
---------------------直接选择排序----------------------
初始关键字: 9 8 7 6 5 4 3 2 1
i = 1 1 8 7 6 5 4 3 2 9
i = 2 1 2 7 6 5 4 3 8 9
i = 3 1 2 3 6 5 4 7 8 9
i = 4 1 2 3 4 5 6 7 8 9
直接选择排序算法是从数组无序区域第一个位置元素开始,和该位置元素为标准,不断的寻找最小的元素位置,然后让该
元素和最小的元素位置进行交换.加入到有序的区域内。
*/
void Sort::selectSort(RecType *R, int n)
{
traverseArray(R, n);
int k = 0;//最小记录的元素位置
RecType tmp;
for (int i = 0; i < n - 1; i++)
{
k = i;//最小元素位置设为当前的位置
for (int j = i + 1; j < n; j++)
{
if (R[j].key < R[k].key)
{
k = j;//最小位置改变
}
}
//最后当前位置和最小位置的值进行交换
//i = k代表就是这个位置已经是正确的了
if (i != k)
{
tmp = R[k];
R[k] = R[i];
R[i] = tmp;
}
}
traverseArray(R, n);
}
/*
---------------------冒泡排序----------------------
初始关键字 9 8 7 6 5 4 3 2 1
i = 1 1 9 8 7 6 5 4 3 2
i = 2 1 2 9 8 7 6 5 4 3
i = 3 1 2 3 9 8 7 6 5 4
i = 4 1 2 3 4 9 8 7 6 5
i = 5 1 2 3 4 5 9 8 7 6
i = 6 1 2 3 4 5 6 9 8 7
i = 7 1 2 3 4 5 6 7 9 8
i = 8 1 2 3 4 5 6 7 8 9
冒泡排序算法是属于交换算法,首先先从初始关键字数组种的底部开始,对两个数进行比较.如果顺序不对就进行交换,否则不动.
现在以 i = 1作为例子.
循环如下:
1和2对比 1小2大 交换 此时 数组是这样的 9 8 7 6 5 4 3 1 2
然后 3 1对比 同理 9 8 7 6 5 4 1 3 2
然后 4 1对比 9 8 7 6 5 1 4 3 2
下面都是这样道理,只要1交换到最前面就是 i = 1的那个结果了.原理就是这样.
*/
void Sort::bubbleSort(RecType *R, int n)
{
traverseArray(R, n);
RecType tmp;
int hasChanges = 0; //是否有过交换
for (int i = 0; i < n - 1; i++)
{
for (int j = n - 1; j > i; j--)
{
hasChanges = 0;//没有过交换
if (R[j - 1].key > R[j].key)
{
//数据交换
tmp = R[j];
R[j] = R[j - 1];
R[j - 1] = tmp;
hasChanges = 1;
}
}
//代表本次循环中没有过任何数据交换,就不用继续比较了
if (hasChanges == 0) {
break;
}
}
traverseArray(R, n);
}
void Sort::insertSort_Shell(RecType *R, int n)
{
traverseArray(R,n);
//初始增量
int d = n/2;
//增量大于1
while (d >= 1)
{
shell_sort(R, d, n);
d = d/2;
}
traverseArray(R,n);
}
/*
二分法插入排序算法其实和普通的插入排序算法最大区别就是,因为普通的插入排序算法将元素一一比较然后
插入在有序区域里面.所以在有序区域里面插入可以利用二分法来插入不用一个一个比较.提高效率
*/
void Sort::insertSort_dichotomy(RecType R[], int n)
{
std::cout<<"+++++二分法插入排序算法函数测试+++++"<<std::endl;
traverseArray(R,n);
int low,high,mid;//二分法最低位/最高位/中间位置
RecType tmp;
for (int i = 1; i < n; i++)
{
tmp = R[i];
low = 0;
high = i - 1;
//二分法遍历,low大于high时候退出循环 此high位置是比前面一个数要小
while(low <= high)
{
//开始循环之前找中间位置
mid = (low + high) / 2;
//该数目比中间数小(在左边)
//该数目比中间数大或者等于(在右边)
//记住新区间不包括中间的位置
if (tmp.key < R[mid].key )
{
high = mid - 1;
}
else
{
low = mid + 1;
}
}
//移动元素,用二分法确定元素位置后
for (int j = i - 1; j >= high + 1; j--) {
R[j + 1] = R[j];
}
R[high + 1] = tmp;
}
traverseArray(R, n);
}
void Sort::heapSort(RecType R[], int n)
{
traverseArray(R, n);
//建立初始堆(只是必须要的)
for (int i = n - 1; i >= 0; i--)
{
sift(R, i, n);
}
int last = n - 1;//最后面一个节点
for (int i = 1; i <= n;i++,last--)
{
RecType temp = R[0];
R[0] = R[last];
R[last] = temp;
sift(R, 0, last);
}
traverseArray(R, n);
}
/*
------------------插入排序----------------------
初始关键字 9 8 7 6 5 4 3 2 1
第一次循环 i = 1 [8 9] 7 6 5 4 3 2 1 将8插入9前面
第二次循环 i = 2 [7 8 9] 6 5 4 3 2 1 将7插入8前面
第三次循环 i = 3 [6 7 8 9] 5 4 3 2 1 将6插入7前面
第四次循环 i = 4 [5 6 7 8 9] 4 3 2 1 *
第五次循环 i = 5 [4 5 6 7 8 9] 3 2 1 *
第六次循环 i = 6 [3 4 5 6 7 8 9] 2 1 *
第七次循环 i = 7 [2 3 4 5 6 7 8 9] 1 *
第八次循环 i = 8 [1 2 3 4 5 6 7 8 9] 将1插入2前面
插入排序算法主要分为有序区域和无序区域,将需要进行排序的数组归为无序区域,将排序结束后的区域
称为有序区域.插入算法的基本思想就是从无序区域取出第一个值放入有序区域内,然后在无序区域从左到右
取第二值开始,不断的和有序区域内的元素比较(我这里是从右到左,就是从大到小),所以比较的出如果目前
的值如果比有序区域内的元素值大就放在该元素左边,否则一直往左边移动,不断比较.
*/
void Sort::insertSort(RecType R[], int n)
{
std::cout<<"+++++插入排序算法函数测试+++++"<<std::endl;
traverseArray(R, n);
RecType tmp;//用于临时存储
for (int i = 1; i < n; i++)
{
tmp = R[i]; //取需要比较的变量
//在有序区域内循环比较
for (int j = i - 1; j >= 0; j--)
{
if (tmp.key < R[j].key)
{
//数据往前移动
R[j + 1] = R[j];
R[j] = tmp;
}
}
}
traverseArray(R, n);
}
void test_asArray(){
LinkedList list = createList();
void *item = (int *)malloc(sizeof(int));
*(int *)item = 10;
int length = add_to_list(&list, item);
void *item1 = (int *)malloc(sizeof(int));
*(int *)item1 = 11;
length = add_to_list(&list, item1);
void *item2 = (int *)malloc(sizeof(int));
*(int *)item2 = 12;
length = add_to_list(&list, item2);
void *item3 = (char *)malloc(sizeof(char));
*(char *)item3 = 13;
length = add_to_list(&list, item3);
void *array[4];
int maxItems = 4;
int no_of_elements = asArray(list, array,maxItems);
assert(no_of_elements == 4);
traverseArray(list, array, maxItems);
printf("Items are inserted into the given array\n");
}
void Sort::quickSort(RecType *R, int n)
{
traverseArray(R, n);
quick_sort(R, 0, n - 1);
traverseArray(R, n);
}