java常用算法

冒泡排序:

    //降序
    public static int[] bubbleSort(int[] array){
        for(int i = 0; i < array.length; i++){
            int curval = array[i];
            for(int j = i - 1; j >= 0; j--){
                int temp = array[j];
                if(curval > temp){
                    array[j] = curval;
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
    //升序
    public static int[] bubbleSort(int[] array){
        for(int i = array.length - 1; i >= 0; i--){
            int curval = array[i];
            for(int j = i; j < array.length-1; j++){
                int tempval = array[j+1];
                if(tempval < curval){
                    array[j+1] = curval;
                    array[j] = tempval;
                }
            }
        }
        return array;
    }

二分法查找

//降序
    public static int binarySearch (int[] array, int search){
        int start = 0;
        int end = array.length-1;
        int middle = array.length / 2;
        for(; start <= end; ){
            middle = (start + end) / 2;
            int val = array[middle];
            if(val == search){
                return middle;
            }else if(val > search){
                start = middle + 1;
            }else{
                end = middle - 1;
            }
        }

        return -1;

    }
  //升序
    public static int binarySearch(int[] array, int search){
        int start = 0;
        int end = array.length - 1;
        int middle = (start + end) / 2;
        for(;start <= end;){
            middle = (start + end) / 2;
            int midval = array[middle];
            if(midval > search){
                end = middle - 1;
            }else if(midval < search){
                start = middle + 1;
            }else{
                return middle;
            }
        }
        return -1;
    }

调用

    public static void main(String[] args){
        int[] test = new int[]{1,200,164,29,298,188,34,52,287,100,33};
        int[] bubres = bubbleSort(test);
        for(int i = 0; i < bubres.length; i++){
            System.out.println(i + "*************" + bubres[i]);
        }

        System.out.println("-----*****" + binarySearch(bubres, 1));
    }
时间: 2024-10-14 15:10:06

java常用算法的相关文章

闭关修炼中 *** Java常用算法之 -- 栈结构

什么是栈结构: 栈结构从数据的运算来分类,栈结构具有特殊的运算规则. 从数据的逻辑结构来看,栈结构其实就是一种线性结构. but!!! 从数据的存储结构来划分,栈结构分为两类: 顺序表结构:即用一组地址连续的内存单元依次保存栈中的数据.在程序中,可以定义一个 指定大小的结构数组来作为栈,序号为0的元素就是栈底,在定义一个top保 存栈顶的序号. 链式栈结构:即使用链式形式保存栈中各元素的值.链表首部(head引用所指向元素)为栈顶, 链表尾部(指向地址为null)为栈底. 栈结构遵循:后进先出(

闭关修炼中 *** Java常用算法之 -- 顺序表结构

给我的好姐姐聊聊天代码也打完了,小弟可是一心二用了,不过代码确实是挺长的. 代码打的时间长短不重要,重要的是理解~理解~理解.重要的事说三遍!!! 每天的重复,恨不得一天过成两天马上结束了,能多学点是点了. 山再高,咱能有耐心.同样如此~哈哈. 贴上代码吧: 1 import java.util.Scanner; 2 3 /***************************************** 4 * * 5 * 顺序结构 * 6 * * 7 ********************

闭关修炼中 *** Java常用算法之 -- 队列结构

什么是队列结构: 队列结构和栈结构很相类似. 和栈结构一样是一种具有特殊的运算规则,从数据的逻辑结构看,队列结构其实 是一种线性结构. 从存储结构来进一步划分,也分为两类: 顺序队列结构:即使用一组地址连续的内存单元依次保存队列中的数据. 在 程序中,可以定义一个指定大小的结构数组作为队列. 链式队列结构:即用链表形式保存队列中各元素的值. 典型的队列结构: 在队列结构中允许对两端进行操作,但两端的操作不同.一端只能删除--队头,一 端只能插入--队尾. 队列的运算规则: 是按照先进后出(Fir

Java学习资料-Java常用算法-直接插入算法

SortAscending源程序public class SortAscending { public SortAscending () {  System.out.println("直接插入排序法"); } public static int[] sortAscending(int[] with) { // 直接插入法递增排序  int length = with.length;      // 待排数组的长度  int[] temp = new int[length];    //

Java学习资料-Java常用算法-选择排序算法

ChooseSort源程序public class ChooseSort { private static void ChooseSort (int [] a){  for(int i = 0; i < a.length; i++){   //对数组循环,假设数据排在前面的元素总比后面的小,然后与后面的数据进行比较   int k = i;   for(int j = i+1; j <a.length; j++){//对数据遍历,寻找最小的数据元素的数组下标    if(a[j]<a[k

java 常用算法

插入排序: public static void main(String[] args) { int array[] = {5,4,2,45,44,34,22}; System.out.println(Arrays.toString(array)); for (int i = 0; i < array.length; i++) { int tempMin = array[i]; for (int j = i+1; j < array.length; j++) { if(array[j]<

Java学习资料-Java常用算法-堆排序

/** * 堆排序 * * @param array * @param length */ public void heapSort(int[] array, int length) { // 调整为大根堆的形式 // 存储根堆的元素个数 int currentSize = length; int start = (currentSize - 2) >>> 1; while (start >= 0) { siftDown(array, start, currentSize - 1)

Java学习资料-Java常用算法-二分查找算法

binarySearch源程序 public class binarySearch { public static int binarySearch(int[] dataset ,int data) { int beginIndex = 0; //定义起始位置 int endIndex = dataset.length - 1;  //定义结束位置 int midIndex = -1; //定义中点 if(data <dataset[beginIndex]||data>dataset[endI

Java常用排序算法+程序员必须掌握的8大排序算法+二分法查找法

Java 常用排序算法/程序员必须掌握的 8大排序算法 本文由网络资料整理转载而来,如有问题,欢迎指正! 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分配排序(基数排序) 所需辅助空间最多:归并排序 所需辅助空间最少:堆排序 平均速度最快:快速排序 不稳定:快速排序,希尔排序,堆排序. 先来看看 8种排序之间的关系: 1.直接插入排序 (1)基本思想:在要排序的一组数中,假设前面(n-1)[n>=2]