数据库入门级之算法【一】

 对DBA来说，算法很重要。下面和大家一起分享学习(代码为C++代码)。

折半查找又称二分查找。

使用条件：有序集合。

算法思想：先确定待查记录所在的范围（区间），然后逐步缩小范围直到找到或者不找到为止。

关键点在于比较中间位置所记录的关键字和给定值的比较，如果比给定值大（这里假设集合从小到大排列）那么可以缩小区间范围（集合开始-->中间位置的上一位），在比较该区间的中间位置所记录的关键字与给定值，依次循环到找到或者找不到位置。

举例编程：这里有一个整数数据 int a[10]={1,5,10,13,17,23,65,77,81,93};

1）这是递归

1. //折半查找
2. //数组必须按照一定的顺序
3. //参数：最大，最小，目标（参数类型为整数）
4. int BinarySearch(int min,int max,int num) 
5. { 
6.     if(min < max)    return -1;
7.     int mid = (min+max)/2;
8.     if(a[mid] == num)
9.         return mid;
10.     if(a[mid] > num)   
11.         return BinarySearch(min,mid-1,num);
12.     else
13.         return BinarySearch(mid+1,max,num);
14. } 

2）非递归

1. //非递归算法
2. int BinarySearch_F(int num) 
3. { 
4.     int min = 0,max = 9;
5.     while(min<= max)
6.     {
7.         int mid = (min+max)/2;
8.         if(a[mid] == num)
9.             return mid;
10.         if(a[mid] > num)
11.             max = mid-1;
12.         else
13.             min = mid+1;
14.     }
15.     return -1;
16. } 

性能分析：时间复杂度O(logn)

 

插入排序

使用条件：可对比大小的集合。

算法思想：将一个记录插入到已排好序的有序列中，从而得到一个新的，记录数增1的有序序列。待插记录依次比较已经排好序列，如果序列数大于该待插记录，那么该序列往后挪一位，直到找到序列小于待插记录，那么此时插入到该序列的后一个位置，依次上面操作，直至插完位置。

举例编程：int b[10]={77,1,65,13,81,93,10,5,23,17}将其排序

1. //插入排序
2. //这里temp是哨兵位
3. //从小到大
4. void InsertSort()
5. { 
6.     int i,j;
7.     for(i = 1; i<10; i++)
8.     {
9.         int temp = b[i];
10.         for(j = i-1; j>=0; j--)
11.         {
12.             if(b[j] > temp)
13.             {
14.                 b[j+1] = b[j];
15.             }
16.             else
17.             {
18.                 break;
19.             }
20.         }
21.         b[j+1] = temp;
22.     }
23. }

性能分析：时间复杂度O（n^2)

 

折半插入排序

使用条件：可对比大小的集合。

算法思想：基本思想与简单插入排序思想相似，唯一的不同点在于找出插入的位置，简单插入排序用的是依次比较，这里折半插入排序改进了，将依次查找改进成折半查找

举例编程：int b[10]={77,1,65,13,81,93,10,5,23,17}将其排序

1. void BinaryInsertSort()
2. {
3.     int i,j;
4.     for(i = 1; i<10; i++)
5.     {
6.         int temp = b[i];
7.         int min = 0,max=i-1;
8.         while(min<=max)
9.        { 
10.             int mid = (min+max)/2;
11.             if(b[mid]<=temp)
12.                 min = mid+1;
13.             else
14.                 max=mid-1;
15.         }
16.         for(j = i; j >=max+1; j--)
17.         {
18.             b[j+1] = b[j];
19.         } 
20.         b[max+1] = temp;
21.     }
22. }

性能分析：时间复杂度O（n^2)

虽然这里时间复杂度与简单插入排序一样，但是通过查找找到插入的位置用的比较次数是明显减少的。

 

原文链接： http://www.cnblogs.com/couhujia/archive/2011/03/23/1991110.html