算法与数据结构：
1.数据结构：数据、数据元素、数据对象、数据结构、数据类型、抽象数据类型（DAT）。
2.算法：有穷性、确定性、可行性、输入（0个或多个）、输出（1个或者多个输出）。
3.排序算法：
    冒泡排序：每次找出最大值，然后放到所在范围的最后一位（是一种简单的易于理解的排序算法，但是效率很低，由于循环一次，只是要找出最大元素，好多元素的交换是没有意义的）；
    选择排序 ：每次找出最小值，放在指定范围的最前面，并且将最小值所在位置和第一个元素交换位置。（关键是找出指定范围内的最小元素下标，交换的次数较少）
    快速排序：每次找出一个轴点，将轴点分为两部分做同样的操作。效率很高的排序算法。
4.查找：
    顺序排序：从前往后查找，不靠谱的算法
    二分查找：必须是有序的表，从中间分为两个部分。
    注：循环的终止条件就是递归的终止条件，递归函数不需要循环。
    5.链表：和数组类似，只是数组大小固定，不能动态的更改数组大小，数据的插入和删除困难，但是可以快速的读取元素。链表的元素存储单元，可以使连续的，也可以是不连续的。是有多个node连接起来，但是快速定位比较慢。
    清空链表的时候，只保留首节点，首先，我们应该得到当前的节点，保存到一个node里面，然后将当前节点指向next，删除node。注：最后应该将first的next设置为NULL。
    链表的合并：就是讲两个链表联合在一起，将首节点去掉。
程序：
1.选择排序：
//最小元素下标
int minkey(int *p, int low, int high)
{
    int key = p[low];
    int min = low;
    int i;
    for (i = low + 1; i<high; i++)
    {
        if (key > p[i])
        {
            key = p[i];
            min = i;
        }
    }
    return min;
}
//选择排序算法
void select(int p[], int low, int high)
{
    int i, j;
    for (i = low; i < high; i++)
    {
        j = minkey(p, i, high);
        if (j != i)
        {
            swap(&p[j], &p[i]);
        }
    }
}
思路：要在指定范围内找到最小的元素位置；如果指定范围内的第一个元素不是最小元素，将最小元素和第一个元素交换位置，如果是的话，就结束。
2.快速排序：
int partition(int p[], int low, int high)
{
int povitkey = p[low];//轴点等于第一个元素
while (low < high)
{
while (low < high && p[high] >= povitkey)
    high--;
    p[low] = p[high];//将小于轴点的元素放到轴点的前面
while (low < high && p[low] <= povitkey)
    low++;
    p[high] = p[low];//将大于轴点的元素放到轴点的后面
    }
    p[low] = povitkey;
    return low;//返回轴点的下标
}
void q_sort(int p[], int low, int high)
{
    if (low < high)
    {
        int povitloc = partition(p, low, high);//对轴点进行排序，并且得到排序后轴点的位置
        q_sort(p, povitloc + 1, high);//递归对轴点的下半部分排序
        q_sort(p, low, povitloc - 1);//递归对轴点的上半部分排序
    }
}
void quick_sort(int p[], int low, int high)
{
    q_sort(p, low, high - 1);
}
思路：建立一个轴点（将第一个元素作为轴点），将大于轴点的值，依次放到轴点的右边，反之，放在左边；将轴点分为两部分做相同的操作。
3.快速查找 ：不需要排序效率低
int bin(int s[], int low, int high, int data)
{
    int i;
    for(i = low; i < high; i++)
    {
        if(data == s[i])
            return i;
    }
    return - 1;
}

4.二分查找：需要排序
//循环实现
int bin(int s[], int low, int high, int data)
{
    while (low <= high)
    {
        int mid = (low + high) / 2;
        if (s[mid] == data)
            return mid;
        else if (data > s[mid])
            low = mid + 1;
        else
            high = mid - 1;
    }
    return -1;
}
//递归实现
int bin1(int s[], int low, int high, int data)
{
int mid = (low + high) / 2;
if(low <= high)
{
if (data == s[mid])
        return mid;
else if (data > s[mid])
    return bin1(s, mid + 1, high, data);
else
    return bin1(s, low, mid - 1, data);
    }
    return -1;
}
思路：在有序集合内分为两部分，如果中间元素正好和data相等，那么就返回；如果大于data，那就在前半部分，那就将前半部分作为一个整体，然后再比较；如果小于data，那就在后半部分，那就将后半部分作为一个整体，然后再比较；如果没有找到，就返回-1.

算法与数据结构：
1.数据结构：数据、数据元素、数据对象、数据结构、数据类型、抽象数据类型（DAT）。
2.算法：有穷性、确定性、可行性、输入（0个或多个）、输出（1个或者多个输出）。
3.排序算法：
    冒泡排序：每次找出最大值，然后放到所在范围的最后一位（是一种简单的易于理解的排序算法，但是效率很低，由于循环一次，只是要找出最大元素，好多元素的交换是没有意义的）；
    选择排序 ：每次找出最小值，放在指定范围的最前面，并且将最小值所在位置和第一个元素交换位置。（关键是找出指定范围内的最小元素下标，交换的次数较少）
    快速排序：每次找出一个轴点，将轴点分为两部分做同样的操作。效率很高的排序算法。
4.查找：
    顺序排序：从前往后查找，不靠谱的算法
    二分查找：必须是有序的表，从中间分为两个部分。
    注：循环的终止条件就是递归的终止条件，递归函数不需要循环。
    5.链表：和数组类似，只是数组大小固定，不能动态的更改数组大小，数据的插入和删除困难，但是可以快速的读取元素。链表的元素存储单元，可以使连续的，也可以是不连续的。是有多个node连接起来，但是快速定位比较慢。
    清空链表的时候，只保留首节点，首先，我们应该得到当前的节点，保存到一个node里面，然后将当前节点指向next，删除node。注：最后应该将first的next设置为NULL。
    链表的合并：就是讲两个链表联合在一起，将首节点去掉。
程序：
1.选择排序：
//最小元素下标
int minkey(int *p, int low, int high)
{
    int key = p[low];
    int min = low;
    int i;
    for (i = low + 1; i<high; i++)
    {
        if (key > p[i])
        {
            key = p[i];
            min = i;
        }
    }
    return min;
}
//选择排序算法
void select(int p[], int low, int high)
{
    int i, j;
    for (i = low; i < high; i++)
    {
        j = minkey(p, i, high);
        if (j != i)
        {
            swap(&p[j], &p[i]);
        }
    }
}
思路：要在指定范围内找到最小的元素位置；如果指定范围内的第一个元素不是最小元素，将最小元素和第一个元素交换位置，如果是的话，就结束。
2.快速排序：
int partition(int p[], int low, int high)
{
int povitkey = p[low];//轴点等于第一个元素
while (low < high)
{
while (low < high && p[high] >= povitkey)
    high--;
    p[low] = p[high];//将小于轴点的元素放到轴点的前面
while (low < high && p[low] <= povitkey)
    low++;
    p[high] = p[low];//将大于轴点的元素放到轴点的后面
    }
    p[low] = povitkey;
    return low;//返回轴点的下标
}
void q_sort(int p[], int low, int high)
{
    if (low < high)
    {
        int povitloc = partition(p, low, high);//对轴点进行排序，并且得到排序后轴点的位置
        q_sort(p, povitloc + 1, high);//递归对轴点的下半部分排序
        q_sort(p, low, povitloc - 1);//递归对轴点的上半部分排序
    }
}
void quick_sort(int p[], int low, int high)
{
    q_sort(p, low, high - 1);
}
思路：建立一个轴点（将第一个元素作为轴点），将大于轴点的值，依次放到轴点的右边，反之，放在左边；将轴点分为两部分做相同的操作。
3.快速查找 ：不需要排序效率低
int bin(int s[], int low, int high, int data)
{
    int i;
    for(i = low; i < high; i++)
    {
        if(data == s[i])
            return i;
    }
    return - 1;
}

4.二分查找：需要排序
//循环实现
int bin(int s[], int low, int high, int data)
{
    while (low <= high)
    {
        int mid = (low + high) / 2;
        if (s[mid] == data)
            return mid;
        else if (data > s[mid])
            low = mid + 1;
        else
            high = mid - 1;
    }
    return -1;
}
//递归实现
int bin1(int s[], int low, int high, int data)
{
int mid = (low + high) / 2;
if(low <= high)
{
if (data == s[mid])
        return mid;
else if (data > s[mid])
    return bin1(s, mid + 1, high, data);
else
    return bin1(s, low, mid - 1, data);
    }
    return -1;
}
思路：在有序集合内分为两部分，如果中间元素正好和data相等，那么就返回；如果大于data，那就在前半部分，那就将前半部分作为一个整体，然后再比较；如果小于data，那就在后半部分，那就将后半部分作为一个整体，然后再比较；如果没有找到，就返回-1.