更新数据结构代码

DataStructure/BinaryTree.cpp

@@ -0,0 +1,196 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+#define TRUE 1
+#define FALSE 0
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -1
+#define SUCCESS 1
+#define UNSUCCESS 0
+
+#define dataNum 5
+int i = 0;
+int dep = 0;
+char data[dataNum] = { 'A', 'B', 'C', 'D', 'E' };
+
+typedef int Status;
+typedef char TElemType;
+
+typedef struct BiTNode
+{
+    TElemType data;
+    struct BiTNode *lchild, *rchild;
+}BiTNode, *BiTree;
+
+void InitBiTree(BiTree &T);                                //创建一颗空二叉树
+BiTree MakeBiTree(TElemType e, BiTree L, BiTree R);        //创建一颗二叉树T，其中根节点的值为e，L和R分别作为左子树和右子树
+void DestroyBiTree(BiTree &T);                            //销毁二叉树
+Status BiTreeEmpty(BiTree T);                            //对二叉树判空。若为空返回TRUE，否则FALSE
+Status BreakBiTree(BiTree &T, BiTree &L, BiTree &R);    //将一颗二叉树T分解成根、左子树、右子树三部分
+Status ReplaceLeft(BiTree &T, BiTree &LT);                //替换左子树。若T非空，则用LT替换T的左子树，并用LT返回T的原有左子树
+Status ReplaceRight(BiTree &T, BiTree &RT);                //替换右子树。若T非空，则用RT替换T的右子树，并用RT返回T的原有右子树
+
+int Leaves(BiTree T);
+int Depth(BiTree T);
+
+Status visit(TElemType e);
+void UnionBiTree(BiTree &Ttemp);
+
+
+//InitBiTree空二叉树是只有一个BiTree指针？还是有一个结点但结点域为空？
+void InitBiTree(BiTree &T)
+{
+    T = NULL;
+}
+
+BiTree MakeBiTree(TElemType e, BiTree L, BiTree R)
+{
+    BiTree t;
+    t = (BiTree)malloc(sizeof(BiTNode));
+    if (NULL == t) return NULL;
+    t->data = e;
+    t->lchild = L;
+    t->rchild = R;
+    return t;
+}
+      
+Status visit(TElemType e)
+{
+    printf("%c", e);
+    return OK;
+}
+
+
+int Leaves(BiTree T)   //对二叉树T求叶子结点数目
+{
+    int l = 0, r = 0;
+
+    if (NULL == T) return 0;
+    if (NULL == T->lchild && NULL == T->rchild) return 1;
+
+    //问题分解，2个子问题
+
+
+    //求左子树叶子数目
+    l = Leaves(T->lchild);
+
+    //求右子树叶子数目
+    r = Leaves(T->rchild);
+
+    //组合
+    return r + l;
+}
+
+int depTraverse(BiTree T)    //层次遍历：dep是个全局变量,高度
+{
+    if (NULL == T) return ERROR;
+
+    dep = (depTraverse(T->lchild) > depTraverse(T->rchild)) ? depTraverse(T->lchild) : depTraverse(T->rchild);
+
+    return dep + 1;
+}
+
+
+void levTraverse(BiTree T, Status(*visit)(TElemType e), int lev) //高度遍历：lev是局部变量，层次
+{
+    if (NULL == T) return;
+
+    visit(T->data);
+    printf("的层次是%d\n", lev);
+
+    levTraverse(T->lchild, visit, ++lev);
+    levTraverse(T->rchild, visit, lev);
+
+}
+
+void InOrderTraverse(BiTree T, Status(*visit)(TElemType e), int &num) //num是个全局变量
+{
+    if (NULL == T) return;
+    visit(T->data);
+    if (NULL == T->lchild && NULL == T->rchild) { printf("是叶子结点"); num++; }
+    else printf("不是叶子结点");
+    printf("\n");
+    InOrderTraverse(T->lchild, visit, num);
+    InOrderTraverse(T->rchild, visit, num);
+}
+
+Status BiTreeEmpty(BiTree T)
+{
+    if (NULL == T) return TRUE;
+    return FALSE;
+}
+
+Status BreakBiTree(BiTree &T, BiTree &L, BiTree &R)
+{
+    if (NULL == T) return ERROR;
+    L = T->lchild;
+    R = T->rchild;
+    T->lchild = NULL;
+    T->rchild = NULL;
+    return OK;
+}
+
+Status ReplaceLeft(BiTree &T, BiTree &LT)
+{
+    BiTree temp;
+    if (NULL == T) return ERROR;
+    temp = T->lchild;
+    T->lchild = LT;
+    LT = temp;
+    return OK;
+}
+
+Status ReplaceRight(BiTree &T, BiTree &RT)
+{
+    BiTree temp;
+    if (NULL == T) return ERROR;
+    temp = T->rchild;
+    T->rchild = RT;
+    RT = temp;
+    return OK;
+}
+
+void UnionBiTree(BiTree &Ttemp)
+{
+    BiTree L = NULL, R = NULL;
+    L = MakeBiTree(data[i++], NULL, NULL);
+    R = MakeBiTree(data[i++], NULL, NULL);
+    ReplaceLeft(Ttemp, L);
+    ReplaceRight(Ttemp, R);
+}
+
+
+int main()
+{
+
+    BiTree T = NULL, Ttemp = NULL;
+
+    InitBiTree(T);
+    if (TRUE == BiTreeEmpty(T)) printf("初始化T为空\n");
+    else printf("初始化T不为空\n");
+
+    T = MakeBiTree(data[i++], NULL, NULL);
+
+    Ttemp = T;
+    UnionBiTree(Ttemp);
+
+    Ttemp = T->lchild;
+    UnionBiTree(Ttemp);
+
+
+    Status(*visit1)(TElemType);
+    visit1 = visit;
+    int num = 0;
+    InOrderTraverse(T, visit1, num);
+    printf("叶子结点是 %d\n", num);
+
+    printf("叶子结点是 %d\n", Leaves(T));
+
+    int lev = 1;
+    levTraverse(T, visit1, lev);
+
+    printf("高度是 %d\n", depTraverse(T));
+                          
+    return 0;
+}

DataStructure/HashTable.cpp

@@ -0,0 +1,161 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+#define SUCCESS 1
+#define UNSUCCESS 0
+#define OVERFLOW -1
+#define OK 1
+#define ERROR -1
+
+typedef int Status;
+typedef int KeyType;
+
+typedef struct{
+    KeyType key;
+}RcdType;
+
+typedef struct{
+    RcdType *rcd;
+    int size;
+    int count;
+    int *tag;
+}HashTable;
+
+int hashsize[] = { 11, 31, 61, 127, 251, 503 };
+int index = 0;
+
+Status InitHashTable(HashTable &H, int size){
+    int i;
+    H.rcd = (RcdType *)malloc(sizeof(RcdType)*size);
+    H.tag = (int *)malloc(sizeof(int)*size);
+    if (NULL == H.rcd || NULL == H.tag) return OVERFLOW;
+    for (i = 0; i< size; i++)  H.tag[i] = 0;
+    H.size = size;
+    H.count = 0;
+    return OK;
+}
+
+int Hash(KeyType key, int m){
+    return (3 * key) % m;
+}
+
+void collision(int &p, int m){  //线性探测
+    p = (p + 1) % m;
+}
+
+Status SearchHash(HashTable H, KeyType key, int &p, int &c) {
+    p = Hash(key, H.size);
+    int h = p;
+    c = 0;
+    while ((1 == H.tag[p] && H.rcd[p].key != key) || -1 == H.tag[p]){
+        collision(p, H.size);  c++;
+    }
+
+    if (1 == H.tag[p] && key == H.rcd[p].key) return SUCCESS;
+    else return UNSUCCESS;
+
+}
+
+void printHash(HashTable H) //打印哈希表
+{
+    int  i;
+    printf("key : ");
+    for (i = 0; i < H.size; i++)
+        printf("%3d ", H.rcd[i].key);
+    printf("\n");
+    printf("tag : ");
+    for (i = 0; i < H.size; i++)
+        printf("%3d ", H.tag[i]);
+    printf("\n\n");
+}
+
+Status InsertHash(HashTable &H, KeyType key);  //对函数的声明
+
+//重构
+Status recreateHash(HashTable &H){
+    RcdType *orcd;
+    int *otag, osize, i;
+    orcd = H.rcd;
+    otag = H.tag;                
+    osize = H.size;     
+                                
+    InitHashTable(H, hashsize[index++]);
+    //把所有元素，按照新哈希函数放到新表中
+    for (i = 0; i < osize; i++){
+        if (1 == otag[i]){     
+            InsertHash(H, orcd[i].key);
+        }
+    }
+}
+
+Status InsertHash(HashTable &H, KeyType key){
+    int p, c;
+    if (UNSUCCESS == SearchHash(H, key, p, c)){ //没有相同key
+        if (c*1.0 / H.size < 0.5){ //冲突次数未达到上线
+            //插入代码
+            H.rcd[p].key = key;
+            H.tag[p] = 1;
+            H.count++;        
+            return SUCCESS;
+         }
+         else recreateHash(H); //重构哈希表 
+    }
+    return UNSUCCESS;
+}
+   
+Status DeleteHash(HashTable &H, KeyType key){
+    int p, c;
+    if (SUCCESS == SearchHash(H, key, p, c)){
+        //删除代码
+        H.tag[p] = -1;
+        H.count--;
+          
+        
+        return SUCCESS;
+    }
+    else return UNSUCCESS;
+}
+
+void main()
+{
+    printf("-----哈希表-----\n");
+    HashTable H;
+    int i;
+    int size = 11;
+    KeyType array[8] = { 22, 41, 53, 46, 30, 13, 12, 67 };
+    KeyType key;      
+    RcdType e;
+    
+    //初始化哈希表
+    printf("初始化哈希表\n");
+    if (SUCCESS == InitHashTable(H, hashsize[index++])) printf("初始化成功\n");
+    
+    //插入哈希表
+    printf("插入哈希表\n");
+    for (i = 0; i <= 7; i++){
+        key = array[i];
+        InsertHash(H, key);
+        printHash(H);
+    }
+    
+    //删除哈希表
+    printf("删除哈希表\n");
+    int p, c;                            
+    if (SUCCESS == DeleteHash(H, 12)) {
+        printf("删除成功，此时哈希表为：\n");
+        printHash(H);
+    }
+    
+    //查询哈希表
+    printf("查询哈希表\n");
+    if (SUCCESS == SearchHash(H, 67, p, c)) printf("查询成功\n");
+    
+    //再次插入，测试哈希表的重构
+    printf("再次插入，测试哈希表的重构：\n");
+    KeyType array1[8] = { 27, 47, 57, 47, 37, 17, 93, 67 };        
+    for (i = 0; i <= 7; i++){
+        key = array1[i];
+        InsertHash(H, key);
+        printHash(H);
+    }    
+}

DataStructure/LinkList.cpp

@@ -0,0 +1,152 @@
+/**
+* @author huihut
+* @E-mail:huihut@outlook.com
+* @version 创建时间：2016年9月18日
+* 说明：本程序实现了一个单链表。
+*/
+
+#include "stdio.h"
+#include "stdlib.h"
+#include "malloc.h"
+
+//5个常量定义
+#define TRUE 1
+#define FALSE 0
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -1
+
+//类型定义
+typedef int Status;
+typedef int ElemType;
+
+//测试程序长度定义
+#define LONGTH 5
+
+//链表的类型
+typedef struct LNode {
+    ElemType data;
+    struct LNode *next;
+} LNode, *LinkList; 
+
+Status InitList_L(LinkList &L);
+Status DestroyList_L(LinkList &L);
+Status ClearList_L(LinkList &L);
+Status ListEmpty_L(LinkList L);
+int ListLength_L(LinkList L);
+LNode* Search_L(LinkList L, ElemType e);
+LNode* NextElem_L(LNode *p);
+Status InsertAfter_L(LNode *p, LNode *q);
+Status DeleteAfter_L(LNode *p, ElemType &e);
+void ListTraverse_L(LinkList L, Status(*visit)(ElemType e));
+
+
+//创建包含n个元素的链表L，元素值存储在data数组中
+Status create(LinkList &L, ElemType *data, int n) {
+    LNode *p, *q;
+    int i;
+    if (n < 0) return ERROR;
+    L = NULL;
+    p = L;
+    for (i = 0; i < n; i++)
+    {
+        q = (LNode *)malloc(sizeof(LNode));
+        if (NULL == q) return OVERFLOW;
+        q->data = data[i];
+        q->next = NULL;
+        if (NULL == p) L = q;
+        else p->next = q;
+        p = q;
+    }
+    return OK;
+}
+
+//e从链表末尾入链表
+Status EnQueue_LQ(LinkList &L, ElemType &e) {
+    LinkList p, q;
+
+    if (NULL == (q = (LNode *)malloc(sizeof(LNode)))) return OVERFLOW;
+    q->data = e;
+    q->next = NULL;
+    if (NULL == L) L = q;
+    else
+    {
+        p = L;
+        while (p->next != NULL)
+        {
+            p = p->next;
+        }
+        p->next = q;
+    }
+    return OK;
+}
+
+
+//从链表头节点出链表到e
+Status DeQueue_LQ(LinkList &L, ElemType &e) {
+    if (NULL == L) return ERROR;
+    LinkList p;
+    p = L;
+    e = p->data;
+    L = L->next;
+    free(p);
+    return OK;
+}
+
+//遍历调用
+Status visit(ElemType e) {
+    printf("%d\t", e);
+}
+
+//遍历单链表
+void ListTraverse_L(LinkList L, Status(*visit)(ElemType e))
+{
+    if (NULL == L) return;
+    for (LinkList p = L; NULL != p; p = p -> next) {
+        visit(p -> data);
+    }
+}
+
+int main() {
+    int i;
+    ElemType e, data[LONGTH] = { 1, 2, 3, 4, 5 };
+    LinkList L;
+
+    //显示测试值
+    printf("---【单链表】---\n");
+    printf("待测试元素为：\n");
+    for (i = 0; i < LONGTH; i++) printf("%d\t", data[i]);
+    printf("\n");
+
+    //创建链表L
+    printf("创建链表L\n");
+    if (ERROR == create(L, data, LONGTH))
+    {
+        printf("创建链表L失败\n");
+        return -1;
+    }
+    printf("成功创建包含%d个元素的链表L\n元素值存储在data数组中\n", LONGTH);
+
+    //遍历单链表
+    printf("此时链表中元素为：\n");
+    ListTraverse_L(L, visit);
+
+    //从链表头节点出链表到e
+    printf("\n出链表到e\n");
+    DeQueue_LQ(L, e);
+    printf("出链表的元素为：%d\n", e);
+    printf("此时链表中元素为：\n");
+    //遍历单链表
+    ListTraverse_L(L, visit);
+
+    //e从链表末尾入链表
+    printf("\ne入链表\n");
+    EnQueue_LQ(L, e);
+    printf("入链表的元素为：%d\n", e);
+    printf("此时链表中元素为：\n");
+    //遍历单链表
+    ListTraverse_L(L, visit);
+    printf("\n");
+
+    return 0;
+}

DataStructure/LinkList_with_head.cpp

@@ -0,0 +1,162 @@
+/**
+* @author huihut
+* @E-mail:huihut@outlook.com
+* @version 创建时间：2016年9月23日
+* 说明：本程序实现了一个具有头结点的单链表。
+*/
+
+#include "stdio.h"
+#include "stdlib.h"
+#include "malloc.h"
+
+//5个常量定义
+#define TRUE 1
+#define FALSE 0
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -1
+
+//类型定义
+typedef int Status;
+typedef int ElemType;
+
+//测试程序长度定义
+#define LONGTH 5
+
+//链表的类型
+typedef struct LNode {
+    ElemType data;
+    struct LNode *next;
+} LNode, *LinkList;
+     
+Status InitList_L(LinkList &L);
+Status DestroyList_L(LinkList &L);
+Status ClearList_L(LinkList &L);
+Status ListEmpty_L(LinkList L);
+int ListLength_L(LinkList L);
+LNode* Search_L(LinkList L, ElemType e);
+LNode* NextElem_L(LNode *p);
+Status InsertAfter_L(LNode *p, LNode *q);
+Status DeleteAfter_L(LNode *p, ElemType &e);
+void ListTraverse_L(LinkList L, Status(*visit)(ElemType e));
+
+
+//创建包含n个元素的链表L，元素值存储在data数组中
+Status create(LinkList &L, ElemType *data, int n) {
+    LNode *p, *q;
+    int i;
+    if (n < 0) return ERROR;    
+    p = L = NULL;
+    
+    q = (LNode *)malloc(sizeof(LNode));
+    if (NULL == q) return OVERFLOW;  
+    q->next = NULL;
+    p = L = q;
+        
+    for (i = 0; i < n; i++)
+    {
+        q = (LNode *)malloc(sizeof(LNode));
+        if (NULL == q) return OVERFLOW;
+        q->data = data[i];
+        q->next = NULL;      
+        p->next = q;
+        p = q;
+    }
+    return OK;
+}
+
+//e从链表末尾入链表
+Status EnQueue_LQ(LinkList &L, ElemType &e) {
+    LinkList p, q;
+
+    if (NULL == (q = (LNode *)malloc(sizeof(LNode)))) return OVERFLOW;
+    q->data = e;
+    q->next = NULL;
+    if (NULL == L)
+    {
+        L = (LNode *)malloc(sizeof(LNode));
+        if (NULL == L) return OVERFLOW;
+        L -> next = q;
+    }
+    else if (NULL == L->next) L = q;
+    else
+    {
+        p = L;
+        while (p->next != NULL)
+        {
+            p = p->next;
+        }
+        p->next = q;
+    }
+    return OK;
+}
+
+
+//从链表头节点出链表到e
+Status DeQueue_LQ(LinkList &L, ElemType &e) {
+    if (NULL == L || NULL == L->next) return ERROR;
+    LinkList p;
+    p = L->next;
+    e = p->data;
+    L->next = p->next;
+    free(p);
+    return OK;
+}
+
+//遍历调用
+Status visit(ElemType e) {
+    printf("%d\t", e);
+}
+
+//遍历单链表
+void ListTraverse_L(LinkList L, Status(*visit)(ElemType e))
+{
+    if (NULL == L || NULL == L->next) return;
+    for (LinkList p = L -> next; NULL != p; p = p -> next) {
+        visit(p -> data);
+    }
+}
+
+int main() {
+    int i;
+    ElemType e, data[LONGTH] = { 1, 2, 3, 4, 5 };
+    LinkList L;
+
+    //显示测试值
+    printf("---【有头结点的单链表】---\n");
+    printf("待测试元素为：\n");
+    for (i = 0; i < LONGTH; i++) printf("%d\t", data[i]);
+    printf("\n");
+
+    //创建链表L
+    printf("创建链表L\n");
+    if (ERROR == create(L, data, LONGTH))
+    {
+        printf("创建链表L失败\n");
+        return -1;
+    }
+    printf("成功创建包含1个头结点、%d个元素的链表L\n元素值存储在data数组中\n", LONGTH);
+
+    //遍历单链表
+    printf("此时链表中元素为：\n");
+    ListTraverse_L(L, visit);
+
+    //从链表头节点出链表到e
+    printf("\n出链表到e\n");
+    DeQueue_LQ(L, e);
+    printf("出链表的元素为：%d\n", e);
+    printf("此时链表中元素为：\n");
+    //遍历单链表
+    ListTraverse_L(L, visit);
+
+    //e从链表末尾入链表
+    printf("\ne入链表\n");
+    EnQueue_LQ(L, e);
+    printf("入链表的元素为：%d\n", e);
+    printf("此时链表中元素为：\n");
+    //遍历单链表
+    ListTraverse_L(L, visit);
+    printf("\n");
+
+    return 0;
+}

DataStructure/SqList.cpp

@@ -0,0 +1,192 @@
+
+/**
+* @author huihut
+* @E-mail:huihut@outlook.com
+* @version 创建时间：2016年9月9日
+* 说明：本程序实现了一个顺序表。
+*/
+
+#include "stdio.h"
+#include "stdlib.h"
+#include "malloc.h"
+
+//5个常量定义
+#define TRUE 1
+#define FALSE 0
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -1
+
+//测试程序长度定义
+#define LONGTH 5
+
+//类型定义
+typedef int Status;
+typedef int ElemType;
+
+//顺序栈的类型
+typedef struct {
+    ElemType *elem;
+    int length;
+    int size;
+    int increment;
+} SqList;
+
+Status InitList_Sq(SqList &L, int size, int inc);    //初始化顺序表L
+Status DestroyList_Sq(SqList &L);                     //销毁顺序表L
+Status ClearList_Sq(SqList &L);                         //将顺序表L清空
+Status ListEmpty_Sq(SqList L);                         //若顺序表L为空表，则返回TRUE，否则FALSE
+int ListLength_Sq(SqList L);                         //返回顺序表L中元素个数
+Status GetElem_Sq(SqList L, int i, ElemType &e);     //用e返回顺序表L中第i个元素的值
+int Search_Sq(SqList L, ElemType e);                 //在顺序表L顺序查找元素e，成功时返回该元素在表中第一次出现的位置，否则返回-1
+Status ListTraverse_Sq(SqList L, Status(*visit)(ElemType e));    //遍历顺序表L，依次对每个元素调用函数visit()
+Status PutElem_Sq(SqList &L, int i, ElemType e);     //将顺序表L中第i个元素赋值为e
+Status Append_Sq(SqList &L, ElemType e);             //在顺序表L表尾添加元素e
+Status DeleteLast_Sq(SqList &L, ElemType &e);         //删除顺序表L的表尾元素，并用参数e返回其值
+
+//初始化顺序表L
+Status InitList_Sq(SqList &L, int size, int inc) {
+    L.elem = (ElemType *)malloc(size * sizeof(ElemType));
+    if (NULL == L.elem) return OVERFLOW;
+    L.length = 0;
+    L.size = size;
+    L.increment = inc;
+    return OK;
+}
+
+//销毁顺序表L
+Status DestroyList_Sq(SqList &L) {
+    free(L.elem);
+    L.elem = NULL;
+    return OK;
+}
+
+//将顺序表L清空
+Status ClearList_Sq(SqList &L) {
+    if (0 != L.length) L.length = 0;
+    return OK;
+}
+
+//若顺序表L为空表，则返回TRUE，否则FALSE
+Status ListEmpty_Sq(SqList L) {
+    if (0 == L.length) return TRUE;
+    return FALSE;
+}
+
+//返回顺序表L中元素个数
+int ListLength_Sq(SqList L) {
+    return L.length;
+}
+
+// 用e返回顺序表L中第i个元素的值
+Status GetElem_Sq(SqList L, int i, ElemType &e) {
+    e = L.elem[--i];
+    return OK;
+}
+
+
+// 在顺序表L顺序查找元素e，成功时返回该元素在表中第一次出现的位置，否则返回 - 1
+int Search_Sq(SqList L, ElemType e) {
+    int i = 0;
+    while (i < L.length && L.elem[i] != e) i++;
+    if (i < L.length) return i;
+    else return -1;
+}
+
+//遍历调用
+Status visit(ElemType e) {
+    printf("%d\t",e);
+}
+
+//遍历顺序表L，依次对每个元素调用函数visit()
+Status ListTraverse_Sq(SqList L, Status(*visit)(ElemType e)) {
+    if (0 == L.length) return ERROR;
+    for (int i = 0; i < L.length; i++) {
+        visit(L.elem[i]);
+    }
+    return OK;
+}
+
+//将顺序表L中第i个元素赋值为e
+Status PutElem_Sq(SqList &L, int i, ElemType e) {
+    if (i > L.length) return ERROR;
+    e = L.elem[--i];
+    return OK;
+
+}
+
+//在顺序表L表尾添加元素e
+Status Append_Sq(SqList &L, ElemType e) {
+    if (L.length >= L.size) return ERROR;
+    L.elem[L.length] = e;
+    L.length++;
+    return OK;
+}
+
+//删除顺序表L的表尾元素，并用参数e返回其值
+Status DeleteLast_Sq(SqList &L, ElemType &e) {
+    if (0 == L.length) return ERROR;
+    e = L.elem[L.length - 1];
+    L.length--;
+    return OK;
+}
+
+int main() {
+    //定义表L
+    SqList L;
+
+    //定义测量值
+    int size, increment, i;
+
+    //初始化测试值
+    size = LONGTH;
+    increment = LONGTH;
+    ElemType e, eArray[LONGTH] = { 1, 2, 3, 4, 5 };
+
+    //显示测试值
+    printf("---【顺序栈】---\n");
+    printf("表L的size为：%d\n表L的increment为：%d\n", size, increment);
+    printf("待测试元素为：\n");
+    for (i = 0; i < LONGTH; i++) {
+        printf("%d\t", eArray[i]);
+    }
+    printf("\n");
+
+    //初始化顺序表
+    if (!InitList_Sq(L, size, increment)) {
+        printf("初始化顺序表失败\n");
+        exit(0);
+    }
+    printf("已初始化顺序表\n");
+
+    //判空
+    if(TRUE == ListEmpty_Sq(L)) printf("此表为空表\n");
+    else printf("此表不是空表\n");
+
+    //入表
+    printf("将待测元素入表：\n");
+    for (i = 0; i < LONGTH; i++) {
+        if(ERROR == Append_Sq(L, eArray[i])) printf("入表失败\n");;
+    }
+    printf("入表成功\n");
+
+    //遍历顺序表L
+    printf("此时表内元素为：\n");
+    ListTraverse_Sq(L, visit);
+    
+    //出表
+    printf("\n将表尾元素入表到e：\n");
+    if (ERROR == DeleteLast_Sq(L, e)) printf("出表失败\n");
+    printf("出表成功\n出表元素为%d\n",e);
+
+    //遍历顺序表L
+    printf("此时表内元素为：\n");
+    ListTraverse_Sq(L, visit);
+
+    //销毁顺序表
+    printf("\n销毁顺序表\n");
+    if(OK == DestroyList_Sq(L)) printf("销毁成功\n");
+    else printf("销毁失败\n");
+
+    return 0;
+}

DataStructure/SqStack.cpp

@@ -0,0 +1,159 @@
+/**
+* @author huihut
+* @E-mail:huihut@outlook.com
+* @version 创建时间：2016年9月9日
+* 说明：本程序实现了一个顺序栈。
+* 功能：有初始化、销毁、判断空、清空、入栈、出栈、取元素的操作。
+*/
+
+#include "stdio.h"
+#include "stdlib.h"
+#include "malloc.h"
+
+//5个常量定义
+#define TRUE 1
+#define FALSE 0
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -1
+
+//测试程序长度定义
+#define LONGTH 5
+
+//类型定义
+typedef int Status;
+typedef int ElemType; 
+
+//顺序栈的类型
+typedef struct {
+    ElemType *elem;
+    int top;
+    int size;
+    int increment;
+} SqSrack;
+
+//函数声明
+Status InitStack_Sq(SqSrack &S, int size, int inc);  //初始化顺序栈
+Status DestroyStack_Sq(SqSrack &S);                    //销毁顺序栈
+Status StackEmpty_Sq(SqSrack S);                    //判断S是否空，若空则返回TRUE，否则返回FALSE
+void ClearStack_Sq(SqSrack &S);                        //清空栈S
+Status Push_Sq(SqSrack &S, ElemType e);                //元素e压入栈S
+Status Pop_Sq(SqSrack &S, ElemType &e);                //栈S的栈顶元素出栈，并用e返回
+Status GetTop_Sq(SqSrack S, ElemType &e);            //取栈S的栈顶元素，并用e返回
+
+//初始化顺序栈
+Status InitStack_Sq(SqSrack &S, int size, int inc) {
+    S.elem = (ElemType *)malloc(size * sizeof(ElemType));
+    if (NULL == S.elem) return OVERFLOW;
+    S.top = 0;
+    S.size = size;
+    S.increment = inc;
+    return OK;
+}
+
+//销毁顺序栈
+Status DestroyStack_Sq(SqSrack &S) {
+    free(S.elem);
+    S.elem = NULL;
+    return OK;
+}
+
+//判断S是否空，若空则返回TRUE，否则返回FALSE
+Status StackEmpty_Sq(SqSrack S) {
+    if (0 == S.top) return TRUE;
+    return FALSE;
+}
+
+//清空栈S
+void ClearStack_Sq(SqSrack &S) {
+    if (0 == S.top) return;
+    S.size = 0;
+    S.top = 0;
+}
+
+//元素e压入栈S
+Status Push_Sq(SqSrack &S, ElemType e) {
+    ElemType *newbase;
+    if (S.top >= S.size) {
+        newbase = (ElemType *)realloc(S.elem, (S.size + S.increment) * sizeof(ElemType));
+        if (NULL == newbase) return OVERFLOW;
+        S.elem = newbase;
+        S.size += S.increment;
+    }
+    S.elem[S.top++] = e;
+    return OK;
+}
+
+//取栈S的栈顶元素，并用e返回
+Status GetTop_Sq(SqSrack S, ElemType &e) {
+    if (0 == S.top) return ERROR;
+    e = S.elem[S.top - 1];
+    return e;
+}
+
+//栈S的栈顶元素出栈，并用e返回
+Status Pop_Sq(SqSrack &S, ElemType &e) {
+    if (0 == S.top) return ERROR;
+    e = S.elem[S.top - 1];
+    S.top--;
+    return e;
+}
+
+int main() {
+    //定义栈S
+    SqSrack S;
+    
+    //定义测量值
+    int size, increment, i;
+
+    //初始化测试值
+    size = LONGTH;
+    increment = LONGTH;
+    ElemType e, eArray[LONGTH] = { 1, 2, 3, 4, 5 };
+
+    //显示测试值
+    printf("---【顺序栈】---\n");
+    printf("栈S的size为：%d\n栈S的increment为：%d\n", size, increment);
+    printf("待测试元素为：\n");
+    for (i = 0; i < LONGTH; i++) {
+        printf("%d\t", eArray[i]);
+    }
+    printf("\n");
+
+    //初始化顺序栈
+    if (!InitStack_Sq(S, size, increment)) {
+        printf("初始化顺序栈失败\n");
+        exit(0);
+    }
+    printf("已初始化顺序栈\n");
+
+    //入栈
+    for (i = 0; i < S.size; i++) {
+        if (!Push_Sq(S, eArray[i])) {
+            printf("%d入栈失败\n", eArray[i]);
+            exit(0);
+        }
+    }
+    printf("已入栈\n");
+
+    //判断非空
+    if(StackEmpty_Sq(S)) printf("S栈为空\n");
+    else printf("S栈非空\n");
+
+    //取栈S的栈顶元素    
+    printf("栈S的栈顶元素为：\n");
+    printf("%d\n", GetTop_Sq(S, e));    
+
+    //栈S元素出栈
+    printf("栈S元素出栈为：\n");
+    for (i = 0, e = 0; i < S.size; i++) {
+        printf("%d\t", Pop_Sq(S, e));
+    }  
+    printf("\n");
+
+    //清空栈S
+    ClearStack_Sq(S);
+    printf("已清空栈S\n"); 
+    
+    return 0;                              
+}

README.md

@@ -43,6 +43,8 @@
 
 #### 顺序栈（Sequence Stack）
 
+[SqStack.cpp](DataStructure/SqStack.cpp)
+
 ```cpp
 typedef struct {
 	ElemType *elem;
@@ -79,6 +81,8 @@ typedef struct {
 
 #### 顺序表（Sequence List）
 
+[SqList.cpp](DataStructure/SqList.cpp)
+
 ```cpp
 typedef struct {
 	ElemType *elem;
@@ -92,6 +96,10 @@ typedef struct {
 
 ### 链式结构
 
+[LinkList.cpp](DataStructure/LinkList.cpp)
+
+[LinkList_with_head.cpp](DataStructure/LinkList_with_head.cpp)
+
 ```cpp
 typedef struct LNode {
     ElemType data;
@@ -119,6 +127,8 @@ typedef struct LNode {
 
 ### 哈希表
 
+[HashTable.cpp](DataStructure/HashTable.cpp)
+
 #### 概念
 
 哈希函数：`H(key): K -> D , key ∈ K`
@@ -227,6 +237,8 @@ typedef struct GLNode1 {
 
 ### 二叉树
 
+[BinaryTree.cpp](DataStructure/BinaryTree.cpp)
+
 #### 性质
 
 1. 非空二叉树第 i 层最多 2^(i-1) 个结点 (i >= 1)
@@ -240,6 +252,14 @@ typedef struct GLNode1 {
 
 #### 存储结构
 
+```cpp
+typedef struct BiTNode
+{
+    TElemType data;
+    struct BiTNode *lchild, *rchild;
+}BiTNode, *BiTree;
+```
+
 ##### 顺序存储
 
 ![](images/SqBinaryTree.png)
@@ -269,7 +289,7 @@ typedef struct GLNode1 {
     * LR型：根的左孩子左旋，再右旋
     * RL型：右孩子的左子树，先右旋，再左旋
 
-### 森林
+### 其他树及森林
 
 #### 树的存储结构
 
@@ -281,12 +301,14 @@ typedef struct GLNode1 {
 
 一种不相交的子集所构成的集合 S = {S1, S2, ..., Sn}
 
+#### 平衡二叉树（AVL树）
+
+#### 红黑树
+
 #### B树
 
 #### B+树
 
-#### 红黑树
-
 #### 八叉树
 
 ### 图