【算法】-CSDN博客

本文链接：https://blog.csdn.net/qq_61513126/article/details/130272002

查找算法

算法
排序算法

算法

1.基本查找

顺序查找

2.二分查找

折半查找: 元素必须是有序的，从小到大，或者从大到小都是可以的。

package day2.homework;

//二分查找；
public class practise2 {
    public static void main(String[] args) {
        int[]a={6,1,3,4,5,2,7};
        int number=16;
        System.out.println(search(a,number));
        int number1=1;
        System.out.println(search(a,number1));
    }
    public static boolean search(int []a,int number){
        int min=0;
        int max=a.length-1;
        while (true) {
            if(min>max){
                return false;
            }
            int mid=(min+max)/2;
            if(number>mid){
                min=mid+1;
            }
            else if(mid>number){
                max=mid-1;
            }
            else {
                return true;
            }
        }
    }

}

3.插值查找

4.斐波那契查找

5.分块查找

数据无序

查找是否存在某数并返回索引

 /*     分块查找
        核心思想：
        块内无序，块间有序
        实现步骤：
        1.创建数组blockArr存放每一个块对象的信息
        2.先查找blockArr确定要查找的数据属于哪一块
        3.再单独遍历这一块数据即可
                */
        int[] arr = {
                32, 23, 37, 26, 45, 34,
                16, 5, 9, 12,21, 18,
                50, 48, 61, 52, 73, 66
        };
        Blockx block2=new Blockx(5,21,6,11);
        Blockx block1=new Blockx(23,45,0,5);
        Blockx block3=new Blockx(50,73,12,17);
        //分块索引表
        Blockx[] block={block1,block2,block3};
        int number=37;
        //
       int x=getIndex(block,arr,number);
        System.out.println(x);

getIndex方法求出索引并返回

private static int getIndex(Blockx[] blocks, int[] arr, int number) {
        int index=blockindex(blocks,number);
       // System.out.println(index);
        int startindex=blocks[index].getStartIndex();
        int endindex=blocks[index].getEndIndex();
        for (int i =startindex; i <=endindex; i++) {
            if(arr[i]==number){
                return i;
            }
        }
        return -1;
    }

blockindex方法求出所在分块的索引

 private static int blockindex(Blockx[] blocks, int number){
        for (int i = 0; i < blocks.length; i++) {
            if(blocks[i].getMax()>=number&&blocks[i].getMin()<=number)return i;

        }
        return -1;
    }

保存每个分块的最大，最小值并记录分块的开始，结尾索引

class Blockx{
    private int min;
   private int max;
   private int startIndex;
   private int endIndex;

    public Blockx() {
    }

    public Blockx(int max, int startIndex, int endIndex) {
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    public Blockx(int min, int max, int startIndex, int endIndex) {
        this.min = min;
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    /**
     * 获取
     * @return max
     */
    public int getMax() {
        return max;
    }

    /**
     * 设置
     * @param max
     */
    public void setMax(int max) {
        this.max = max;
    }

    /**
     * 获取
     * @return startIndex
     */
    public int getStartIndex() {
        return startIndex;
    }

    /**
     * 设置
     * @param startIndex
     */
    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }

    /**
     * 获取
     * @return endIndex
     */
    public int getEndIndex() {
        return endIndex;
    }

    /**
     * 设置
     * @param endIndex
     */
    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }

    public String toString() {
        return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }

    /**
     * 获取
     * @return min
     */
    public int getMin() {
        return min;
    }

    /**
     * 设置
     * @param min
     */
    public void setMin(int min) {
        this.min = min;
    }
}

6.哈希查找

7.树表查找

排序算法

1.冒泡排序

package itheima.src.suanfa.sort;

import java.util.Arrays;

public class Bubble {
    public static void main(String[] args) {

        /*
            冒泡排序：
            核心思想：
            1，相邻的元素两两比较，大的放右边，小的放左边。
            2，第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推。
            3，如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以。
        */
        int []arr={2,1,3,5,4,6,8,9,7,11,10};
        for (int i = 0; i <Math.sqrt(arr.length); i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1])
                {

                    int x=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=x;
                }
            }
        }
  //      for (int i = 0; i < arr.length; i++) {
            System.out.println(Arrays.toString(arr));


    }
}

2.选择排序

package suanfa.sort;

import java.util.Arrays;
/*
    选择排序：
        1，从0索引开始，跟后面的元素一一比较。
        2，小的放前面，大的放后面。
        3，第一次循环结束后，最小的数据已经确定。
        4，第二次循环从1索引开始以此类推。

 */
public class sectionsort {
    public static void main(String[] args) {
        int []arr={2,4,6,3,1,4,7,6,4};
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i]>arr[j]){
                    int x=arr[j];
                    arr[j]=arr[i];
                    arr[i]=x;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

3.插入排序

package itheima.src.suanfa.sort;

import java.util.Arrays;

public class insertDemo {
    public static void main(String[] args) {
        /*
            插入排序：
                将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当成是无序的。
                遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。
                N的范围：0~最大索引

        */
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        int start = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > arr[i + 1]) {
                start = i + 1;
                break;
            }
        }
        System.out.println(start);
        for (int i = start; i < arr.length; i++) {
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                int x = arr[j];
                arr[j] = arr[j - 1];
                arr[j-1] = x;
                j--;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    }

4.快速排序

package itheima.src.suanfa.sort;

import java.util.Arrays;

public class quicksort {
    public static void main(String[] args) {
        /*
        快速排序：
            第一轮：以0索引的数字为基准数，确定基准数在数组中正确的位置。
            比基准数小的全部在左边，比基准数大的全部在右边。
            后面以此类推。
      */

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


        Quicksort(arr,0,arr.length-1);
        System.out.println((Arrays.toString(arr)));

    }

   public static void Quicksort(int[] arr, int i, int j) {
        int start=i;
        int end=j;
        if(start>end){
            return;
        }
        int baseNumber=arr[i];
        while (start!=end){
            while(true){
                if(end<=start||arr[end]<baseNumber){
                    break;
                }
                end--;
            }

      // System.out.println(end);
        while(true){
           if(start>=end||arr[start]>baseNumber){
               break;
           }
           start++;
       }
        int temp=arr[end];
        arr[end]=arr[start];
        arr[start]=temp;

        }
        int temp=arr[i];
        arr[i]=arr[start];
        arr[start]=temp;
       Quicksort(arr,i,start-1);
       Quicksort(arr,end+1,j);
   }
}