数组排序

数组

• 数组的出现，是为了我们方便地去操作多个数据
• 数组下标越界异常：ArrayIndexOutofBoundsExcetion

数组概念

• 数组是存储同一种数据类型多个元素的集合，也可以看成是一个容器。

• 数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式：数据类型【】 数组名，数据类型 数组名【】

数组遍历

package com.xiao;

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
            int[] arr = {10,20,30,40,50};
            //遍历数组
        // int length = arr.length;//获取数组的元素的个数
       // System.out.println(length);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }
}

反向遍历

package com.xiao;

public class Demo {
    public static void main(String[] args) {
        int[] arr = {10,20,30,40,50};
        for (int i = arr.length -1; i >= 0; i--) {
            System.out.print(arr[i]);

        }
    }
}

获取数组中的最大值或者最小值

package com.xiao;

public class Demo {
    public static void main(String[] args) {
        int[] arr={10,2,3,4,5,6};
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]<max){
                max = arr[i]
            }
        }
        System.out.println(max);
    }
}

最小值

class de{
    public static void main(String[] args) {
        int[] arr={10,80,90,2,3,4,5};
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]<max){
                max=arr[i];
            }
        }
        System.out.println("数组中的最xiao值是："+max);

    }
}

反转数组中的元素（收尾元素互调）

package com.xiao;

public class Demo09 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,2,2,2,3,44};
        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.println(arr[i]);
        }
    }
}

数组排序

冒泡排序

排序原理：数组元素量量比较，交换位置，大元素往后放，那么经过一轮比较后，最大的元素，就会出现在最大的索引处。

package com.xiao;

import java.util.Arrays;

public class Demo09 {
    public static void main(String[] args) {
        int[] arr = {24,69,80,57,13};
        for (int y = 0; y < 4; y++) {
            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));
    }
}

选择排序

排序原理：从0索引处开始，依次和后面的元素进行比较，小的元素往前放，经过一轮比较厚，最小的元素就出现在了最小索引处

package com.xiao;

import java.util.Arrays;

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = {24,93,44,22,21};
        int x=0;
            for (int i = 0; i < arr.length; i++) {
                if (arr[x] >arr[i]){
                    int t = arr[x];
                    arr[x] = arr[i];
                    arr[i] = t;
                }
            }
        
        System.out.println(Arrays.toString(arr));
    }
}

插入排序

排序原理：算法思路：直接插入排序，是一种最简单的排序方法，他的基本操作是讲一个记录插入到一个长度为m的有序列表中，使之仍保持有序

package com.xiao;

import java.util.Arrays;

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = {3,2,1,0,10,20,30,5,4};
        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));
    }
}

希尔排序

• 希尔排序又称缩小增量排序

• 基本思想：先将原标按增量ht分组，每个子文件按照直接插入法排序。同样，用下一个增量ht/2将文件再分成子文件，在直接插入法排序。知道ht=1时，整个文件排好序。

• 关键：选择合适的增量。

• 希尔排序算法9-3:可以通过三重循环来实现。

package com.xiao;

import java.util.Arrays;

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = {46,55,13,42,17,94,4,70};
        shellSort (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]){


                }
            }
        }
    }
    public static void swapValue(int[] arr,int i,int j){
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

快速排序

• 分治法：比大小，再分区

1、从数组中取出一个数，作为基准数。

2、分区：将比这个数大或等于的数全放到她的右边，小雨他的数全放到左边

3、在对左右区间重复第二部，直到个区间只有一个数

• 挖坑填数

1. 将基数挖出行成第一个坑
2. 由后向前找比他小的数，找到后挖出此数天到前一个坑中。
3. 由前向后找比他大或者等于的数，找到后也挖出此数填到前一个坑中
4. 再重复执行2，3辆步骤。

package com.xiao;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {10,3,5,6,1,0,100,40,50,8,-1,-3,-2};
        //调用工具类，进行快速排序，传入数组，传入其实位置，传入结束位置
        QuickSorUtils.quickSort(arr,0,arr.length-1);
        //输出排序后的结果
        System.out.println(Arrays.toString(arr));
    }
}

package com.xiao;

public class QuickSorUtils {
    public static void quickSort(int[] arr,int start,int end){
        //找出分左右两区的缩阴位置，然后对左右两区进行递归调用
        if (start<end){
            int index = getIndex(arr,start,end);
            quickSort(arr,start,index-1);
            quickSort(arr,index+1,end);
        }
    }
    //将基准数坑挖出形成第一个坑。
    //由后向钱找比他小的数，找到后挖出此数填到前一个坑中。
    //由前向后找比他大或者等于的数，找到后挖出此数填到前一个坑中。
    //再重复2，3步骤
    private static int getIndex(int[] arr, int start, int end) {
        int i =start;
        int j = end;
        int x= arr[i];
        while (i<j){
            while (i<j && arr[j] >= x){
                j--;
            }
            if (i<j){
                arr[i] = arr[j];
                i++;
            }

            //由前向后找比他大或者等于的数，找到后挖出此数填到前一个坑中。

            while (i<j && arr[i] < x){
                i++;
            }
            if (i<j){
                arr[j] = arr[i];
                i--;
            }
        }
        arr[i] = x;
        return i;
    }
}

归并排序

• 归并排序（Merge Sort）就是李通归并的思想实现排序的方法。

• 它的原理是假设初始化序列由n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2个长度为2或1的序子序列，再两两归并.....如此重复，直至得到一个长度为n的有序序列位置，这种排序方法称为2路归并排序。

package com.xiao;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        //原始待排序数组
        int[] arr ={10,30,2,1,0,8,7,5,19,29};
        //我们先给一个左右两边是有序的一个数组，先来进行归并操作
       // int[] arr = {4,5,7,8,1,2,3,6};
        //拆分
            chaifen(arr,0,arr.length-1);


        //归并
      //  guibing(arr,0,3,arr.length-1);

        //输出原来数组
       System.out.println(Arrays.toString(arr));
    }

    private static void chaifen(int[] arr, int startIndex, int enIndex) {
        //计算中间索引
        int centerTndex=(startIndex+enIndex)/2;
        if (startIndex<enIndex){
            chaifen(arr,startIndex,centerTndex);
            chaifen(arr,centerTndex+1,enIndex);
            guibing(arr,startIndex,centerTndex,enIndex);
        }
    }

    private static void guibing(int[] arr, int startIndex, int centerIndex, int endIndex) {
        //定义一个临时数组
        int[] tempArr = new int[endIndex - startIndex +1];
        //定义左边数组的起始索引
        int i = startIndex;
        //定义右边数组的起始所有
        int j = centerIndex+1;
        //定义临时数组的起始索引
        int index = 0;
        //比较左右两个数组的元素大小，往临时数组中方
        while (i<=centerIndex && j<=endIndex){
            if (arr[i] <= arr[j]){
                tempArr[index] = arr[i];
                i++;
            }else {
                tempArr[index] = arr[j];
                j++;
            }
            index++;
        }
        //处理剩余元素
        while (i <= centerIndex){
            tempArr[index] = arr[i];
            i++;
            index++;
        }
        while (j <= endIndex){
            tempArr[index] = arr[j];
            j++;
            index++;
        }
      // System.out.println(Arrays.toString(arr));
        //将临时数组中的元素取到原数组中
        for (int i1 = 0; i1 < tempArr.length; i1++) {
            arr[i1+startIndex] = tempArr[i1];
        }
    }
}

基数排序

• 基数排序不同于之前所介绍的各类排序。
• 前边介绍的排序方法或多或少的是通过是使用比较和移动记录来实现排序。
• 而基数排序的实现不需要进行对关键字的比较。
• 只需要对关键字进行“分配”与“收集”两种操作即可完成。

package com.xiao;

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        //基数排序，通过分配在收集的方式进行排序
        int[] arr = {2,1,5,31,444,23,33,47,10,903,124,987,100};
        //群定排序轮次
        //获取数组中的最大值
        int max = getmax(arr);
        //基数排序
        sortArray(arr);

        //输出排序过后的数组
        System.out.println(Arrays.toString(arr));
    }

    private static void sortArray(int[] arr) {
        //定义二维数组，放10个桶
        int[][] tempArr = new int[10][arr.length];
        //定义统计数组
        int[] couts = new int[10];
        int max = getmax(arr);
        int len = String.valueOf(max).length();
        for (int i = 0,n=1;i < len; i++, n*=10) {
            for (int j = 0; j < arr.length; j++) {

                //获取每个位上的数字
                int ys = arr[j]/n%10;
                tempArr[ys][couts[ys]++] = arr[j];
            }
            //取出桶中的元素
            int index = 0;
            for (int k = 0; k < couts.length; k++) {
                if (couts[k] != 0){
                    for (int h = 0; h < couts[k]; h++) {
                        //从桶中取出元素放回原数组
                        arr[index] = tempArr[k][h];
                        index++;
                    }
                    couts[k] = 0;//清除上一次统计的个数
                }
            }
        }
    }

    private static int getmax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
        }
        return max;
    }
}

堆排序

• 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序。

堆排序的基本思想是：

1. 将待排序序列构成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。
2. 将其与末尾元素进行交换，此时末尾就为最大值。
3. 然后将剩余n-1元素重新构造成一个堆，这样会得到n个元素的次小值。
4. 如此反复执行，便能得到一个有序序列。

package com.xiao;

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        // 定义一个数组
        int[] arr = {1,0,6,7,2,3,4};
        //调整成大顶堆的方法
        int startIndex = (arr.length -1)/2;
        //循环开始调
        for (int i = startIndex;i >= 0;i--){
            toMaxHeap(arr,arr.length,i);
        }
        System.out.println(Arrays.toString(arr));
        //经过上面的操作，已经把数组编程一个大顶堆，把跟元素和最后一个元素进行调换
        for (int i = arr.length-1;i>0;i--){
            //进行调换
            int t = arr[0];
            arr[0] = arr[i];
            arr[i] = t;
            //换完之后，我们再把剩余元素调成大顶堆
            toMaxHeap(arr,i,0);
        }
        System.out.println(Arrays.toString(arr));
    }



    //要排序的数组
    //调整的元素个数
    //从哪里开始调整
    private static void toMaxHeap(int[] arr, int size, int index) {
        //获取左右字节的索引
        int leftNodeIndex = index*2+1;
        int rightNodeIndex = index*2+2;
        //查找最大节点所对应的索引
        int maxIndex = index;
        if (leftNodeIndex < size&&arr[leftNodeIndex] > arr[maxIndex]){
            maxIndex = leftNodeIndex;
        }
        if (rightNodeIndex<size&&arr[rightNodeIndex]>arr[maxIndex]){
            maxIndex = rightNodeIndex;
        }
        //调换位置
        if (maxIndex != index){
            int t = arr[maxIndex];
            arr[maxIndex] = arr[index];
            arr[index] = t;
            //调换完之后，可能会影响到下面的子数，不是大顶堆，我们还需要再次调换
            toMaxHeap(arr,size,maxIndex);
        }
    }
}