简单排序算法

最新推荐文章于 2024-04-23 00:27:34 发布

元汐

最新推荐文章于 2024-04-23 00:27:34 发布

阅读量44

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/simulatorwf/article/details/114107040

版权

Java数组

Java中的数组必须先初始化才能使用

而所谓的初始化：就是为数组中的元素分配内存空间，并为每个数组元素赋值

一般分为：

A.动态初始化:指定长度，由系统给出初始值

B.静态初始化：给出初始值，由系统决定长度

二维数组：将一个一维数组作为一维数组的元素，便构成了二维数组

public class Demo02 {
    public static void main(String[] args) {
        int[][] array1=new int[3][2];
        //使用一维数组覆盖二维数组的元素（也就是一维数组）
        array1[0]=new int[2];
        array1[1]=new int[2];
        array1[2]=new int[2];
        //
        int[][] array02=new int[][]{{10,20,30},{40,33,56},{23,45,89}};
        System.out.println(array02[0][1]);
        //or
        int[][] array03={{12,12},{12,12}};
    }
}

杨辉三角

import java.util.Scanner;

public class Demo03 {
    //杨辉三角
    /*　　　　　１
　　　　　　　１　１
　　　　　　１　２　１
　　　　　１　３　３　１
　　　　１　４　６　４　１
　　　１　５　10　10　５　１
　　１　６　15　20　15　６　１
　１　７　21　35　35　21　７　１
１　８　28　56　70　56　28　８　１*/
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入行数");
        int n= sc.nextInt();
        int[][] arr=new int[n][n];
        //吧每一行的第一列和最后一列设置为一
        for (int i = 0; i < arr.length; i++) {
            arr[i][0]=1;
            arr[i][i]=1;

        }
        for (int i = 2; i < arr.length; i++) {
            for(int j=1;j<=i;j++){
                arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
            }
        }
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            for(int j=0;j<i+1;j++){
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }

    }
}

二分查找

使用二分查找的前提是：该数组的元素必须有序

二分查找的思想：每一次都查找中间的元素，比较大小就能减少一半的元素。

当最小索引等于最大索引时，该元素即被找到并返回

public class Demo06 {
    //二分查找
    public static void main(String[] args) {
        int[] arr={10,20,30,40,50,60,70,80,90};
        int index = getIndex( arr,30);
        System.out.println(index);
    }
    public static int getIndex(int[] arr,int ele){
       int minIndex=0;
       int maxIndex=arr.length-1;
       int centerIndex=(minIndex+maxIndex)/2;
       while(minIndex<=maxIndex) {
           //当该元素与中心索引所对应的元素相等时
           if (ele == arr[centerIndex]) {
               return centerIndex;
           } else if (ele < arr[centerIndex]) {
               maxIndex = centerIndex - 1;
           } else {
               minIndex = centerIndex;
           }
           centerIndex = (minIndex + maxIndex) / 2;
       }
       return -1;
    }
}

冒泡排序

相邻元素比较大小

public class Demo08 {
    //冒泡排序
    public static void main(String[] args) {
        int[] arr={21,34,69,12,45,61,29,66};
        maoPao(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void maoPao(int[] arr){
        int cnt=arr.length;
        int temp;
        while(cnt>1){
            for (int i = 1; i < arr.length; i++) {
                if(arr[i-1]>arr[i]){
                    temp=arr[i-1];
                    arr[i-1]=arr[i];
                    arr[i]=temp;
                }
            }
            cnt--;
        }
    }
}

选择排序

思路：固定一个数，将该数与其他数作比较

public class Demo09 {
    //选择排序
    public static void main(String[] args) {
        int[] arr={21,34,69,12,45,61,29,66};
        tuiDao(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }
    public static void tuiDao(int[] arr){
        for(int index=0;index<arr.length-1;index++){
            for(int i=1+index;i<arr.length;i++){
                if(arr[index]>arr[i]){
                    int temp=arr[i];
                    arr[i]=arr[index];
                    arr[index]=temp;
                }
            }
        }
    }
    /*推导
    public static void xuanZe(int[] arr){
       int index=0;
       //第一轮比较
       for(int i=1;i<arr.length;i++){
           if(arr[index]>arr[i]){
               int temp=arr[i];
               arr[i]=arr[index];
               arr[index]=temp;
           }
       }
       //第二轮比较
        index=1;
        for(int i=1+index;i<arr.length;i++){
            if(arr[index]>arr[i]){
                int temp=arr[i];
                arr[i]=arr[index];
                arr[index]=temp;
            }
        }
        //第三轮比较
        index=2;
        for(int i=1+index;i<arr.length;i++){
            if(arr[index]>arr[i]){
                int temp=arr[i];
                arr[i]=arr[index];
                arr[index]=temp;
            }
        }
        //...
    }
     */
}

插入排序

import java.util.Arrays;

public class Demo10 {
    //插入排序
    public static void main(String[] args) {
        int[] arr={0,2,1,4,0,9,1,9,5,2,0};
        for (int i = 1; i < arr.length; i++) {
            int j=i;
            while(j>0&&arr[j]<arr[j-1]){
                int temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;
                j--;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

插入排序的定义是将一组无须的数组插入一组有序的数组中，且最后总的数组依然有序，其实质是假设对象数组的第一个元素构成一个有序的数组，剩余的元素依次插入有序数组中。因此，编程逻辑是使用外层循环控制插入元素的个数，也就是arr,length-1个元素，使用内层循环将插入元素与有序数组中的元素依次比较，放到合适的位置。

希尔排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RAnEjNvY-1614260087674)(D:\图片\希尔排序.png)]

希尔排序是对插入排序的优化

import java.util.Arrays;

public class Demo11 {
    //希尔排序法
    public static void main(String[] args) {
        int[] arr={0,2,1,4,0,9,1,9,5,2};
        //第一轮 h=4
        /*
        int h1=4;
        for (int i = h1; i < arr.length; i++) {
            for(int j=i;j>h1-1;j-=h1){
                if(arr[j]<arr[j-h1]){
                    int temp=arr[j];
                    arr[j]=arr[j-h1];
                    arr[j-h1]=temp;
                }
            }
        }
        //第二轮 h=2
        int h2=2;
        for (int i = h2; i < arr.length; i++) {
            for(int j=i;j>h2-1;j-=h2){
                if(arr[j]<arr[j-h2]){
                    int temp=arr[j];
                    arr[j]=arr[j-h2];
                    arr[j-h2]=temp;
                }
            }
        }
        //第三轮
        int h3=1;
        for (int i = h3; i < arr.length; i++) {
            for(int j=i;j>h3-1;j-=h3){
                if(arr[j]<arr[j-h3]){
                    int temp=arr[j];
                    arr[j]=arr[j-h3];
                    arr[j-h3]=temp;
                }
            }
        }
        */
        for(int h=4;h>0;h/=2){
            for (int i = h; i < arr.length; i++) {
                for(int j=i;j>h-1;j-=h){
                    if(arr[j]<arr[j-h]){
                        int temp=arr[j];
                        arr[j]=arr[j-h];
                        arr[j-h]=temp;
                    }
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

第一次增量选择数组的一半还未达到最好的效果

效果较好的一般使用Knuth序列

h1=1

h2=h2*3+1//1 4 13 …

使用Knuth方法选取增量

import java.util.Arrays;

public class Demo11 {
    //希尔排序法
    public static void main(String[] args) {
        int[] arr={0,2,1,4,0,9,1,9,5,2};
        //第一轮 h=4
        /*
        int h1=4;
        for (int i = h1; i < arr.length; i++) {
            for(int j=i;j>h1-1;j-=h1){
                if(arr[j]<arr[j-h1]){
                    int temp=arr[j];
                    arr[j]=arr[j-h1];
                    arr[j-h1]=temp;
                }
            }
        }
        //第二轮 h=2
        int h2=2;
        for (int i = h2; i < arr.length; i++) {
            for(int j=i;j>h2-1;j-=h2){
                if(arr[j]<arr[j-h2]){
                    int temp=arr[j];
                    arr[j]=arr[j-h2];
                    arr[j-h2]=temp;
                }
            }
        }
        //第三轮
        int h3=1;
        for (int i = h3; i < arr.length; i++) {
            for(int j=i;j>h3-1;j-=h3){
                if(arr[j]<arr[j-h3]){
                    int temp=arr[j];
                    arr[j]=arr[j-h3];
                    arr[j-h3]=temp;
                }
            }
        }
        */
        //采用Knuth间隔
        int jiange=1;
        while(jiange<arr.length/3){
            jiange=jiange*3+1;
        }
        for(int h=jiange;h>0;h=(h-1)/3){
            for (int i = h; i < arr.length; i++) {
                for(int j=i;j>h-1;j-=h){
                    if(arr[j]<arr[j-h]){
                        int temp=arr[j];
                        arr[j]=arr[j-h];
                        arr[j-h]=temp;
                    }
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

元汐

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
简单排序算法

Java数组Java中的数组必须先初始化才能使用而所谓的初始化：就是为数组中的元素分配内存空间，并为每个数组元素赋值一般分为：A.动态初始化:指定长度，由系统给出初始值B.静态初始化：给出初始值，由系统决定长度二维数组：将一个一维数组作为一维数组的元素，便构成了二维数组public class Demo02 { public static void main(String[] args) { int[][] array1=new int[3][2]; /
复制链接

扫一扫