首页 > 编程语言 >数组-算法-排序

数组-算法-排序

时间：2022-10-08 16:36:35浏览次数：78  
标签：index arr int 算法 ++ length 数组 排序

定义数组

public static void main(String[] args) {
    //我们的数组必须初始化，才能使用
    //动态出初始化：接受由我们指定的长度，由系统赋初始值
    int[] arr = new int[5];
    //静态初始化由我们赋值，由系统计算长度
    int[] arr2=new int[]{10,20,3,};
    //静态初始化数组的简写方式
    double[] arr3={10.0,20.1};
    //给数组赋值
    arr[0]=10;
    arr[1]=20;
    int num1=arr[0];
    int num2=arr[1];
    System.out.println(num1);
    System.out.println(num2);
    System.out.println(arr[2]);
}

数组的常见操作

  1. 数组的元素的遍历

    public static void main(String[] args) {
    //定义数组
    int[] arr=new int[]{10,2,30,42};
    //遍历数组
    System.out.print("获取数组中元素的个数：");
    int length = arr.length;//获取数组中元素的个数
    System.out.println(length);
    for (int i=0;i<=arr.length;i++){
        System.out.println(arr[i]);
    }
}

  2. 数组常见的角标越界异常：ArrayIndexOutOfBoundsException

  3. 数组元素的反向遍历

    public static void main(String[] args) {
    //定义数组
    int[] arr=new int[]{10,2,30,42};
    //数组的反向遍历
    for (int i=arr.length-1;i>=0;i--){
        System.out.println(arr[i]);
    }
}

  4. 获取数组中的元素的最大值或最小值

    public static void main(String[] args) {
    //定义数组
    int[] arr=new int[]{10,2,30,42};
    //获取数组中的元素的最大值或最小值
    //定义一个参照值
    int max=arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i]<max){
            max=arr[i];
        }
    }
    System.out.println("最小值："+max);
}
    public static void main(String[] args) {
    //定义数组
    int[] arr=new int[]{10,2,30,42};
    //获取数组中的元素的最大值或最小值
    //定义一个参照值
    int max=arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i]>max){
            max=arr[i];
        }
    }
    System.out.println("最大值："+max);
}

  5. 数组元素的反转

    public static void main(String[] args) {
    //定义数组
    int[] arr=new int[]{10,2,30,42};
    for (int i=0;i<arr.length/2;i++){
        int t=arr[i];
        arr[i]=arr[arr.length-1-i];
        arr[arr.length-1-i]=t;
    }
    //遍历数组
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+" ");
    }
}

数组之常见的排序算法

  1. 冒泡排序（07：数组排序之冒泡排序哔哩哔哩bilibili）

    public class 冒泡排序 {
    public static void main(String[] args) {
        int[] arr = new int[]{80, 50, 2, 10, 42,102,8};
//        sort(arr);
        //优化冒泡排序
        bubbleSort(arr);
​
​
    }
​
    private static void sort(int[] arr) {
        //第一轮比较：会把最大的一个数字往后移
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                //交换位置
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第二轮比较：会把最大的一个数字往后移
        for (int i = 0; i < arr.length - 1 - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                //交换位置
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第三轮比较：会把最大的一个数字往后移
        for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                //交换位置
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第三轮比较：会把最大的一个数字往后移
        for (int i = 0; i < arr.length - 1 - 1 - 1 - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                //交换位置
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
​
    //优化冒泡排序
    private static void bubbleSort(int[] arr) {
        for (int j = 0; j < arr.length - 1; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int t = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
​
    }
}

  2. 选择排序（08：数组排序之选择排序哔哩哔哩bilibili）

    public class 选择排序 {
    public static void main(String[] args) {
        int[] arr = new int[]{80, 50, 2, 10, 42};
        //普通排序
        sort(arr);
        //优化排序
        selectSort(arr);
    }
    private static void sort(int[] arr){
        //第一轮比较从0索引开始比
        int index=0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[index]>arr[i]){
                int t=arr[index];
                arr[index]=arr[i];
                arr[i]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第二轮比较从1索引开始比
        index=1;
        for (int i = 1+index; i < arr.length; i++) {
            if (arr[index]>arr[i]){
                int t=arr[index];
                arr[index]=arr[i];
                arr[i]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第三轮比较从1索引开始比
        index=2;
        for (int i = 1+index; i < arr.length; i++) {
            if (arr[index]>arr[i]){
                int t=arr[index];
                arr[index]=arr[i];
                arr[i]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第四轮比较从1索引开始比
        index=3;
        for (int i = 1+index; i < arr.length; i++) {
            if (arr[index]>arr[i]){
                int t=arr[index];
                arr[index]=arr[i];
                arr[i]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    private static void selectSort(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 t=arr[index];
                    arr[index]=arr[i];
                    arr[i]=t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

  3. 插入排序（09：数组排序之直接插入排序哔哩哔哩bilibili）

    public class 插入排序 {
    public static void main(String[] args) {
        int[] arr = new int[]{80, 50, 2, 10, 42, 102, 8};
        //普通排序
        sort(arr);
        //优化排序
        insertSort(arr);
    }
​
    private static void sort(int[] arr) {
        //直接插入排序，从1索引处开始，将后面的元素，插入之前的有序列表
        //外层循环定义轮次
        for (int i = 1; i < arr.length; i++) {
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                int t = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = t;
                j--;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    private static void insertSort(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j >0 ; j--) {
                if (arr[j]<arr[j-1]){
                    int t=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=t;
                }
​
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

  4. 希尔排序（10：数组排序之希尔排序哔哩哔哩bilibili）

    public class 希尔排序 {
    public static void main(String[] args) {
        //希尔排序，他是对插入排序的一个优化，核心的思想计算合理的选取增量，经过一轮排序后，就会让序列大致有序
        //然后再不断的缩小增量，进行插入排序，直到增量位1那整个排序结构
        //直接插入排序，其实计算增量位1的希尔排序
        int[] arr = new int[]{17, 55, 13, 42, 46, 94, 5, 70};
        //普通排序
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
        //优化排序
        hillsort(arr);
        //自己瞎搞
        hillsortTest(arr);
        System.out.println(Arrays.toString(arr));
        hillsort2(arr);
        System.out.println(Arrays.toString(arr));
    }
​
    private static void shellSort(int[] arr) {
        //定义一个增量
        //第一轮
        int h = 4;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    swapValue(arr, j, j - h);
                }
            }
        }
        //第二轮
        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]) {
                    swapValue(arr, j, j - h);
                }
            }
        }
        //第二轮
        h = 1;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    swapValue(arr, j, j - h);
                }
            }
        }
    }
​
    public static void swapValue(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
​
    public static void hillsort(int[] arr) {
        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]) {
                        swapValue(arr, j, j - h);
                    }
                }
            }
        }
​
    }
​
    public static void hillsort2(int[] arr) {
        for (int h = arr.length / 2; 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]) {
                        swapValue(arr, j, j - h);
                    }
                }
            }
        }
    }
​
    public static void hillsortTest(int[] arr) {
        for (int h = 1; h < arr.length / 2; h++) {
            for (int i = h; i < arr.length; i++) {
                for (int j = i; j > h - 1; j -= h) {
                    if (arr[j] < arr[j - h]) {
                        swapValue(arr, j, j - h);
                    }
                }
            }
        }
    }
​
​
}

  5. 快速排序（11：数组排序之快速排序哔哩哔哩bilibili）

  6. 归元排序

  7. 基础排序

  8. 堆排序

标签：index,arr,int,算法,++,length,数组,排序
From： https://www.cnblogs.com/lyhidea/p/16769349.html

相关文章

  • C# 最基础知识介绍(四)——数组、字符串、结构体、枚举、类
    C#最基础知识介绍(四)——数组、字符串、结构体、枚举、类数组（Array）......
  • AcWing算法提高课 分解质因数求组合数
    模板：intprimes[N],cnt;boolnot_prime[N];voidInit(){for(inti=2;i<N;i++){if(!not_prime[i]){primes[cnt++]=i;......
  • AVX图像算法优化系列一: 初步接触AVX。
    弄了SSE指令集，必然会在不同的场合不同的人群中了解到还有更为高级的AVX指令集的存在，早些年也确实有偶尔写点AVX的函数，但是一直没有深入的去了解，今年十一期间也没到那里......
  • 插入排序 和 希尔排序 java
    ​​http://mp.weixin.qq.com/s/deUy_VPJ2m6BFbrEZp9DKg​​​选择排序/***Createdbyfupengon2017/1/19.*/publicclassinsertstaticvoidshow(int[]a){......
  • 字符数组和字符串
      注意事项：  关于第三点：  后面？的表示垃圾值或是无用值，反正不知道 关于第四点：  数组已经满了，没有空间放结束标志\0了（空间足够的时候系统会自动给你......
  • 【算法浅谈】二分法
    二分法注意边界的开闭，以及除法自动取整的特性。publicintmySqrt(intx){//使用简单二分法进行排除得出开方结果intans=0;//对输入为0的情况......
  • 【重识Java】你这 数组 挺能藏啊？
    本文主要介绍一些关于Java数组的易错易忘的知识点，并不系统完善，如有在意，还请见谅。一、数组初始化......
  • 数组案例应用
    1.1#include<stdio.h>23voidmain(){4charword[26];5for(inti=0;i<26;i++){6word[i]='A'+i;7}89for(int......
  • 对象数组的排序
    假如我们想实现，把这样一个数组排下序，先按一个属性排，再按另一个属性排vararr=[{cezuProjectName:'1',group:'a'},{cezuProjectName:'2',group:'b'},{cezuProjec......
  • 数组
      其中，a是数组名，类型为int，[5]是大小，即a数组最多存放五个int类型的数据1.数组名代表该数组的首地址，即a[0]的地址2.数组的各个元素是连续分布的，如：a[0]地址为0x1123，则......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99