C++博客-守望-文章分类-算法

[排序]冒泡排序（Bubble sort）

winter — Sat, 22 Oct 2011 13:35:00 GMT

用一个标记flag标识此趟遍历是否有元素交换，如果没有则说明已经排好序了

1 void bubble_sort(int array[], int n)
2 {
3    int i;
4    int j;
5    for (i = n - 1; i > 0; --i)
6    {
7       int flag = 0;
8       for (j = 0; j < i; ++j)
9       {
10          if (array[j] > array[j + 1])
11          {
12             int tmp = array[j];
13             array[j] = array[j + 1];
14             array[j + 1] = tmp;
15             flag = 1;
16          }
17       }
18
19       if (flag == 0)
20          break;
21    }
22 }
23

winter 2011-10-22 21:35 发表评论

[排序]选择排序(Selection sort)

winter — Mon, 03 Oct 2011 06:59:00 GMT

第一步，选择一个最大的元素，放在列表的尾端。
第二部，从第0个到第n-1个元素中选择一个最大的，放在列表倒数第二个位置。
。。。。。

1template <class Record>
2void SelectionSort(Record *array, int count)
3{
4    for (int i = count - 1; i > 0; --i)
5    {
6        int max = MaxKey(Record *array, 0, i);
7        Record tmp = array[max];
8        array[max] = array[i];
9        array[i] = tmp;
10    }
11}
12
13template <class Record>
14int MaxKey(Record *array, int low, int high)
15{
16    int largest = low;
17    for (int cur = low + 1; cur <= high; ++cur)
18    {
19        if (array[largest] < array[cur])
20        {
21            largest = cur;
22        }
23    }
24
25    return largest;
26}

时间复杂度：
比较：1/2n^2 + O(n)
赋值：O(n)

稳定性：
不稳定。
但把19行的条件改为

if (array[largest] <= array[cur])

就是稳定的了

winter 2011-10-03 14:59 发表评论

[排序]插入排序(Insertion sort)

winter — Mon, 03 Oct 2011 05:29:00 GMT

顾名思义，遍历待排序的列表，把当前元素插入到它应该在地位置。
Contiguous version:

1template <class Record>
2void InsertionSort(Record *array, int count)
3{
4    // "fu" means first unsorted
5    for (int fu = 1; fu < count; ++fu)
6    {
7        if (array[fu] < array[fu - 1])
8        {
9            int pos = fu;
10            Record current = array[fu];
11            do
12            {
13                array[pos] = array[pos - 1];
14                --pos;
15            } while (pos > 0 && array[pos - 1] > current);
16            array[pos] = current;
17        }
18    }
19}

Linked Version:

template
void InsertionSort(Node *list)
{
    if (list != NULL)
    {
        // "ls" means last sorted
        Node *ls = list;
        while (ls->next != NULL)
        {
            // "fu" means first unsorted
            Node *fu = ls->next;
            if (fu->data < list->data)
            {
                ls->next = fu->next;
                fu->next = list;
                list = fu;
            }
            else
            {
                Node *itr = list;
                Node *cur = itr->next;
                while (fu->data > cur->data)
                {
                    itr = cur;
                    cur = itr->next;
                }

    if (fu == cur)
    {
        ls = fu;
    }
                else
                {
        ls->next = fu->next;
                    fu->next = cur;
                    itr->next = fu;
                }
            }
        }
    }
}

时间复杂度：
1/4n^2 + O(n)

稳定性：
稳定

winter 2011-10-03 13:29 发表评论