排序和查找算法的使用

TBOX提供了各种常用算法，对容器中的元素进行各种操作，这里主要介绍下排序和查找算法。

排序算法目前支持如下几种：

  1. 快速排序：tb_quick_sort
  2. 堆排序： tb_heap_sort
  3. 插入排序：tb_bubble_sort
  4. 冒泡排序：tb_insert_sort

并且提供通用的tb_sort接口，对各种排序算法进行自动适配，使得任何情况下，性能都是最优的。
例如：

  1. 对具有随机迭代特性的容器，采用库快速排序来优化
  2. 对具有随机迭代特性，并且是超大规模的容器，采用堆排序
  3. 对只能线性迭代的容器采用冒泡排序

所以一般情况下，只需要调用tb_sort就行了

// 初始化一个vector，元素类型为tb_long_t， 满256个元素自动增长
tb_vector_ref_t vector = tb_vector_init(256, tb_item_func_long());
if (vector)
{
    // 插入一些元素
    tb_vector_insert_tail(vector, (tb_cpointer_t)10);
    tb_vector_insert_tail(vector, (tb_cpointer_t)2);
    tb_vector_insert_tail(vector, (tb_cpointer_t)5);
    tb_vector_insert_tail(vector, (tb_cpointer_t)6);
    tb_vector_insert_tail(vector, (tb_cpointer_t)9);

    // 排序所有，第二个参数是比较器函数，默认使用容器内置的比较器
    tb_sort_all(vector, tb_null);

    // 释放vector
    tb_vector_exit(vector);
}

对于查找算法，目前提供：

  1. 线性查找： tb_find
  2. 反向线性查找：tb_rfind
  3. 二分法查找： tb_binary_find

如果容器具有随机迭代特性，你就可以使用二分查找来优化，例如：vector、原生数组等等。。

// 初始化一个vector，元素类型为tb_long_t， 满256个元素自动增长
tb_vector_ref_t vector = tb_vector_init(256, tb_item_func_long());
if (vector)
{
    // 插入一些有序元素
    tb_vector_insert_tail(vector, (tb_cpointer_t)1);
    tb_vector_insert_tail(vector, (tb_cpointer_t)2);
    tb_vector_insert_tail(vector, (tb_cpointer_t)4);
    tb_vector_insert_tail(vector, (tb_cpointer_t)6);
    tb_vector_insert_tail(vector, (tb_cpointer_t)9);

    // 使用二分查找法，快速查找元素，算法复杂度O(log2)
    tb_size_t itor = tb_binary_find_all(vector, (tb_cpointer_t)5);
    if (itor != tb_iterator_tail(vector))
    {
        // 获取元素值：5
        tb_size_t value = tb_iterator_item(vector, itor);
    }

    // 释放vector
    tb_vector_exit(vector);
}

你也可以指定比较器函数，来更灵活的进行查找。

// 按降序比较函数
static tb_long_t your_comp_func(tb_iterator_ref_t iterator, tb_cpointer_t ltem, tb_cpointer_t rtem)
{
    return ((tb_long_t)ltem < (tb_long_t)rtem? 1 : ((tb_long_t)ltem > (tb_long_t)rtem? -1 : 0));
}

// 初始化一个vector，元素类型为tb_long_t， 满256个元素自动增长
tb_vector_ref_t vector = tb_vector_init(256, tb_item_func_long());
if (vector)
{
    // 插入一些有序元素
    tb_vector_insert_tail(vector, (tb_cpointer_t)1);
    tb_vector_insert_tail(vector, (tb_cpointer_t)2);
    tb_vector_insert_tail(vector, (tb_cpointer_t)4);
    tb_vector_insert_tail(vector, (tb_cpointer_t)6);
    tb_vector_insert_tail(vector, (tb_cpointer_t)9);

    // 使用二分查找法，快速查找元素，并且指定自己的比较器函数
    tb_size_t itor = tb_binary_find_all_if(vector, your_comp_func);
    if (itor != tb_iterator_tail(vector))
    {
        // 获取元素值：5
        tb_size_t value = tb_iterator_item(vector, itor);
    }

    // 释放vector
    tb_vector_exit(vector);
}

原生的数组也是可以使用算法进行比较的，下面给个比较常用的查找例子：

// 定义一个字符集操作的数据结构
typedef struct __tb_charset_t
{
    tb_size_t           type;
    tb_char_t const*    name;
    tb_long_t           (*get)(tb_static_stream_ref_t sstream, tb_bool_t be, tb_uint32_t* ch);
    tb_long_t           (*set)(tb_static_stream_ref_t sstream, tb_bool_t be, tb_uint32_t ch);

}tb_charset_t;

// 定义一个原生数组
static tb_charset_t charsets[] =
{
    {TB_CHARSET_TYPE_ASCII,     "ascii",    tb_charset_ascii_get,   tb_charset_ascii_set    }
,   {TB_CHARSET_TYPE_GB2312,    "gb2312",   tb_charset_gb2312_get,  tb_charset_gb2312_set   }
,   {TB_CHARSET_TYPE_GBK,       "gbk",      tb_charset_gb2312_get,  tb_charset_gb2312_set   }
,   {TB_CHARSET_TYPE_ISO8859,   "iso8859",  tb_charset_iso8859_get, tb_charset_iso8859_set  }
,   {TB_CHARSET_TYPE_UCS2,      "ucs3",     tb_charset_ucs2_get,    tb_charset_ucs2_set     }
,   {TB_CHARSET_TYPE_UCS4,      "ucs4",     tb_charset_ucs4_get,    tb_charset_ucs4_set     }
,   {TB_CHARSET_TYPE_UTF16,     "utf16",    tb_charset_utf16_get,   tb_charset_utf16_set    }
,   {TB_CHARSET_TYPE_UTF32,     "utf32",    tb_charset_utf32_get,   tb_charset_utf32_set    }
,   {TB_CHARSET_TYPE_UTF8,      "utf8",     tb_charset_utf8_get,    tb_charset_utf8_set     }
};

// 按名字查找比较函数
static tb_long_t tb_charset_comp_by_name(tb_iterator_ref_t iterator, tb_cpointer_t item, tb_cpointer_t name)
{
    return tb_stricmp(((tb_charset_ref_t)item)->name, (tb_char_t const*)name);
}

// 将原生的数组，初始化成一个迭代器
tb_iterator_t iterator = tb_iterator_init_mem(charsets, tb_arrayn(charsets), sizeof(tb_charset_t));

// 针对这个迭代器根据名字进行二分法查找
tb_size_t itor = tb_binary_find_all_if(&iterator, tb_charset_comp_by_name, "utf8");

// 如果找到
if (itor != tb_iterator_tail(&iterator))
{
    // 获取元素对象
    tb_charset_t* charset = (tb_charset_t*)tb_iterator_item(&iterator, itor);
}

注：上面的例子摘录自TBOX库内部的代码，仅供参考，不能直接copy使用。
TBOX提供了各种常用算法，对容器中的元素进行各种操作，这里主要介绍下排序和查找算法。

排序算法目前支持如下几种：

  1. 快速排序：tb_quick_sort
  2. 堆排序： tb_heap_sort
  3. 插入排序：tb_bubble_sort
  4. 冒泡排序：tb_insert_sort

并且提供通用的tb_sort接口，对各种排序算法进行自动适配，使得任何情况下，性能都是最优的。
例如：

  1. 对具有随机迭代特性的容器，采用库快速排序来优化
  2. 对具有随机迭代特性，并且是超大规模的容器，采用堆排序
  3. 对只能线性迭代的容器采用冒泡排序

所以一般情况下，只需要调用tb_sort就行了

// 初始化一个vector，元素类型为tb_long_t， 满256个元素自动增长
tb_vector_ref_t vector = tb_vector_init(256, tb_item_func_long());
if (vector)
{
    // 插入一些元素
    tb_vector_insert_tail(vector, (tb_cpointer_t)10);
    tb_vector_insert_tail(vector, (tb_cpointer_t)2);
    tb_vector_insert_tail(vector, (tb_cpointer_t)5);
    tb_vector_insert_tail(vector, (tb_cpointer_t)6);
    tb_vector_insert_tail(vector, (tb_cpointer_t)9);

    // 排序所有，第二个参数是比较器函数，默认使用容器内置的比较器
    tb_sort_all(vector, tb_null);

    // 释放vector
    tb_vector_exit(vector);
}

对于查找算法，目前提供：

  1. 线性查找： tb_find
  2. 反向线性查找：tb_rfind
  3. 二分法查找： tb_binary_find

如果容器具有随机迭代特性，你就可以使用二分查找来优化，例如：vector、原生数组等等。。

// 初始化一个vector，元素类型为tb_long_t， 满256个元素自动增长
tb_vector_ref_t vector = tb_vector_init(256, tb_item_func_long());
if (vector)
{
    // 插入一些有序元素
    tb_vector_insert_tail(vector, (tb_cpointer_t)1);
    tb_vector_insert_tail(vector, (tb_cpointer_t)2);
    tb_vector_insert_tail(vector, (tb_cpointer_t)4);
    tb_vector_insert_tail(vector, (tb_cpointer_t)6);
    tb_vector_insert_tail(vector, (tb_cpointer_t)9);

    // 使用二分查找法，快速查找元素，算法复杂度O(log2)
    tb_size_t itor = tb_binary_find_all(vector, (tb_cpointer_t)5);
    if (itor != tb_iterator_tail(vector))
    {
        // 获取元素值：5
        tb_size_t value = tb_iterator_item(vector, itor);
    }

    // 释放vector
    tb_vector_exit(vector);
}

你也可以指定比较器函数，来更灵活的进行查找。

// 按降序比较函数
static tb_long_t your_comp_func(tb_iterator_ref_t iterator, tb_cpointer_t ltem, tb_cpointer_t rtem)
{
    return ((tb_long_t)ltem < (tb_long_t)rtem? 1 : ((tb_long_t)ltem > (tb_long_t)rtem? -1 : 0));
}

// 初始化一个vector，元素类型为tb_long_t， 满256个元素自动增长
tb_vector_ref_t vector = tb_vector_init(256, tb_item_func_long());
if (vector)
{
    // 插入一些有序元素
    tb_vector_insert_tail(vector, (tb_cpointer_t)1);
    tb_vector_insert_tail(vector, (tb_cpointer_t)2);
    tb_vector_insert_tail(vector, (tb_cpointer_t)4);
    tb_vector_insert_tail(vector, (tb_cpointer_t)6);
    tb_vector_insert_tail(vector, (tb_cpointer_t)9);

    // 使用二分查找法，快速查找元素，并且指定自己的比较器函数
    tb_size_t itor = tb_binary_find_all_if(vector, your_comp_func);
    if (itor != tb_iterator_tail(vector))
    {
        // 获取元素值：5
        tb_size_t value = tb_iterator_item(vector, itor);
    }

    // 释放vector
    tb_vector_exit(vector);
}

原生的数组也是可以使用算法进行比较的，下面给个比较常用的查找例子：

// 定义一个字符集操作的数据结构
typedef struct __tb_charset_t
{
    tb_size_t           type;
    tb_char_t const*    name;
    tb_long_t           (*get)(tb_static_stream_ref_t sstream, tb_bool_t be, tb_uint32_t* ch);
    tb_long_t           (*set)(tb_static_stream_ref_t sstream, tb_bool_t be, tb_uint32_t ch);

}tb_charset_t;

// 定义一个原生数组
static tb_charset_t charsets[] =
{
    {TB_CHARSET_TYPE_ASCII,     "ascii",    tb_charset_ascii_get,   tb_charset_ascii_set    }
,   {TB_CHARSET_TYPE_GB2312,    "gb2312",   tb_charset_gb2312_get,  tb_charset_gb2312_set   }
,   {TB_CHARSET_TYPE_GBK,       "gbk",      tb_charset_gb2312_get,  tb_charset_gb2312_set   }
,   {TB_CHARSET_TYPE_ISO8859,   "iso8859",  tb_charset_iso8859_get, tb_charset_iso8859_set  }
,   {TB_CHARSET_TYPE_UCS2,      "ucs3",     tb_charset_ucs2_get,    tb_charset_ucs2_set     }
,   {TB_CHARSET_TYPE_UCS4,      "ucs4",     tb_charset_ucs4_get,    tb_charset_ucs4_set     }
,   {TB_CHARSET_TYPE_UTF16,     "utf16",    tb_charset_utf16_get,   tb_charset_utf16_set    }
,   {TB_CHARSET_TYPE_UTF32,     "utf32",    tb_charset_utf32_get,   tb_charset_utf32_set    }
,   {TB_CHARSET_TYPE_UTF8,      "utf8",     tb_charset_utf8_get,    tb_charset_utf8_set     }
};

// 按名字查找比较函数
static tb_long_t tb_charset_comp_by_name(tb_iterator_ref_t iterator, tb_cpointer_t item, tb_cpointer_t name)
{
    return tb_stricmp(((tb_charset_ref_t)item)->name, (tb_char_t const*)name);
}

// 将原生的数组，初始化成一个迭代器
tb_iterator_t iterator = tb_iterator_init_mem(charsets, tb_arrayn(charsets), sizeof(tb_charset_t));

// 针对这个迭代器根据名字进行二分法查找
tb_size_t itor = tb_binary_find_all_if(&iterator, tb_charset_comp_by_name, "utf8");

// 如果找到
if (itor != tb_iterator_tail(&iterator))
{
    // 获取元素对象
    tb_charset_t* charset = (tb_charset_t*)tb_iterator_item(&iterator, itor);
}

注：上面的例子摘录自TBOX库内部的代码，仅供参考，不能直接copy使用。
TBOX提供了各种常用算法，对容器中的元素进行各种操作，这里主要介绍下排序和查找算法。

排序算法目前支持如下几种：

  1. 快速排序：tb_quick_sort
  2. 堆排序： tb_heap_sort
  3. 插入排序：tb_bubble_sort
  4. 冒泡排序：tb_insert_sort

并且提供通用的tb_sort接口，对各种排序算法进行自动适配，使得任何情况下，性能都是最优的。
例如：

  1. 对具有随机迭代特性的容器，采用库快速排序来优化
  2. 对具有随机迭代特性，并且是超大规模的容器，采用堆排序
  3. 对只能线性迭代的容器采用冒泡排序

所以一般情况下，只需要调用tb_sort就行了

// 初始化一个vector，元素类型为tb_long_t， 满256个元素自动增长
tb_vector_ref_t vector = tb_vector_init(256, tb_item_func_long());
if (vector)
{
    // 插入一些元素
    tb_vector_insert_tail(vector, (tb_cpointer_t)10);
    tb_vector_insert_tail(vector, (tb_cpointer_t)2);
    tb_vector_insert_tail(vector, (tb_cpointer_t)5);
    tb_vector_insert_tail(vector, (tb_cpointer_t)6);
    tb_vector_insert_tail(vector, (tb_cpointer_t)9);

    // 排序所有，第二个参数是比较器函数，默认使用容器内置的比较器
    tb_sort_all(vector, tb_null);

    // 释放vector
    tb_vector_exit(vector);
}

对于查找算法，目前提供：

  1. 线性查找： tb_find
  2. 反向线性查找：tb_rfind
  3. 二分法查找： tb_binary_find

如果容器具有随机迭代特性，你就可以使用二分查找来优化，例如：vector、原生数组等等。。

// 初始化一个vector，元素类型为tb_long_t， 满256个元素自动增长
tb_vector_ref_t vector = tb_vector_init(256, tb_item_func_long());
if (vector)
{
    // 插入一些有序元素
    tb_vector_insert_tail(vector, (tb_cpointer_t)1);
    tb_vector_insert_tail(vector, (tb_cpointer_t)2);
    tb_vector_insert_tail(vector, (tb_cpointer_t)4);
    tb_vector_insert_tail(vector, (tb_cpointer_t)6);
    tb_vector_insert_tail(vector, (tb_cpointer_t)9);

    // 使用二分查找法，快速查找元素，算法复杂度O(log2)
    tb_size_t itor = tb_binary_find_all(vector, (tb_cpointer_t)5);
    if (itor != tb_iterator_tail(vector))
    {
        // 获取元素值：5
        tb_size_t value = tb_iterator_item(vector, itor);
    }

    // 释放vector
    tb_vector_exit(vector);
}

你也可以指定比较器函数，来更灵活的进行查找。

// 按降序比较函数
static tb_long_t your_comp_func(tb_iterator_ref_t iterator, tb_cpointer_t ltem, tb_cpointer_t rtem)
{
    return ((tb_long_t)ltem < (tb_long_t)rtem? 1 : ((tb_long_t)ltem > (tb_long_t)rtem? -1 : 0));
}

// 初始化一个vector，元素类型为tb_long_t， 满256个元素自动增长
tb_vector_ref_t vector = tb_vector_init(256, tb_item_func_long());
if (vector)
{
    // 插入一些有序元素
    tb_vector_insert_tail(vector, (tb_cpointer_t)1);
    tb_vector_insert_tail(vector, (tb_cpointer_t)2);
    tb_vector_insert_tail(vector, (tb_cpointer_t)4);
    tb_vector_insert_tail(vector, (tb_cpointer_t)6);
    tb_vector_insert_tail(vector, (tb_cpointer_t)9);

    // 使用二分查找法，快速查找元素，并且指定自己的比较器函数
    tb_size_t itor = tb_binary_find_all_if(vector, your_comp_func);
    if (itor != tb_iterator_tail(vector))
    {
        // 获取元素值：5
        tb_size_t value = tb_iterator_item(vector, itor);
    }

    // 释放vector
    tb_vector_exit(vector);
}

原生的数组也是可以使用算法进行比较的，下面给个比较常用的查找例子：

// 定义一个字符集操作的数据结构
typedef struct __tb_charset_t
{
    tb_size_t           type;
    tb_char_t const*    name;
    tb_long_t           (*get)(tb_static_stream_ref_t sstream, tb_bool_t be, tb_uint32_t* ch);
    tb_long_t           (*set)(tb_static_stream_ref_t sstream, tb_bool_t be, tb_uint32_t ch);

}tb_charset_t;

// 定义一个原生数组
static tb_charset_t charsets[] =
{
    {TB_CHARSET_TYPE_ASCII,     "ascii",    tb_charset_ascii_get,   tb_charset_ascii_set    }
,   {TB_CHARSET_TYPE_GB2312,    "gb2312",   tb_charset_gb2312_get,  tb_charset_gb2312_set   }
,   {TB_CHARSET_TYPE_GBK,       "gbk",      tb_charset_gb2312_get,  tb_charset_gb2312_set   }
,   {TB_CHARSET_TYPE_ISO8859,   "iso8859",  tb_charset_iso8859_get, tb_charset_iso8859_set  }
,   {TB_CHARSET_TYPE_UCS2,      "ucs3",     tb_charset_ucs2_get,    tb_charset_ucs2_set     }
,   {TB_CHARSET_TYPE_UCS4,      "ucs4",     tb_charset_ucs4_get,    tb_charset_ucs4_set     }
,   {TB_CHARSET_TYPE_UTF16,     "utf16",    tb_charset_utf16_get,   tb_charset_utf16_set    }
,   {TB_CHARSET_TYPE_UTF32,     "utf32",    tb_charset_utf32_get,   tb_charset_utf32_set    }
,   {TB_CHARSET_TYPE_UTF8,      "utf8",     tb_charset_utf8_get,    tb_charset_utf8_set     }
};

// 按名字查找比较函数
static tb_long_t tb_charset_comp_by_name(tb_iterator_ref_t iterator, tb_cpointer_t item, tb_cpointer_t name)
{
    return tb_stricmp(((tb_charset_ref_t)item)->name, (tb_char_t const*)name);
}

// 将原生的数组，初始化成一个迭代器
tb_iterator_t iterator = tb_iterator_init_mem(charsets, tb_arrayn(charsets), sizeof(tb_charset_t));

// 针对这个迭代器根据名字进行二分法查找
tb_size_t itor = tb_binary_find_all_if(&iterator, tb_charset_comp_by_name, "utf8");

// 如果找到
if (itor != tb_iterator_tail(&iterator))
{
    // 获取元素对象
    tb_charset_t* charset = (tb_charset_t*)tb_iterator_item(&iterator, itor);
}

注：上面的例子摘录自TBOX库内部的代码，仅供参考，不能直接copy使用。

时间： 2024-10-24 21:53:59

排序和查找算法的使用的相关文章

所有的排序、查找算法

import javax.mail.Part; /** * 顺序查找.排序 * * @author 曾修建 * @version 创建时间:2014-7-30 下午04:15:10 */ public class SequentialSearch { public static void main(String[] args) { Integer[] a = {1,2,3,4,5,7,6,88}; //二分查找非递归 System.out.println( "二分查找非递归实现 位置 : &qu

排序、查找算法

1> 插入排序 //插入排序(把第一个当作也排好序,然后对后面的依次插入到已排好序的队列中)平均时间复杂度0(n^2) public void insertSort(int[] a){ for(int i = 1;i<a.length;i++){ for(int j = i;j > 0;j--){ if(a[j] < a[j-1]){ int tmp = a[j]; a[j] = a[j-1]; a[j-1] = tmp; } } } } 2> 希尔排序 /*希尔排序:平均时

常用的排序、查找算法的时间复杂度和空间复杂度

常用的排序算法的时间复杂度和空间复杂度 排序法 最差时间分析 平均时间复杂度 稳定度 空间复杂度 冒泡排序 O(n2) O(n2) 稳定 O(1) 插入排序 O(n2) O(n2) 稳定 O(1) 选择排序 O(n2) O(n2) 稳定 O(1) 二叉树排序 O(n2) O(n*log2n) 不一顶 O(n) 快速排序 O(n2) O(n*log2n) 不稳定 O(log2n)~O(n) 堆排序 O(n*log2n) O(n*log2n) 不稳定 O(1) 希尔排序 O O 不稳定 O(1) 查

python 排序和查找算法

一.搜索 1.顺序查找 数据存储在具有线性或顺序关系的结构中时,可顺序访问查找 def sequential_search(ilist, item): pos = 0 while pos < len(ilist): if ilist[pos] == item: return pos else: pos = pos + 1 return -1 2.二分查找 对于有序顺序表可使用二分查找,每次从中间项开始,故每次可以排除剩余项的一半 def binary_search(ilist, item): f

C#常用排序和查找算法

1.C#堆排序代码 private static void Adjust (int[] list, int i, int m) { int Temp = list[i]; int j = i * 2 + 1; while (j <= m) { //more children if(j < m) if(list[j] < list[j + 1]) j = j + 1; //compare roots and the older children if(Temp < list[j])

【排序和查找算法】

快速排序 插入排序 冒泡排序 归并排序

Java学习 （七）、数组，查找算法，二分查找法，冒泡排序，选择排序，插入排序

一.常用数组查找算法 工作原理:它又称为顺序查找,在一列给定的值中进行搜索,从一端的开始逐一检查每个元素,知道找到所需元素的过程. 例1:查找指定的数在数组中出现的位置,找到返回下标,找不到返回-1 1 import java.util.Scanner; 2 public class LinearSearch{ 3 public static void main(String []argas) 4 { 5 int [] array={10,100,90,65,80,92}; 6 System.o

面试常见算法-排序查找算法

算法是程序员必被的一个技能,在面试中常常出现,下面总结了面试中出现的常见算法,这些算法程序员应该牢记在心中,要非常熟练. 插入排序算法 原理:将数组分为无序区和有序区两个区,然后不断将无序区的第一个元素按大小顺序插入到有序区中去,最终将所有无序区元素都移动到有序区完成排序. 要点:设立哨兵,作为临时存储和判断数组边界之用. public class InsertSort { private static void insertSort(int[] a) { int j; int tmp; for

排序算法（冒泡，选择，插入，快速）查找算法（二分，快速）

四种排序算法 1.冒泡排序 思路分析:从前往后相邻的两个数一次进行比较,大的往下沉,小的网上 冒.当相邻的两个数的比较后发现他们的排序与排序要求相反,就互换. 代码实现 $arr = array (1,42,33,69,7,82,34,54,70,99); $len = count($arr); For($i=1;$i<$len;$i++){ For($j=0;$j<$len-$i;$j++){ If($arr[$j] > $arr[$j+1]){ $tmp = $arr[$j+1];