zoukankan      html  css  js  c++  java
  • 常见的算法

    二分法查找

    private static int binarySearch(int[] list,int target) {
            int low = 0;
            int high = list.length - 1;
            //直到low>high时还没找到关键字就结束查找,返回-1
            while(low<=high){
            int mid = (low+high) / 2;
            if(target < list[mid]){
                high = mid - 1;
            }
            else if(target > list[mid]){
                low = mid + 1;
            }
            else if(target == list[mid]){
                return mid;
                }
            }
            return -1;
        }

    冒泡排序

    public static void bubbleSort(int[] arr) {
         /*
         * 外面的for循环决定一个长度为 n 的数据要比较多少轮才能完成排序。
         * 里面的for循环决定每次一轮循环中要做多少次才能结束。
         */
         for(int i = 0; i < arr.length - 1; i++) {
             for(int j = 0; j < arr.length - 1 - i; j++){
                 //从小到大,大的值放后面位置。 
                 if (arr[j] > arr[j+1]){
                    int temp = arr[j]
                    arr[j] = arr[j + 1]
                    arr [j + 1] = temp 
                 }
             }
         } 
    }

    快速排序

    基本思想是将要排序的数据分割成独立的两部分 ,其中一部分的所有数据都比另外一部分的所有数据都要小 ,然后在按照此方法对两部分数据分别进行快速排序 ,最终得到一个有序的序列。

    private static void quickSort(int[] a, int low, int high) {  
            //找到递归算法的出口  
            if( low > high) {
                return;
            }
            int i = low;  
            int j = high;  
            //默认 key
            int key = a[low];  
            //开始一趟排序
            while( i < j) {
                //先从右往左找到第一个小于 key 的数 ,
                //这么做是因为在与 key 值交换的时候,保证了交换的数小于现有的 key 值
                //若是大于的话,j 指针就会继续向左移动 。
                while(i<j && a[j] > key){  
                    j--;  
                }
                //从左往右找到第一个大于等于 key 的数  
                while( i<j && a[i] <= key) {  
                    i++;  
                }
                //交换,达到以 key “分治” 的效果
                if(i<j) {
                    int temp = a[i];  
                    a[i] = a[j];  
                    a[j] = temp;  
                }  
            }
            // 当 i = j 时,调整 key 的值为 a[i] == a[j]  
            int temp = a[i];  
            a[i] = a[low];  
            a[low] = temp;  
            //对 key 左边的数快速排序
            quickSort(a, low, i-1 );  
            //对 key 右边的数快速排序  
            quickSort(a, i+1, high);  
    }

    快速排序原理示例

    假设要排的数组为:int[] a = { 5 2 8 9 2 3 4 9 };
    
    选择 key = 5, 开始时 i = 0,j = 7
    
    下标         0    1    2    3    4    5    6    7
    
    开始         5    2    8    9    2    3    4    9
                i                                  j  
    
    第一次找     5    2    8    9    2    3    4    9
                          i                   j
    
    交换:       5    2    4    9    2    3    8    9 
                          i                   j
    
    第二次找     5    2    4    9    2    3    8    9
                               i         j
    
    交换:       5    2    4    3    2    9    8    9
                               i         j
    
    第三次找     5    2    4    3    2    9    8    9
                                   ij
    
    调整key:    2    5    4    3    5    9    8    9
                                   ij
  • 相关阅读:
    Exchange 2013与 Office Web Apps 整合
    SharePoint2013 以其他用户登录和修改AD域用户密码 功能
    sharepoint 2010 自定义页面布局
    sharepoint 2010 记录管理 对象模型
    SharePoint2010 对象模型 关联列表
    在SharePoint Server 2010中更改“我的网站”
    xenapp 6.5 客户端插件第一次安装总是跳到官网
    如何解决在Windows Server 2008 R2 上安装证书服务重启后出现 CertificationAuthority 91错误事件
    在Win7 Hyper-v虚拟机中挂接真实机的声卡
    win8 中如何删除 共享文件夹 用户名和密码
  • 原文地址:https://www.cnblogs.com/niudaben/p/11928119.html
Copyright © 2011-2022 走看看