算法（java实现）

 

 

 

 算法过程我用的java

二分查找(Binary Search)

1、定义

    二分查找又称折半查找，它是一种效率较高的查找方法。

    二分查找要求：线性表是有序表，即表中结点按关键字有序，并且要用向量作为表的存储结构。不妨设有序表是递增有序的

/**
 * $Id: DemoTest.java,v 1.0 2018/8/27 20:25 潘明生 Exp $
 * <p>
 * Copyright 2016 Asiainfo Technologies(China),Inc. All rights reserved.
 */

/**
 * @author 潘明生
 * @version $Id: DemoTest.java,v 1.1 2018/8/27 20:25 潘明生 Exp $
 * Created on 2018/8/27 20:25
 */
public class DemoTest {
    public static int funBinSearch(int[] array, int data){

        int low=0; /*定义最底下标为记录首位*/
        int high=array.length-1;/*定义最高下标为记录末位*/

        while(low<=high){
            int mid=(low+high)/2;  /*折半*/
            if(data==array[mid]){
                return mid;
            }else if(data<array[mid]){
                high = mid - 1;
            }else{
                low = mid + 1;
            }
        }
        return -1;
    }
    public static void main(String[] args){
        int [] array = {1,2,3,4,5,6,7,8,66};
        int data = 5;

        //预想结果return 4 ，位置是第四个
        System.out.println( funBinSearch(array,data));
    }
}

选择排序

        简单选择排序:

     简单选择排序的基本原理如下：对于给定的一组记录，经过第一轮比较后得到最小的记录，然后将该记录与第一个记录的位置进行交换；接着对不包括第一个记录以外的其他记录进行第二轮比较，得到最小的记录并与第二个记录进行位置交换；重复该过程，直到进行比较的记录只有一个时为止。

实现过程为：
（1）将整个记录序列划分为有序区和无序区，初始时，有序区为空，无序区含有待排序的所有记录。
（2）在无序区中选取关键码最小的记录，将它与无序区中的第一个记录交换，使得有序区扩展了一个记录，同时无序区减少了一个记录。
（3）不断重复（2），直到无序区只剩下一个记录为止。此时所有的记录已经按关键码从小到大的顺序排列。

/**
 * $Id: TestDemo.java,v 1.0 2018/8/23 20:47 潘明生 Exp $
 * <p>
 * Copyright 2016 Asiainfo Technologies(China),Inc. All rights reserved.
 */
package com.asiainfo.emos.sec.api.impl;

/**
 * @author 潘明生
 * @version $Id: TestDemo.java,v 1.1 2018/8/23 20:47 潘明生 Exp $
 * Created on 2018/8/23 20:47
 */
public class TestDemo {
    static void selectSort(int arr[]){
        int i;
        int j;
        //用temp记录在一趟比较过程最小记录
        int temp = 0;
        //用flag记录在一趟比较过程最小的记录位置
        int flag = 0;

        /**
         * 个人理解：大的循环首先要遍历每个参数，内循环假设首个最小值与每个值进行对比，利用中间参数temp接收最小值
         * 将假定首位的值放入真正最小值的位置相当于替换它，将真正最小值temp放入首位，
         *
         *
         */
        for ( i=0; i<arr.length-1; i++)
        {
            //每轮开始temp设定为当前无序区的最小记录。
            temp = arr[i];
            //每轮开始时将(flag=i)设定为当前无序区的第一个位置
            flag = i;

            // 用temp与无序区中的其他记录进行比较
            for (j = i+1; j< arr.length; j++)
            {
                if (arr[j] < temp)
                {
                    temp = arr[j];
                    flag = j;
                }
            }

            //一趟比较结束后，flag中保留的就是本趟排序的关键码最小的记录位置，temp中保留的就是本趟排序的关键码最小的记录。
            if (flag !=i)
            {
                // 将每轮开始时假定的无序区的最小值arr[i](即本轮无序区的首元素)，放到真正最小值的位置；然后将真正的最小值temp，放在本轮无序区的首位
                //将首位的值放到被排序出来刚被排序出来的位置
                arr[flag] = arr[i];
                arr[i] = temp;

            }
        }

    }

    public static void main(String[] args) {

        int arr[] = {2,5,8,1,3,6,9,0,4,7};


        selectSort(arr);

        for (int i = 0; i < arr.length; i++)

            System.out.println(arr[i]);



    }


}

 

 

直接插入排序(Insertion Sort)的基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。

 

 static void Insertsort1(int a[])
    {
        int i, j, k;
        for (i = 1; i < a.length; i++)
        {
            //为a[i]在前面的a[0...i-1]有序区间中找一个合适的位置
            for (j = i - 1; j >= 0; j--)
                if (a[j] < a[i])
                    break;

            //如找到了一个合适的位置
            if (j != i - 1)
            {
                //将比a[i]大的数据向后移
                int temp = a[i];
                for (k = i - 1; k > j; k--)
                    a[k + 1] = a[k];
                //将a[i]放到正确位置上
                a[k + 1] = temp;
            }
        }
    }