2018年3月

MYSQL基础之SELECT语句（一）：SELECT的基本用法

作者: 编程我只用CPP
时间: 2018-03-25
分类: 数据库
评论

一、SELECT介绍

1.1 SELECT

SELECT是数据库四大基本操作的一种，用于查询表中的数据信息。

基本的查询语法为：SELECT 列1, 列2, ... FROM 表，表示从表中取出对应的列。

SELECT语句的用法多种多样，并且还有很多高级的操作（如排序、分组以及联合等等），是增删改查四种基本操作中用法最多也运用最广的命令。

1.2 测试数据

创建测试表stu_info，所有的测试将会在这张表上进行：

CREATE TABLE `stu_info` (
  `stu_id` int(12) unsigned zerofill NOT NULL AUTO_INCREMENT,
  `stu_name` varchar(255) NOT NULL DEFAULT '',
  `age` tinyint(4) NOT NULL,
  `classno` tinyint(4) NOT NULL,
  `city` varchar(255) NOT NULL,
  PRIMARY KEY (`stu_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

表中数据：

+--------------+-----------+-----+---------+----------+
| stu_id       | stu_name  | age | classno | city     |
+--------------+-----------+-----+---------+----------+
| 000000000001 | maqian    |  24 |       1 | changsha |
| 000000000002 | xiaoming  |  19 |       2 | shanghai |
| 000000000003 | xiaohua   |  23 |       2 | shenzhen |
| 000000000004 | xiaobai   |  22 |       3 | shenzhen |
| 000000000005 | xiaowang  |  19 |       4 | hunan    |
| 000000000006 | xiaozhou  |  20 |       3 | wuhan    |
| 000000000007 | xiaoli    |  20 |       1 | changsha |
| 000000000008 | xiaopeng  |  23 |       1 | changsha |
| 000000000009 | xiaozheng |  22 |       1 | fujian   |
+--------------+-----------+-----+---------+----------+

二、使用SELECT查询数据

2.1 查询单列数据

查询所有的学生名字：

SELECT stu_name FROM stu_info;

结果：

+-----------+
| stu_name  |
+-----------+
| maqian    |
| xiaoming  |
| xiaohua   |
| xiaobai   |
| xiaowang  |
| xiaozhou  |
| xiaoli    |
| xiaopeng  |
| xiaozheng |
+-----------+

注意事项：查询时，如果没有明确指定排序对象，返回的数据中顺序没有特殊意义，每次返回的顺序可能都不同。只要保证每次返回的行数是一样的就是正常。

2.2 查询多个列

查询所有学生的名字及年龄信息，查询多列时，不同列之间使用,隔开：

SELECT stu_name, age FROM stu_info;

结果：

+-----------+-----+
| stu_name  | age |
+-----------+-----+
| maqian    |  24 |
| xiaoming  |  19 |
| xiaohua   |  23 |
| xiaobai   |  22 |
| xiaowang  |  19 |
| xiaozhou  |  20 |
| xiaoli    |  20 |
| xiaopeng  |  23 |
| xiaozheng |  22 |
+-----------+-----+

2.3 查询所有列

使用通配符*表示查询所有列：

SELECT * FROM stu_info;

结果：

+--------------+-----------+-----+---------+----------+
| stu_id       | stu_name  | age | classno | city     |
+--------------+-----------+-----+---------+----------+
| 000000000001 | maqian    |  24 |       1 | changsha |
| 000000000002 | xiaoming  |  19 |       2 | shanghai |
| 000000000003 | xiaohua   |  23 |       2 | shenzhen |
| 000000000004 | xiaobai   |  22 |       3 | shenzhen |
| 000000000005 | xiaowang  |  19 |       4 | hunan    |
| 000000000006 | xiaozhou  |  20 |       3 | wuhan    |
| 000000000007 | xiaoli    |  20 |       1 | changsha |
| 000000000008 | xiaopeng  |  23 |       1 | changsha |
| 000000000009 | xiaozheng |  22 |       1 | fujian   |
+--------------+-----------+-----+---------+----------+

使用*来输出所有列时，会严重降低检索和应用程序的性能。大部分时候，尽量少使用用通配符，明确自己所需要的列。

2.4 去除重复数据

在查询时，可以通过DISTINCT关键字来剔除重复的行。如查询所有的班级（不重复）：

SELECT DISTINCT classno FROM stu_info;

结果：

+---------+
| classno |
+---------+
|       1 |
|       2 |
|       3 |
|       4 |
+---------+

当对多个关键字使用DISTINCT时，只有所有列都相同才会被认为是重复的，其中某个字段相同并不会认为是同一个行：

SELECT DISTINCT classno, city FROM stu_info;

上面的数据中，有多个classno=1并且city=changsha的结果，使用DISTINCT之后，这些重复的行被剔除了，而同样classno=但是city=fujian的记录却依然存在：

+---------+----------+
| classno | city     |
+---------+----------+
|       1 | changsha |
|       2 | shanghai |
|       2 | shenzhen |
|       3 | shenzhen |
|       4 | hunan    |
|       3 | wuhan    |
|       1 | fujian   |
+---------+----------+

2.5 限制结果

使用LIMIT关键字可以限制输出的结果数量，语法格式为：

LIMIT N：只输出前面N条记录。
LIMIT M,N：从第M条记录开始，输出N条记录。
LIMIT N OFFSET M：MYSQL从5.0开始支持的语法，作用和第二条一样，从M开始输出N条记录。

第三种用法实际上是为了解决用户会混淆M,N究竟是从M开始的N条记录还是N开始的M条记录的问题。

2.5.1 显示前面5条记录

SELECT classno, city FROM stu_info LIMIT 5;

结果：

+---------+----------+
| classno | city     |
+---------+----------+
|       1 | changsha |
|       2 | shanghai |
|       2 | shenzhen |
|       3 | shenzhen |
|       4 | hunan    |
+---------+----------+

2.5.2 从第5条之后显示5条记录

SELECT classno, city FROM stu_info LIMIT 5, 5;

结果：

+---------+----------+
| classno | city     |
+---------+----------+
|       3 | wuhan    |
|       1 | changsha |
|       1 | changsha |
|       1 | fujian   |
+---------+----------+

当实际的记录数量小于剩余记录时，输出的结果并不会达到我们想要的行数。

使用SELECT classno, city from stu_info LIMIT 4 OFFSET 5的结果也和上面一样！

三、对结果排序

排序是查询是最常用的的功能之一，语法格式为ORDER BY col1, col2，表示根据col1和col2排序。

MYSQL支持对单行和多行数据排序，也支持正序和倒序排序。默认情况是正序排序，逆序排序需要手动添加关键字DESC。

3.1 对单列数据排序

输出学生的年龄、班级和名字，并针对年龄排序：

SELECT age, stu_name FROM stu_info ORDER BY age;

结果：

+-----+---------+-----------+
| age | classno | stu_name  |
+-----+---------+-----------+
|  19 |       2 | xiaoming  |
|  19 |       4 | xiaowang  |
|  20 |       3 | xiaozhou  |
|  20 |       1 | xiaoli    |
|  22 |       3 | xiaobai   |
|  22 |       1 | xiaozheng |
|  23 |       2 | xiaohua   |
|  23 |       1 | xiaopeng  |
|  24 |       1 | maqian    |
+-----+---------+-----------+

可以看到，age列都是从小到大排列，而classno还是处于无序的状态。

3.2 对多列数据排序

在上面的基础上，添加对班级排序逻辑。即当学生年龄一致的时候，根据所在的班级排序：

SELECT age, classno, stu_name FROM stu_info ORDER BY age, classno;

结果：

+-----+---------+-----------+
| age | classno | stu_name  |
+-----+---------+-----------+
|  19 |       2 | xiaoming  |
|  19 |       4 | xiaowang  |
|  20 |       1 | xiaoli    |
|  20 |       3 | xiaozhou  |
|  22 |       1 | xiaozheng |
|  22 |       3 | xiaobai   |
|  23 |       1 | xiaopeng  |
|  23 |       2 | xiaohua   |
|  24 |       1 | maqian    |
+-----+---------+-----------+

结果中，所有年龄相同的行，班级序号也是有序的。

3.3 逆序排序

逆序输出所有的学生名字：

SELECT stu_name FROM stu_info ORDER BY stu_name DESC;

结果：

+-----------+
| stu_name  |
+-----------+
| xiaozhou  |
| xiaozheng |
| xiaowang  |
| xiaopeng  |
| xiaoming  |
| xiaoli    |
| xiaohua   |
| xiaobai   |
| maqian    |
+-----------+

四、其他

4.1 使用完全限定的表名

查询时，可以明确查询的表名和列名，如：

SELECT stu_info.stu_name from stu_info;

注意：不可省略最后的表信息，不要认为列中限定了表名最后就不用再添加表名了。

效果等同于：

SELECT stu_name FROM stu_info;

这种用法一般适用于多表之间的联合查询，当两个表中的字段有重合时，需要明确指定表名来限定查询的是哪个表中的字段。

数据结构之树：二叉树的实现

作者: 编程我只用CPP
时间: 2018-03-25
分类: 数据结构和算法
评论

相对于栈和链表等数据结构来说，树有着更复杂的结构。正如我们平常生活中看到的树一样，它有很多分支，而且分支上面还会有分支。

树的用途十分广泛，最常见的树是二叉树，衍生了很多类型的树，红黑树，搜索树等等，被用来查找效率十分高，一个最典型的应用就是mysql中的索引。

树是由很多个节点构成，要实现一个树最最主要的就是实现树的节点。

- 阅读剩余部分 -

链表的遍历和反转

作者: 编程我只用CPP
时间: 2018-03-25
分类: 数据结构和算法
评论

一、链表的遍历

链表的遍历算是十分简单了，从头到尾获取next指针的值，如果next不为0，一直打印。

// 遍历链表，结果保存在vector中返回
template <typename T>
std::vector<T> CMyList<T>::traversal() const {
    vector<T> v;
    CListNode<T> *p = root.getNext();
    while (p)
    {
        v.push_back(p->getData());
        p = p->getNext();
    }

    return v;
}

- 阅读剩余部分 -

数据结构之列表：双向链表的实现

作者: 编程我只用CPP
时间: 2018-03-25
分类: 数据结构和算法
评论

双向链表是链表的一个分支，相比单向链表来说多了个一个前向指针pre，指向当前节点的前一个节点，查找起来更为灵活。

- 阅读剩余部分 -

数据结构之链表（一）：单向链表实现

作者: 编程我只用CPP
时间: 2018-03-25
分类: 数据结构和算法
评论

一、单向链表

1.1 单向链表

链表是一种线性结构，通过一个链把所有的节点都链起来，因此叫做链表。它和数组最大的不同是：数组的内存是连续的，而链表不是。数组支持随机读写，但是插入和删除麻烦，链表不支持随机读写，但是插入和删除很方便。在更多场景下，链表用途更广。

一个链表的图形示例如下，每个链表节点都包含了一个数据域和指向下一个节点指针：

链表是由一系列的节点构成，从面向对象角度来说，链表和节点是两个完全不同的东西。节点是链表中的实体，而链表只是节点的抽象，它包含若干个组成链表的节点。因此，链表和节点这两个对象应该区别开来。

一个基本的单向链表支持的操作：

添加节点
删除节点
查找节点

1.2 节点定义

一个节点的结构至少应该包含必要的数据域和next指针域，next只用用于指向下一个节点的地址。

以下是一个最简单的链表节点示例：

链表节点的C++定义：

template<typename T>
class list_node {
    // 友元类，方便链表类读取节点元素数据
    friend class singly_linklist<T>;
private:
    T data; // 数据域
    list_node<T> *next; // 下一个节点指针
};

1.3 链表定义

链表是由一个个的节点构成，在它的内部只要保存链表头节点的地址，就能找到链表中所有节点地址。

因此一个链表中，只要包含头结点的地址就行了。然后根据其他的扩展，我们可能还需要用到：

长度字段：O(1)的时间复杂度返回链表长度。
尾结点指针：保存末尾节点的指针，尾插时O(1)的时间复杂度即可定位到尾结点。

链表的结构示意图：

链表的C++定义：

template<typename T>
class singly_linklist {
public:
    singly_linklist() : len(0), head(nullptr), tail(nullptr) {}
private:
    size_t len; // 链表长度
    list_node<T> *head; // 头结点
    list_node<T> *tail; // 尾结点
};

所有代码使用C++完成，后面的函数无特殊说明都是类成员函数。

二、插入节点

2.1 插入逻辑

以下图为例，不考虑首尾节点状态以及插入位置，一个节点被插入的逻辑是：

设置新增节点node2的next指向为node3
修改原节点node1的next指向新节点node2
插入完成

在链表类中，定义一个私有的添加节点函数add_node来完成这个插入操作：

/*
 * 添加节点操作，新添加的节点需确保不是空值
 * @new_node 新节点，不能为空
 * @prev 前驱节点，可能为空
 * @next 后继节点，可能为空
 */
void add_node(list_node<T> *new_node, list_node<T> *prev, list_node<T> *next) {
    if (new_node == nullptr)
        return;
    
    len++; // 长度加1
    new_node->next = next;
    if (prev) {
        prev->next = new_node;
    }
}

2.2 头插法

头插法的意思是把节点插入到链表头部，这种情况下除了插入节点到链表中，还要注意的是修改链表的head节点指针。

头插法函数实现：

/*
 * 插入数据到链表开头
 * @node 待插入的数据节点
 */
singly_linklist &push_front(list_node<T> *node) {
    if (node == nullptr)
        return *this;

    // 添加节点到头部
    add_node(node, nullptr, head);
    // 修改首尾节点指针
    head = node;
    if (tail == nullptr)
        tail = node;

    return *this;
}

2.3 尾插法

尾插法和头插法相对，尾插法的意思是把节点插入到链表尾部，因此，插入后也要更新尾结点指针。

尾插法代码实现：

/*
 * 插入元素到末尾
 * @node 待插入的数据节点
 */
singly_linklist &push_front(list_node<T> *node) {
    if (node == nullptr)
        return *this;

    // 添加节点到头部
    add_node(node, nullptr, head);
    // 修改首尾节点指针
    head = node;
    if (tail == nullptr)
        tail = node;

    return *this;
}

三、查找元素

3.1 查找指定值的节点

/*
 * 在链表中查找指定值的节点
 * @data 待查找节点
 * @return 找到返回对应的节点，否则返回nullptr
 */
list_node<T> *find(const T &data) {
    list_node<T> *p = head;
    // 遍历链表
    while (p) {
        // 找到了
        if(p->data == data)
            return p;
        // 没找到，继续找下一个
        p = p->next;
    }
    return p;
}

3.2 查找指定节点的前节点

在增加或删除节点之前，都要修改前节点的指针指向，因此，需要实现一个查找指定节点的头结点函数。

/*
 * 查找某个节点的前一个节点
 * @node 当前节点
 * @return 如果存在上一个节点，返回上一个节点的地址，否则返回nullptr
 */
list_node<T> *find_prev(list_node<T> *node) {
    list_node<T> *p = head;
    if (node == nullptr)
        return nullptr;

    while (p != nullptr) {
        if (p->next == node) {
            return p;
        }
        p = p->next;
    }
    return p;
}

四、删除元素

4.1 删除逻辑

以下图为例，删除节点2的操作是：

修改节点1的next指向node3
删除node2的next指向，删除完成

核心的删除代码：

/*
 * 删除节点，待删除的节点请确保不是空值
 * @del_node 待删除节点，不为空
 * @prev 前驱节点，可能为空
 * @next 后继节点，可能为空
 */
void remove_node(list_node<T> *del_node, list_node<T> *prev, list_node<T> *next) {
    if (del_node == nullptr)
        return;

    len--; // 链表长度减1
    del_node->next = nullptr; // 被删除节点的next指针置空

    if (prev) { // prev可能为空
        prev->next = next;
    }
}

4.2 删除指定节点

删除节点的一种操作是找到前节点指针，同时要注意的是，删除节点可能导致首尾指针失效，要注意更新首尾指针。

/*
 * 删除节点
 * @node 待删除节点
 */
singly_linklist<T> &remove(list_node<T> *node) {
    list_node<T> *prev;
    if (node == nullptr)
        return *this;

    // 找到前节点
    prev = find_prev(node);

    // 修改首尾节点指向
    if (head == node)
        head = node->next;
    if (tail == node)
        tail = prev;

    // 删除节点
    remove_node(node, prev, node->next);
    delete node;

    return *this;
}

4.3 删除首尾元素

有了上面的删除指定节点函数之后，删除首尾元素的操作就变得非常简单了：

// 弹出首元素
singly_linklist &pop_front() {
    return remove(head);
}
// 弹出尾元素
singly_linklist &pop_back() {
    return remove(tail);
}

五、单元测试

5.1 头插法测试

TEST(singly_linklist, push_front) {
    int i;
    singly_linklist<int> list;
    const list_node<int> *p;
    vector<int> v{1, 2, 3};

    list.push_front(3).push_front(2).push_front(1);
    EXPECT_EQ(3, list.get_len());

    p = list.get_head();
    for (i = 0; i < v.size(); i++) {
        EXPECT_EQ(p->get_data(), v[i]);
        p = p->get_next();
    }
    EXPECT_EQ(p, nullptr);
}

5.2 尾插法测试

TEST(singly_linklist, push_back) {
    int i;
    singly_linklist<int> list;
    const list_node<int> *p;
    vector<int> v{1, 2, 3};

    list.push_back(1).push_back(2).push_back(3);
    EXPECT_EQ(3, list.get_len());

    p = list.get_head();
    for (i = 0; i < v.size(); i++) {
        EXPECT_EQ(p->get_data(), v[i]);
        p = p->get_next();
    }
    EXPECT_EQ(p, nullptr);
}

5.3 查找前一个节点测试

TEST(singly_linklist, get_prev) {
    int i;
    singly_linklist<int> list;
    const list_node<int> *p;
    list_node<int> *node1, *node2, *node3;

    // 插入3个节点
    node1 = new list_node<int>(1);
    node2 = new list_node<int>(2);
    node3 = new list_node<int>(3);
    list.push_back(node1).push_back(node2).push_back(node3);
    EXPECT_EQ(3, list.get_len());

    p = list.find_prev(node1);
    EXPECT_EQ(p, nullptr);
    p = list.find_prev(node2);
    EXPECT_EQ(p, node1);
    p = list.find_prev(node3);
    EXPECT_EQ(p, node2);
}

5.4 删除节点测试

// 测试删除节点
TEST(singly_linklist, remove) {
    int i;
    singly_linklist<int> list;
    const list_node<int> *p;
    list_node<int> *node1, *node2, *node3;

    node1 = new list_node<int>(1);
    node2 = new list_node<int>(2);
    node3 = new list_node<int>(3);

    list.push_front(node1);
    list.push_back(node2);
    list.push_back(node3);

    // 删除中间节点
    list.remove(node2);
    EXPECT_EQ(node1, list.get_head());
    EXPECT_EQ(node3, list.get_tail());
    EXPECT_EQ(node1->get_next(), node3);

    // 删除头节点
    list.remove(node1);
    EXPECT_EQ(node3, list.get_head());
    EXPECT_EQ(node3, list.get_tail());
    EXPECT_EQ(node3->get_next(), nullptr);

    // 删除尾节点
    list.remove(node3);
    EXPECT_EQ( list.get_head(), nullptr);
    EXPECT_EQ( list.get_tail(), nullptr);
}

数据结构之队列：队列的实现

作者: 编程我只用CPP
时间: 2018-03-25
分类: 数据结构和算法
评论

队列是一种先进先出的数据结构，因和平常生活中的排队流程一样因此被称为队列。操作逻辑和栈刚好相反。

常用操作：

enqueue: 元素入队
dequeue: 首元素出队
size: 返回队列中元素的个数
empty: 判断队列是否为空
front: 返回队首元素

它有两个指针分别指向队列开头和结尾，出队和入队的流程为：

- 阅读剩余部分 -

数据结构之栈（三）：顺序栈实现

作者: 编程我只用CPP
时间: 2018-03-25
分类: 数据结构和算法
评论

顺序栈的实现和使用数组实现原理一样，都是预先申请一段连续的地址块作为数据域，通过栈顶下标或指针移动完成压栈、出栈等操作。不同的是，使用指针的顺序栈支持栈满时扩容操作，原理更倾向于vector的实现。

顺序栈初始化时申请一块固定大小内存空间保存数据，栈顶指针在内存区域来回移动：

- 阅读剩余部分 -

数据结构之栈（二）：链式栈实现

作者: 编程我只用CPP
时间: 2018-03-24
分类: 数据结构和算法
评论

链栈的原理和链表的原理一样，通过一个next指针把一个个的节点链起来：

初始时，栈底指针和栈顶指针都为空，每插入一个节点，栈顶指针改变，当前插入节点的next指针指向之前的栈顶元素。

- 阅读剩余部分 -

数据结构之栈（一）：使用数组实现栈

作者: 编程我只用CPP
时间: 2018-03-24
分类: 数据结构和算法
评论

栈是一种“先进后出”的数据结构，最先进入栈的元素位于栈的底端，最后进入的位于顶端。

其主要的接口函数为：

pop(): 弹出顶端元素
size(): 返回栈容量
empty(): 判断栈是否为空
push(T data): 添加元素到栈顶
top(): 返回顶端元素

- 阅读剩余部分 -

设置vim打开文件时光标在上次退出位置

作者: 编程我只用CPP
时间: 2018-03-20
分类: Linux运维
评论

在.vimrc文件中添加：

au BufReadPost * if line("'\"") > 0 | if line("'\"") <= line("$") | exe("norm '\"") | else |exe "norm $"| endif | endif

如果添加后无效，可能是~/.viminfo和~/.vimrc这两个文件的所有者非当前用户导致的。

因为vim运行过程中的操作记录（如历史操作和记录上次退出的行数等）都是写入到~/.viminfo中去的，如果当前用户没有权限的话会导致写入失败，功能不生效。

以我这台电脑为例，.viminfo的所有者是root，这样就不行：

修改所有者的命令：

sudo chown $USER ~/.viminfo

一、SELECT介绍

1.1 SELECT

1.2 测试数据

二、使用SELECT查询数据

2.1 查询单列数据

2.2 查询多个列

2.3 查询所有列

2.4 去除重复数据

2.5 限制结果

2.5.1 显示前面5条记录

2.5.2 从第5条之后显示5条记录

三、对结果排序

3.1 对单列数据排序

3.2 对多列数据排序

3.3 逆序排序

四、其他

4.1 使用完全限定的表名

一、链表的遍历

一、单向链表

1.1 单向链表

1.2 节点定义

1.3 链表定义

二、插入节点

2.1 插入逻辑

2.2 头插法

2.3 尾插法

三、查找元素

3.1 查找指定值的节点

3.2 查找指定节点的前节点

四、删除元素

4.1 删除逻辑

4.2 删除指定节点

4.3 删除首尾元素

五、单元测试

5.1 头插法测试

5.2 尾插法测试

5.3 查找前一个节点测试

5.4 删除节点测试

最新文章

最近回复

分类

归档

其它