数据结构和设计模式01（数据结构的基础）

第十三章 数据结构的基础
本章包含：数据结构、字符串的使用、栈、堆、排序等

1.链表
链表的创建、逆置、插入、删除等操作是重点。
创建单链表步骤：创建节点的数据结构——创建空的列表——利用（Node*）malloc（sizeof(Node)）函数分配节点空间——新节点的指针赋值为NULL——插入。如下：

<span style="font-family:SimSun;font-size:10px;">struct node //①定义链表数据结构
{
int num;
struct node *next;
};
main()
{
struct node *creat();
void print();
struct node *head;
head = NULL;    //②建一个空表
head = creat(head);/*创建单链表*/
print(head);/*打印单链表*/
}
/******************************************/
struct node* creat(struct node *head)/*返回的是与节点相同类型的指针*/
{
struct node*p1, *p2;
//③利用malloc ( )函数向系统申请分配一个节点
p1 = p2 = (struct node*)malloc(sizeof(struct node));/*新节点*/
printf("p1= %d\n", p1);
scanf("%d", &p1->num);/*输入节点的值*/
p1->next = NULL;/*将新节点的指针置为空*/
while (p1->num > 0)/*输入节点的数值大于0*/
{
//④将新节点的指针成员赋值为空。若是空表，将新节点连接到表头；若是非空表，将新
//节点接到表尾;
if (head == NULL)
head = p1;/*空表，接入表头*/
else
p2->next = p1;/*非空表，接到表尾*/
p2 = p1;
p1 = (struct node*)malloc(sizeof(struct node));/*下一个新节点*/
printf("p2= %d\n", p2);
scanf("%d", &p1->num);/*输入节点的值*/
//⑤判断一下是否有后续节点要接入链表，若有转到3 )，否则结束;
}
printf("p2->next=%d\n", p2->next);
return head;/*返回链表的头指针*/
}
/*******************************************/
void print(struct node*head)/*出以head为头的链表各节点的值*/
{
struct node *temp;
temp = head;/*取得链表的头指针*/
while (temp != NULL)/*只要是非空表*/
{
printf("%6d", temp->num);/*输出链表节点的值*/
temp = temp->next;/*跟踪链表增长*/
}
}</span>

插入、删除的操作非常简单，就是分配空间（malloc）、释放空间（free）以及指针指向的问题，此处不再举例了。

判断单链表是否有环以及环的入口问题：
判断是否有环：设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。(当然，fast先行头到尾部为NULL，则为无环链表)。

<span style="font-family:SimSun;font-size:10px;">bool isExitsLoop(list *head)
{
list *slow = head, *fast = head;
while (fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
if (slow == fast) break;
}
return !(fast == NULL || fast->next == NULL);
}</span>

此问题可扩展至：求循环链表任一节点“对面的”（最远端）的节点，算法同上，当fast到达head（此处head为任一节点）或head->next时，slow指示的就是最远端的节点。
确定有环后，寻找环的入口，算法如下：

当fast若与slow相遇时，slow肯定没有走遍历完链表，而fast已经在环内循环了n圈(1<=n)。假设slow走了s步，则fast走了2s步（fast步数还等于s 加上在环上多转的n圈），设环长为r，则：

2s = s + nr 则s= nr

设整个链表长L，入口环与相遇点距离为x，起点到环入口点的距离为a。

a + x = nr

a + x = (n – 1)r +r = (n-1)r + L - a

a = (n-1)r + (L – a – x)

(L – a – x)为相遇点到环入口点的距离，由此可知，从链表头到环入口点等于(n-1)循环内环+相遇点到环入口点，于是我们从链表头、与相遇点分别设一个指针，每次各走一步，两个指针必定相遇，且相遇第一点为环入口点。

<span style="font-family:SimSun;font-size:10px;">list* FindLoopNode(list* head)
{
list *slow = head, *fast = head;

while (fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
if (slow == fast) break;
}

if (fast == NULL || fast->next == NULL)
return NULL;

slow = head;
while (slow != fast)
{
slow = slow->next;
fast = fast->next;
}

return slow;
}</span>

此问题可扩展至：判断两个单链表是否相交，如果相交，给出相交的第一个点（两个链表都不存在环）。

根据问题描述，两个单链表自相交点起，将合并为一个单链表，这是理解算法的关键。

算法描述：

将其中一个链表首尾相连，检测另外一个链表是否存在环，如果存在，则两个链表相交，而检测出来的依赖环入口即为相交的第一个点

双链表：
基本流程和单链表一样（吧单链表搞懂了，双链表非常简单），只是节点多了一个父指针，节点的数据结构如下：

<span style="font-family:SimSun;font-size:10px;">typedef struct Node
{
int data;
struct Node* prev;
struct Node* next;
}Node;</span>

2.队列
遵循先进先出，从尾部插入节点，从头部pop节点，队列只有头部指针和尾部指针，中间的节点指针都隐藏，如下：

<span style="font-family:SimSun;font-size:10px;">typedef struct Node
{
int data;
struct Node *next;
}node;
typedef struct Queue    //notice :队列的数据结构只是包括两个节点指针（头和尾）；
{
node* first;
node* back;
}queue;</span>

插入删除操作很简单：
插入：用（node*）malloc（sizeof(node)）分配内存，然后将节点添加到Queue的尾部
删除：pop队列的first节点，指针指向下一个节点，然后free空间；

3.栈
后进先出，插入和删除节点都在链表一端（头部、尾部其中一个就可以了，视节点指针指向next、pre而定，不需要用双向链表，）进行，这个也叫顺序栈，或者链栈。节点的数据结构和栈的结构（可以有多种形式，反正满足后进先出就行，就按始终在链表头部进行，很好理解）如下：

<span style="font-family:SimSun;font-size:10px;">typedef struct Node
{
int data;
struct Node *next;
}node, SqStack; //栈和节点的数据结构<span style="color:#ff0000;">可以</span>完全一样;</span>

变量的入栈顺序：和编译器有关（http://segmentfault.com/a/1190000002630697），一般没有溢出保护机制是按变量声明的顺序，反之，则逆序。
函数的参数入栈顺序：从右到左，最后是压入函数的地址，如果是数组或者指针，则压入的都是首地址。
栈的生长方向：从上到下（高地址到低地址）关键在栈的定义，定义一个栈——这是高地址，每次压入一个数据，栈指针esp减去4（32操作系统），所以栈顶的地址是最小的。
堆的增长方向：与栈的相反，对的顶部地址最大。

引申：大端小端：
1) Little-Endian就是低位字节排放在内存的低地址端（高位字节排放在内存的高地址端）。
2) Big-Endian就是高位字节排放在内存的低地址端(低位字节排放在内存的高地址端)。

举一个例子，比如数字0x12 34 56 78在内存中的表示形式为：

1)大端模式：
低地址 -----------------> 高地址

0x12 | 0x34 | 0x56 | 0x78

2)小端模式：
低地址 ------------------> 高地址

0x78 | 0x56 | 0x34 | 0x12

可见，大端模式和字符串的存储模式类似。

3）为什么会有大小端模式之分呢？

这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如果将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。例如一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。对于大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，刚好相反。我们常用的X86结构是小端模式，而KEIL
C51则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

4）常见的字节序

一般操作系统都是小端，而通讯协议是大端的。

4.堆和栈对比
一、预备知识—程序的内存分配

一个由C/C++编译的程序占用的内存分为以下几个部分

1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其

操作方式类似于数据结构中的栈。

2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回

收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的

全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另

一块区域。 - 程序结束后由系统释放。

4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放

5、程序代码区—存放函数体的二进制代码。

二、例子程序（有前辈将程序员宝典的总结全部写过了，我这儿直接复制来的。如下）

//main.cpp
int   a   =   0;   全局初始化区
char   *p1;   全局未初始化区
main()
{
int   b;   栈
char   s[]   =   "abc";   栈
char   *p2;   栈
char   *p3   =   "123456";   123456/0在常量区，p3在栈上。
static   int   c   =0；   全局（静态）初始化区
p1   =   (char   *)malloc(10);
p2   =   (char   *)malloc(20);
分配得来得10和20字节的区域就在堆区。
strcpy(p1,   "123456");   123456/0放在常量区，编译器可能会将它与p3所指向的"123456"
优化成一个地方。
}

二、堆和栈的理论知识

2.1申请方式

stack: 由系统自动分配。例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间

heap: 需要程序员自己申请，并指明大小，在c中malloc函数，如p1= (char *)malloc(10);
在C++中用new运算符如p2 = new char[10];

但是注意p1、p2本身是在栈中的。

2.2 申请后系统的响应

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

2.3申请大小的限制

栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

2.4申请效率的比较：

栈由系统自动分配，速度较快。但程序员是无法控制的。堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一块内存，虽然用起来最不方便。但是速度快，也最灵活。

2.5堆和栈中的存储内容

栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

2.6存取效率的比较


char s1[] = "aaaaaaaaaaaaaaa";

char *s2 = "bbbbbbbbbbbbbbbbb";

aaaaaaaaaaa是在运行时刻赋值的；

而bbbbbbbbbbb是在编译时就确定的；

但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。

比如：

#include
void   main()
{
char   a   =   1;
char   c[]   =   "1234567890";
char   *p   ="1234567890";
a   =   c[1];
a   =   p[1];
return;
}

对应的汇编代码

10:   a   =   c[1];
00401067   8A   4D   F1   mov   cl,byte   ptr   [ebp-0Fh]
0040106A   88   4D   FC   mov   byte   ptr   [ebp-4],cl
11:   a   =   p[1];
0040106D   8B   55   EC   mov   edx,dword   ptr   [ebp-14h]
00401070   8A   42   01   mov   al,byte   ptr   [edx+1]
00401073   88   45   FC   mov   byte   ptr   [ebp-4],al

第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，再根据edx读取字符，显然慢了。

2.7小结：

堆和栈的区别可以用如下的比喻来看出：

使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。

使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。