数据结构总结

一、线性表

1、线性表的顺序存储结构

（1）线性表顺序存储结构代码：

#define MAXSIZE 20    
typedef int ElemType;
typedef struct
{
ElemType data[MAXSIZE];
int length;    // 线性表当前长度
} SqList;

（2）获得元素操作

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;

// Status 是函数的类型，其值是函数结果状态代码，如OK等。
// 初始条件：顺序线性表L已存在，1 <= i <= ListLength(L)
// 操作结果：用e返回L中第i个数据元素的值。

Status GetElem(SqList L, int i, ElemType *e)
{
    if( L.length==0 || i<1 || i>L.length )
    {
        return ERROR;
    }
    *e = L.data[i-1];

    return OK;
}

（3）插入操作

/* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L)。 */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L长度+1。*/

Status ListInsert(SqList *L, int i, ElemType e)
{
    int k;

    if( L->length == MAXSIZE )  // 顺序线性表已经满了
    {
        return ERROR;
    }
    if( i<1 || i>L->length+1)   // 当i不在范围内时
    {
        return ERROR;
    }
    if( i <= L->length )   // 若插入数据位置不在表尾
    {
        /* 将要插入位置后数据元素向后移动一位 */
        for( k=L->length-1; k >= i-1; k-- )
        {
            L->data[k+1] = L->data[k];
        }
    }

    L->data[i-1] = e;  // 将新元素插入
    L->length++;

    return OK;
}

（4）删除操作

/* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度-1 */
Status ListDelete(SqList *L, int i, ElemType *e)
{
    int k;

    if( L->length == 0 )
    {
        return ERROR;
    }
    if( i<1 || i>L->length )
    {
        return ERROR;
    }

    *e = L->data[i-1];

    if( i < L->length )
    {
        for( k=i; k < L->length; k++ )
        {
            L->data[k-1] = L->data[k];
        }
    }

    L->length--;

    return OK;
}

 

2、单链表

（1）、单链表存储结构

typedef struct Node
{
ElemType data;      // 数据域
struct Node* Next;  // 指针域
} Node;
typedef struct Node* LinkList;

（2）单链表的读取

/* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */

Status GetElem( LinkList L, int i, ElemType *e )
{
    int j;
    LinkList p;

    p = L->next;
    j = 1;

    while( p && j<i )
    {
        p = p->next;
        ++j;
    }

    if( !p || j>i )
    {
        return ERROR;
    }

    *e = p->data;

    return OK;
}

（3）单链表的插入

/* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L) */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */

Status ListInsert(LinkList *L, int i, ElemType e)
{
    int j;
    LinkList p, s;

    p = *L;
    j = 1;

    while( p && j<i )   // 用于寻找第i个结点
    {
        p = p->next;
        j++;
    }

    if( !p || j>i )
    {
        return ERROR;
    }

    s = (LinkList)malloc(sizeof(Node));
    s->data = e;

    s->next = p->next;
    p->next = s;

    return OK;
}

（4）单链表的删除

/* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度-1 */

Status ListDelete(LinkList *L, int i, ElemType *e)
{
    int j;
    LinkList p, q;

    p = *L;
    j = 1;

    while( p->next && j<i )
    {
        p = p->next;
        ++j;
    }

    if( !(p->next) || j>i )
    {
        return ERROR;
    }

    q = p->next;
    p->next = q->next;

    *e = q->data;
    free(q);

    return OK;
}

（5）单链表的整表创建

a.头插法

/* 头插法建立单链表示例 */

void CreateListHead(LinkList *L, int n)
{
    LinkList p;
    int i;

    srand(time(0));   // 初始化随机数种子

    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;

    for( i=0; i < n; i++ )
    {
        p = (LinkList)malloc(sizeof(Node));  // 生成新结点
        p->data = rand()%100+1;
        p->next = (*L)->next;
        (*L)->next = p;
    }
}

b.尾插法

/* 尾插法建立单链表演示 */

void CreateListTail(LinkList *L, int n)
{
    LinkList p, r;
    int i;

    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;

    for( i=0; i < n; i++ )
    {
        p = (Node *)malloc(sizeof(Node));
        p->data = rand()%100+1;
        r->next = p;
        r = p;                 // 备注：初学者可能很难理解这句，重点解释。
    }

    r->next = NULL;
}

（6）单链表的整表删除

Status ClearList(LinkList *L)
{
    LinkList p, q;

    p = (*L)->next;

    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }

    (*L)->next = NULL;

    return OK;
}

 

3、静态链表

（1）线性表的静态链表存储结构

#define MAXSIZE 1000
typedef struct
{
ElemType data;  // 数据
int cur;        // 游标（Cursor）
} Component, StaticLinkList[MAXSIZE];

（2）静态链表进行初始化

Status InitList(StaticLinkList space)
{
int i;
for( i=0; i < MAXSIZE-1; i++ )
space[i].cur = i + 1;

space[MAXSIZE-1].cur = 0;

return OK;
}

（3）获得空闲分量的下标

int Malloc_SLL(StaticLinkList space)
{
int i = space[0].cur;
if( space[0].cur )
space[0].cur = space[i].cur;
   // 把它的下一个分量用来作为备用。
return i;
}

（4）静态链表的插入

/* 在静态链表L中第i个元素之前插入新的数据元素e */

Status ListInsert( StaticLinkList L, int i, ElemType e )
{
    int j, k, l;

    k = MAX_SIZE - 1;    // 数组的最后一个元素
    if( i<1 || i>ListLength(L)+1 )
    {
        return ERROR;
    }

    j = Malloc_SLL(L);
    if( j )
    {
        L[j].data = e;
        for( l=1; l <= i-1; l++ )
        {
            k = L[k].cur;
        }
        L[j].cur = L[k].cur;
        L[k].cur = j;

        return OK;
    }

    return ERROR;
}

（5）静态链表的删除操作

/* 删除在L中的第i个数据元素 */
Status ListDelete(StaticLinkList L, int i)
{
    int j, k;

    if( i<1 || i>ListLength(L) )
    {
        return ERROR;
    }

    k = MAX_SIZE - 1;

    for( j=1; j <= i-1; j++ )
    {
        k = L[k].cur;    // k1 = 1, k2 = 5
    }

    j = L[k].cur;        // j = 2
    L[k].cur = L[j].cur;

    Free_SLL(L, j);

    return OK;
}

/* 将下标为k的空闲结点回收到备用链表 */
void Free_SLL(StaticLinkList space, int k)
{
    space[k].cur = space[0].cur;
    space[0].cur = k;
}

/* 返回L中数据元素个数 */
int ListLength(StaticLinkList L)
{
    int j = 0;
    int i = L[MAXSIZE-1].cur;

    while(i)
    {
        i = L[i].cur;
        j++;
    }

    return j;
}

 

4、循环链表

（1）初始化部分

/*初始化循环链表*/
void ds_init(node **pNode)
{
    int item;
    node *temp;
    node *target;

    printf("输入结点的值，输入0完成初始化\n");

    while(1)
    {
        scanf("%d", &item);
        fflush(stdin);

        if(item == 0)
            return;

        if((*pNode) == NULL)
        { /*循环链表中只有一个结点*/
            *pNode = (node*)malloc(sizeof(struct CLinkList));
            
            if(!(*pNode))
                exit(0);
            
            (*pNode)->data = item;
            (*pNode)->next = *pNode;
        }
        else
        {
            /*找到next指向第一个结点的结点*/
            for(target = (*pNode); target->next != (*pNode); target = target->next)
                ;

            /*生成一个新的结点*/
            temp = (node *)malloc(sizeof(struct CLinkList));

            if(!temp)
                exit(0);

            temp->data = item;
            temp->next = *pNode;
            target->next = temp;
        }
    }
}

（2）插入部分

/*链表存储结构的定义*/
typedef struct CLinkList
{
    int data;
    struct CLinkList *next;
}node;

/*插入结点*/
/*参数：链表的第一个结点，插入的位置*/
void ds_insert(node **pNode , int i)
{
    node *temp;
    node *target;
    node *p;
    int item;
    int j = 1;

    printf("输入要插入结点的值:");
    scanf("%d", &item);

    if(i == 1)
    { //新插入的结点作为第一个结点
        temp = (node *)malloc(sizeof(struct CLinkList));

        if(!temp)
            exit(0);

        temp->data = item;

        /*寻找到最后一个结点*/
        for(target = (*pNode); target->next != (*pNode); target = target->next)
            ;

        temp->next = (*pNode);
        target->next = temp;
        *pNode = temp;
    }
    else
    {
        target = *pNode;

        for( ; j < (i-1); ++j )
        {
            target = target->next;
        }  
        
        // target指向第三个元素的
        
        temp = (node *)malloc(sizeof(struct CLinkList));

        if(!temp)
            exit(0);

        temp->data = item;
        
        p = target->next;
        target->next = temp;
        temp->next = p;
    }
}

（3）删除部分

/*删除结点*/
void ds_delete(node **pNode, int i)
{
    node *target;
    node *temp;
    int j = 1;

    if(i == 1)
    { //删除的是第一个结点
        /*找到最后一个结点*/
        for(target = *pNode; target->next != *pNode;target = target->next)
            ;

        temp = *pNode;
        *pNode = (*pNode)->next;
        target->next = *pNode;
        free(temp);
    }
    else
    {
        target = *pNode;

        for( ; j < i-1; ++j)
        {
            target = target->next;
        }
        
        temp = target->next;
        target->next = temp->next;
        free(temp);
    }
}

（4）返回结点所在位置

/*返回结点所在位置*/
int ds_search(node *pNode, int elem)
{
    node *target;
    int i = 1;

    for(target = pNode; target->data != elem && target->next != pNode; ++i)
    {
        target = target->next;
    }
    
    if(target->next == pNode) /*表中不存在该元素*/
        return 0;
    else
        return i;
}

 

5、双向链表

（1）双向链表结点结构

typedef struct DualNode
{
ElemType data;
struct DualNode *prior;  //前驱结点
struct DualNode *next;   //后继结点
} DualNode, *DuLinkList;

（2）双向链表的插入操作

s->next = p;    
s->prior = p->prior;    
p->prior->next = s;    
p->prior = s;

（3）双向链表的删除操作

p->prior->next = p->next;
p->next->prior = p->prior;    
free(p);

 

 

 

 

 

二、栈

1、栈

（1）栈的顺序存储结构

typedef struct
{
ElemType *base;
ElemType *top;
int stackSize;
}sqStack;

（2）创建一个栈

#define STACK_INIT_SIZE 100
initStack(sqStack *s)
{
s->base = (ElemType *)malloc( STACK_INIT_SIZE * sizeof(ElemType) );
if( !s->base )
exit(0);
s->top = s->base;   // 最开始，栈顶就是栈底
s->stackSize = STACK_INIT_SIZE;
}

（3）入栈操作

#define SATCKINCREMENT 10

Push(sqStack *s, ElemType e)
{
    // 如果栈满，追加空间
    if( s->top – s->base >= s->stackSize )
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if( !s->base )
            exit(0);

        s->top = s->base + s->stackSize;              // 设置栈顶
        s->stackSize = s->stackSize + STACKINCREMENT; // 设置栈的最大容量
    }

    *(s->top) = e;
    s->top++;
}

（4）出栈操作

Pop(sqStack *s, ElemType *e)
{
if( s->top == s->base )  // 栈已空空是也
return;
*e = *--(s->top);
}

（5）销毁一个栈

DestroyStack(sqStack *s){
int i, len;
len = s->stackSize;
for( i=0; i < len; i++ ){
free( s->base );
s->base++;
}
s->base = s->top = NULL;
s->stackSize = 0;
}

（6）计算栈的当前容量

int StackLen(sqStack s)
{
return(s.top – s.base);  // 初学者需要重点讲解
}

 

2、栈的链式存储结构

（1）栈的链式存储结构

teypedef struct StackNode
{
ElemType data;    // 存放栈的数据
struct StackNode *next;
} StackNode, *LinkStackPtr;
teypedef struct LinkStack
{
LinkStackPrt top;    // top指针
int count;        // 栈元素计数器
}

（2）进栈操作

Status Push(LinkStack *s, ElemType e)
{
LinkStackPtr p = (LinkStackPtr) malloc (sizeof(StackNode));
p->data = e;
p->next = s->top;
s->top = p;
s->count++;
return OK;
}

（3）出栈操作

Status Pop(LinkStack *s, ElemType *e)
{
LinkStackPtr p;
if( StackEmpty(*s) )  // 判断是否为空栈
return ERROR;
*e = s->top->data;
p = s->top;
s->top = s->top->next;
free(p);
s->count--;
return OK;
}

 

 

 

 

 

 

 

三、队列

1、队列

（1）创建一个队列

initQueue(LinkQueue *q)
{
q->front=q->rear=(QueuePtr)malloc(sizeof(QNode));
if( !q->front )
        exit(0);
q->front->next = NULL;
}

（2）入队列操作

InsertQueue(LinkQueue *q, ElemType e)
{
QueuePtr p;
p = (QueuePtr)malloc(sizeof(QNode));
if( p == NULL )
exit(0);
p->data = e;
p->next = NULL;
q->rear->next = p;
q->rear = p;
}

（3）出队列操作

DeleteQueue(LinkQueue *q, ELemType *e)
{
QueuePtr p;
if( q->front == q->rear )
return;
p = q->front->next;
*e = p->data;
q->front->next = p->next;
if( q->rear == p )
q->rear = q->front;
free(p);
}

（4）销毁一个队列

DestroyQueue(LinkQueue *q)
{
while( q->front ) {
q->rear = q->front->next;
free( q->front );
q->front = q->rear;
}
}

 

2、循环队列

（1）定义一个循环队列

#define MAXSIZE 100
typedef struct
{
ElemType *base; // 用于存放内存分配基地址
            // 这里你也可以用数组存放
int front;
int rear;
}

（2）初始化一个循环队列

initQueue(cycleQueue *q)
{
q->base = (ElemType *) malloc (MAXSIZE * sizeof(ElemType));
if( !q->base )
exit(0);
q->front = q->rear = 0;
}

（3）入队列操作

InsertQueue(cycleQueue *q, ElemType e)
{
if( (q->rear+1)%MAXSIZE == q->front )
return; // 队列已满
q->base[q->rear] = e;
q->rear = (q->rear+1) % MAXSIZE;
}

（4）出队列操作

DeleteQueue(cycleQueue *q, ElemType *e)
{
if( q->front == q->rear )
return ; // 队列为空
*e = q->base[q->front];
q->front = (q->front+1) % MAXSIZE;
}

 

 

 

 

四、递归

1、斐波那契数列的递归实现

 /*
      0，当n=0
F(n) =   1，当n=1
         F(n-1)+F(n-2)，当n>1
*/
int Fib(int i)
{
    if( i < 2 )
        return i == 0 ? 0 : 1;
    return Fib(i-1) + Fib(i-2);
}

2、计算n的阶乘n!

  /*
      1            n = 0
n! = 
          n*(n-1)    n > 0
*/

int  factorial( n )
{
if( 0 == n )    return 1;
else   return  n * factorial( n - 1 );
}

3、实现将输入的任意长度的字符串反向输出的功能。

/*
将“#”作为一个输入结束的条件。
*/
void print()
{
    char a;
    scanf(“%c”, &a);
if( a !=‘#’)  print();
if( a !=‘#’)  printf(“%c”, a);
}

 

 

 

 

五、字符串

（1）BF算法

有两个字符串S和T，长度为N和M。首先S[1]和T[1]比较，若相等，则再比较S[2]和T[2]，一直到T[M]为止；若S[1]和T[1]不等，则T向右移动一个字符的位置，再依次进行比较。

// 返回子串T在主串S中第pos个字符之后的位置
// 若不存在，则返回0
// T非空，1 <= pos <= strlen(S)
// 注意：我们这里为了表述方便，字符串使用了第一个元素表示长度的方式。

int index( String S, String T, int pos )
{
    int i = pos;    // i用于主串S中当前位置下标
    int j = 1;        // j用于子串T中当前位置下标
    
    while( i <= S[0] && j <= T[0] )    // i或j其中一个到达尾部即终止搜索！
    {
        if( S[i] == T[i] )    // 若相等则继续下一个元素匹配
        {
            i++;
            j++;
        }
        else                // 若失配则j回溯到第一个元素从新匹配
        {
            i = i-j+2;        // i回溯到上次匹配首位的下一个元素，这是效率低下的关键！
            j = 1;
        }
    }
    
    if( j > T[0] )
    {
        return i - T[0];
    }
    else
    {
        return 0;
    }
}

 

 

 

 

六、数

1、双亲表示法

// 树的双亲表示法结点结构定义
#define MAX_TREE_SIZE 100

typedef int ElemType;

typedef struct PTNode
{
    ElemType data;    // 结点数据
    int parent;        // 双亲位置
}PTNode;

typedef struct
{
    PTNode nodes[MAX_TREE_SIZE];
    int r;            // 根的位置
    int n;            // 结点数目
}PTree;

 2、孩子表示法

#define MAX_TREE_SIZE     100

typedef char ElemType;

// 孩子结点
typedef struct CTNode
{
    int child;                // 孩子结点的下标
    struct CTNode *next;    // 指向下一个孩子结点的指针
} *ChildPtr;

// 表头结构
typedef struct
{    
    ElemType data;            // 存放在树中的结点的数据
    int parent;                // 存放双亲的下标
    ChildPtr firstchild;    // 指向第一个孩子的指针
} CTBox;

// 树结构
typedef struct
{
    CTBox nodes[MAX_TREE_SIZE];    // 结点数组
    int r, n;
}

3、孩纸兄弟表示法

/*
孩纸兄弟表示法
*/
typedef struct CSNode
{
    TElemType data;
    struct CSNode *firstchild,*rightsib;//第一个孩纸，和它右边的孩纸
}CSNode,*CSTree;

 4、二叉树的儿茶链表结点结构定义

/*
二叉树的二叉链表结点结构定义
*/

typedef struct BiTNode
{
    TElemType data;//结点数据
    struct BiTNode *lchild,*rchild;//左右孩纸
}BiTNode,*BiTree;

5、二叉树前序遍历法

/*
二叉树前序遍历法
*/
void PreOrderTraverse(BiTree T)
{
    if(T==ULL)
        return;

    printf("%c",T->data);//显示结点数据，可以更改为其他队结点操作

    PreOrderTraverse(T->lchild);//再先序遍历左子树

    PreOrderTraverse(T->rchild);//最后先序右子树

}

6、二叉中序遍历算法

/*
二叉树中序遍历算法
*/

void InOrderTraverse(BiTree T)
{
    if(T==NULL)
        return;

    InOrderTraverse(T->lchild);//中序遍历左子树

    printf("%c",T->data);//显示节点数据，可以更改为其他对结点操作

    InOrderTraverse(T->rchild);//最后中序遍历右子树
}

 7、二叉后序遍历算法

/*
二叉后序遍历递归算法
*/

void PostOrderTraverse(BiTree T)
{
    if(T==NULL)
        return;

    PostOrderTraverse(T->lchild)//先后序遍历左子树

    PostOrderTraverse(T->rchild);//再后序遍历右子树

    printf("%c",T->data);//显示结点数据，可以更改为其他对结点操作

}

 8、二叉树的建立

/*
二叉树的建立,按前序输入二叉树中结点的值，#表示空树链表表示二叉数T
*/
void CreateBiTree(BiTree *T)
{
    TElemType ch;
    scanf("%c",&ch);//输入字符串

    if(ch=='#')//如果是空树
       *T=NULL;

    else
    {
        *T=(BiTree)malloc(sizeof(BiTNode));//获取空间

        if(!*T)
            exit(OVERFLOW);

        (*T)->data=ch;//生成根结点
        CreateBiTree(&(*T>lhild);//构造左子树
        CreateBiTree(&(*T>rhild);//构造右子树
    }

}

 9、线索二叉树结构定义

/*
线索二叉树结构定义
*/

typedef enum
{
    Link,//Link==0表示指向左右孩纸指针
    Thread//Thread==1表示指向前驱或后继的线索
}PointerTag;

typedef struct BitThrNode
{
    TElemType data;//结点标志
    struct BiThrNode *lchilde,*rchild;//左右孩纸指针
    PointerTag LTag;
    PointerTag RTag;//左右标志
}BitThrNode,*BitThrTree;

10、中序遍历线索化的递归函数

/*
中序遍历线索化的递归函数
*/
void InThreading(BiThrTree p)
{
    if(p)
    {
        InTreading(p->lchild);//递归左子树线索花

        if(!p->lchild)//没有左孩纸
        {
            p->LTag=Thread;//前驱线索
            p->child=pre;//左孩纸指针指向前驱
        }

        if(!pre->rchild)//没有右孩纸
        {
            pre->RTag=Thread;//后继线索
            pre->rchild=p;//前驱右孩纸指针指向后继
        }

        pre=p;//保持pre指向p的前驱

        InThreading(p->rchild);//递归右子树线索化

    }
}

11、遍历

/*
T指向头结点，头结点左链lchild指向根结点，头结点右链rchild指向中序遍历的，最后一个结点。
中序遍历二叉线索链表表示的二叉树T
*/


Status InOrderTraverse_Thr(BiThrTree T)
{
    BiThrTree p;
    p=T->child;//p指向根结点

    while(p!=T)//空树或遍历结束时，p==T
    {
        while(p->LTag==Link)//当LTag==0时循环到中序序列第一个节点
            p=p->lchild;

        printf("%c",p->data);//显示结点数据，可以更改为其他对结点操作

        while(p->RTag==Thread && p->rchild!=T)
        {
            p=p->rchild;
            printf("%c",p->data);
        }

        p=p->child;//p进至其右子树根
    }

    return OK;
}