java_排序算法

1.冒泡排序

大的数字往上去，一趟冒泡排序可以找到这个数组中最大的元素
核心代码：

public class Main{
    public static void main(String[] args) throws Exception{
        int[] so=new int[]{23,24,42,13,43};
        for(int i=0;i<so.length-1;i++){//冒泡次数（总共有几项要比）
            //冒泡步骤(每一项要和几个项比）
            for(int j=0;j<so.length-1-i;i++)
                if(so[j]>so[j+1]){
                    int t=so[j];
                    so[j]=so[j+1];
                    so[j+1]=t; } } }}

2.选择排序：

public class Main{
    public static void main(String[] args) throws Exception{
        int[] so=new int[]{23,24,42,13,43};
        for(int i=0;i<so.length-1;i++){//选择排序次数（总共有几项要比）
            int min=i;
            //每轮需要比较的次数为n-i
            for(int j=i+1;j<so.length;j++){
                if(so[j]<so[min]){
                    min=j;
                }
            }
            //将找到的最小值和i位置所在的值进行交换
            if(i!=min){
                int t=so[i];
                so[i]=so[min];
                so[min]=t;
            }
                 } }}

3.插入排序：

 public static void insertSort(int[] arr){
        for(int i=1;i<arr.length;i++)//len-1(从第二个元素开始判断是否往左边移动）
        {
            int insertIndex=i;
            int insertValue=arr[i];//要比较的值保留在这个变量中
            //插入的值要比当前索引的前一个值才能插进去
            while(insertIndex>0&&insertValue<arr[insertIndex-1]){
                arr[insertIndex]=arr[insertIndex-1];//arr[1]=arr[0]
                insertIndex--;
            }
            arr[insertIndex]=insertValue;
        }
 }
}

4.希尔排序

普通的插入排序是间隔一个比，步长为1
希尔排序的步长是变的

5.快速排序

public static void quickSort(int[] arr,int left,int right){
    int l=left;
    int r=right;
    int mid=arr[(left+right)/2];
    int temp=0;
    while(l<r){
        while(arr[l]<mid)
            l++;
        while(arr[r]>mid)
            r--;
        if(l>=r)
            break;
        //如果发生左索引和右索引停住了，就需要交换值
        temp=arr[l];
        arr[l]=arr[r];
        arr[r]=temp;
        //如果碰到了 6(mid) 7 6这种僵持的情况，需要右索引打破僵局
        if(arr[l]==mid)
            r--;
        //如果碰到了 6 7 6(mid)这种僵持的情况，需要左索引打破僵局
        if(arr[r]==mid)
            l++;
    }
    //第一次循环结束后，选择的基准点将数组分为两部分
    if(l==r){
        l++;
        r--;
    }
    if(left<r)//左半部分的排序
        quickSort(arr,left,r);
    if(right>l)//右半部分的排序
        quickSort(arr,l,right);
}
}

例题：
输入格式
第 11 行为一个正整数 NN，第 22 行包含 NN 个空格隔开的正整数 a_ia
i，为你需要进行排序的数，数据保证了 A_iA i​不超过 10^910

输出格式
将给定的 NN 个数从小到大输出，数之间空格隔开，行末换行且无空格。

输入输出样例
输入 #1复制
5
4 2 4 5 1
输出 #1复制
1 2 4 4 5
说明/提示
对于 20%20% 的数据，有 N\leq 10^3N≤10 3
对于 100%100% 的数据，有 N\leq 10^5N≤10 5 。

import java.util.Scanner;
public class Main{
    //记住这种开数组的方式，先定义一个static的不定义大小的数组，后面在主函数中在定义数组的大小
    static int []arr;
    static void quickSort(int left,int right){
        int l=left;
        int r=right;
        int mid=arr[(l+r)/2];
        int temp=0;
        while(l<r){
            while(arr[l]<mid)
                l++;
            while(arr[r]>mid)
                r--;
            if(l>=r)
                break;
            temp=arr[l];
            arr[l]=arr[r];
            arr[r]=temp;
            if(mid==arr[r])
                l++;
            if(mid==arr[l])
                r--;
        }
        if(l==r){
            l++;
            r--;
        }
        if(l<right)
            quickSort(l,right);
        if(r>left)
            quickSort(left,r);
    }

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        arr =new int[n];
        for(int i=0;i<n;i++){
            arr[i]=in.nextInt();
        }
        quickSort(0,n-1);
        for(int i=0;i<n;i++)
        {
            System.out.print(arr[i]);
            if(i<n-1)
                System.out.print(" ");
        }
    }
}

6.二分查找法：

使用前提：
数组已经按照升序排列
基本原理：
首先要将查找的元素(key)与数组的中间元素比较
1.如果Key小于中间元素，只需要在数组的前一半元素中继续查找
2.如果Key等于中间元素，匹配成功，查找结束
3.如果key大于中间元素，只需要在数组的后一半元素中继续查找

import java.util.*;
public class Main{
    public static int SecondSearch(String[] nn,String q){
            int min=0;
            int max=nn.length-1;
            int mid=0;
            while(min<=max){
                mid=(min+max)/2;
                if(Integer.parseInt(q)<Integer.parseInt(nn[mid])){//在左边
                    max=mid-1;
                }
                if(Integer.parseInt(q)>Integer.parseInt(nn[mid]))//在右边
                {
                    min=mid+1;
                }
                if(Integer.parseInt(q)==Integer.parseInt(nn[mid])){
                    return mid+1;
                }
            }
            return -1;
    }
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        String q=in.nextLine();
        String[] one=in.nextLine().split(" ");
        String[] two=in.nextLine().split(" ");
        for(int i=0;i<two.length;i++){
            System.out.print(SecondSearch(one,two[i]));
            if(i<two.length-1)
                System.out.print(" ");
        }
    }
}