算法导论笔记(一) 插入排序

插入排序:

插入排序属于原地排序(sorted in place),使用的是增量(incremental)方法。

排序从第二个元素开始遍历。在排好序的子数组[1 .. j -1]中,将元素A[j]插入,形成排好序的子数组[1 .. j];然后,重复此操作,直到整个数组有序。

使用for循环实现的升序插入排序:

void insertion_sort_asc(int arr[], int len)
{
    if (len <= 0)
        throw "The length of input array is less than one.";

    if (len == 1)
        return;

    int key;
    for (int i = 1; i < len; i++)
    {
        key = arr[i];

        int j;
        for (j = i; j > -1; j--)
        {
            if (arr[j - 1] <= key)
                break;

            arr[j] = arr[j - 1];
        }

        arr[j] = key;
        show(arr, 6);
    }
}

使用while循环实现的升序插入排序:

void insertion_sort_asc_with_while(int a[], int len)
{
    if (len <= 0)
        throw "The length of input array is less than one.";

    if (len == 1)
        return;

    int key;
    for (int i = 1; i < len; i++)
    {
        key = a[i];
        int j = i - 1;
        while ((j > -1) && (key < a[j]))
        {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = key;

        show(a, len);
    }
}

使用for循环实现的降序插入排序:

void insertion_sort_des(int arr[], int len)
{
    if (len <= 0)
        throw "The length of input array is less than one.";

    if (len == 1)
        return;

    int key;
    for (int i = 1; i < len; i++)
    {
        key = arr[i];

        int j;

        for (j = i - 1; j >= 0; j--)
        {
            if (arr[j] > key)
                break;

            arr[j + 1] = arr[j];
        }

        arr[j + 1] = key;
        show(arr, len);
    }
}

show函数的定义如下:

void show(int arr[], int len)
{
    for (int i = 0; i < len; i++)
        cout << arr[i] << " ";

    cout << endl;
}

测试代码:

int main()
{
    int a[] = { 1, 4, 2, 7, 10, 5 };
    //insertion_sort_asc(a, 6);
    insertion_sort_asc_with_while(a, 6);
    //insertion_sort_des(a, 6);
    show(a, 6);

    return 0;
}

测试结果:

时间: 2024-11-19 23:07:40

算法导论笔记(一) 插入排序的相关文章

算法导论笔记1 - 插入排序 vs 归并排序

import random import time __author__ = 'Administrator' LENGTH = 3000 base = [] for i in range(0, LENGTH): base.append(random.randint(0, LENGTH)) def ins_sort(array): for border in range(1, len(array)): j = border - 1 key = array[border] while j >= 0

MIT算法导论笔记

详细MIT算法导论笔记 (网络链接) 第一讲:课程简介及算法分析 第二讲:渐近符号.递归及解法

算法导论—排序之插入排序

void insertion_sort(vector<int> &num){ for(int i = 1; i < num.size(); i++){ int j = i-1; int val = num[i]; while(j>=0 && num[j] >= val){ num[j+1] = num[j]; j--; } num[j+1] = val; } } 每次迭代时,将num[i] 作为key值,且前子数组[0,i-1] 构成已排好序,每次与左

[算法学习笔记]直接插入排序笔记

直接插入排序概念: 带排元素放在elem[0...n-1]中,初始化时,elem[0]自成1个有序区,无序区为elem[1...n-1],从i=1起,到i=n-1,依次将elem[i]插入有序区[0...n-1]中 直接插入排序算法步骤: 1.在当前有序区域R[1,i-1]中查找R[i]的正确插入位置K(1<=K<=i-1) 2.将R[K,i-1]中的记录均向后移动 3.移动后腾出K位置,插入R[i] (最坏)时间复杂度:O(n^2) 空间复杂度:O(1) /// <summary>

八大排序算法学习笔记:插入排序(一)

插入排序     包括:直接插入排序,二分插入排序(又称折半插入排序),链表插入排序,希尔排序(又称缩小增量排序).属于稳定排序的一种(通俗地讲,就是两个相等的数不会交换位置) . 直接插入排序: 1.算法的伪代码(这样便于理解):     INSERTION-SORT (A, n)             A[1 . . n] for j ←2 to n do key ← A[ j] i ← j – 1 while i > 0 and A[i] > key do A[i+1] ← A[i]

八大排序算法学习笔记:插入排序(二分插入排序)

二分插入排序   也称折半插入排序, 1.基本思想:设数列[0....n]分为两部分一部分是[0...i]为有序序列,另一部分是[i+1.....n]为无序序列,从无序序列中取一个数 x ,利用二分查找算法找到 x 在有序序列中的插入位置并插入,有序序列还是有序的,接下来重复上述步骤,直到无序序列全部插入有序序列 ,这是整个序列只剩下有序序列即有序了. 2.代码:    3.复杂度: 用二分插入排序所要进行的总比较次数为O(lgn),当n较大时,比直接插入排序的最大比较次数小得多,但大于最小比较

散列表(算法导论笔记)

散列表 直接寻址表 一个数组T[0..m-1]中的每个位置分别对应全域U中的一个关键字,槽k指向集合中一个关键字为k的元素,如果该集合中没有关键字为k的元素,则T[k] = NIL 全域U={0,1,…,9}中的每个关键字都对应于表中的一个下标值,由实际关键字构成的集合K={2,3,5,8}决定表中的一些槽,这些槽包含指向元素的指针,而另一些槽包含NIL 直接寻址的技术缺点非常明显:如果全域U很大,则在一台标准的计算机可用内存容量中,要存储大小为|U|的一张表T也许不太实际,甚至是不可能的.还有

算法导论学习之插入排序+合并排序

最近准备花时间把算法导论详细的看一遍,强化一下算法和数据结构的基础,将一些总结性的东西写到博客上去. 一.插入排序 算法思想:如果一个数组A,从A[1–n-1]都是有序的,然后我们将A[n]插入到A[1–n-1]的某个合适的位置上去那么就可以保证A[1–n]都是有序的.这就是插入排序的思想:具体实现的时候我们将数组的第一个元素看出有序,然后从第二个元素开始按照上面的步骤进行插入操作,直到插入最后一个元素,然后整个数组都是有序的了. 时间复杂度分析:代码中有两重for循环,很容易看出时间复杂度是n

算法导论学习 之 插入排序

刚刚开始系统学习算法导论和c++,每次学习的算法都用c++ 实现一边,加深理解,方便回顾. 先从最简单的插入排序开始吧: code: #include<iostream> #include<vector> #include<map> using namespace std; void Insertion_Sort(int * a,int length) { int i,j,key; for(i = 1;i < length;i ++){ key = a[i]; j

算法导论笔记第6章 堆和堆排序

堆排序结合了插入排序和归并排序的有点:它空间复杂度是O(1), 时间复杂度是O(nlgn). 要讲堆排序,先讲数据结构"堆" 堆: 堆是用数组来存放一个完全二叉树的数据结构.假设数组名是A,树的根节点存放在A[1].它的左孩子存放在A[2],右孩子存放在A[3] 即:对于某个下标位i的节点,它的左孩子是A[2i],  右孩子是A[2i+1].  父节点是A[i/2] PARENT(i) return ?i/2? LEFT(i) return 2i RIGHT(i) return 2i