算法基础知识

算法所具有的特征

算法：能够对一定规范的输入，在有限时间内获得所要求的输出。

• 有穷性，指算法必须能在执行有限个步骤之后终止-
• 确切性，算法的每一步骤必须有确切的定义
• 输入项，一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定义除了初始条件
• 输出项，一个算法有一个或多个输出，以反映对输入数据加工后的结果，没有输出的算法是无意义的
• 可行性，算法中执行的任何计算步骤都是可以被分解为基本的可执行操作步骤，即每个计算步骤都可以在有限的时间内完成。
• top-k问题，常用堆排序

排序算法

冒泡排序中比较次数与初始列表的排列次序无关

直接选择排序算法的时间复杂度与初始排序无关

插入排序在初始列表基本有序的情况下效率最高

快速排序的所选出的中枢元素是在其最终位置上的。快速排序的 递归的次数与 初始 数据的排列顺序有关， 递归次数与每次划分后得到的分区处理顺序无关

顺序查找，时间复杂度O(N),

分块查找，时间复杂度O(logN+N/m);

折半查找，时间复杂度O(logN)

哈希查找，时间复杂度O(1)

 // 输入：数据元素数组r，数组r 的待排序区间[low..high]输出：
    // 数组r 以关键字有序 代码：
    public void bubbleSort(Object[] r, int low, int high) {
        int n = high - low + 1;
        for (int i = 1; i < n; i++)
            for (int j = low; j <= high - i; j++)
                if (strategy.compare(r[j], r[j + 1]) > 0) {
                    Object temp = r[j];
                    r[j] = r[j + 1];
                    r[j + 1] = temp;
                }

    }// end of bubbleSort
    
    
    //优化过的冒泡排序
    void  BubbleSort2( int  a[],  int  n)  
{  
       int  j, k;  
       bool  flag;  
       k = n;  
       flag = true ;  
       while  (flag)  
       {  
              flag = false ;  
              for  (j = 1; j < k; j++)  
                     if  (a[j - 1] > a[j])  
                     {  
                            Swap(a[j - 1], a[j]);  
                            flag = true ;  
                     }  
              k--;  
       }  
}  

//选择排序
    public void selectSort(Object[] r, int low, int high) {
        for (int k = low; k < high - 1; k++) { // 作n-1 趟选取
            int min = k;
            for (int i = min + 1; i <= high; i++) // 选择关键字最小的元素
                if (strategy.compare(r[i], r[min]) < 0)
                    min = i;
            if (k != min) {
                Object temp = r[k]; // 关键字最小的元素与元素r[k]交换
                r[k] = r[min];
                r[min] = temp;
            } // end of if
        } // end of for(int k=0…
    }// end of selectSort

 /**
     * 插入排序
     */
    public void insertSort(Object[] r, int low, int high) {
        for (int i = low + 1; i <= high; i++)
            if (strategy.compare(r[i], r[i - 1]) < 0) { // 小于时，需将r[i]插入有序表
                Object temp = r[i];
                r[i] = r[i - 1];
                int j = i - 2;
                for (; j >= low && strategy.compare(temp, r[j]) < 0; j--)
                    r[j + 1] = r[j]; // 记录后移
                r[j + 1] = temp; // 插入到正确位置
            }
    }