JAVA数据结构-数组&简单排序

请参考百度文库。

1. 数组

数组（array）是相同类型变量的集合，可以使用共同的名字引用它。数组可被定义为任何类型，可以是一维或多维。数组中的一个特别要素是通过下标来访问它。数组提供了一种将有联系的信息分组的便利方法。

一维数组

一维数组（one-dimensional array）实际上是相同类型变量列表。要创建一个数组，你必须首先定义数组变量所需的类型。

通用的一维数组的声明格式是： type var-name[];

获得一个数组需要两步：第一步，定义变量所需的类型；第二步，使用运算符new来为数组所要存储的数据分配内存，并把它们分配给数组变量。

数组的初始化（array initializer）：包括在花括号之内用逗号分开的表达式的列表。Java会自动地分配一个足够大的空间来保存指定的初始化元素的个数，而不必使用运算符new。

Java严格地检查以保证不会意外地存储或引用在数组范围以外的值。Java的运行系统会检查以保证所有的数组下标都在正确的范围以内（在这方面java与C/C++从根本上不同，C/C++提供运行边界检查）。

多维数组
在Java中，多维数组（multidimensional arrays）实际上是数组的数组。例如，定义一个二维数组变量：int twoD[][] = new int[4][5];

2. 简单排序

包括冒泡排序、选择排序、插入排序

①. 冒泡排序

假设有N个数据需要排序，则从第0个数开始，依次比较第0和第1个数据，如果第0 个大于第1 个则两者交换，否者什么动作都不做，继续比较第1个和第2 个……，这样依次类推，直至所有数据都“冒泡”到了数据顶上。

代码实现：

/**
  *  冒泡排序
  *  比较相邻元素的大小，将小的前移，大的后移，就像水中的气泡一样，
  *  最小的元素经过几次移动，最终会浮在水面上。
  *  2 7 4 6 9 1 首先比较最后两个数字，发现1比9小，于是前移
  *  2 7 4 6 1 9 然后比较6和1
  *  2 7 4 1 6 9 继续前移，然后是4和1
  *  2 7 1 4 6 9 7和1比较
  *  2 1 7 4 6 9 2和1
  *  1 2 7 4 6 9 
  *  至此，第一趟冒泡过程完成，
  *  最小的元素1被移到第一个，    
  *  不再参与后面的排序过程。
  *  下一趟冒泡过程同理，比较6和9，以此类推，最终得到结果。       
 **/
Public void bubbleSort(){
    int in, out;
    for(out = nElem - 1;out > 0;out--){
        for(in = 0;in < out;in++){
            if(a[in] > a[in + 1]){
                swap(in, in + 1);
            }
        }
    }
}
/**
  * 时间复杂度：
  * 因为在每一趟排序中都使有序区增加了一个气泡，
  * 因此在n-1趟排序之后，有序区中就有n-1个气泡，
  * 而无序区中的气泡的重量总是大于等于有序区中气泡的重量，
  * 所以整个冒泡排序过程至少需要n-1趟排序。
  * 因此显而易见，这个算法的时间复杂度也是O(n*n)。
***/

算法的时间复杂度：$O(N^2)$。

②. 选择排序

假设有N条数据，则暂且标记第0个数据为MIN（最小），使用OUT标记最左边未排序的数据，然后使用IN标记第一个数据，依次与MIN进行比较，如果比MIN小，则将该数据标记为MIN，当第一轮比较完后，最终的MIN与OUT标记数据交换，依次类推。

代码实现：

/**
 * 选择排序： 
 * 首先，找出数组中的最小元素，并用首位置的元素与它交换。
 * 然后，找出次大元素，并用第二个位置的元素与它交换。
 * 它重复性地选择剩余元素中的最小元素来完成排序。  
 * 
 * 当索引i从左向右遍历时，
 * 其右边的元素在数组中的位置就是其最终位置（而且再也不会被比较），
 * 所以当i到达右终端时，
 * 数组已经完全排序完毕。
**/
Public void selectSort(){
    int in, out, min;
    for(out = 0;out < nElems - 1;out++){
        min = out; //从第一个数开始
        For(int = out + 1;in < nElems;in++){
            if(a[in] < a[min]){
                min = in; //找到最小的替换
                swap(out, min);
            }
        }
    }
}

算法的时间复杂度：$O(N^2)$。

③. 插入排序

插入排序：类似于打牌。每抓一张牌我们的将其插入到已有的排好序的手牌中即为，将新来的元素按顺序放入一个已有的有序序列中。 在计算机实现中，我们需要将较大的元素移到右边，为插入的元素准备空间，然后再在空位置上插入该元素。

• 8 2 4 9 3 6 首先我们考虑数字2，假设后面的数字不存在（手中只有一张8，又抓来了2），那么显然2应该放在8的前面。
• 2 8 4 9 3 6 又抓来了一张4，现在大家都知道应该怎么办了吧？
• 2 4 8 9 3 6 又来了个9，没错，正好不用换顺序
• 2 4 8 9 3 6 同样的道理，考虑3该放的位置，显然放在2和4的中间
• 2 3 4 8 9 6 最后一个也是一样，最后得到从小到大的序列
• 2 3 4 6 8 9 完成排序

代码实现：

Public void InsertionSort(){
    int in, out;
    for(out = 1;out < nElems;out++){
        long temp = a[out];
        in = out;
        while(in > 0&&a[in - 1] > temp){
            a[in] = a[in - 1];
            --in;
        }
    a[in] = temp;
    }   
}
/**
  * 时间复杂度：O(n*n)
  * 由于需要两层循环，外层循环n-1次，内层循环每次递增一次。
  * 当输入完全从小到大有序时，
  * 只需要常数的时间，这当然是最好的情况。
  * 但是我们不能期望输入，当输入完全逆序时，最坏的情况就出现了。
 **/

算法的时间复杂度：$O(N^2)$。