链表、链式栈、链式队列、二叉树的C简要实现

最新推荐文章于 2023-05-07 20:20:04 发布

HWHuangeian

最新推荐文章于 2023-05-07 20:20:04 发布

阅读量829

点赞数 1

分类专栏：数据结构与算法文章标签：单链表栈队列

本文链接：https://blog.csdn.net/HWHuangeian/article/details/50766921

版权

数据结构与算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

/*单链表简要实现  
 *  
 *  
 */    
#include <stdio.h>        
#include <stdlib.h>        
      
struct Node;      
typedef struct Node* PtrToNode;      
typedef PtrToNode List;      
typedef PtrToNode Position;      
typedef int ElementType;      
      
struct Node{      
    ElementType data;      
    Position Next;      
};      
      
/*整表创建（头插法）*/      
List CreateList_Pre();      
/*整表创建（尾插法）*/      
List CreateList_Bac();      
/*整表删除*/      
void DeleteList(List L);      
/*得到当前链表的长度*/      
int ListLength(List L);      
/*得到指定位置的元素*/      
int getElement(List L, ElementType i);      
/*插入指定值到指定位置前面*/      
void Insert_Pre(List L, ElementType element, int i);      
/*插入指定值到指定位置后面*/      
void Insert_Bac(List L, ElementType element, int i);      
/*删除指定位置的元素*/      
void Delete(List L, ElementType i);      
/*遍历链表*/      
void ListTraverse(List L);      
      
List CreateList_Pre(){      
    Position NewNode;      
    List L = malloc(sizeof(struct Node));      
      
    if (L == NULL)      
        return;      
    L->Next = NULL;      
      
    for (int i = 1; i <= 10; i++){      
        NewNode = malloc(sizeof(struct Node));      
        NewNode->data = i;      
        NewNode->Next = L->Next;      
        L->Next = NewNode;      
    }      
    return L;      
}      
      
List CreateList_Bac(){      
    Position NewNode;      
    Position FirstNode;      
    List L = malloc(sizeof(struct Node));      
    FirstNode = L;      
      
    if (L == NULL)      
        return;      
      
    for (int i = 1; i <= 10; i++){      
        NewNode = malloc(sizeof(struct Node));      
        NewNode->data = i;      
        L->Next = NewNode;      
        L = NewNode;      
    }      
    L->Next = NULL;      
    return FirstNode;      
}      
      
void DeleteList(List L){      
    Position P, Q;      
    P = L->Next;      
      
    while (P != NULL){      
        Q = P->Next;      
        free(P);      
        P = Q;      
    }      
    L->Next = NULL;      
}      
      
int ListLength(List L){      
    Position P;      
    int count = 0;      
    P = L->Next;      
      
    while (P != NULL){      
        P = P->Next;      
        count++;      
    }      
    return count;      
}      
      
int getElement(List L, ElementType i){      
    Position P;      
    int count = 1;      
    P = L->Next;      
      
    if (P == NULL && i < count)      
        return;      
      
    while (P != NULL && i > count){      
        P = P->Next;      
        count++;      
    }      
      
    return P->data;      
}      
      
void Insert_Pre(List L, ElementType element, int i){      
    Position P, NewNode;      
    int count = 1;      
    P = L;      
      
    while (P->Next != NULL && count < i){      
        P = P->Next;      
        count++;      
    }      
      
    if (P == NULL || i < count)      
        return;      
      
    NewNode = malloc(sizeof(struct Node));      
    NewNode->data = element;      
    NewNode->Next = P->Next;      
    P->Next = NewNode;      
}      
      
void Insert_Bac(List L, ElementType element, int i){      
    Position P, NewNode;      
    int count = 1;      
    P = L->Next;      
      
    while (P != NULL && count < i){      
        P = P->Next;      
        count++;      
    }      
      
    if (P == NULL || i < count)      
        return;      
      
    NewNode = malloc(sizeof(struct Node));      
    NewNode->data = element;      
    NewNode->Next = P->Next;      
    P->Next = NewNode;      
}      
      
void Delete(List L, ElementType i){      
    Position P, Tmp;      
    int count = 1;      
    P = L;      
      
    while (P->Next != NULL && i > count){      
        P = P->Next;      
        count++;      
    }      
      
    if (P->Next == NULL || i < count)      
        return;      
      
    Tmp = P->Next;      
    P->Next = Tmp->Next;      
    free(Tmp);      
}      
      
void ListTraverse(List L){      
    Position P;      
    P = L->Next;      
      
    while (P != NULL){      
        printf("%d ", P->data);      
        P = P->Next;      
    }      
    printf("\n");      
}      
      
void main(){      
    List L;      
      
    L = CreateList_Bac();      
    printf("新建链表（尾插法）:　");      
    ListTraverse(L);      
    printf("当前链表长度为: %d\n", ListLength(L));      
    printf("当前链表第7个元素为: %d\n", getElement(L, 7));      
      
    Insert_Pre(L, 16, 5);      
    printf("插入至指定元素前面： ");      
    ListTraverse(L);      
    Insert_Bac(L, 16, 5);      
    printf("插入至指定元素后面： ");      
    ListTraverse(L);      
      
    Delete(L, 5);      
    printf("删除指定元素： ");      
    ListTraverse(L);      
      
    DeleteList(L);      
    printf("删除链表： ");      
    ListTraverse(L);      
    printf("当前链表长度为: %d\n", ListLength(L));      
      
    printf("\n");      
      
    L = CreateList_Pre();      
    printf("新建链表（头插法）:　");      
    ListTraverse(L);      
    printf("当前链表长度为: %d\n", ListLength(L));      
    printf("当前链表第7个元素为: %d\n", getElement(L, 7));      
      
    Insert_Pre(L, 16, 5);      
    printf("插入至指定元素前面： ");      
    ListTraverse(L);      
    Insert_Bac(L, 16, 5);      
    printf("插入至指定元素后面： ");      
    ListTraverse(L);      
      
    Delete(L, 5);      
    printf("删除指定元素： ");      
    ListTraverse(L);      
      
    DeleteList(L);      
    printf("删除链表： ");      
    ListTraverse(L);      
    printf("当前链表长度为: %d\n", ListLength(L));      
}

/*链式栈的简要实现  
 *  
 *  
 */    
#include <stdio.h>      
#include <stdlib.h>      
    
#define MAXSIZE 20    
struct StackNode;    
struct LinkStack;    
    
typedef struct StackNode* PtrToStack;    
typedef struct LinkStack* PtrToLink;    
typedef PtrToStack Node;    
typedef PtrToStack LinkStackPtr;    
typedef PtrToLink Link;    
typedef int ElementType;    
    
struct StackNode{    
    int data;    
    Node Next;    
};    
struct LinkStack{    
    LinkStackPtr top;    
    int count;    
};    
Link InitStack();/*初始化链栈*/    
void ClearStack(Link L);/*清空链栈*/    
void StackEmpty(Link L);/*检查链栈是否为空*/    
int StackLength(Link L);/*检查链栈长度*/    
int GetTop(Link L);/*得到栈顶元素*/    
int Push(Link L, ElementType e);/*压栈操作*/    
int Pop(Link L);/*弹栈操作*/    
void LinkTraverse(Link L);/*遍历链栈*/    
    
/*初始化链栈*/    
Link InitStack(){    
    Link L = malloc(sizeof(struct LinkStack));    
    if (L == NULL)    
        return;    
    L->top = malloc(sizeof(struct StackNode));    
    if (L->top == NULL)    
        return;    
    L->top = NULL;    
    L->count = 0;    
    return L;    
}    
    
/*清空链栈*/    
void ClearStack(Link L){    
    LinkStackPtr P, Q;    
    P = L->top;    
    while (P != NULL){    
        Q = P->Next;    
        free(P);    
        P = Q;    
    }    
    L->count = 0;    
}    
    
/*检查链栈是否为空*/    
void StackEmpty(Link L){    
    if (L->count == 0)    
        printf("链栈为空\n");    
    else    
        printf("链栈不为空\n");    
}    
    
/*检查链栈长度*/    
int StackLength(Link L){    
    return L->count;    
}    
    
/*得到栈顶元素*/    
int GetTop(Link L){    
    if (L->top == NULL)    
        return NULL;    
    if (L->top == NULL)    
        return;    
    return L->top->data;    
}    
    
/*压栈操作*/    
int Push(Link L, ElementType e){    
    LinkStackPtr S = malloc(sizeof(struct StackNode));    
    S->data = e;    
    S->Next = L->top;    
    L->top = S;    
    L->count++;    
    return e;    
}    
    
/*弹栈操作*/    
int Pop(Link L){    
    LinkStackPtr P;    
    int e = L->top->data;    
    P = L->top;    
    L->top = P->Next;    
    free(P);    
    L->count--;    
    return e;    
}    
    
/*遍历链栈*/    
void LinkTraverse(Link L){    
    LinkStackPtr P;    
    P = L->top;    
    while (P != NULL){    
        printf("%d\n", P->data);    
        P = P->Next;    
    }    
}    
    
void main(){    
    Link L;    
    L = InitStack();    
    
    printf("压栈(由底至顶):\n");    
    for (int i = 1; i <= 10; i++){    
        Push(L, i);    
    }    
    LinkTraverse(L);    
    StackEmpty(L);    
    printf("链栈长度为: %d\n",StackLength(L));    
    printf("链栈顶的元素为: %d\n", GetTop(L));    
    
    printf("\n");    
    
    printf("出栈(由顶至底):\n");    
    for (int i = 10; i > 0; i--){    
        printf("%d\n", Pop(L));    
    }    
    LinkTraverse(L);    
    StackEmpty(L);    
    printf("链栈长度为: %d\n", StackLength(L));    
    printf("链栈顶的元素为: %d\n", GetTop(L));    
}

/*链式队列的简要实现 
 * 
 * 
 */  
#include <stdio.h>      
#include <stdlib.h>      
  
#define MAXSIZE 20  
struct Node;  
struct LinkQueue;  
typedef struct Node* PtrToNode;  
typedef struct LinkQueue* PtrToQueue;  
typedef PtrToNode QNode;  
typedef PtrToNode QueuePtr;  
typedef PtrToQueue Queue;  
typedef int ElementType;  
  
struct Node{  
    ElementType data;  
    QNode Next;  
};  
struct LinkQueue{  
    QueuePtr front;  
    QueuePtr rear;  
};  
  
Queue InitQueue();/*初始化队列*/  
void DestroyQueue(Queue Q);/*销毁一个队列*/  
void ClearQueue(Queue Q);/*清空队列*/  
void QueueEmpty(Queue Q);/*检查队列是否为空*/  
int QueueLength(Queue Q);/*获取队列长度*/  
int GetHead(Queue Q);/*得到队列头元素*/  
int EnQueue(Queue Q, ElementType e);/*入列*/  
int DeQueue(Queue Q);/*出列*/  
void QueueTraverse(Queue Q);/*遍历队列*/  
  
/*初始化队列*/  
Queue InitQueue(){  
    Queue Q = malloc(sizeof(struct LinkQueue));  
    if (Q == NULL)  
        return NULL;  
    Q->front = Q->rear = malloc(sizeof(struct Node));  
    Q->front->Next = NULL;  
    return Q;  
}  
  
/*销毁一个队列*/  
void DestroyQueue(Queue Q){  
    while (Q->front != NULL){  
        Q->rear = Q->front->Next;  
        free(Q->front);  
        Q->front = Q->rear;  
    }  
}  
  
/*清空队列*/  
void ClearQueue(Queue Q){  
    QueuePtr P, K;  
    Q->rear = Q->front;  
    P = Q->front->Next;  
    Q->front->Next = NULL;  
    while (P != NULL){  
        K = P->Next;  
        free(P);  
        P = K;  
    }  
}  
  
/*检查队列是否为空*/  
void QueueEmpty(Queue Q){  
    if (Q->front == Q->rear)  
        printf("\n队列为空\n");  
    else  
        printf("\n队列不为空\n");  
}  
  
/*获取队列长度*/  
int QueueLength(Queue Q){  
    QueuePtr P;  
    int count = 0;  
    P = Q->front;  
    while (Q->rear != P){  
        P = P->Next;  
        count++;  
    }  
    return count;  
}  
  
/*得到队列头元素*/  
int GetHead(Queue Q){  
    QueuePtr P;  
    if (Q->front == Q->rear)  
        return NULL;  
    P = Q->front->Next;  
    return P->data;  
}  
  
/*入列*/  
int EnQueue(Queue Q, ElementType e){  
    QueuePtr S = malloc(sizeof(struct Node));  
    if (S == NULL)  
        return NULL;  
    S->data = e;  
    S->Next = NULL;  
    Q->rear->Next = S;  
    Q->rear = S;  
    return e;  
}  
  
/*出列*/  
int DeQueue(Queue Q){  
    QueuePtr P;  
    if (Q->front == Q->rear)  
        return NULL;  
    P = Q->front->Next;  
    ElementType e = P->data;  
    Q->front->Next = P->Next;  
    if (Q->rear == P) /*如果队头就是队尾*/  
        Q->front = Q->rear;  
    free(P);  
    return e;  
}  
  
/*遍历队列*/  
void QueueTraverse(Queue Q){  
    QueuePtr P;  
    P = Q->front->Next;  
    while (P != NULL){  
        printf("%d ", P->data);  
        P = P->Next;  
    }  
}  
  
void main(){  
    Queue Q;  
    Q = InitQueue();  
      
    printf("入列：\n");  
    for (int i = 1; i <= 10; i++){  
        EnQueue(Q, i);  
    }  
    QueueTraverse(Q);  
    QueueEmpty(Q);  
    printf("队列长度为: %d\n", QueueLength(Q));  
    printf("队列头元素为: %d\n", GetHead(Q));  
  
    printf("\n");  
  
    printf("出列：\n");  
    for (int i = 1; i <= 5; i++){  
        DeQueue(Q, i);  
    }  
    QueueTraverse(Q);  
    QueueEmpty(Q);  
    printf("队列长度为: %d\n", QueueLength(Q));  
    printf("队列头元素为: %d\n", GetHead(Q));  
    ClearQueue(Q);  
    printf("清空队列后，队列长度为: %d\n", QueueLength(Q));  
}

/*二叉树的链式结构实现 
 * 
 * 
 */  
#include <stdio.h>        
#include <stdlib.h>        
  
struct TreeNode;  
typedef int ElementType;  
typedef char TElementType;  
typedef char* String;  
typedef struct TreeNode* PtrToNode;  
typedef PtrToNode Tree;  
  
String str = "ABDH#K###E##CFI###G#J##";/*前序遍历序列*/  
ElementType index = 0;  
  
struct TreeNode{  
    TElementType data;  
    Tree LChild;  
    Tree RChild;  
};  
  
Tree CreateBiTree();/*前序遍历法创建一棵二叉树*/  
void Disptree(Tree T);/*凹入表示法输出二叉树* / 
void PreOrderTraverse(Tree T);/*前序遍历二叉树*/  
void InOrderTraverse(Tree T);/*中序遍历二叉树*/  
void PostOrderTraverse(Tree T);/*后序遍历二叉树*/  
void TreeEmpty(Tree T);/*检查二叉树是否为空*/  
void ClearTree(Tree T);/*清空一颗二叉树*/  
int TreeDepth(Tree T);/*返回树的深度*/  
TElementType Root(Tree T);/*返回根节点*/  
  
/*前序遍历法创建一颗二叉树*/  
Tree CreateBiTree(){  
    char ch = str[index++];  
    Tree T;  
    if (ch == '#')  
        T = NULL;  
    else{  
        T = malloc(sizeof(struct TreeNode));  
        T->data = ch;  
        T->LChild = CreateBiTree();  
        T->RChild = CreateBiTree();  
    }  
    return T;  
}  
  
/*前序遍历二叉树*/  
void PreOrderTraverse(Tree T){  
    if (T != NULL){  
        printf("%c ", T->data);  
        PreOrderTraverse(T->LChild);  
        PreOrderTraverse(T->RChild);  
    }  
}  
  
/*中序遍历二叉树*/  
void InOrderTraverse(Tree T){  
    if (T != NULL){  
        InOrderTraverse(T->LChild);  
        printf("%c ", T->data);  
        InOrderTraverse(T->RChild);  
    }  
}  
  
/*后序遍历二叉树*/  
void PostOrderTraverse(Tree T){  
    if (T != NULL){  
        PostOrderTraverse(T->LChild);  
        PostOrderTraverse(T->RChild);  
        printf("%c ", T->data);  
    }  
}  
  
/*检查二叉树是否为空*/  
void TreeEmpty(Tree T){  
    if (T == NULL)  
        printf("二叉树为空");  
    else  
        printf("二叉树不为空");  
}  
  
//凹入表示法输出二叉树  
void Disptree(Tree T)  
{  
    if (T)  
    {  
        printf("%c", T->data);  
        if (T->LChild || T->RChild)  
        {  
            printf("(");  
            Disptree(T->LChild);  
            if (T->RChild)  
                printf(",");  
            Disptree(T->RChild);  
            printf(")");  
        }  
    }  
}  
  
/*清空一颗二叉树*/  
void ClearTree(Tree T){  
    if (T != NULL){  
        ClearTree(T->LChild);  
        ClearTree(T->RChild);  
        free(T);  
    }  
    return NULL;  
}  
  
/*返回树的深度*/  
int TreeDepth(Tree T){  
    int left, right;  
    if (T == NULL)  
        return NULL;  
  
    if (T->LChild != NULL)  
        left = TreeDepth(T->LChild);  
    else  
        left = 0;  
  
    if (T->RChild != NULL)  
        right = TreeDepth(T->RChild);  
    else  
        right = 0;  
  
    return left > right ? left + 1 : right + 1;  
}  
  
/*返回根节点*/  
TElementType Root(Tree T){  
    if (T != NULL)  
        return T->data;  
}  
  
void main(){  
    Tree T;  
    T = CreateBiTree();  
  
    printf("凹入表示法：\n");  
    Disptree(T);  
  
    printf("\n前序遍历：\n");  
    PreOrderTraverse(T);  
    printf("\n中序遍历：\n");  
    InOrderTraverse(T);  
    printf("\n后序遍历：\n");  
    PostOrderTraverse(T);  
  
    printf("\n树是否为空：");  
    TreeEmpty(T);  
    printf("\n树的深度为：%d", TreeDepth(T));  
    printf("\n树的根节点为：%c", Root(T));  
}

HWHuangeian

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
链表、链式栈、链式队列、二叉树的C简要实现

/*单链表简要实现 * * */ #include #include struct Node; typedef struct Node* PtrToNode; typedef PtrToNode List; typedef PtrToNode Position; typede
复制链接

扫一扫