常用的排序和查找

冒泡排序

void BubbleSort(int *a, int n)
{
  int i,j,t;
  for(i=0; i<n-1; i++)
  {
    for(j=0; j<n-1-i; j++)
    {
      if(a[j]>a[j+1])
      {
        t = a[j];
        a[j] = a[j+1];
        a[j+1] = t;
      }
    }
  }
}

选择排序

void SelectSort(int *a, int n)
{
int i,j,m,t;
for(i=0; i<n-1; i++)
{
m = i;
for(j=i+1; j<n; j++)
{
if(a[m]>a[j])
{
m=j;
}
}
t=a[m];
a[m] = a[i];
a[i] = t;
}
}

插入排序

void InsertSort(int *a, int n)
{
int in,out,t;
for(out=1; out<n; out++)
{
t = a[out];
in = out;
while(in>0 && a[in-1]>=t)
{
a[in] = a[in-1];
in--;
}
a[in] = t;
}
}

快速排序

void QuickSort(int *a, int l, int r)
{
int i,j,t;
if(l <r)
{
i=l;
j=r;
t = a[i];
while(i<j)
{
while(i<j && a[j]>t) j--;
if(i<j)
{
a[i] = a[j];
i++;
}
while(i<j && a[i]<t) i++;
if(i<j)
{
a[j] = a[i];
j--;
}
}
a[i] = t;
QuickSort(a, l, i-1);
QuickSort(a, i+1, r);
}
}

归并排序

void Merge(int *initList, int *mergeList, int left, int mid, int right)
{
int i,j,k;
i=left;
j=mid+1;
k=left;
while(i<=mid && j<=right)
{
if(initList[i]<initList[j])
{
mergeList[k++]=initList[i++];
}
else
{
mergeList[k++]=initList[j++];
}

if(i>mid)
{
while(j<=right)
{
mergeList[k++]=initList[j++];
}

}
else if(j>right)
{
while(i<=mid)
{
mergeList[k++]=initList[i++];
}
}

}
}
void MergePass(int *initList, int *mergeList, int n, int s)
{
int i,j;
for(i=0; i<=n-2*s+1; i+=2*s)
{
Merge(initList, mergeList, i, i+s-1, i+2*s-1);
}
if(i+s<n)
Merge(initList, mergeList, i, i+s-1, n-1);
else
for(j=i; j<=n-1; j++)
mergeList[j] = initList[j];
}
void MergeSort(int *a, int b, int n)
{
int s=1;
while(s<n)
{
MergePass(a, b, n, s);
s*=2;
MergePass(b, a, n, s);
}
}

基数排序

int get_index(int num, int dec,int order)
{
int i,j,n;
int index;
int div;
for(i=dec; i>order; i--)
{
n=1;
for(j=0; j<dec-1; j++)
n*=10;
div=num/n;
num-=div*n;
dec--;
}
n=1;
for(i=0;i<order-1;i++)
n*=10;
index=num/n;
return index;
}
void radis_sort(int array[], int dec, int order)
{
int i,j;
int index;
int tmp[10]={0};
int num[10]={0};
for(i=0; i<10; i++)
{
index=get_index(array[i], dec, order);
num[index]++;
}
for(i=1; i<10; i++)
num[i]+=num[i-1];
for(i=10-1;i>=0;i--)
{
index=get_index(array[i], dec, order);
{
j=--num[index];
tmp[j]=array[i];
}
}
for(i=0;i<10;i++)
{
array[i]=tmp[i];
}
}

二分查找

int BinSelect(int x, int a[], int n)
{
int low=0, hight=n-1, mid;

while(low <= hight)
{
mid = (low + hight)/2;
if(x > a[mid])
{
low = mid +1;
}
else if(x < a[mid])
{
hight = mid-1;
}
else if(x == a[mid])
{
return mid-1;
}

}
return -1;
}

时间: 2024-10-05 20:25:01

常用的排序和查找的相关文章

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

常用的排序算法的时间复杂度和空间复杂度 排序法 最差时间分析 平均时间复杂度 稳定度 空间复杂度 冒泡排序 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) 查

常用排序,查找,树算法集锦

本文转载至  http://blog.csdn.net/zhangkongzhongyun/article/details/8080466 分类: c语言2012-10-17 11:16 275人阅读 评论(0) 收藏 举报 算法google 前面写了好些排序,红黑树,B 树算法的文章,还剩下查找这一大块没有写,查找相关的算法代码已经实现,但是却没有写查找算法日志的闲情了,只好先在这里放出代码来,以后有空有闲情再补上吧. 算法代码 Google 仓库:点击这里 已完成算法 排序 插入排序 希尔排

排序和查找算法的使用

TBOX提供了各种常用算法,对容器中的元素进行各种操作,这里主要介绍下排序和查找算法. 排序算法目前支持如下几种: 快速排序:tb_quick_sort 堆排序: tb_heap_sort 插入排序:tb_bubble_sort 冒泡排序:tb_insert_sort 并且提供通用的tb_sort接口,对各种排序算法进行自动适配,使得任何情况下,性能都是最优的. 例如: 对具有随机迭代特性的容器,采用库快速排序来优化 对具有随机迭代特性,并且是超大规模的容器,采用堆排序 对只能线性迭代的容器采用

js算法之最常用的排序

引入 大学学习计算机语言的那几年,从c语言,到c++,再到数据结构JAVA..让我印象最深刻的还是最开始老师讲冒泡算法的时候,直到现在大四快毕业了我才渐渐通窍了.刚学前端的时候以为前端就是做出好看很炫的页面就行了,后来才渐渐懂得前端不只是页面仔.一次美团面试,面试官说他们要的不仅是前端,他们要的是"工程师",从面试开始到结束问都是算法,顿时把我给打击了.二叉树.基本算法还有时间复杂度都是很重要的东西,不仅体现了一个前端的学习深度,还体现了一名计算机学生的专业水平.所以,为了查缺补漏,我

几种常用的排序算法总结

主要针对于插入排序,交换(冒泡和快速),选择,堆排序,归并这几种排序的基本原理和时间复杂度,及空间复杂度的一个总结. 一.插入排序 基本执行过程:3  5  2  7  9  8 1.从小到大:从第二个数开始,每次比较都与前边的几个数进行比较 但是从大到小,要先与前边排好序的几个数中的最大的开始进行比较即倒序比较,依次往前推. 如:5 先与3进行比较,比3大,所以直接排在3的后边为:3 5: 2要先与5进行比较,比5小,再与3比较,比3小,所以排序后为 2 3 5: 7要先与5比,比5大,所以直

(八)数组以及排序和查找

JavaSE(八) --数组以及排序和查找 一.数组的定义 三种定义方法: int b[]=new int[5]; Int []b=new int[5]; int[] a=new int[5]; (建议使用这种定义方法) //必须规定数组长度,因为在编译的时候就要分配内存. 我们也可以在定义的时候就初始化数组 Int[] a={1,2,3,3,5}; 这默认了数组a的长度是5. 分配内存详情如下: 开辟一块内存,有5个小块,a指向数组的首地址. int[][] b=new int[5][];  

leetcode 题解:Search in Rotated Sorted Array II (旋转已排序数组查找2)

题目: Follow up for "Search in Rotated Sorted Array":What if duplicates are allowed? Would this affect the run-time complexity? How and why? Write a function to determine if a given target is in the array. 说明: 1)和1比只是有重复的数字,整体仍采用二分查找 2)方法二 : 实现:  

java 数组比较,元素的比较,Comparable,Comparator比较的应用实现,排序,查找示例

java 数组比较,元素的比较,自定义Comparator的实现,排序,查找示例 package org.rui.array.compar; import java.util.Arrays; import java.util.Random; import org.rui.generics.anonymity.Generator; /** * 程序设计的基本目标是"将保持不变的事物与会发生改变的事物相分离" * 而这是,不变的是通用的排序算法,变化的是各种对象相互比较的方式, * 因此,

JavaScript实现常用的排序算法

▓▓▓▓▓▓ 大致介绍 由于最近要考试复习,所以学习js的时间少了 -_-||,考试完还会继续的努力学习,这次用原生的JavaScript实现以前学习的常用的排序算法,有冒泡排序.快速排序.直接插入排序.希尔排序.直接选择排序 ▓▓▓▓▓▓ 交换排序 交换排序是一类在排序过程中借助于交换操作来完成排序的方法,基本思想是两两比较排序记录的关键字,如果发现两个关键字逆序,则将两个记录位置互换,重复此过程,直到该排序列中所有关键字都有序为止,接下来介绍交换排序中常见的冒泡排序和快速排序 ▓▓▓▓▓▓