下载文档原格式
数组及操作⽅法（详解）数组数组的概念数组是⼀个存放相同数据类型的容器，也是⼀个变量。
举个简单的例⼦：货架上的商品是⼀堆相同的商品，⽽货架就是存放商品的数组。
创建数组语法⼀：var arr = []; // 创建了⼀个空数组var arr = ["张三","李四","王五"]; // 创建了⼀个数组，⾥⾯存了三个姓名语法⼆：使⽤构造函数的形式创建数组var arr = new Array(); // 创建了⼀个空数组var arr = new Array(3); // 创建了⼀个长度为3的数组var arr = new Array("张三","李四","王五"); // 创建了⼀个数组，⾥⾯存了三个姓名使⽤构造函数的⽅式创建数组的时候，如果其中只有⼀个值，如果这个值是整数，表⽰数组的长度，否则表⽰这个数组中有⼀个元素，就是这个值。
var arr = new Array(3)console.log(arr);//输出结果//Array(3)//length: 3//__proto__: Array(0)数组中可以存放任意类型的值，但实际情况中，我们习惯将同类型的数据存到⼀个数组中。
var arr = ['张三',123,true,'underfind']数组的操作访问数组中的元素：数组[下标]，例：var arr = ["张三","李四","王五"];console.log(arr[1]); // 李四数组中下标是从0开始查看数组中元素的个数 - 数组的长度：数组.length，例：var arr = ['张三',"李四","王五","赵六"];var arr1 = [1,2,3,4,5,6];console.log(arr.length); // 4数组中长度length与下标不同，使⽤时易混淆数组的长度可以访问，也可以赋值，⽤来修改数组的长度。
C语言数组函数的使用方法1. 介绍C语言是一种广泛应用于系统开发、嵌入式设备、游戏开发等领域的编程语言。
在C语言中，数组是一种特殊的数据结构，它可以容纳多个相同类型的元素，并通过索引来访问和操作这些元素。
函数是C语言中的重要概念，它可以使程序模块化并提高代码的可读性和复用性。
本文将介绍C语言中数组函数的使用方法。
2. 定义和初始化数组定义数组是指给数组分配内存空间，并为数组元素指定类型。
C语言中，可以使用以下语法来定义一个数组：<数据类型> <数组名>[<数组大小>];例如，定义一个包含5个整数的数组：int numbers[5];数组的大小指定了数组可以容纳的元素个数。
数组的索引从0开始，因此上述数组的索引范围是0到4。
进行数组初始化可以分为两种情况：2.1 静态初始化静态初始化是指在定义数组时直接给数组元素赋初值。
例如，下面的代码定义并初始化了一个包含5个整数的数组：int numbers[5] = {1, 2, 3, 4, 5};上述代码将数组的前5个元素分别赋值为1、2、3、4和5。
2.2 动态初始化动态初始化是指在定义数组后，通过循环或用户输入等方式给数组元素赋值。
例如，下面的代码定义了一个包含5个整数的数组，并通过循环给数组元素赋值：int numbers[5];int i;for (i = 0; i < 5; i++) {numbers[i] = i + 1;}上述代码通过循环将数组的前5个元素分别赋值为1、2、3、4和5。
3. 数组函数的定义和使用数组函数是指以数组为参数和/或返回值的函数。
在C语言中，可以通过以下方式定义数组函数：<返回类型> <函数名>(<数据类型> <数组名>[<数组大小>]) {// 函数体}下面是一个示例，定义了一个数组函数用于计算数组中所有元素的和：int sum(int numbers[], int size) {int result = 0;int i;for (i = 0; i < size; i++) {result += numbers[i];}return result;}上述代码定义了一个名为sum的函数，接受一个整数数组和数组大小作为参数，并返回数组元素的和。
数组反转方法在编程中，数组是一种重要的数据结构，它允许我们存储和处理大量相似类型的数据。
数组中的元素按照特定的顺序存储，并且可以通过索引访问。
有时候我们需要对数组中的元素进行反转操作，即将原来的顺序颠倒过来。
本文将介绍一些常见的数组反转方法，帮助您在实际编程中灵活运用。
一、内置方法实现数组反转在许多编程语言中，提供了内置的方法来实现数组的反转操作。
下面是一些常见语言的例子：1. Python语言：在Python中，可以使用[::-1]的方式对数组进行反转。
例如，有一个名为arr的数组，可以通过arr[::-1]来实现数组元素的反转。
2. JavaScript语言：在JavaScript中，可以使用Array对象的reverse()方法对数组进行反转。
例如，有一个名为arr的数组，可以通过arr.reverse()来实现数组元素的反转。
这些内置方法是实现数组反转的最简单、快速的方法之一。
然而，有时候我们可能需要自己编写算法来完成数组反转，下面将介绍其他实现方法。
二、循环交换法实现数组反转另一种常见的数组反转方法是循环交换法。
该方法使用两个指针分别指向数组的首尾元素，然后交换它们的值，并依次向中间移动。
具体步骤如下：1. 初始化两个指针，一个指向数组的首元素，记为left，另一个指向数组的尾元素，记为right。
2. 当left小于right时，交换left和right位置上的元素，并将left指针右移一位，将right 指针左移一位。
3. 重复步骤2，直到left大于或等于right为止。
下面是一个使用循环交换法实现数组反转的示例代码（以Java语言为例）：```javavoid reverseArray(int[] arr) {int left = 0;int right = arr.length - 1;while (left < right) {int temp = arr[left];arr[left] = arr[right];arr[right] = temp;left++;right--;三、递归实现数组反转除了循环交换法，我们还可以使用递归的方式实现数组反转。
c语言数组小案例C语言是一种广泛应用的编程语言，数组是C语言中常用的数据结构之一。
它可以存储多个相同类型的数据，并通过索引访问和操作这些数据。
下面列举了10个关于C语言数组的小案例，以帮助读者更好地理解和掌握数组的使用。
1. 计算数组元素的总和编写一个程序，从用户输入一组整数，并计算它们的总和。
使用数组来存储输入的整数，并通过循环遍历数组来计算总和。
2. 查找数组中的最大值和最小值编写一个程序，从用户输入一组整数，并找到其中的最大值和最小值。
使用数组来存储输入的整数，并通过循环遍历数组来找到最大值和最小值。
3. 数组的逆序排列编写一个程序，从用户输入一组整数，并将它们按逆序排列。
使用数组来存储输入的整数，并通过循环遍历数组来实现逆序排列。
4. 数组的去重编写一个程序，从用户输入一组整数，并去除其中的重复元素。
使用数组来存储输入的整数，并通过循环遍历数组来去除重复元素。
5. 数组的排序编写一个程序，从用户输入一组整数，并将它们按升序或降序排序。
使用数组来存储输入的整数，并通过循环遍历数组来实现排序。
6. 数组的拷贝编写一个程序，从用户输入一组整数，并将它们拷贝到另一个数组中。
使用两个数组分别存储输入的整数，并通过循环遍历数组来实现拷贝。
7. 数组的搜索编写一个程序，从用户输入一组整数，并在数组中搜索指定的值。
使用数组来存储输入的整数，并通过循环遍历数组来搜索指定的值。
8. 数组的合并编写一个程序，从用户输入两组整数，并将它们合并为一个数组。
使用两个数组分别存储输入的整数，并通过循环遍历数组来实现合并。
9. 数组的平均值和方差编写一个程序，从用户输入一组整数，并计算它们的平均值和方差。
使用数组来存储输入的整数，并通过循环遍历数组来计算平均值和方差。
10. 数组的矩阵操作编写一个程序，从用户输入一个矩阵，并实现矩阵的转置、矩阵的相加和矩阵的乘法等操作。
使用二维数组来存储输入的矩阵，并通过循环遍历数组来实现矩阵操作。
精选10个汇编语言程序案例集摘要：一、汇编语言简介二、案例1：简单算术运算三、案例2：字符串处理四、案例3：逻辑与关系运算五、案例4：循环与条件语句六、案例5：函数调用与参数传递七、案例6：数组与指针操作八、案例7：内存管理九、案例8：输入输出操作十、案例9：操作系统调用十一、案例10：网络编程十二、总结与拓展正文：一、汇编语言简介汇编语言是一种低级编程语言，它与计算机硬件的操作紧密相关。
汇编语言通过对计算机指令进行汇编，实现对计算机资源的控制。
下面将介绍10个汇编语言程序案例。
二、案例1：简单算术运算案例1是一个实现加减乘除算术运算的汇编程序。
通过编写相应的汇编指令，实现对两个整数的加减乘除操作。
三、案例2：字符串处理案例2是一个处理字符串的汇编程序。
通过汇编指令实现字符串的输入、输出、查找、替换等功能。
四、案例3：逻辑与关系运算案例3是一个处理逻辑与关系运算的汇编程序。
通过汇编指令实现逻辑与、逻辑或、逻辑非以及关系运算。
五、案例4：循环与条件语句案例4是一个处理循环与条件语句的汇编程序。
通过汇编指令实现for、while、if-else等循环与条件控制结构。
六、案例5：函数调用与参数传递案例5是一个处理函数调用与参数传递的汇编程序。
通过汇编指令实现函数调用，以及将参数传递给函数。
七、案例6：数组与指针操作案例6是一个处理数组与指针操作的汇编程序。
通过汇编指令实现数组的创建、访问、排序等操作，以及指针的运算与控制。
八、案例7：内存管理案例7是一个处理内存管理的汇编程序。
通过汇编指令实现内存的分配、释放、拷贝等操作。
九、案例8：输入输出操作案例8是一个处理输入输出操作的汇编程序。
通过汇编指令实现键盘输入、显示输出等功能。
十、案例9：操作系统调用案例9是一个处理操作系统调用的汇编程序。
通过汇编指令实现操作系统提供的功能，如文件操作、进程管理等。
十一、案例10：网络编程案例10是一个处理网络编程的汇编程序。
C语言程序设计中数组的有效运用周亚辉（荆州教育学院，湖北荆州434000）摘要：随着人工智能和计算机技术的不断发展，C语言因其独特优势一直被广泛应用。
数组是C语言中常用的数据类型之一，本文介绍了C语言在程序设计中数组的有效运用，首先文章从数组的排序、插入、删除和应用四个方面介绍了数组的各类应用和编程方法，然后介绍了数组和指针的关系，并以处理转置矩阵为例介绍了数组和指针的联合应用是如何解决实际问题的。
本文所做研究对C语言的数组的学习和应用提供了一定的指导意义。
关键词：C语言；数组；应用中图分类号：TP311文献标识码：A文章编号：1009-3044(2020)35-0209-02开放科学（资源服务）标识码（OSID）：1引言自1972年C语言作为一种独立的面向过程的开发语言问世以来，一直作为适应于底层开发的通用设计语言。
因其编译方式简单，低级存储器便可处理编译工作，不需要任何其他编译环境，且支持高校程序设计，多年来一直被广大开发者热衷[1]。
其跨平台输出的特点，决定了C语言程序可在嵌入式处理器等平台中被编译和使用。
与C++和JAVA等面向对象编程的语言不同，C语言的主要目标是实现简易编译、适应低级存储器，高编译效率[2]。
C语言主要的数据类型包括：整数型、字符型、实型、浮点型、枚举型、数组类型、结构体类型、共用体类型、指针类型和空类型。
数组是一组有序的元素组合序列，为了方便计算机进行数据处理[3]，把无序的元素按照一定的次序有序组织起来。
从数据处理角度讲，数组能够方便解决各类复杂的数据处理问题。
元素是构成数组的基本单位，不同元素通过顺序号将其顺序标识。
根据数组中元素的类型可以分为字符型数组、数值型数组、指针数组和结构数组等[4]。
虽然C语言中数组类型定义比较简单，但因其由于范围广，在进行排序、字符串处理、计算函数处理等过程中，都离不开数组[5]。
本文介绍C语言设计过程中，数组的有效运用，对其在解决实际问题过程中的方法进行总结。
数组循环的六种方法数组循环是编程中常用的操作之一，通过遍历数组中的元素，可以实现对数组进行各种处理和操作。
在不同的编程语言中，有多种不同的方法可以实现数组循环。
下面将介绍六种常用的数组循环方法，并进行详细的说明。
1. for循环for循环是最常见和最常用的数组循环方法之一、通过使用for循环，可以对数组中的每个元素进行遍历和操作。
for循环的语法如下：```for (int i = 0; i < array.length; i++)//对数组元素进行操作```其中，i是循环变量，用于追踪当前数组元素的索引。
array.length是数组的长度，通过它可以确定循环的结束条件。
在循环体内部，可以对数组元素进行操作。
例如，可以打印数组中的每个元素：```for (int i = 0; i < array.length; i++)System.out.println(array[i]);```2. for-each循环for-each循环也是一种常用的数组循环方法。
它可以更加简洁地实现数组的遍历和操作。
for-each循环的语法如下：```for (Type element : array)//对数组元素进行操作```其中，Type是数组中元素的数据类型，element是循环变量，用于追踪当前数组元素的值。
在循环体内部，可以对数组元素进行操作。
例如，可以打印数组中的每个元素：```for (int element : array)System.out.println(element);```注意，for-each循环只能对数组中的元素进行操作，无法获取当前元素的索引。
3. while循环while循环是一种基本的循环结构，也可以用于数组的遍历和操作。
通过使用while循环，可以根据条件判断来控制循环的执行。
while循环的语法如下：```while (i < array.length)//对数组元素进行操作i++;```在循环体内部，可以对数组元素进行操作。
matlab数组用法一、概述Matlab是一种基于矩阵运算的高级技术计算语言，其数组是Matlab 的重要组成部分。
Matlab数组可以存储多个数值或字符等数据类型，并且可以进行各种数学运算和数据处理。
二、创建数组1. 直接赋值法可以使用中括号[]来创建数组，用逗号分隔不同元素，如：a = [1,2,3,4,5]2. linspace函数linspace函数可以在指定的区间内生成指定数量的等差数列，如：b = linspace(0,1,11)3. logspace函数logspace函数可以在指定的区间内生成指定数量的对数数列，如：c = logspace(0,1,11)4. zeros和ones函数zeros和ones函数可以创建全为0或全为1的矩阵或向量，如：d = zeros(3,4)e = ones(2,3)三、访问数组元素1. 使用下标访问Matlab中使用下标来访问数组元素，下标从1开始计数。
如：a(2)表示访问a数组中第二个元素。
2. 使用冒号操作符访问多个元素冒号操作符(:)用于表示连续的整数序列。
如：a(2:4)表示访问a数组中第二到第四个元素。
四、修改数组元素使用下标可以修改数组元素的值。
如：a(2) = 6五、数组运算1. 数组加减乘除Matlab中可以对数组进行加减乘除等运算，如：a = [1,2,3]b = [4,5,6]c = a + b2. 数组点乘和点除使用.*和./可以对两个数组进行对应元素的乘法和除法，如：a = [1,2,3]b = [4,5,6]c = a .* b六、数组函数Matlab中提供了众多的数组函数，可以方便地进行各种数学运算和数据处理。
以下是一些常用的数组函数：1. sum函数：计算数组元素之和。
2. mean函数：计算数组元素的平均值。
3. max函数：返回数组中最大元素。
4. min函数：返回数组中最小元素。
5. sort函数：对数组进行排序。
数组排序函数c语言数组排序函数是计算机编程中常用的一种函数，它的作用是将一个数组中的元素按照一定的规则进行排序。
在C语言中，有多种方法可以实现数组的排序，包括冒泡排序、选择排序、插入排序、快速排序等。
本文将介绍这些排序算法的原理和实现方式。
一、冒泡排序冒泡排序是一种简单直观的排序算法，它的原理是通过比较相邻元素的大小，将较大的元素逐渐“冒泡”到数组的末尾。
具体实现时，我们可以使用两层循环来完成冒泡排序的过程。
外层循环控制比较的轮数，内层循环用于比较相邻元素的大小并进行交换。
经过多轮比较和交换，最终数组中的元素按照从小到大的顺序排列。
二、选择排序选择排序是一种简单但低效的排序算法，它的原理是每次从未排序的元素中选择最小的元素，然后与未排序部分的第一个元素交换位置，这样每一轮都能确定一个最小元素的位置。
具体实现时，我们可以使用两层循环来完成选择排序的过程。
外层循环控制比较的轮数，内层循环用于寻找未排序部分的最小元素并进行交换。
经过多轮比较和交换，最终数组中的元素按照从小到大的顺序排列。
三、插入排序插入排序是一种简单直观的排序算法，它的原理是将一个元素插入到已经排好序的数组中的合适位置。
具体实现时，我们可以使用两层循环来完成插入排序的过程。
外层循环控制待插入的元素，内层循环用于比较已排序部分的元素并进行移动。
经过多轮比较和移动，最终数组中的元素按照从小到大的顺序排列。
四、快速排序快速排序是一种高效的排序算法，它的原理是通过选择一个基准元素，将数组分成两部分，左边部分的元素都小于基准元素，右边部分的元素都大于基准元素，然后递归地对左右两部分进行排序。
具体实现时，我们可以使用递归函数来完成快速排序的过程。
在每一轮排序中，我们选择一个基准元素，将数组分成两部分，并对这两部分进行递归排序。
经过多轮递归排序，最终数组中的元素按照从小到大的顺序排列。
以上是常见的几种数组排序函数的原理和实现方式。
在实际编程中，我们可以根据具体的需求选择合适的排序算法。
c语言数组函数的使用方法一、前言C语言是一种非常流行的编程语言，其强大的数据处理和算法能力使其成为许多程序员的首选。
在C语言中，数组是一种非常重要的数据类型，它可以存储多个相同类型的元素。
而函数则是C语言中另一个非常重要的概念，它可以将代码分解为可重用的模块。
本文将介绍C语言中数组和函数的基本概念以及如何使用它们。
我们将讨论如何创建和初始化数组、如何使用数组进行简单的数学计算、以及如何定义和调用函数。
二、数组2.1 创建和初始化数组在C语言中，我们可以使用以下方式来创建一个数组：```cint myArray[10];```这样就创建了一个包含10个整数元素的整型数组。
注意，这里我们需要指定数组元素的类型（int），并且需要指定数组元素数量（10）。
我们也可以在定义时对数组进行初始化：```cint myArray[5] = {1, 2, 3, 4, 5};```这样就创建了一个包含5个整数元素的整型数组，并将第1个到第5个元素分别初始化为1到5。
如果我们只想对部分元素进行初始化，也可以这样做：```cint myArray[5] = {1, 2};```这样就创建了一个包含5个整数元素的整型数组，并将第1个和第2个元素分别初始化为1和2，其余元素将被自动初始化为0。
如果我们不指定数组大小，也可以使用以下方式来创建一个动态数组：```cint* myArray = malloc(sizeof(int) * 10);```这样就创建了一个包含10个整数元素的整型动态数组。
注意，我们需要使用malloc函数来分配内存空间，并且需要指定内存空间的大小（sizeof(int) * 10）。
2.2 访问和修改数组元素要访问数组中的某个元素，我们可以使用以下语法：```cmyArray[index];```其中，index表示需要访问的元素下标。
注意，C语言中的数组下标从0开始计数。
例如，要访问myArray中的第3个元素，可以这样做：```cint x = myArray[2];```这样就将myArray中的第3个元素赋值给了变量x。
这是Java的一个由我自定义的数组相关操作的程序一个是SmalltoBig类：主要的核心方法封装在该类中，主要拥有一些简单的排序（冒泡、插入、选择排序）方法，删除数组中的重复项，依址查找数组项，数据匹配，显示数组等方法另一个是ordersort类：定义为一个拥有自己的数组的外部类调用SmalltoBig类里的方法对其自己的数组进行相关操作它们封装在DealData包中，所以在cmd下的javac编译命令必须写为：javac –d . SmalltoBig.javajavac –d . ordersort.javajava运行命令应是java DealData/SmalltoBigjava DealData/ordersort我自认为这个SmalltoBig类从封装和构造上及相关算法上来说相当完美了（当然，只是在简单操作方面，不考虑效率的前提下），我很满足对于异常的相关处理操作（try……catch……），没有警告错误和在运行中出现异常（因为会出现的异常全被catch捕获了）我是一个java初学者，现在还没有涉及图形操作如Swing之类的，因为我才刚起步，所以别当心这是神马恶意代码神马的，我还没有这技术……这个程序是我第一个编出来的近乎完美实用程序（能用得上吧），如果读者在运行中发现了什么错误等的，可以通过百度联系我…………不解释了放源代码：这是SmalltoBig源代码，要使用的话，打开记事本将下面的代码复制粘贴，保存为SmalltoBig.java（默认是.txt的后缀，要改成.java,这个很重要，一定要改）。
package DealData;import java.util.*;import java.io.IOException;class SmalltoBig{private int nums[];//本类的操作对象private short pre,back,size;//必要全局变量private byte line;//用于输出时显示每行数据数的全局变量private int up,down;//Match算法需要的全局变量private boolean TCF=false;private byte TCI=0;private int ExceptionIF(String range,int Allownum){//加入异常判定的数据输入算法TCF=false;int temp=0;while(!TCF){try{Scanner in=new Scanner(System.in);temp=in.nextInt(); TCF=true;}catch(InputMismatchException IOError){System.out.println("<<<请不要输入字符或实数以及超过表示范围！");switch (TCI){case 3: System.out.printf("\n==>请按区间要求重新输入([%d,%d]):",down,up);break;case 4: System.out.printf("\n==>请按区间要求重新输入([1,%d]):",size);break;case 5: System.out.printf("\n==>请按区间要求重新输入%s%d]):",range,up);break;case 6: System.out.printf("\n==>请按区间要求重新输入第%d个数%s:",Allownum,range);break;default: System.out.printf("\n==>请按区间要求重新输入%s:",range);break;}}switch(TCI){case 1:if(TCF&&(temp<1||temp>Allownum)){System.out.println("<<<请不要输入超过表示范围的数！");System.out.printf("\n==>请按要求重新输入%s:",range);TCF=false; temp=0;}break;case 2 :if(temp<0||temp>32767){System.out.println("<<<请不要输入超过指定范围的数！");System.out.printf("\n==>请按区间要求重新输入%s:",range);TCF=false; temp=0;}break;case 3 :if(TCF&&(temp>up||temp<down)){System.out.println("<<<请不要输入超过表示范围的数！");System.out.printf("\n==>请按其区间要求重新输入([%d,%d]):",down,up);TCF=false; temp=0;}break;case 4:if(TCF&&(temp<1||temp>size)){System.out.println("<<<请不要输入超过表示范围的数！");System.out.printf("\n==>请按要求重新输入([1,%d]):",size);TCF=false; temp=0;}break;}}return temp;}private short NumSize(){//规定数组大小System.out.print("\n===================================数组构建算法===================================\n==>请输入需要排序的数组的长度([0,32767]):");TCI=2;short Length=(short)ExceptionIF("([0,32767])",0);return Length;}private void ManualPut(){//手动输入元素TCI=6;System.out.println("==>开始输入数组元素([-2147483648,2147483647])！");for(pre=0;pre<nums.length;pre++){System.out.printf("第%d个数组元素:",pre+1);nums[pre]=ExceptionIF("([-2147483648,2147483647])",pre+1);}}private void AutoPut(){//自动生成元素up=LimitUp(); down=LimitDown();while(up<down){System.out.println("\n<<<上限不能比下限小！请重新输入！");down=LimitDown();if(up>=down) break;}for(pre=0;pre<nums.length;pre++)nums[pre]=(int)(Math.random()*(up-down+1)+down);}private int LimitDown(){//下限大小int downlimit=0;TCI=5;System.out.printf("==>请输入其下限大小([-2147483648,%d]):",up);downlimit=ExceptionIF("([-2147483648,",0);return downlimit;}private int LimitUp(){//上限大小int uplimit=0;TCI=0;System.out.print("==>请输入其上限大小([-2147483648,2147483647]):");uplimit=ExceptionIF("([-2147483648,2147483647])",0);return uplimit;}private byte ShowLine(){//显示每行元素的个数System.out.print("==>之后显示的数组一行需要显示几个元素？([1-10]):");TCI=1;byte Linenum=(byte)ExceptionIF("([1-10])",10);return Linenum;}private void DisplayNums(String object){//开始输出数组System.out.printf("<<<%s:",object);Display(size);}private void Display(short length){//输出数组for(pre=0;pre<length;pre++){if(pre%line==0){System.out.println();System.out.printf("%11d",nums[pre]);}else System.out.printf("%11d",nums[pre]);}}private char Jugement(char ans1,char ans2,char ansi,char ansii){//流程判定char YN='Z';Scanner in=new Scanner(System.in);while(YN!=ans1||YN!=ans2||YN!=ansi||YN!=ansii){ String Temp=in.nextLine();YN=Temp.charAt(0);if(Temp.length()==1){if(YN==ans1||YN==ans2||YN==ansi||YN==ansii) break;System.out.printf("\n<<<输入错误，请根据要求输入！\n==>再次输入(<%s/%s>/<%s/%s>):",ans1,ans2,ansi,ansii);}else System.out.printf("\n<<<输入错误，请根据要求输入！\n==>再次输入(<%s/%s>/<%s/%s>):",ans1,ans2,ansi,ansii);}return YN;}private boolean Sort1(){//选择排序System.out.println("\n\n\n================================== =选择排序算法===================================");char PD=IFShowSortStep();boolean HaveSorted=true;for(pre=1;pre<nums.length;pre++)//判定数组是否已为有序数组if(nums[pre]<nums[pre-1]){HaveSorted=false;break;}else HaveSorted=true;for(pre=0;pre<nums.length-1;pre++){//选择排序核心算法for(back=(short)(pre+1);back<nums.length;back++){if(nums[pre]>nums[back]){int temp=nums[pre];nums[pre]=nums[back];nums[back]=temp;HaveSorted=false;}}if(!HaveSorted) SortStep((short)0,PD,(short)(pre+1));}SortResult("选择排序算法",HaveSorted,pre);return HaveSorted;}private boolean Sort2(){//插入排序System.out.println("\n\n\n================================== =插入排序算法===================================");char PD=IFShowSortStep();boolean HaveSorted=true;for(pre=1;pre<nums.length;pre++)//判定数组是否已为有序数组if(nums[pre]<nums[pre-1]){HaveSorted=false;break;}else HaveSorted=true;for(pre=1;pre<nums.length;pre++){//插入排序核心算法if(nums[pre]<nums[pre-1]){int temp=nums[pre];nums[pre]=nums[pre-1];for(back=(short)(pre-1);back>=0&&temp<nums[back];back--) nums[back+1]=nums[back];nums[back+1]=temp;}if(!HaveSorted) SortStep((short)0,PD,pre);}SortResult("插入排序算法",HaveSorted,(short)(pre-1));return HaveSorted;}private boolean Sort3(){//快速排序System.out.println("\n\n\n================================== =快速排序算法===================================");char PD=IFShowSortStep();short YN=0; boolean special=true;for(pre=1;pre<nums.length&&YN<nums.length-pre;pre++){ //快速排序核心算法for(back=1;back<nums.length-pre+1;back++){if(nums[back]<nums[back-1]){int temp=nums[back];nums[back]=nums[back-1];nums[back-1]=temp;YN=0; special=false;}else YN++;}if(YN>=nums.length-pre) break;SortStep(YN,PD,pre);SortResult("快速（冒泡）排序算法",special,(short)(pre-1));return special;}private void SelectSortAlgorithm(){//选择要使用的排序算法System.out.println("\n\n<<<该程序集成了:\n<1>选择排序算法\n<2>插入排序算法\n<3>快速（冒泡）排序算法");System.out.print("==>请输入你要使用的算法前的序号以对其进行调用(<1>/<2>/<3>):");TCI=1;byte CA=(byte)ExceptionIF("算法选择项(<1>/<2>/<3>)",3);line=ShowLine(); System.out.println("\n");DisplayNums("原数组");switch (CA){//算法选择开关case 1: if(!Sort1()) DisplayNums("排序后");break;case 2: if(!Sort2()) DisplayNums("排序后");break;case 3: if(!Sort3()) DisplayNums("排序后");break;up=nums[size-1]; down=nums[0];}private char IFShowSortStep(){//判断是否显示排序步骤char PD='A';if(size<=10){System.out.print("==>是否显示排序的具体过程？(<Y/y>/<N/n>):");PD=Jugement('Y','y','N','n');}return PD;}private void SortStep(short YN,char PD,short step){//显示排序步骤if(size<=10&&YN<nums.length-pre)if(PD=='Y'||PD=='y'){System.out.printf("!!第%d趟排序结果:",step);for(byte p=0;p<nums.length;p++) System.out.printf("%11d",nums[p]);System.out.println();}}private void SortResult(String algorithm,boolean qualifications,short step){ //排序报告if(!qualifications){System.out.printf("！！%s算法将%d个元素的无序数组排成升序状态历经了%d趟",algorithm,size,step);System.out.println("\n");}if(qualifications) System.out.print("！！该数组已经是个有序数组没有进行排序的必要");}private void DelRepeat(){//删除重复项操作System.out.println("\n\n\n================================== =重复项删除算法===================================");for(pre=0,back=1;back<nums.length;pre++,back++){if(nums[pre]==nums[back]){short Add[]=new short[size/2];int Elem[]=new int[size/2];short Del[]=new short[size];short Dels[]=new short[size/2];short add=0, elem=0, del=1, dels=1, present=1, total=0;boolean bool=false;int MAX=nums[size-1];char Y_N,Y_N2;System.out.print("<<<经检测，该数组中含有重复项！\n\n==>是否消除重复项？(<Y/y>/<N/n>):");Y_N=Jugement('Y','y','N','n');if(Y_N=='Y'||Y_N=='y'){dels=1;Del[0]=0;//处理删除的元素和元素所在的地址for(pre=0,back=1;back<nums.length;pre++,back++,del++){if(nums[pre]==nums[back]){Del[del]=dels++;if(bool==false){//开始记录删除的元素和元素所在的地址Add[add]=back; add++;Elem[elem]=nums[back]; elem++;bool=true;}}else{//处理删除元素个数bool=false; d els=1;Del[del]=0;}}for(pre=1,dels=0;pre<del;pre++){if(Del[pre]==0)if(Del[pre-1]!=0){Dels[dels]=Del[pre-1];total=(short)(total+Dels[dels]);dels++;}}if(Del[pre-1]!=0&&pre==del){Dels[add-1]=Del[pre-1];total=(short)(total+Dels[add-1]);}DeleteResult(Add,Dels,Elem,total,add);AfterDelete(present,MAX);}break;}up=nums[size-1]; down=nums[0];}if(back==nums.length) System.out.print("<<<没有重复项！");}private short DeleteResult(short Add[],short Dels[],int Elem[],short total,short add){//删除重复项结果System.out.print("\n\n===================================重复项删除结果===================================");for(pre=0;pre<add;pre++) System.out.printf("\n!!从排序后的数组的第%d个元素位置开始删除了%d个元素%d",Add[pre],Dels[pre],Elem[pre]);System.out.printf("\n！！共删除了%d个重复元素！\n！！共删除了%d个重复元素类型！\n！！删除重复项的数组的长度由原来的%d 个元素长度减为%d\n",total,add,size,size-total);return total;}private void AfterDelete(short present,int MAX){//删除重复项结果for(pre=0,back=1;nums[back]<MAX;pre++,back++)if(nums[pre]!=nums[back]){if(nums[present]!=nums[back])nums[present]=nums[back];present++;}nums[present]=MAX;System.out.print("\n<<<消除重复项之后的数组:");if(nums[0]==nums[present]) System.out.printf("%11d",nums[0]);else Display(++present);size=present;}private void Match(){//数据匹配System.out.println("\n\n\n================================== =数据匹配算法===================================");System.out.print("==>是否在数组中进行数据匹配操作？(<Y/y>/<N/n>):");char YN='Y';if(YN=='y'||YN=='Y'){double failure=0,success=0;char PP=Jugement('Y','y','N','n');while(PP=='y'||PP=='Y'){int record[]=new int[size];int Mods=CreateMods(); System.out.printf("==>匹配数为%d\n",Mods);for(pre=0,back=0;pre<size;pre++){if(nums[pre]==Mods){record[back]=pre; back++;}}System.out.println("\n\n===================================数据匹配结果===================================");if(back==0){System.out.println("！！！未找到！");failure++;}else{System.out.println("！！！找到了！\n");success++;for(pre=0;pre<back;pre++) System.out.printf("!!该数在排序后的数组中第%d个元素位置出现\n",record[pre]+1);}System.out.print("==>是否继续匹配？(<Y/y>/<N/n>):");PP=Jugement('Y','y','N','n');}MatchResult(failure,success);}}private void MatchResult(double failure,double success){//数据匹配结果double probability=success/(success+failure)*100;System.out.printf("==>查询了%d次，成功%d次，失败%d次，查找成功率为%f%%\n",(byte)success,(byte)success,(byte)failure,probability);}private int CreateMods(){//创建匹配算法需要的匹配数System.out.print("\n\n===================================构建匹配数据===================================\n");System.out.print("==>是自动生成随机数还是手动输入？(<A/a>/<C/c>):");char AC=Jugement('A','a','C','c');TCI=3;int Up=up;int Down=down;if(AC=='A'||AC=='a'){System.out.printf("<<<自动在[%d,%d]内生成随机匹配数",down,up);return ((int)(Math.random()*(Up-Down+1)+Down));}if(AC=='C'||AC=='c'){System.out.printf("==>请输入一个待匹配的数([%d,%d]):",down,up);return (ExceptionIF(" ",0));}return 0;}private void GetaNum(){//依址查找System.out.println("\n\n===================================依址查找算法===================================");System.out.print("==>是否在数组中寻找指定位置的数据？(<Y/y>/<N/n>):");char YNG=Jugement('Y','y','N','n'),REYNG='Y';if(YNG=='Y'||YNG=='y'){while(REYNG=='Y'||REYNG=='y'){TCI=4;System.out.printf("==>请输入需要查找那个位置的数据([1,%d]):",size);short Getnum=(short)ExceptionIF(" ",0);REYNG=AfterGet(Getnum);if(REYNG=='N'||REYNG=='n') break;}}}private char AfterGet(short Getnum){//依址查找结果System.out.println("\n\n===================================依址查找结果===================================");System.out.println("！！数组位置为"+Getnum+"的元素为"+nums[--Getnum]);System.out.print("\n==>是否继续查找？(<Y/y>/<N/n>):");char Temp=Jugement('Y','y','N','n');return Temp;}private void Start(){//使用该类生成的数组的话从这开始System.out.print("#####################输入提示#####################\n以下步骤中输入:\n<A/a>表示自动生成\n<C/c>表示手动输入\n<Y/y>表示是\n<N/n>表示否\n\n\n");size=NumSize();nums=new int[size];if(size==0){System.out.println("\n\n===================================报告结果===================================");System.out.println("<<<指定的数组长度为0，是个空数组，无任何操作可施与！");}else{System.out.print("==>自动生成数组元素还是手动输入？(<A/a>/<C/c>):");char ac=Jugement('A','a','C','c');if(ac=='C'||ac=='c') ManualPut();if(ac=='A'||ac=='a'){AutoPut();System.out.printf("\n<<<指定随机生成数组元素的范围是[%d,%d]\n",down,up);}if(size==1){System.out.print("\n\n<<<指定的数组长度为1，只有一个元素，不用排序！");Match();GetaNum();}else{SelectSortAlgorithm();DelRepeat();Match();GetaNum();}}CopyRight();}void CopyRight(){//Logo System.out.println("\n\n\n\n>>>>>>>>>>>>>>>>>>>>>>>>>程序运行结束<<<<<<<<<<<<<<<<<<<<<<<<<");System.out.printf("*******感谢使用*******%38s\n\n","Made By:ZERO");}public SmalltoBig(){//外部类建立对象时必要的构造函数System.out.println("\n>>>>>>>>>>>>>>>>>>>>>>>>>数组操作程序开始运行<<<<<<<<<<<<<<<<<<<<<<<<<");System.out.printf("@CopyRight 2011%55s\n\n","Version 5.9");}public int[] SmalltoBig(int Num[]){//外部类调用此构造函数进入NumT oNums(Num);Start2();int Tempnums[]=new int[size];for(pre=0;pre<size;pre++) Tempnums[pre]=nums[pre];return Tempnums;}private void Start2(){System.out.println("#####################输入提示#####################");System.out.println("以下步骤中输入\n<A/a>表示自动生成\n<C/c>表示手动输入\n<Y/y>表示是\n<N/n>表示否");if(size==0){System.out.println("\n\n===================================报告结果===================================");System.out.println("<<<指定的数组长度为0，是个空数组，无任何操作可施与！");}else{if(size==1){System.out.print("\n\n<<<指定的数组长度为1，只有一个元素，不用排序！");Match();GetaNum();}else SelectSortAlgorithm();DelRepeat();Match();GetaNum();}}public int GetNum(int num[]){NumT oNums(num);System.out.println("\n\n===================================依址查找算法===================================");TCI=4;System.out.printf("==>请输入需要查找那个位置的数据([1,%d]):",size);short Getnum=(short)ExceptionIF(" ",0);System.out.println("\n\n===================================依址查找结果===================================");System.out.println("！！数组位置为"+Getnum+"的元素为"+nums[--Getnum]);return Getnum;}public void ShowNums(int num[]){NumT oNums(num);line=ShowLine();for(pre=0;pre<nums.length;pre++){if(pre%line==0){System.out.println();System.out.printf("%11d",nums[pre]);}else System.out.printf("%11d",nums[pre]);}}public void NumToNums(int Num[]){nums=Num;size=(short)nums.length;}public void help(){System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>欢迎使用SmalltoBig类<<<<<<<<<<<<<<<<<<<<<<<<<");System.out.println("该类的作用主要是进行数组排序，还有一些附属方法：");System.out.println("int GetNum(int num[])：可以对其传入的数组进行依址查找数据，返回值为该数据");System.out.println("void ShowNums(int num[])：可以对其传入的数组进行显示操作");System.out.println("int[] Small2Big(int Num[])：可以对其传入的数组进行所有可进行的操作，且返回操作后的数组");CopyRight();}public static void main(String ord[]){//主函数SmalltoBig SORT=new SmalltoBig();SORT.Start();}}这是ordersort源代码，要使用的话，操作和之前的一样，保存为ordersort.java。
