数据结构：数组

一、 一维数组（最简单的数据结构）
定义：占据一块连续内存并按照顺序存储数据。创建时先指定大小，分配内存。
优点：时间效率高。实现简单的hash（下标为key,对应的数据为value）
缺点：空间效率差。如果我们只在数组中存一个数字，也先分配所有的内存。
扩展：动态数组（解决空间效率差），手段：扩容后，复制内容到新的数组，释放之前的内存。时间性能变差，因此，要尽量减少改变数组容量的次数。

数组与指针：声明一个数组时，数组名字也是一个指针，指向数组的第一个元素。

二维数组例题（最后看）：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序，请完成一个函数，输入这样一个二维数组和一个整数，判断数组中是否含有整数。

思路：
写一个bool Find(int* matrix, int rows, int columns, int number)函数，将一个矩阵的右上角的值a和这个整数b进行对比.
if(a==b) return true;
else if (a>b) 去掉当前列，在剩下的列中进行查找。

else 去掉当前行，在剩下的行中进行查找。

#include <iostream>
using namespace std;
bool Find(int* matrix, int rows, int columns, int number)  
{  
    bool found = false;  
  
    if(matrix != NULL&& rows > 0 && columns > 0)  
    {  
        int row = 0;  
        int column = columns - 1;  
        while(row < rows && column >=0)  
        {  
            if(matrix[row * columns + column] == number)  
            {  
                found = true;  
                break;  
            }  
            else if(matrix[row * columns + column] > number)  
                -- column;  
            else  
                ++ row;  
        }  
    }  
  
    return found;  
}  
//========测试代码=============  
void Test(char * testName, int * matrix, int rows, int columns, int number, bool expected)  
{  
    if(testName != NULL)  
        printf("%s begins: ",testName);  
    bool result=Find(matrix, rows, columns, number);  
    if(result == expected)  
        printf("Passed.\n");  
    else  
        printf("Failed.\n");  
}  
//  1   2   8   9  
//  2   4   9   12  
//  4   7   10  13  
//  6   8   11  15  
// 要查找的数在数组中  
void Test1()  
{  
    int matrix[][4] = {{1, 2, 8, 9}, {2, 4, 9, 12}, {4, 7, 10, 13}, {6, 8, 11, 15}};  
    Test("Test1", (int*)matrix, 4, 4, 7, true);  
}  
  
//  1   2   8   9  
//  2   4   9   12  
//  4   7   10  13  
//  6   8   11  15  
// 要查找的数不在数组中  
void Test2()  
{  
    int matrix[][4] = {{1, 2, 8, 9}, {2, 4, 9, 12}, {4, 7, 10, 13}, {6, 8, 11, 15}};  
    Test("Test2", (int*)matrix, 4, 4, 5, false);  
}  
  
//  1   2   8   9  
//  2   4   9   12  
//  4   7   10  13  
//  6   8   11  15  
// 要查找的数是数组中最小的数字  
void Test3()  
{  
    int matrix[][4] = {{1, 2, 8, 9}, {2, 4, 9, 12}, {4, 7, 10, 13}, {6, 8, 11, 15}};  
    Test("Test3", (int*)matrix, 4, 4, 1, true);  
}  
  
//  1   2   8   9  
//  2   4   9   12  
//  4   7   10  13  
//  6   8   11  15  
// 要查找的数是数组中最大的数字  
void Test4()  
{  
    int matrix[][4] = {{1, 2, 8, 9}, {2, 4, 9, 12}, {4, 7, 10, 13}, {6, 8, 11, 15}};  
    Test("Test4", (int*)matrix, 4, 4, 15, true);  
}  
  
//  1   2   8   9  
//  2   4   9   12  
//  4   7   10  13  
//  6   8   11  15  
// 要查找的数比数组中最小的数字还小  
void Test5()  
{  
    int matrix[][4] = {{1, 2, 8, 9}, {2, 4, 9, 12}, {4, 7, 10, 13}, {6, 8, 11, 15}};  
    Test("Test5", (int*)matrix, 4, 4, 0, false);  
}  
  
//  1   2   8   9  
//  2   4   9   12  
//  4   7   10  13  
//  6   8   11  15  
// 要查找的数比数组中最大的数字还大  
void Test6()  
{  
    int matrix[][4] = {{1, 2, 8, 9}, {2, 4, 9, 12}, {4, 7, 10, 13}, {6, 8, 11, 15}};  
    Test("Test6", (int*)matrix, 4, 4, 16, false);  
}  
  
// 鲁棒性测试，输入空指针  
void Test7()  
{  
    Test("Test7", NULL, 0, 0, 16, false);  
}  
void main()  
{  
    Test1();  
    Test2();  
    Test3();  
    Test4();  
    Test5();  
    Test6();  
    Test7();  
} 

总结：1.数组存储的数据在地址空间上是连续的.

          2.方便数据的查找，查找数据的时间复杂度为O(1）。

注意：1.sizeof(data1)是求数组data1(假设data1为数组)的大小。data2为指针且指向data1，对data2求sizeof为4，因为data2本质上是一个指针，在32位系统上，对任意指针求sizeof得到的结果都是4。在C/C++中，当数组作为函数参数进行传递时，数组自动退化为同类型的指针。

题目：1.找出数组中重复的数字：可以利用哈希表思想。2.不修改数组找出（任意）重复的数字：与二分查找相似。

二：二维数组：见上面的例题。

思路：【缩小查找范围】1.数组选取的数字和要查找的数字的大小关系确定查找的大致位置（稍有欠缺）。2.每次选取右上角的数字与要查找的数字的大小关系确定查找的大致位置。