java学习day006

一.排序

指数据按照一定顺序排列

十大经典排序算法总结整理_十大排序算法-CSDN博客

1.1 交换变量的值

//中间变量
int x = 10;
int y = 11;
int temp = x;
X=y;
y=temp;
//位移运算
x = 10;
y = 11;
x = x^y;
y = x^y;
x = x^y;
//加减法
x = 10;
y = 11;
x = X +y;
y = x - y;
x =x - y;
​
System.out.println("x="+x+",y="+y);

1.2 冒泡排序

        1.比较相邻的元素。如果第一个比第二个大，就交换它们两个; ​
        2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数; ​
        3.针对所有的元素重复以上的步骤，除了最后一个; ​
        重复步骤1~3，直到排序完成。

package day006_sort;
​
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[] {2,4,6,3,1,7,9,8};
        Bubblesort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }
    public static void Bubblesort(int[] arr){
        //外层循环  
        //内层循环  执行一次是将相邻的两个数比较大小,然后交换;
        //                执行一轮是将所有的相邻的两个数比较,然后交换位置,即将最大(小)的数放到最后面;
        //小于length-1,10个数只需要比较九次就可以;
        for(int i = 0; i < arr.length - 1; i++){
            //length -1, 如果执行j = length-1的话,数组最后一个数将会与下一个比较,会造成越界;
            //length -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;
                }
            }
        }
    }
}
​

1.3 选择排序

        选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

package day006_sort;
​
public class SelectSort {
    public static void main(String[] args) {
        int[] arr = new int[] { 2, 4, 6, 3, 1, 7, 9, 8 };
        Selectsort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    public static void Selectsort(int[] arr){
        //与冒泡排序一样 10个数执行9次后不需要在执行最后一次
        for(int i = 0;i < arr.length - 1; i++){
            //假设arr[i]是数组中最小的数,记录其下标为min
            int min = i;
            //内层循环 要与数组中第i个数后面的都要进行比较,因此要执行到数组最后一个即为arr[arr.length-1],所以j<arr.length
            //              执行一次即为比较arr[min]与其后第一个数比较
            //              执行一轮即为与数组中所有数比较
            for(int j = i; j < arr.length; j++){
                //当数组中有数比arr[min]大时,将其下标跟新min
                if(arr[min] > arr[j])
                    min = j;
            }
            //判断 当min不等于i时,则说明有数比arr[i]大,因此需要换位
            if(min != i){
                int temp = arr[min];
                arr[min] = arr[j];
            }
        }
    }
}

二.查询

2.1 顺序查找

        入参: 数组,数组中数据
        出参: 索引

        缺点: 不稳定查询时数据在前速度快,数据靠后速度慢 尤其是大量数据的时候,性能相对较低

public class Array_04_Search {
    public static void main(String[] args) {
        int[] arr = { 1，4,5,6,7，9，13,15,16,19,22 }int target = 16;
        System.outprintln(search1(arr, target));
    }
    //顺序查找,不稳定,数据靠前就快,数据靠后就慢
    //尤其是大量数据的时候,性能相对较低
    public static int search1(int[] arr, int target){
        for (int i = 0; i < arr.length; i++){
            if (arr[i] == target) {
                return i;
            }
        }
        return -1;
    }
}

2.2 二分法

        又称为折半查找,数据必须有序 由于数据保证有序,所以添加和删除相对麻烦,因为要考虑数据移位. 适合应用于数据不会变动的数组 相对比较稳定,随机性查询性能较好

        算法实现: 每次都和中间数据比较
1.如果目标数据大于中间数据,则取后半截,起始索引=中间+1，结束索引不变，重新生成中间数据 2.如果目标数据=中间数据则返回m即可
3.如果目标数据小于中间数据,则取前半截,起始索引不变，结束索引=中间-1，重新生成中间数据
4.当起始索引大干结束索引时说明不存在返回-1

public static void main(String[] args){
    int[] arr = {1,4,6,8,12,23,33,35,43}
    System.out.println(binarySearch(arr,target));
}
public static int binarySearch(int[] arr,int target){
    //起始索引
    int startIndex = 0;
    //结束索引
    int endIndex = arr.length-1;
    //中间数据
    int m = (startIndex+endIndex)/2;
    //当起始索引大于结束索引是.说明不存在返回-1
    while(startIndex <= endIndex){
        //如果目标数据=中间数据则返回m即可
        if(target == arr[m]){
            return m;
        }
        //如果目标数据大于中间数据,则取后半截,起始索引=中间+1，结束索引不变，重新生成中间数据
        if(target > arr[m]){
            startIndex = startIndex + 1; 
            //如果目标数据小于中间数据,则取前半截起始索引不变，结束索引=中间-1，重新生成中间数据
        }else if(targer < arr[m]){
            endIndex = endIndex - 1;
        }
        m = (startIndex+endIndex)/2;
    }
    return -1;
}