Java数组03-常见排序算法-CSDN博客

本文链接：https://blog.csdn.net/LYly_B/article/details/125723786

常见排序算法

1.冒泡排序

不停地两两对比排列顺序

//从大到小排序
class Bubble{
    public int[] sort(int[] array){
        int temp = 0; //用来当容器交换数字
        for(int i = 0;i < array.length - 1; i++){
            int flag = 0; //避免无用比较
            for(int j = 0; j < array.length - i - 1; j++){
                if(array[j+1] > array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = 1;
               }
           }
            if(flag == 0) {
                break;
           }
       }
        return array;
   }
    public static void main(String[] args){
        Bubble bubble = new Bubble();
        int[] array = {2,3,5,2,7,3,5,7,2,0};
        int[] sort = bubble.sort(array);
        for(int num : sort){
            System.out.print(num + "\t");
       }
   }
}

2.选择排序

不停找出数组中的最大(最小)元素排列

class SelectSort{
    public int[] sort(int arr[]){
        int temp = 0;
        for(int i = 0; i < arr.lrngth - 1; i++){
            int mixIndex = i;
            for(int j = i + 1; j < arr.lrngth; j++){
                if(arr[minIndex] > arr[j]){
                    minIndex = j;
               }
           }
            if(i != minIndex){
                temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
           }
       }
        return arr;
   } 
    public static void main(String[] args){
        SelectSort selectSort = new SelectSort();
        int[] array = {2,3,5,2,7,3,5,7,2,0};
        int[] sort = selectSort.sort(array);
        for(int num : sort){
            System.out.print(num + "\t");
       }
   }
}

3.稀疏数组

当数组中大部分元素为同一值时，用稀疏数组来保存数组。

处理方式：记录数组有几行几列，有几个不同的值。

把具有不同值的元素和行列及值记录在一个小规模的数组中。

0	0	0	22	0
0	11	0	0	17
0	0	0	-6	0
0	0	0	0	39
91	0	0	0	0
0	0	28	0	0

	行	列	值
[0]	6	7	8	总共6行7列，有8个不同数
[1]	0	3	22	在几行几列(坐标)，值
[2]	0	6	15	在几行几列(坐标)，值
[3]	1	1	11	在几行几列(坐标)，值
[4]	1	5	17	在几行几列(坐标)，值
[5]	2	3	-6	在几行几列(坐标)，值
[6]	3	5	39	在几行几列(坐标)，值
[7]	4	0	91	在几行几列(坐标)，值
[8]	5	2	28	在几行几列(坐标)，值

//11*11棋盘，0：无子,1:黑棋,2:白棋
public class ArrayDemo{
    public static void main(String[] args){
        //创建二维数组
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //转换为稀松数组
        //1.获取有效值的个数
        int sum = 0;
        for(int i = 0; i < 11; i++){
            for(int j = 0; i < 11; j++){
                if(array1[i][j] != 0){
                    sum++;
               }
           }
       }
        //2.创建一个稀松数组的数组
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //遍历二维数组，将非0的值存放在稀疏数组中
        int count = 0;
        for(int i = 0; i < array1[i].length; j++){
            if(array1[i][j] != 0){
                count++;
                array2[count][0] = i;
                array2[count][1] = j;
                array2[count][2] = array1[i][j];
           }
       }
   }
    //还原
    //1.读取稀疏数组
    int[][] array3 = new int[ array2[0][0] ][ array2[0][1] ];
    //2.还原值
    for(int i = 1; i < array2.length; i++){
        array3[ array2[i][0] ][ array2[i][j] ] = array2[i][2];
   }
}