数据结构笔记一

1. 一些基本概念

数据结构的研究范畴主要是非数值计算问题的操作对象以及它们之间的关系，以及在计算机中的表示和实现。
数据是客观事物的符号表示，是计算机中可以操作的对象，也就是一切能输入到计算机中并能被处理的符号的总称。
数据元素数据的基本单位，在计算机中能作为整体进行处理。数据元素（也叫记录）可以由数据项组成。
数据结构指相互之间存在一定关系的数据元素的集合。
数据类型指一组相同的值的集合以及定义在此集合上的一些操作的总称。
抽象抽取出事物具有普遍性的本质。
抽象数据类型（ADT）指定义由于表示应用问题的数学模型，以及定义在此数学模型上的一组操作的总称。

1.1 常见的数据结构类型

集合结构：不考虑元素之间的关系
线性结构：元素之间存在一个对应一个的关系，也就是说除了第一个节点没有前驱和最后一个节点没有后继外其他元素都有唯一的前驱和后继。
树状结构：元素之间存在一个对应多个的关系。数据元素之间存在层次关系，除了根节点无前驱外其他数据元素存在唯一的前驱节点。
图状结构：数据元素之间存在多个对应多个的关系，也就是任意数据元素可能有多个前驱和后继。

2. C++程序的典型架构

以hello world 为例：
hello.h中是hello();函数的声明，hello.cpp中是hello()函数的实现。main.cpp中调用hello()函数。

2.1 C++程序文件主要的分类

头文件（扩展名为.h）：一般用于存放函数原型。
源程序文件(扩展名为.cpp)：存放函数的实现。

在hello world例子中，hello.h和hello.cpp的文件名是相同的，只是扩展名不同，在编译时对函数实现进行编译，在链接时实现对函数的引用。然而,对于模板给出的参数化数据类型函数，如果将函数体单独存放于一个源程序文件中，由于在编译这个源程序文件时无法确定模板给出的参数化数据类型的具体类型，这时无法进一步编译，这样在链接时无法确定函数实现的代码，将会出现连接错误，这时只能将函数声明和实现放在同一个头文件中。

3. C++的类和对象

类和对象的关系：对象是类的实例化，也就是对象是一类为类型的变量。

3.1 类中成员的三级访问权限：public，private 和 protected。

在public中声明的成员可以在程序中直接进行访问。
在private 和 protected 中声明的成员可以被此类的成员函数及声明为友元函数访问。
在protected 中声明的成员可以被此类派生的类所访问，而在 private中声明的成员则不能被此类派生的类所访问。

析构函数：当对象被释放时，将自动调用析构函数。析构函数主要用于含指针的数据成员中释放动态数据成员。

3.2 C++的友元函数

友元函数不是类的函数成员，但是友员函数能引用类的私有成员和保护成员。

//友元函数声明
class Rectangle
{
 public:
 friend int volume(Rectangle oRectangle);
};

//友元函数的实现
int volume(Rectangle oRectangle)
{
    return 1;
}

//友元函数的调用
int main()
{
    Rectangle thisRectangle(6,8,9);
    int volume = Volume(thisRectangle);

    return 0;
}

3.2 运算符重载

运算符和普通函数使用的不同之处是普通函数参数出现在括号内，而运算符的参数出现在运算符的左右两侧。
运算符重载的两种方式：
（1）. 将运算符重载为全局函数。这时只有一个参数的运算符称为单目运算符，有两个参数的的运算符叫做双目运算符，这种情况常声明为类的友元，以便引用类的私有成员。例如，复数的加法运算”+”可重载为：

friend Complex operator+(const Complex &a, const Complex &b);

（2）. 运算符被重载为类的成员函数。此时对象自己成了左侧参数，所以单目运算符没有参数，双目运算符只有右侧参数。例如，复数加减运算可重载如下：

Complex operator-(const Complex &a);

实例程序：

//运算符重载声明
class Complex
{
private:
    double m_real;
    double m_image;
public:
    //作为全局函数，一般作为友元函数
    friend Complex operator+(const Complex &a, const Complex &b);
    //作为成员函数
    Complex operator-(const Complex &b);
}

//友元函数的实现
Complex operator+(const Complex &a, const Complex &b)
{
    Complex c;
    c.real = a.real + b.real;
    c.image = a.image + b.image;

    return c;
}

Complex Complex::operator-(const Complex &b)
{
    Complex c;
    c.real = this.real - b.real;
    c.image = this.image - b.image;
    return c;
}

3.3 C++模板

在有模板的算法中，只能将函数声明与函数实现放在同一个文件中。
程序实例：

//冒泡排序实例
//头文件 bubblesort.h
#ifndef__BUBBLESORT_H__
#define__BUBBLESORT_H__

#define MAX_SIZE 100
#include<iostream>
using namespace std;

//类的声明部分
template<class ElemType>
class DataList
{
private:
    ElemType data[MAX_SIZE];//存储数据元素值
    int size;//元素个数
    void Swap(const int mark1, const int mark2);//交换data[mark1]与data[mark2]
public:
    DataList(int sz=6):size(sz){};//构造函数，利用参数列表的形式对成员进行初始化
    ~DataList(){};//析构函数
    void SelectSort();//选择排序
    void Input();//输入数据元素值
    void Show();//显示数据元素值
}


//类的实现部分
template<class ElemType>
void DataList<ElemType>::Swap(const int mark1, const int mark2)
//操作结果：交换data[mark1]与data[mark2]的值
{
    //使用循环赋值交换data[mark1]和data[mark2]
    ElemType temp;
    temp = data[mark1];
    data[mark1] = data[mark2];
    data[mark2] = temp;
}

template<class ElemType>
void DataList<ElemType>::SelectSort()
//操作结果:选择排序
{
    for(int i = 0; i < size - 1; i++)
    {//在data[i]与data[size - 1]之间选出最小值
        int curLargePos = i;//假设data[i]为当前的最小元素
        for( int j = i+1; j < size; j++)
        {
            if(data[j] < data[curlargePos])
            {
                curLargePos = j;
            }
        }   
        if(curLargePos != i)
        {//当data[i]不是最小元素时，则交换data[curLargePos]与data[i]
            Swap(curLargePos,i);
        }   
    }
}
#endif

//调用
//mian.cpp
#include<iostream>
#include"bubblesort.h"
#include<stdlib.h> //包含库函数system()原型的头文件
const int SIZE = 6;
using namespace std;
int main()
{
    DataList<int > List(SIZE);
    return 0;
}