数组与排序

最新推荐文章于 2022-11-23 21:30:24 发布
最新推荐文章于 2022-11-23 21:30:24 发布
阅读量398 收藏 1
点赞数 2
文章标签： java 算法 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43265483/article/details/119953325
版权

数组

一,数组的概念

数组是一个可以存储多个相同数据类型的容器。可以让我们更方便的操作多个数据

二,数组的初始化

(1)什么是数组的初始化

java中的数组必须先初始化，然后才能使用

初始化：就是给数组中的数组元素分配内存空间，并未每个数组元素赋值。

(2)数组初始化的分类

  1. 动态初始化： 只指定长度，有系统给出初始化值

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

注意事项：这两种初始化方式只能使用一种，不能动静结合

(3)动态初始化的格式：

数据类型[] 数组名 = new 数据类型[数组长度]；

int[] arr = new int[5];

ps：数组长度其实就是数组中元素的个数。

(4)静态初始化的格式：

数据类型[] 数组名 = new 数据类型[] {数组元素,数组元素};

int[] arr = new int[]{1,2,3,4,5}；

静态数组的简写

int[] arr = {1,2,3,4,5}；

三,数组的使用

  1. 动态初始化的数组，在定义的同事已经被赋值 例如：int数组默认值位“0”

  2. 数组通过下标取得数组元素；

    int num = arr[1];

  3. 数组通过下标修改数组元素：

    arr[1] = 20;

四,数组的常见操作

通过[数组.length]可以获取数组中数组元素的个数

int length = arr.length;

(1)数组的元素遍历

  • 通过for循环来遍历数组

    for(int i = 0; i < arr.length; i++){
    System.out.println(arr[i]);
}

  • 通过增强for循环遍历数组

    for(int i : arr){
    System.out.println(i);
}

(2)数组常见的下标越界异常

ArrayIndexOutOfBoundsException

(3)数组的反向遍历

通过for循环来反向遍历数组

for(int i = arr.length - 1; i > 0; i--){
    System.out.println(arr[i]);
}

(4)获取数组元素的最大值或最小值

获取数组元素的最大值

int max = arr[0];
for(int i = 1; i < arr.length; i++){
    if(arr[i] > max){
        max = arr[i];
    }
}
​
System.out.pringln("数组中的最大值:" + max)

获取数组元素的最小值

int min = arr[0];
for(int i = 1; i < arr.length; i++){
    if(arr[i] < min){
        max = arr[i];
    }
}

System.out.pringln("数组中的最小值:" + min)

(5)数组元素的反转

思路:首尾元素互换

for(int i = 0; i < arr.length / 2; i++){
    int temp = arr[i];
    arr[i] = arr[length - i - 1];
    arr[length - i - 1] = temp;
}

五,二维数组

(1)二维数组概述

二维数组:其实就是一维数组的数组

(2)二维数组定义格式

  • 动态初始化(我们指定数组的长度,由系统为数组元素赋默认值)二维数组

    // 我们定义的一个二维素组,这个二维数组里面有三个一维数组,每个一维数组中有两个数组元素
int[][] arr = new int[3][2];
// 取得二维数组中的一维数组
int[] arr1 = arr[0];
// 取得二维数组中的值
int value = arr[0][0];

  • 静态初始化(我们给数组赋值,由系统为数组分配空间)二维数组

    // 我们定义的一个二维素组
int[][] arr = new int[][]{{1,2},{3,4},{4,5}};
// 取得二维数组中的3
int int_3 = arr[1][0];
// 取得二维数组中的5
int int_5 = arr[2][1];
// 取得数组元素中最后一个数组元素
int int_last = arr[arr.lengthh - 1][arr[arr.lengthh - 1].length - 1]

  • 二维数组的使用和一位数组相同,都是通过下标对数组元素进行操作

  • 二维数组的其他定义方式

    // 二维数组的简化方式
int[][] arr = {{1,2},{3,4},{4,5}};
​
// 二维数组的其他定义方式(不建议使用)
int arr[][] = {{1,2},{3,4},{4,5}};
int[] arr[] = {{1,2},{3,4},{4,5}};
​
// 定义了一个一维数组g,和一个二维素组j
int[] g,j[];

(3)二维数组的遍历

  • 通过for循环来遍历数组

    for(int i = 0; i < arr.length; i++){
    // System.out.println(arr[i]);
    for(int j = 0; j < arr[i].length; j++){
        System.out.println(arr[i][j]);
    }
}

(4)二维数组的练习

案例演示1:

​

/*需求:公司销售额求和:
某公司按照季度和月份统计的数据如下:单位(万元 )
第一季度:22,66,44
第二季度:77,33,88
第三季度:25,45,65
第四季度:11,66,99*/
int[][] arr = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};
int sum = 0;
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        sum += arr[i][j];
    }
}
​
System.out.println("总销售额为:" + sum);

案例演示2:

        /*
         * 需求: 打印杨辉三角形(行数可以键盘录入)
         * 1
         * 1 1
         * 1 2 1
         * 1 3 3 1
         * 1 4 6 4 1
         * 1 5 10 10 5 1
         *
         * 观察发现:
         * 1.每一行的第一列和最后一列都是1
         * 2.从第三行开始,从第二列开始,每个数字等于她上一行的前一列,和上一行本列之和
         * 3.行数和列数相同
         *
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数:");
        int n = sc.nextInt();
        // 定义二维数组,存储数据
        int arr[][] = new int[n][n];
        // 每一行的第一列和最后一列都是1
        for (int i = 0; i < arr.length; i++) {
            arr[i][0] = 1;
            arr[i][i] = 1;
        }
​
        // 设置中间元素
        // 2.从第三行开始,从第二列开始,每个数字等于她上一行的前一列,和上一行本列之和
        for (int i = 2; i < arr.length; i++) {
            for (int j = 1; j < arr[i].length; 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; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println("");
        }

(5)查找

根据元素查找出该元素,在数组中第一次出现的索引

  1. 基本查找

public int getIndexByElement(int ele, int[] arr){
    // 目标索引
    int index = -1;

    // 遍历数组
    for (int i = 0; i < arr.length; i++) {
        if(ele == arr[i]){
            index = i;
        }
    }
    return index;
}

  1. 二分查找

    前提:该数组元素必须有序

    思想:每次都查找中间的元素,比较大小,就能减少一半的元素

    步骤:

    1).设置最大索引=arr.length-1,最小索引=0和中间索引=(最大索引+最小索引)/2

    2).取中间索引所对应的元素与目标元素比较

    3).比较之后有三种

    ①.目标元素等于中间索引所对应的元素,返回中间索引,结束方法

    ②.目标元素小于中间索引所对应的元素,改变最大索引=中间索引-1,中间索引再次取(最大索引+最小索引)/2,执行2)

    ③.目标元素大于中间索引所对应的元素,改变最小索引=中间索引+1,中间索引再次取(最大索引+最小索引)/2,执行2)

    4).当最小索引大于最大索引,返回-1,方法结束

    public static int getIndexByEle(int[] arr, int ele) {
    // 定义最小索引,最大索引,中间索引
    int minIndex = 0;
    int maxIndex = arr.length - 1;
    int midIndex = (maxIndex + minIndex) / 2;

    while (minIndex <= maxIndex) {
        // ①.目标元素等于中间索引所对应的元素,返回中间索引,结束方法
        if (ele == arr[midIndex])
            return midIndex;
        // ②.目标元素小于中间索引所对应的元素,改变最大索引=中间索引-1
        else if (ele < arr[midIndex])
            maxIndex = midIndex - 1;
        // ③.目标元素大于中间索引所对应的元素,改变最小索引=中间索引+1
        else if (ele > arr[midIndex])
            minIndex = midIndex + 1;
        // 重新计算midIndex
        midIndex = (maxIndex + minIndex) / 2;
    }
    // 当最小索引大于等于最大索引,目标元素不存在这个数组中,返回-1,方法结束
    return -1;
}

数组常见的排序算法

一,冒泡排序

排序原理:数组元素两两比较,交换位置,大元素往后放,最大的元素就会出现在最大的索引处

总结规律:

假设数组有5个元素;

第一轮需要比较4次(第一个元素和其他元素比较)

第二轮需要比较3次(第一轮确定了一个最大值,排除在比较范围之外)

第三轮需要比较2次

第四轮需要比较1次

假设数组有n个元素;

第一轮需要比较n-1次(第一个元素和其他元素比较)

第二轮需要比较n-2次(第一轮确定了一个最大值,排除在比较范围之外)

......

第n-2轮需要比较2次

第n-1轮需要比较1次

public static void bubbleSort(int[] arr) {
    // 外循环为排序轮数，len个数进行len-1轮
    for (int i = 0; i < arr.length - 1; i++) {
        // 内循环为每轮比较的次数，第i趟比较len-i次
        for (int j = 0; j < arr.length - 1 - i; j++) {
            // 相邻元素比较，若逆序则交换（升序为左大于右，降序反之）
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

二,选择排序

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

总结规律:

假设数组有5个元素;

第一轮需要比较4次(第一个元素和其他元素比较)

第二轮需要比较3次(第一轮确定了一个最小值,排除在比较范围之外)

第三轮需要比较2次

第四轮需要比较1次

假设数组有n个元素;

第一轮需要比较n-1次(第一个元素和其他元素比较)

第二轮需要比较n-2次(第一轮确定了一个最小值,排除在比较范围之外)

......

第n-2轮需要比较2次

第n-1轮需要比较1次

public static void selectionSort(int[] arr) {
    // 外循环为排序轮数，len个数进行len-1轮
    for (int i = 0; i < arr.length - 1; i++) {
        // 内循环为每轮比较的次数，第i趟比较len-i次
        for (int j = i + 1; j < arr.length; j++) {
            // 元素比较，若逆序则交换（升序为左大于右，降序反之）
            if (arr[i] > arr[j]) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

三,插入排序

原理:直接插入排序,是一种最简单排序方法,她的基本操作是讲一个记录插入到一个长度为m的有序序列总,是指仍保持有序

public static void insertionSort(int[] arr) {
    // 外循环为排序轮数，从一个元素的有序列表开始
    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--;
        }
    }
}
​
public static void insertionSort2(int[] arr) {
    // 外循环为排序轮数，从一个元素的有序列表开始
    for (int i = 1; i < arr.length; i++) {
       // 内循环进行比较交换
       for (int j = i; j > 0; j--) {
            if (arr[j] < arr[j - 1]) {
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            }
        }
    }
}

四,希尔排序

希尔排序又称缩小增量排序.是对插入排序的优化

  • 基本思想:先将原来的数组按照增量ht分组,每个子序列按照直接插入法排序.同样,用下一个增量ht/2将序列再分为子序列,再按照直接插入法排序.直到增量ht=1时整个文件排好序了.

  • 关键:选择合适的增量.

    • 第一次的增量可以选择数组的一半,然后不断减半

    public static void shellSort1(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]) {
                    int temp = arr[j];
                    arr[j] = arr[j - h];
                    arr[j - h] = temp;
                }
            }
        }
    }
}
通过克努特(Knuth)序列选择增量

h=1

h=h*3-1

public static void shellSort2(int[] arr) {
    // 根据克努特序列取得第一个增量
    int ht = 1;
    while (ht <= arr.length / 3) {
        ht = ht * 3 + 1;
    }
    //外层增量根据克努特序列递减,直到增量=1
    for (int h = ht; 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;
                }
            }
        }
    }
}

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

五,快速排序

原理:

分治法:比大小,再分区

1.从数组中去一个数,作为基准数

2.分区:将等于等于基准数的元素,全部放到他的右边,小于他的 数全部放到他的左边.

3.再对左右区分重复第二部,直到各个区间自由一个数.

步骤:

挖坑填数:

1.将基准数挖出,形成第一个坑;

2.由后向前找比他小的数,找到后挖出此数,填到前一个坑中;

3.由前向后找大于等于他的数,找到后挖出此数,填到前一个坑中;

4.重复2,3步骤

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);

    }
}

/*
 * 1.将基准数挖出,形成第一个坑;
 * 2.由后向前找比他小的数,找到后挖出此数,填到前一个坑中;
 * 3.由前向后找大于等于他的数,找到后挖出此数,填到前一个坑中;
 * 4.重复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];
            j--;
        }

        //把基准数填到最后一个坑中
        arr[i] = x;
    }
    return i;
}

六,归并排序

归并排序(Merge sort)就是利用归并思想实现排序的方法.

原理:假设初始序列有N个记录,责可以看成N个有序的子序列,每个子序列的长度为1,然后两两归并,得到N/2个长度为2或1的有序子序列,再两两归并...

如此重复,直到得到一个长度为N的有序序列为止,这种排序方法被称为二路归并排序.

// 拆分
private static void chaiFen(int[] arr, int startIndex, int endIndex) {
    // 计算中间索引
    int centerIndex = (startIndex + endIndex) / 2;
    // 递归调用
    if (startIndex < endIndex) {
        chaiFen(arr, startIndex, centerIndex);
        chaiFen(arr, centerIndex + 1, endIndex);
        guiBing(arr, startIndex, centerIndex, endIndex);
    }
}
​
// 归并
public static void guiBing(int[] arr, int startIndex, int centerIndex, int endIndex) {
    // 定义一个临时数组
    int[] temp = 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]) {
            temp[index] = arr[i];
            i++;
        } else {
            temp[index] = arr[j];
            j++;
        }
        index++;
    }
​
    // 处理剩余元素
    while (i <= centerIndex) {
        temp[index] = arr[i];
        i++;
        index++;
    }
​
    while (j <= endIndex) {
        temp[index] = arr[j];
        j++;
        index++;
    }
​
    // 将临时数组中的元素取到原数组中
    for (int k = 0; k < temp.length; k++) {
        arr[k + startIndex] = temp[k];
    }
}

七,基数排序

基数排序不同于上述各类排序,上述排序都是通过比较和移动记录来实现排序.而基数排序只需要对关键字进行分配与收集这两种操作就可以完成排序

private static void sortArray(int[] arr) {
    // 定义二维数组,放10个桶
    int[][] tempArr = new int[10][arr.length];
    // 定义统计数组
    int[] counts = new int[10];
    // 首先的确定轮次,获取数组中的最大值
    int max = geMax(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][counts[ys]++] = arr[j];
        }
​
        // 原数组的下标
        int index = 0;
        // 取出桶中的元素
        for (int k = 0; k < counts.length; k++) {
            if (counts[k] != 0) {
                for (int h = 0; h < counts[k]; h++) {
                    // 从桶里取出元素放回原数组
                    arr[index] = tempArr[k][h];
                    index++;
                }
                // 清除上一次统计
                counts[k] = 0;
            }
        }
    }
}
// 获取数组中的最大值
private static int geMax(int[] arr) {
    int max = arr[0];
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

八,堆排序

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

堆排序的基本思想:

1.将待排序序列构造成一个大的顶堆,此时整个序列的最大值就是堆顶的根节点;

2.将其与末尾元素进行交换,那么末尾元素就是最大值;

3.然后将剩余n个元素重新构造成一个堆,这样会得到n个元素的次小值;

堆的定义：

大顶堆：arr[i]>=arr[2i+1] && arr[i]>=arr[2i+2]

小顶堆：arr[i]>=arr[2i+1] && arr[i]>=arr[2i+2]

import java.util.Arrays;
​
/**
 * @PackageName:PACKAGE_NAME
 * @ClassName: ArrayDemo
 * @Description:
 * @Author:lfq
 * @Date:2021/8/2118:54
 */
public class ArrayDemo11 {
    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);
        }
​
        // 经过上面的操作之后,已经将数组变成了一个大顶堆,吧根元素和最后一个元素进行调换
        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));
    }
​
    /**
     * 将数组调整成大顶堆
     *
     * @param arr   要排序的数组
     * @param size  调整的元素个数
     * @param index 从哪里开始调整
     */
    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);
        }
    }
}
​
头疼的一休
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
利用归并排序进行将数组序列从小到大排序
MAIN198的博客
11-23 780
归并排序两个或多个有序记录序列合并成一个有序序列 一次对两个有序记录序的归并称为二路归并排序，也有三路归并排序及多路归并排序 下面代码给出的是二路归并排序
数组及排序算法
weixin_69509991的博客
07-06 91
数组
对数组进行排序
Jerryhome的专栏
04-15 272
  比如有一个整型数组:       int[] intArray = new int[] {4, 1, 3, -23}; 我们如何进行排序呢？你这个时候是否在想快速排序的算法？看看下面的实现方法:       import java.util.*;    public class Sort{        public static void main(String[] args){  ...
一维数组从小到大排序
weixin_46702984的博客
04-04 7780
一维数组排序的思想：通过两个for循环再加上一个中间变量依次比较，再将比较后排序好的数组用for循环依次输出，即可将数组中的元素按照某种序列排序，例如： package lianxi; public class yiweishuzu { public static void main(String[] args) { int[] a=new int[] {67,89,12,23,2,6}; in...
java数组自定义排序
10-31
java中数组的自定义排序，种类繁多，简单实现，可自由操控。
易语言利用数组进行数值排序
08-27
易语言利用数组进行数值排序，简单粗暴
vue数组对象排序的实现代码
08-27
Vue 数组对象排序的实现代码主要介绍了在 Vue 框架中对数组对象的排序方法，包括普通数组的排序和数组对象的排序。下面是对应的知识点： 普通数组的排序 在 Vue 中，对普通数组的排序可以使用 `sort()` 方法，但是...
php数组随机排序实现方法
10-24
主要介绍了php数组随机排序实现方法,涉及php数组随机排序函数shuffle的相关使用技巧,需要的朋友可以参考下
易语言文本数组排序
08-16
在编程领域，数组排序是一个常见的任务，特别是在处理数据时。易语言是一种中文编程语言，它提供了丰富的库函数和结构来简化编程过程。本篇将详细讲解如何在易语言中实现文本数组的排序。 首先，我们需要了解易语言...
排序算法：归并排序
qq_54169998的博客
11-15 862
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。 例如，有两组有序数据，我们可以通过如下方式（以下简称归并排序）让两组数据快速有序 我们可以依次从两组中取最前的那个最小元素依次有序放到新的数组中，然后再把新数组中有序数据拷贝到园数组中，快速完成排序。 依靠这种思路，再结...
LeetCode 74. Search a 2D Matrix--二维数组 每行有序，且当前行的首元素大于上一行的末位元素，判断是否存在某元素
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
11-21 376
74.Search a 2D Matrix Medium Write an efficient algorithm that searches for a value in anmxnmatrix. This matrix has the following properties: Integers in each row are sorted from left to right...
面试题: js实现合并两个已经排好序的数组 (es6 方法 )
业余前端的职业经历
08-06 957
例子： 只是说排好序 并没有说两个数组都是升序或者是降序 var ar1=[2,3,5,8,9]; var arr2=[10,7,4,2]; 将arr2 拼接到 arr1 中 按照 升序排列 相同的元素不去重哦 以前把 我们会用es5得方式进行 解决 又是判断两个的长度又是啥的 还是比较麻烦的 这里就不说es5的方式了 var arr1=[2,3,5,8,9]; var arr2=[10,7,4,2]; function getConcat(arr1,arr2){ return [...arr1,..
动态数组的实现以及排序
m0_56698045的博客
08-28 438
动态数组的实现以及排序 #include<iostream> #include<vector>//动态数组的头文件 #include<time.h> #include<algorithm>//排序的头文件 using namespace std; bool fun(int a, int b) { return a < b; } int main() { srand((unsigned)time(NULL)); vector<int>
数组的排序
HYA2464336555的博客
04-10 1126
数组排序：把一个无序数组，调整元素位置，最终得到一个有序的数组 时间复杂度：衡量算法的执行效率 空间复杂度：算法在执行过程中使用内存空间 稳定性：排序前后，相同的值顺序会不会交换 冒泡排序： 思想：相邻的元素进行比较，如果前面的元素大于后面的元素，交换位置 public class Demo13 { public static void main(String[] args) { int[] arr = {43,56,74,5,46,45,78,78} ;
数据结构与算法：12 | 排序（下）：归并排序与快速排序
zj
07-11 345
文章目录归并排序的原理归并排序的性能分析快速排序的原理快速排序的性能分析解答开篇 今天，讲两种时间复杂度为 O(nlogn) 的排序算法，归并排序和快速排序。这两种排序算法适合大规模的数据排序。 归并排序的原理 如果要排序一个数组，我们先把数组从中间分成前后两部分，然后对前后两部分分别排序，再将排好序的两部分合并在一起，这样整个数组就都有序了。 归并排序使用的就是分治思想。分治，顾名思义，就是分而治之，将一个大问题分解成小的子问题来解决。小的子问题解决了，大问题也就解决了。 分治算法一般都是用递归来实现的
利用快速排序进行将数组序列从小到大排序
JYMA12358的博客
11-23 2073
利用快速排序进行将数组序列从小到大排序
快速排序算法的c++实现
joecy_trigold的博客
05-06 307
快速排序算法的基本思路是：通过每一次的对数据的操作将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
数组排序：给定一个数组，将数组中的元素从小到大排序
热门推荐
shutingzao的博客
10-19 5万+
代码思路：1.从数组中首元素开始和其他元素逐个比较，若其中一个元素比其小（或大），就交换首元素与其位置。 代码：#include<stdio.h> int sortArray(int *array,int account){ int temp; for(int i = 0;i < account;i++){ for(int j = i + 1;j < account;j++){ if(array[
数组排序与去重c++
最新发布
08-14
数组排序与去重是C语言中常见的操作，可以用来对数组进行排序并去除重复元素。 数组排序可以使用多种排序算法来实现，如冒泡排序、插入排序、选择排序等。以下以冒泡排序为例进行说明。 冒泡排序的基本思想是依次比较相邻的两个元素，如果顺序不对则进行交换，直到整个数组有序为止。具体步骤如下： 1. 初始时，设置一个标志位flag为1，用来标识本趟排序是否进行了交换。 2. 从数组的第一个元素开始，依次比较相邻的两个元素，如果顺序不对则进行交换，并将flag置为0。 3. 继续对数组的下一个元素进行比较，直到最后一个元素。 4. 如果flag为1，则表示本趟排序未进行交换，即数组已经有序，排序结束；否则，继续进行下一趟排序，重复步骤2-4。 去重操作则是将数组中重复的元素只保留一个，可以通过双重循环遍历数组，比较相邻的元素是否相等，若相等则进行标记，最后将标记为1的元素保留，其他重复元素去除。 综合而言，实现数组排序与去重可以按照以下步骤进行： 1. 使用冒泡排序或其他排序算法对数组进行排序。 2. 使用双重循环遍历数组，比较相邻的元素是否相等。 3. 若相等，则进行标记，最后将标记为1的元素保留，其他重复元素去除。 通过以上步骤，可以实现对数组的排序与去重操作，并得到一个有序且去重的数组。在C语言中，通过使用循环和条件判断等基本语法，可以简便地实现这些操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值