指针及链表相关知识点复习 ¶

指针的基本操作 ¶

指针的声明 ¶

声明一个指针：

VariableType *pointerName;

其中 VariableType 为指针指向的变量类型，pointerName 为指针的名称。

例如：int *p; 声明了一个指向 int 类型变量的指针，指针的名称为 p。

int n;
const int * pc = &n; // pc 是指向 const int 的非 const 指针
// *pc = 2; // 错误：不能通过不带转型的 pc 修改 n
pc = NULL; // OK：pc 自身可修改

int * const cp = &n; // cp 是一个指向非 const 的 int 的 const 指针
*cp = 2; // OK：通过 cp 修改 n
// cp = NULL; // 错误：cp 自身不能修改

int * const * pcp = &cp; // 指向指向非 const 的 int 的 const 指针的非 const 指针

多级指针的声明 ¶

对多级指针的声明，可以用递归的方式理解。

对于指向 int 类型的一级指针，其 VariableType 为 int；对于二级指针 int **p，即指向指向 int 类型的指针的指针，其 VariableType 为 int *。

int var = 1;
int *p1 = &var;
int **p = &p;

(int **)p -> (int *)p1 -> (int)var

指针数组与数组指针 ¶

很容易搞混，需要技巧来识别。

比如下面两条声明：

char *p[10]; // 大小为 10 的数组，数组元素是指向 char 类型的指针

char (*p)[10]; // 指针，指向大小为 10 的 char 数组

牢记顺时针螺旋法则（Clockwise/Spiral Rule）（详见辅学群群文件中的“浅谈 C 语言的数据类型 .pdf”）。

于是，上面的两条声明就可以公式化地解释：

• char *p[10];: p is an array 10 of pointers to char.
• char (*p)[10];: p is a pointer to an array 10 of char.

上一节的多级指针声明同样可以用这个法则进行解释。

指针的使用 ¶

指针的解引用 ¶

解引用运算符 * 的一般形式为：

* 指针表达式

结果为指代被指向对象的左值表达式，即可以被赋值。

记住 a[b] 等价于 *(a + b)。这个 trick 在一些题目中很有用。

    0 0 0 1 2 3 4 5 6 7 8 9
    ^
    |
p = *(a - 1)

取址操作 ¶

取址运算符 & 早在大家学习输入输出的时候就已经接触过了。在使用 scanf 对 int 等类型的变量进行读入的时候，使用的是如下形式：

int a;
scanf("%d", &a);

这里的 & 对 a 进行取址操作，对 a 的地址而不是 a 的值进行读入。

一般地，取址运算符有如下几种形式：

• & <function>：取函数的地址。这个不做要求。

• & 左值表达式：取左值表达式的地址。结果为指向左值表达式的指针。

  左值表达式

  左值，简单来说可以看作是在内存中有对应存储空间的表达式，如变量、数组元素、结构体成员等。

  相反，若表达式在内存中没有对应存储空间，则不能取址，比如 &a、1+2 等。

• & * 表达式：& 和 * 彼此抵消，均不求值。这个仅作了解。

• & 表达式 [表达式]：等价于 & *(表达式 + 表达式) 等价于 表达式 + 表达式。这个仅作了解。

unsigned long long x;
scanf("%llu", &x);
printf("%lf\n", *((double *)&x));

通过指针进行成员访问 ¶

对于结构体类型的指针，C 语言提供了一个运算符 ->，用于通过指针访问结构体成员。

struct Point { int x, y; }; // 定义结构体 Point
struct Point point = { 1, 2 }; // 定义结构体变量 point

struct Point *p = &point; // p 指向 point 结构体
p->x = 3; // 通过指针 p 访问结构体成员 x
// 等价于 (*p).x = 3;

数组到指针的隐式转换 ¶

简单来说：牢记数组名 不等于 指向数组首元素的指针，当数组名被取址运算符 & 作用，或者作为 sizeof 的操作数时，不会发生隐式转换。

这里要注意的一点是，将数组作为参数传给函数时，函数的形参只能是指针，而不能是数组，此时数组名会发生隐式转换。

char *s = "hello"; // s 类型为 char * ，指向字符串常量
s = "he11o"; // OK

char s[] = "hello"; // s 类型为 char [6] ，数组内容是 "hello\0" 的拷贝
// s[] = "he11o"; // wrong

int a[10], *p = a;
Type1 val_x = &a;
Type2 val_y = &p;

int a[10], *p = a;
size_t size_x = sizeof a;
size_t size_y = sizeof p;

指针的值与指针的地址 ¶

指针的值，又称为指针所指向的内存区。

在计算机中，内存中的所有字节都拥有一个唯一编号，也即内存地址。指针指向某一数据的地址，即指针变量存储了这个数据的内存地址的编号。

注意，一般来说无法预测地址的值，因为内存地址取决于系统的内存分配情况。但部分情况下可以确定内存地址的相对位置，比如同一数组中元素在内存中连续。

此外，指针同样也是一个在内存中有对应存储空间的变量，也有自己的内存地址。在指针的内存地址中，存储的内容是其指向的内容的内存地址。

下标    31       32       33       34      ...     X
arr   data0    data1    data2    data3    ....    32
                 ^                                |
                 +--------------------------------+

int a[] = {1, 2, 3, 4, 5};
int *p = a, *q = &a[2];
printf("%lu\n", q - p);

一些题目 ¶

char *week[]={"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"}, **pw=week;
char c1, c2;
c1 = (*++pw)[1];
c2 = *++pw[1];
printf("%c#%c#", c1, c2);

       "Mon\0"   "Tue\0"   "Wed\0"   "Thu\0"   "Fri\0"   "Sat\0"   "Sun\0"
        ^         ^         ^         ^         ^         ^         ^
        |         |         |         |         |         |         |
week: week[0]   week[1]   week[2]   week[3]   week[4]   week[5]   week[6]
        ^
        |
       pw

char s[2][3] = {"ab", "cd"}, *p = (char *)s;

s:    "ab\0"     "cd\0"
      ^
      |
s(隐式转换)(char *[3])

s:    "ab\0"     "cd\0"
       ^
       |
  p = (char *)s

链表 ¶

基础知识和总结 ¶

链表是一种常用的数据结构，它通过节点的形式存储数据。每个节点包含数据部分和指向下一个节点的指针。链表可以是单向的也可以是双向的，我们先看看单向链表：

typedef struct Node {
    int data;
    struct Node* next;
} Node;

好了，我们已经把链表给定义出来了。但是你会好奇，我们不是只定义出了节点吗？怎么已经定义完了？事实上，这几乎就已经是链表的完整结构了——因为链表就是简单的链表节点的串联。

大家都已经知道了链表的结构，是类似于下面这样的：

所以，链表其实就是以下的东西的结合：

• 一个指向头结点的指针 head ，告诉我们从哪里开始遍历整个链表。
• 头节点指向的下一个节点 head->next 。注意这也是一个指针。
• 头节点指向的下一个节点的下一个节点 head->next->next。
• ...
• 最后一个节点。

我们怎么知道最后一个节点是什么呢？我们规定，最后一个节点指向的位置就是 NULL，也就是 0。这样，只要判断节点的 .next 是否是 NULL，就可以知道这个节点是不是尾节点了。好了，所以我们只需要若干个 Node，然后将他们串联——也就是通过 next 连接，就得到了一个完整的链表。

接下来让我们回忆一下链表的各种操作的实现吧！不过大家在平时做题的时候应该都感觉到了，链表有很多很多难以琢磨的细节和特殊情况！怎么办呢？冷静下来总结，无非就是这几种：

• 特殊情况 \(1\)：如果头指针指向的是NULL，也就是链表本身就为空了。
• 特殊情况 \(2\)：如果当前操作在头节点进行。
• 特殊情况 \(3\)：如果当前操作在尾节点进行。

这些情况如果没有考虑清楚，很可能在写代码的过程中出现 segmentation fault，也就是段错误。这极大概率是因为，你访问了 NULL 位置的一些信息。比如当前节点指针 p 指向了 NULL，但是你却访问了 p->data 或者 p->next，就会报错了。

单向链表的各种经典操作 ¶

Node *create(int w){
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->next = NULL;
    newNode->data = w;
    return newNode;
}

Node *insertAtHead(Node* head, Node* p) {
    if (!head) return p; // 可以发现，这句话不写也没有影响 
    p->Next = head;
    return p;
}

Node *insertAtEnd(Node* head, Node* p) {
    if (!head) return p;
    Node* last = head;
    while (last->next) {
        last = last->next;
    }
    last->next = p;
    return head;
}

Node *deleteNode(Node* head, int key) {
    if (!head) return NULL;
}

Node *deleteNode(Node* head, int key) {
    if (!head) return NULL;
    if (head->data == key){
        node* tmp = head->next; //这么做是因为 free 以后，head->next 就不能获取了。
        free(head);
        return tmp;
    }
}

Node *deleteNode(Node* head, int key) {
    if (!head) return NULL;
    if (head->data == key){
        node* temp = head->next; //这么做是因为 free 以后，head->next 就不能获取了。
        free(head);
        return tmp;
    }
    node* temp = head, prev = NULL;
    while (temp && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    if (!temp) return head;
    prev->next = temp->next; //事实上直接删除就好了，不需要关系情况 3 了，不过特判一下也不错。
    free(temp);
    return head;
}

双向链表 ¶

其实没什么可以讲的，也就是在 struct 的定义中加入了 prev，可以让我们方便的获取上一个节点的指针，这样删除过程中就不需要单独开变量记录了。

typedef struct Node {
    int data;
    struct Node* prev, next;
} Node;

特别的，头结点的 prev 是 NULL。

看一个简单的例题吧 ~

栈和队列 ¶

这一部分的内容相信大家在课上已经有很好的理解了，但是会出一些和链表结合的有难度的理论题和编程题，所以简单带过一下：

通常题目会使用单向链表来实现栈和队列。不过很多题目其实会不告诉你，链表哪一段表示栈顶，哪一段表示队头，哪一段表示队尾。

所以一些题目的实现，默认了链表的头部代表队头。看一下这个题目：

这里需要额外提一个叫做循环队列的东西。它是队列的一种变体，通常使用数组来实现，用来节约队列的空间。循环队列是把顺序队列首尾相连，把存储队列元素的表从逻辑上看成一个环。通常用两个变量代表当前循环队列存储的空间：一个是尾 rear，一个是头front。不过这个是开区间还是闭区间呢，还得看具体实现方式和题干要求，大家最好翻翻老师的 PPT，看看上课是怎么实现的，万一题目没有给出实现方式就按照老师讲的为主吧。

关于编程部分，我们来看一下这个每日一题。