数据结构练习

最新推荐文章于 2024-07-25 17:43:13 发布
最新推荐文章于 2024-07-25 17:43:13 发布
阅读量120 收藏 2
点赞数 2
文章标签： 数据结构 c语言 链表 b树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/legend_shiyan/article/details/128358004
版权

顺序表练习1

#define _CRT_SECURE_NO_WARNINGS 1  
#define TRUE 1  
#define FALSE 0  
#define OK 1  
#define ERROR 0  
 
#define MAXSIZE 100  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
#include <time.h>  
#include <iostream>  
  
typedef int ElemType;  
typedef struct   
{  
    ElemType *elem ;  
    int length;  
  
}Sqlist;  
  
int init_Lnode(Sqlist &L,int ch[], int len)//初始化顺序表  
{  
      
    L.elem = new ElemType[MAXSIZE];  
    if (!L.elem) exit(-1);  
    L.length = 0;  
    for (int i = 0; i < len; i++)  
    {  
        L.elem[i] = ch[i];  
    }  
  
    return OK;  
}  
int insert_Lnode(Sqlist& L, int c, int len)//插入  
{  
    int pos = 0;  
    for (int i = 0; i < len; i++)  
    {  
        if (c > L.elem[i]) continue;  
  
        else if (c <= L.elem[i])  
        {  
            pos = i;  
            break;  
        }  
    }  
    for (int i = len; i >= pos; i--)  
    {  
        L.elem[i + 1] = L.elem[i];  
    }  
    L.elem[pos] = c;  
  
    return OK;  
}  
int main()  
{  
    int ch[10] = { 0 };//输入顺序表的值  
    int len = 0;  
    while (1)  
    {  
        int num;  
        scanf("%d", &num);  
        ch[len] = num;  
        char tep = getchar();  
        len++;  
        if (tep == '\n')  
        {  
            break;  
        }  
    }  
    int c = 0;  
    scanf("%d", &c);  
  
    Sqlist L;  
    init_Lnode(L, ch, len);  
    insert_Lnode(L, c, len);  
    for (int i = 0; i < len + 1; i++)  
    {  
        printf("%d", L.elem[i]);  
        if (i < len)  
        {  
            printf(",");  
        }  
        else  
        {  
            printf("\n");  
        }  
    }  
    return 0;  
}

链表练习— 删除结点

#define _CRT_SECURE_NO_WARNINGS 1  
#define TRUE 1  
#define FALSE 0  
#define OK 1  
#define ERROR 0  
 
#define MAXSIZE 100  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
  
  
  
  
typedef int DataType;  
typedef struct node  
{  
    DataType data;  
    struct node* next;  
  
}Linknode, *Linklist;  
  
void initLinklist(Linklist& head)//初始化链表  
{  
    head = new Linknode;  
    head->next = NULL;  
}  
  
int LengthLinklist(Linklist& head)//计算链表长度  
{  
    Linklist p = head->next;  
    int count = 0;  
    while (p != NULL)  
    {  
        count += 1;  
        p = p->next;  
    }  
    return count;  
}  
  
int FindLinklist(Linklist& L, DataType x)//找出对应元素节点  
{  
    Linklist p = L;  
    int count = 0;  
    while (p->next != NULL)  
    {  
          
        p = p->next;  
        if (p->data == x)  
        {  
            return count;  
        }  
        count += 1;  
    }  
    return 0;  
}  
Linklist LocateLinklist(Linklist& L, int i)//定位第i个元素节点  
{  
    if (i < 0) return NULL;  
    Linklist p = L->next;  
    int count = 0;  
    while (p != NULL)  
    {  
        if (count == i) return p;  
        p = p->next;  
        count += 1;  
    }  
    return NULL;  
}  
int addLinklist(Linklist& P, DataType x)  
{  
    Linklist L = P;  
    if (L == NULL) return 0;  
    while (L->next != NULL)  
    {  
        L = L->next;  
    }  
    Linklist node = new Linknode;  
    if (node != NULL)  
    {  
        node->data = x;  
        node->next = L->next;  
        L->next = node;  
        return 1;  
    }  
    else return 0;  
}  
  
int RemoveLinklist(Linklist& L, int i, DataType& x)//删除指定节点，并返回删除元素  
{  
    Linklist p = LocateLinklist(L, i - 1);  
    if (p == NULL|| p->next==NULL) return 0;  
    x = p->next->data;  
    Linklist s = p->next;  
    p->next = s->next;  
    free(s);  
    return 1;  
}  
  
int main()  
{  
    Linklist head;  
    initLinklist(head);  
    int num = 0;  
    char ch = 0;  
    while (1)  
    {  
        scanf("%d", &num);  
        addLinklist(head, num);  
        ch = getchar();  
        if (ch == '\n')  
        {  
            break;  
        }  
    }  
    scanf("%d", &num);  
    int n = FindLinklist(head, num);  
    int key = RemoveLinklist(head, n - 1, num);  
    if (key == 0)  
    {  
        printf("该结点没有前驱结点\n");  
    }  
    else  
    {  
        int len = LengthLinklist(head);  
        Linklist node = head->next;  
        for (int i = 0; i < len; i++)  
        {  
              
            printf("%d", node->data);  
            if (i < len - 1) printf(" ");  
            else printf("\n");  
            node = node->next;  
  
        }  
    }  
  
    return 0;  
}

链表求交集

#define _CRT_SECURE_NO_WARNINGS 1  
#define TRUE 1  
#define FALSE 0  
#define OK 1  
#define ERROR 0  
 
#define MAXSIZE 100  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
  
typedef int DataType;  
typedef struct node  
{  
    DataType data;  
    struct node* next;  
  
}Linknode, * Linklist;  
  
void initLinklist(Linklist& head)//初始化链表  
{  
    head = new Linknode;  
    head->next = NULL;  
}  
void clearLinklist(Linklist& head)//清空链表  
{  
    Linklist q;  
    while (head->next != NULL)  
    {  
        q = head->next;  
        head->next = q->next;  
        free(q);  
    }  
}  
int LengthLinklist(Linklist& head)//计算链表长度  
{  
    Linklist p = head->next;  
    int count = 0;  
    while (p != NULL)  
    {  
        count += 1;  
        p = p->next;  
    }  
    return count;  
}  
Linklist FindLinklist(Linklist& L, DataType x)//找出对应元素节点  
{  
    Linklist p = L->next;  
    int count = 0;  
    while (p != NULL)  
    {  
        count += 1;  
        p = p->next;  
        if (p->data == x)  
        {  
            return p;  
        }  
    }  
    return 0;  
}  
Linklist LocateLinklist(Linklist& L, int i)//定位第i个元素节点  
{  
    if (i < 0) return NULL;  
    Linklist p = L->next;  
    int count = 0;  
    while (p != NULL)  
    {  
        if (count == i) return p;  
        p = p->next;  
        count += 1;  
    }  
    return NULL;  
}  
int InsertLinklist(Linklist& L, int i, DataType x)//指定位置插入元素  
{  
    Linklist p = LocateLinklist(L, i - 1);  
    if (p == NULL) return 0;  
    Linklist s = new Linknode;  
    if (s != NULL)  
    {  
        s->data = x;  
        s->next = p->next;  
        p->next = s;  
        return 1;  
    }  
    else return 0;  
}  
int RemoveLinklist(Linklist& L, int i, DataType& x)//删除指定节点，并返回删除元素  
{  
    Linklist p = LocateLinklist(L, i - 1);  
    if (p == NULL || p->next == NULL) return 0;  
    x = p->next->data;  
    Linklist s = p->next;  
    p->next = s->next;  
    free(s);  
    return 1;  
}  
int addLinklist(Linklist& P, DataType x)//将元素插入到链表末尾  
{  
    Linklist L = P;  
    if (L == NULL) return 0;  
    while (L->next != NULL)  
    {  
        L = L->next;  
    }  
    Linklist node = new Linknode;  
    if (node != NULL)  
    {  
        node->data = x;  
        node->next = L->next;  
        L->next = node;  
        return 1;  
    }  
    else return 0;  
}  
void maskLinklist(Linklist& head_a, Linklist& head_b, Linklist& head_c)  
{  
    Linklist pa = head_a->next;  
    Linklist pb = head_b->next;  
    Linklist pc = head_c;  
    while (pa != NULL && pb != NULL)  
    {  
        if (pa->data == pb->data)  
        {  
            addLinklist(head_c, pa->data);  
            pa = pa->next;  
            pb = pb->next;  
        }  
        else if (pa->data > pb->data)  
        {  
            pb = pb->next;  
        }  
        else if (pa->data < pb->data)  
        {  
            pa = pa->next;  
        }  
    }  
}  
int main()  
{  
    Linklist head_a;  
    Linklist head_b;  
    Linklist head_c;  
    initLinklist(head_a);  
    initLinklist(head_b);  
    initLinklist(head_c);  
    int num;  
    int count = 0;  
    while (1)  
    {  
        scanf("%d", &num);  
        addLinklist(head_a, num);  
        char tep = getchar();  
        if (tep == '\n') break;  
  
    }  
    while (1)  
    {  
        scanf("%d", &num);  
        addLinklist(head_b, num);  
        char tep = getchar();  
        if (tep == '\n') break;  
  
    }  
  
    maskLinklist(head_a, head_b, head_c);  
    int len = LengthLinklist(head_c);  
    Linklist node = head_c->next;  
    if (head_c->next == NULL)  
    {  
        printf("没有交集\n");  
    }  
    else  
    {  
        for (int i = 0; i < len; i++)  
        {  
            printf("%d", node->data);  
            node = node->next;  
            printf(" ");  
        }  
        printf("\n");  
    }  
  
    return 0;  
}

栈和队列练习—判断字符串是否 回文

#define _CRT_SECURE_NO_WARNINGS 1  
#define TRUE 1  
#define FALSE 0  
#define OK 1  
#define ERROR 0  
 
#define MAXSIZE 100  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
  
typedef char SElemType;  
typedef struct   
{  
    SElemType* elem;  
    int maxsize;  
    int top;  
  
}SeqStack;  
  
int initStack(SeqStack& S)//栈的初始化  
{  
    S.elem = new SElemType[MAXSIZE];  
    if (S.elem == NULL) return -1;  
    S.maxsize = MAXSIZE;  
    S.top = 0;  
}  
  
int pushStack(SeqStack& S, SElemType x)//进栈，栈顶指针等于最后一个元素，既为空时是-1  
{  
    if (S.top == S.maxsize ) return 0;  
    S.elem[++S.top] = x;  
    return 1;  
}  
  
int popStack(SeqStack& S, SElemType& x)//出栈  
{  
    if (S.top == 0) return 0;  
    x = S.elem[S.top];  
    S.top--;  
    return 1;  
}  
  
int gettopStack(SeqStack& S, SElemType& x)//获取栈顶值  
{  
    if (S.top == 0) return 0;  
    x = S.elem[S.top];  
    return 1;  
}  
int emptyStack(SeqStack& S)//栈空为1  
{  
    return S.top == 0;  
}  
  
int FullStack(SeqStack& S)//是否栈满  
{  
    return S.top == S.maxsize;  
}  
  
int SizeStack(SeqStack& S)  
{  
    return S.top;  
}  
int main()  
{  
    SElemType ch[] = {0,0,0,0,0,0,0,0,0,0};  
    int len = 0;  
    while (1)  
    {  
        char arr = getchar();  
        if (arr == '\n') break;  
        ch[len] = arr;  
        len++;  
    }  
    SeqStack S;  
    initStack(S);  
    for (int i = 0; i < len; i++)  
    {  
        pushStack(S, ch[i]);  
    }  
    SElemType ch2[] = {0,0,0,0,0,0,0,0,0,0};  
    for (int i = 0; i < len; i++)  
    {  
        popStack(S, ch2[i]);  
    }  
    for (int i = 0; i < len; i++)  
    {  
        if (ch[i] != ch2[i])  
        {  
            printf("不是回文\n");  
            return 0;  
        }  
    }  
    printf("是回文\n");  
    return 0;  
}

栈和队列练习—奇偶数输出

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
  
typedef int QDataType;  
typedef struct Node//链式队列的节点  
{  
    QDataType data;  
    struct Node* next;  
}LinkNode;  
  
typedef struct {  
    LinkNode* front, * rear;  
}LinkQuene;  
  
void initLinkQuene(LinkQuene Q)//初始化  
{  
    Q.front = Q.rear = NULL;  
}  
  
int EnLinkQuene(LinkQuene *Q, QDataType x)//进队列  
{  
    LinkNode* s = new LinkNode;  
    s->data = x;  
    s->next = NULL;  
    if (Q->rear == NULL) Q->front = Q->rear = s;  
    else  
    {  
        Q->rear->next = s;  
        Q->rear = s;  
    }  
    return 1;  
}  
  
int DeLinkQuene(LinkQuene *Q, QDataType x)//出队列  
{  
      
    if (Q->front == NULL) return 0;  
    LinkNode* p = Q->front;  
    x = p->data;  
    Q->front = p->next;  
    free(p);  
    if (Q->front == NULL) Q->rear = NULL;  
    return x;  
}  
  
int EmptyLinkQuene(LinkQuene *Q)//判断队列是否为空，空返回1  
{  
    return Q->front == NULL;  
}  
  
int main()  
{  
    LinkQuene Q1, Q2;  
    LinkQuene *A = new LinkQuene, * B = new LinkQuene;  
      
    Q1.front = Q1.rear = NULL;  
    Q2.front = Q2.rear = NULL;  
  
    A = &Q1;  
    B = &Q2;  
    int n = 0;  
    int tep = 0;  
    scanf("%d", &n);  
  
    for (int i = 0;i < n; i++)  
    {  
        scanf("%d", &tep);  
        if (tep % 2 == 1)  
        {  
            EnLinkQuene(A, tep);  
        }  
        else if (tep % 2 == 0)  
        {  
            EnLinkQuene(B, tep);  
        }  
    }  
    while (!EmptyLinkQuene(A) && !EmptyLinkQuene(B))  
    {  
        int tep_a=0, tep_b=0;  
        tep_a = DeLinkQuene(A, tep_a);  
        tep_b = DeLinkQuene(B, tep_b);  
        printf("%d %d\n", tep_a, tep_b);  
    }  
    return 0;  
}

栈和队列练习—括号是否配对

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
 
#define MAXSIZE 100  
typedef char SElemType;  
typedef struct  
{  
    SElemType* elem;  
    int maxSize, top;  
}SeqStack;  
  
void InitSeqStack(SeqStack& S)//栈的初始化  
{  
    S.elem = new SElemType[MAXSIZE];  
    if (S.elem == NULL) exit(1);  
    S.maxSize = MAXSIZE;  
    S.top = -1;  
}  
  
int pushSeqStack(SeqStack& S, SElemType x)//进栈  
{  
    if (S.top == S.maxSize - 1) return 0;  
    S.top++;  
    S.elem[S.top] = x;  
    return 1;  
}  
  
int PopSeqStack(SeqStack& S, SElemType& x)//退栈  
{  
    if (S.top == -1) return 0;  
    x = S.elem[S.top];  
    S.top--;  
    return 1;  
}  
  
int GetSeqStack(SeqStack& S, SElemType& x)//获取栈顶元素  
{  
    if (S.top == -1) return 0;  
    x = S.elem[S.top];  
    return 1;  
}  
  
int l_jug(char s)  
{  
    char ch[3] = { '[','(', '{'};  
    for (int i = 0; i < 3; i++)  
    {  
        if (s == ch[i]) return 0;  
    }  
    return 1;  
}  
  
int r_jug(char s)  
{  
    char ch[3] = { ']',')', '}' };  
    for (int i = 0; i < 3; i++)  
    {  
        if (s == ch[i]) return 0;  
    }  
    return 1;  
}  
  
int SeqStackEmpty(SeqStack& S)//判断空栈  
{  
    return S.top == -1;  
}  
  
int main()  
{  
    SeqStack S;  
    InitSeqStack(S);  
    while (1)  
    {  
        char s = 0;  
        scanf("%c", &s);  
        if (s == '\n') break;  
        if (r_jug(s)&&l_jug(s)) continue;  
        if (!l_jug(s)) pushSeqStack(S, s);  
        else if (!r_jug(s))  
        {  
            char tep = 0;  
            GetSeqStack(S, tep);  
            if (s == ')')  
            {  
                if (tep == '(') PopSeqStack(S, tep);  
                else  
                {  
                    printf("括号不配对\n");  
                    return 0;  
                }  
            }  
            else if (s == ']')  
            {  
                if (tep == '[') PopSeqStack(S, tep);  
                else  
                {  
                    printf("括号不配对\n");  
                    return 0;  
                }  
            }  
            else if (s == '}')  
            {  
                if (tep == '{') PopSeqStack(S, tep);  
                else  
                {  
                    printf("括号不配对\n");  
                    return 0;  
                }  
            }  
        }  
          
    }  
    if (SeqStackEmpty(S))  
    {  
        printf("括号配对\n");  
        return 0;  
    }  
    else printf("括号不配对\n");  
    return 0;  
}

栈和队列练习—输出学生成绩

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
 
#define MAXSIZE 100  
typedef int QElemType;  
typedef struct//结构定义  
{  
    QElemType elem[MAXSIZE];  
    int front;  
    int rear;  
}CircQuene;  
  
void initQuene(CircQuene& Q)//初始化  
{//da  
    Q.front = Q.rear = 0;  
}  
  
int EnQuene(CircQuene& Q, QElemType x)//入队列  
{  
    if ((Q.rear + 1) % MAXSIZE == Q.front) return 0;  
    Q.elem[Q.rear] = x;  
    Q.rear = (Q.rear + 1) % MAXSIZE;  
    return 1;  
}  
  
int DeQuene(CircQuene &Q, QElemType& x)//出队列  
{  
    if (Q.rear == Q.front) return 0;  
    x = Q.elem[Q.front];  
    Q.front = (Q.front + 1) % MAXSIZE;  
    return 1;  
}  
  
int EmptyQuene(CircQuene& Q)//判断是否为空，空返回1  
{  
    return Q.front == Q.rear;  
}  
  
int main()  
{  
    CircQuene G1,G2,G3;  
    initQuene(G1);  
    initQuene(G2);  
    initQuene(G3);  
    int n = 0;  
    scanf("%d", &n);  
    for (int i = 0; i < n; i++)  
    {  
        int tep = 0;  
        scanf("%d", &tep);  
        getchar();  
        if (tep < 60) EnQuene(G1, tep);  
        else if (tep >= 60 && tep < 100) EnQuene(G2, tep);  
        else if (tep >= 100) EnQuene(G3, tep);  
    }  
    printf("60>x:");  
    while (!EmptyQuene(G1))  
    {  
        int tep = 0;  
        DeQuene(G1, tep);  
        printf("%d ", tep);  
    }  
    printf("\n");  
    printf("60<=x<100:");  
    while (!EmptyQuene(G2))  
    {  
        int tep = 0;  
        DeQuene(G2, tep);  
        printf("%d ", tep);  
    }  
    printf("\n");  
    printf("x>=100:");  
    while (!EmptyQuene(G3))  
    {  
        int tep = 0;  
        DeQuene(G3, tep);  
        printf("%d ", tep);  
    }  
    printf("\n");  
    return 0;  
}

串练习-串的判等运算

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
int main()  
{  
    char s1[20], s2[20];  
    int l1 = 0, l2 = 0;  
  
    while (1)  
    {  
        char tep = 0;  
        scanf("%c", &tep);  
        if (tep == '\n') break;  
        s1[l1] = tep;  
        l1++;  
    }  
    while (1)  
    {  
        char tep = 0;  
        scanf("%c", &tep);  
        if (tep == '\n') break;  
        s2[l2] = tep;  
        l2++;  
    }  
    if (l1 != l2)  
    {  
        printf("not equal\n");  
        return 0;  
    }  
    else  
    {  
        for (int i = 0; i < l1; i++)  
        {  
            if (s1[i] != s2[i])  
            {  
                printf("not equal\n");  
                return 0;  
            }  
        }  
        printf("equal\n");  
    }  
    return 0;  
}

串练习-串匹配

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
 
#define MAXSIZE 100  
  
typedef struct {  
    char* ch;  
    int maxsize;  
    int n;  
}HString;  
  
void initString(HString& S, int n)  
{  
    if (n < MAXSIZE) n = MAXSIZE;  
    S.ch = new char[n];  
    if (S.ch == NULL) exit(1);  
    S.ch[0] = '\0';  
    S.n = 0;  
    S.maxsize = n;  
}  
  
void createString(HString& S)  
{  
    int l = 0;  
    while (1)  
    {  
        char tep = 0;  
        scanf("%c", &tep);  
        if (tep == '\n') break;  
        S.ch[l] = tep;  
        l++;  
    }  
    S.n = l;  
}  
  
int maxs(HString& P, int j)  
{  
    int max = 0;  
    for (int i = 1; i < j; i++)  
    {  
        int tep = 0;  
        //计算本次的tep值  
        for (int k = 0; k < i;k++)  
        {  
            tep = i;  
            if (P.ch[k] != P.ch[j - i + k])  
            {  
                tep = 0;  
                break;  
            }  
        }  
        //  
        max = tep;  
    }  
    return max;  
}  
  
void findnext(HString& P, int next[])  
{  
    next[0] = -1;  
    next[1] = 0;  
    int j = 2,k = 0;  
  
    while (j < P.n)  
    {  
        k = maxs(P, j);  
        next[j] = k;  
        j++;  
    }  
}  
  
int findfast(HString& S, HString& P, int next[])  
{  
    int i = 0, j = 0;  
    while (j < P.n && i < S.n)  
    {  
        if (j==-1||S.ch[i] == P.ch[j]) i++, j++;  
        else  
        {  
            j = next[j];  
        }  
    }  
    if (j < P.n - 1) return -1;  
    else return i - j + 1;  
}  
  
int main()  
{  
    HString S, P;  
    initString(S, 1);  
    initString(P, 1);  
    createString(S);  
    createString(P);  
    int next[MAXSIZE];  
    findnext(P, next);  
    int position = findfast(S, P, next);  
    printf("%d\n", position);  
    return 0;  
}

二叉树遍历输出

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
 
#define MAXSIZE 100  
  
typedef char TElemType;  
typedef struct BTnode  
{  
    TElemType data;  
    struct BTnode* lchild, * rchild;  
}BiTnode, * BinTree;  
  
void createBinTree_pre(BinTree& T)//先序创建二叉树  
{  
    char ch;  
    scanf("%c", &ch);  
    if (ch == '#') T = NULL;  
    else  
    {  
        T = new BTnode;  
        T->data = ch;  
        createBinTree_pre(T->lchild);  
        createBinTree_pre(T->rchild);  
    }  
}  
  
int headOrderTraverse(BinTree& T)//先序遍历输出  
{  
    if (T == NULL) return 0;  
    else  
    {  
        printf("%c ", T->data);  
        headOrderTraverse(T->lchild);  
        headOrderTraverse(T->rchild);  
    }  
    return 1;  
}  
  
int InOrderTraverse(BinTree& T)//中序遍历输出  
{  
    if (T == NULL) return 0;  
    else  
    {  
        InOrderTraverse(T->lchild);  
        printf("%c ", T->data);  
        InOrderTraverse(T->rchild);  
    }  
    return 1;  
}  
  
int PostOrderTraverse(BinTree& T)//后序遍历输出  
{  
    if (T == NULL) return 0;  
    else  
    {  
        PostOrderTraverse(T->lchild);  
        PostOrderTraverse(T->rchild);  
        printf("%c ", T->data);  
    }  
    return 1;  
}  
  
  
int main()  
{  
    BinTree T;  
    createBinTree_pre(T);  
    printf("前序遍历结果：");  
    headOrderTraverse(T);  
    printf("\n");  
    printf("中序遍历结果：");  
    InOrderTraverse(T);  
    printf("\n");  
    printf("后序遍历结果：");  
    PostOrderTraverse(T);  
    printf("\n");  
    return 0;  
}

叶子结点数及深度

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
 
#define MAXSIZE 100  
  
typedef char TElemType;  
typedef struct BTnode  
{  
    TElemType data;  
    struct BTnode* lchild, * rchild;  
}BiTnode, * BinTree;  
  
void createBinTree_pre(BinTree& T)//先序创建二叉树  
{  
    char ch;  
    scanf("%c", &ch);  
    if (ch == '#') T = NULL;  
    else  
    {  
        T = new BTnode;  
        T->data = ch;  
        createBinTree_pre(T->lchild);  
        createBinTree_pre(T->rchild);  
    }  
}  
  
int headOrderTraverse(BinTree& T)//先序遍历输出  
{  
    if (T == NULL) return 0;  
    else  
    {  
        printf("%c ", T->data);  
        headOrderTraverse(T->lchild);  
        headOrderTraverse(T->rchild);  
    }  
    return 1;  
}  
  
int InOrderTraverse(BinTree& T)//中序遍历输出  
{  
    if (T == NULL) return 0;  
    else  
    {  
        InOrderTraverse(T->lchild);  
        printf("%c ", T->data);  
        InOrderTraverse(T->rchild);  
    }  
    return 1;  
}  
  
int PostOrderTraverse(BinTree& T)//后序遍历输出  
{  
    if (T == NULL) return 0;  
    else  
    {  
        PostOrderTraverse(T->lchild);  
        PostOrderTraverse(T->rchild);  
        printf("%c ", T->data);  
    }  
    return 1;  
}  
  
int leafnumber(BinTree& T)  
{  
    if (T->lchild == NULL && T->rchild == NULL) return 1;  
    else if (T->lchild != NULL && T->rchild == NULL) return leafnumber(T->lchild);  
    else if (T->lchild == NULL && T->rchild != NULL) return leafnumber(T->rchild);  
    else return leafnumber(T->lchild) + leafnumber(T->rchild);  
}  
  
int max(int a, int b)  
{  
    if (a >= b) return a;  
    else return b;  
}  
  
int depthnum(BinTree& T)  
{  
    if (T->lchild == NULL && T->rchild == NULL) return 1;  
    else if (T->lchild != NULL && T->rchild == NULL) return depthnum(T->lchild)+1;  
    else if (T->lchild == NULL && T->rchild != NULL) return depthnum(T->rchild)+1;  
    else return max(depthnum(T->lchild), depthnum(T->rchild)) + 1;  
}  
  
int main()  
{  
    BinTree T;  
    createBinTree_pre(T);  
    int leafs = leafnumber(T);  
    int depths = depthnum(T);  
    printf("leafs=%d\n", leafs);  
    printf("Depth=%d\n", depths);  
    return 0;  
}

图的存储—邻接表的建立

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
 
#define MAXSIZE 100  
 
#define maxVertices 30  
#define maxEdges 900  
#define maxWeight 32767  
  
typedef int Weight;  
typedef char Type;  
  
typedef struct {  
    int numVertices, numEdges;  
    Type VerticesList[maxVertices];  
    Weight Edge[maxVertices][maxVertices];  
}MGraph;  
  
void createMGraph(MGraph& G, int n)//建立邻接矩阵  
{  
    G.numVertices = n;  
    G.numEdges = 0;  
    int i, j, k;  
    Type val;  
    Weight cost, e1, e2;  
      
    for (int i = 0; i < G.numVertices; i++)//定点表  
    {  
        scanf("%c", &val);  
        getchar();  
        G.VerticesList[i] = val;  
  
        for (j = 0; j < G.numVertices; j++)  
        {  
            G.Edge[i][j] = (i == j) ? 0 : maxWeight;//初始化邻接矩阵  
        }  
    }  
  
    k = 0;  
    while (k < G.numVertices)  
    {  
        while (1)  
        {  
            scanf("%d", &e1);  
              
            if (e1 == -1)  
            {  
                getchar();  
                break;  
            }  
            scanf("%d", &cost);  
              
            G.Edge[k][e1] = cost;  
            G.numEdges++;  
        }  
        k++;  
    }  
}  
  
void OutMGraph(MGraph& G)  
{  
    int i, j, k;  
    k = 0;  
    while (k < G.numVertices)  
    {  
        printf("%c  ", G.VerticesList[k]);  
        for (int i = G.numVertices-1; i >=0; i--)  
        {  
            if (G.Edge[k][i] != 0 && G.Edge[k][i] != maxWeight)  
            {  
                printf("(%d,%d)%d  ", k, i, G.Edge[k][i]);  
            }  
        }  
        k++;  
        printf("\n");  
    }  
}  
  
int main()  
{  
    MGraph G;  
    int n = 0;  
    scanf("%d", &n);  
    getchar();  
    createMGraph(G, n);  
    OutMGraph(G);  
    return 0;  
}

二叉排序树

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
 
#define MAXSIZE 100  
  
  
  
typedef int TElemType;  
typedef struct BTnode  
{  
    TElemType data;  
    struct BTnode* lchild, * rchild;  
}BiTnode, * BinTree;  
  
void createBiTree(BinTree& T, int val)//创建二叉树  
{  
    if (T == NULL)  
    {  
        T = new BTnode;  
        T->data = val;  
        T->lchild = NULL;  
        T->rchild = NULL;  
    }  
    else  
    {  
        if (val >= T->data) createBiTree(T->rchild, val);  
        else createBiTree(T->lchild, val);  
    }  
}  
  
BinTree findBiTree(BinTree& T, BinTree& F, int val, int& c)//找到指定值位置  
{  
    if (T->data == val)  
    {  
        return T;  
    }  
    else if (val > T->data)  
    {  
        F = T;  
        c = 1;  
        if (T->rchild == NULL) return NULL;  
        return findBiTree(T->rchild, F, val, c);  
    }  
    else if (val < T->data)   
    {  
        F = T;  
        c = 0;  
        if (T->lchild == NULL) return NULL;  
        return findBiTree(T->lchild, F, val, c);  
    }  
    else if (T == NULL) return NULL;  
}  
  
BinTree findmin(BinTree& T, BinTree& F)  
{  
    if (T->lchild == NULL) return T;  
    else  
    {  
        F = T;  
        return findmin(T->lchild, F);  
    }  
}  
  
int delBiTree(BinTree& T, BinTree& F, int c)  
{  
    BinTree P;  
    if (T->lchild == NULL && T->rchild == NULL)  
    {  
        if (c) F->rchild = NULL;  
        else F->lchild = NULL;  
        free(T);  
        return 1;  
    }  
    else if (T->lchild != NULL && T->rchild == NULL)  
    {  
        P = T->lchild;  
        T->data = P->data;  
        T->lchild = P->lchild;  
        T->rchild = P->rchild;  
        free(P);  
        return 1;  
    }  
    else if (T->lchild == NULL && T->rchild != NULL)  
    {  
        P = T->rchild;  
        T->data = P->data;  
        T->lchild = P->lchild;  
        T->rchild = P->rchild;  
        free(P);  
        return 1;  
    }  
    else if (T->lchild != NULL && T->rchild != NULL)  
    {  
        F = T;  
        P = findmin(T->rchild, F);  
        T->data = P->data;  
        delBiTree(P, F, 0);  
    }  
}  
  
int InOrderTraverse(BinTree& T)//中序遍历输出    
{  
    if (T == NULL) return 0;  
    else  
    {  
        InOrderTraverse(T->lchild);  
        printf("%d  ", T->data);  
        InOrderTraverse(T->rchild);  
    }  
    return 1;  
}  
  
int main()  
{  
    int n, del_val, val;  
    BinTree T;  
    T = NULL;  
    scanf("%d", &n);  
    printf("原始数据：");  
    for (int i = 0; i < n; i++)  
    {  
        scanf("%d", &val);  
        printf("%d ", val);  
        createBiTree(T, val);  
    }  
    printf("\n");  
  
    scanf("%d", &del_val);  
      
  
    printf("中序遍历结果：");  
      
    InOrderTraverse(T);  
    printf("\n");  
    printf("删除结点后结果：");  
    BinTree F = NULL;  
    int c = 0;  
    BinTree P = findBiTree(T, F, del_val, c);  
  
    if (P == NULL)  
    {  
        printf("没有%d结点。\n", del_val);  
    }  
    else  
    {  
        delBiTree(P, F, c);  
        InOrderTraverse(T);  
        printf("\n");  
    }  
  
  
    return 0;  
}

找到两个数

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
 
#define MAXSIZE 100  
  
static int nums[MAXSIZE] = { 0 };  
  
int hash(int target)  
{  
    int leave = 0;  
    int a, b;  
    for (int i = 0; i < sizeof(nums) / 4; i++)  
    {  
        leave = target - nums[i];  
        a = i;  
        for (int j = 0; j < sizeof(nums) / 4; j++)  
        {  
            if (nums[j] == leave)  
            {  
                b = j;  
                printf("%d %d\n", a, b);  
                return 0;  
            }  
        }  
    }  
    return 0;  
}  
  
void inhash(int n)  
{  
    int tep = 0;  
    for (int i = 0; i < n; i++)  
    {  
        scanf("%d", &tep);  
        nums[i] = tep;  
    }  
}  
  
int main()  
{  
    static int n = 0;  
    scanf("%d", &n);  
    inhash(n);  
    int target = 0;  
    scanf("%d", &target);  
    hash(target);  
  
  
  
    return 0;  
}

找出最大的几个数

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
 
#define MAXSIZE 100  
  
static int nums[MAXSIZE] = { 0 };  
  
  
int main()  
{  
    int m=0, n=0;  
    int num[MAXSIZE] = { 0 };  
    int tep = 0;  
    int s = 0;  
    while (s<2)  
    {  
        scanf("%d %d", &n, &m);  
          
        for (int i = 0; i < n; i++)  
        {  
            scanf("%d", &tep);  
            num[i] = tep;  
        }  
        for (int i = 0; i < n; i++)  
        {  
            for (int j = 0; j < n-1; j++)  
            {  
                if (num[j] < num[j + 1])  
                {  
                    tep = num[j];  
                    num[j] = num[j + 1];  
                    num[j + 1] = tep;  
                }  
            }  
        }  
        for (int i = 0; i < m; i++)  
        {  
            printf("%d", num[i]);  
            if (i == m - 1);  
            else printf(" ");  
              
        }  
        printf("\n");  
        s++;  
    }  
    return 0;  
}
legend_shiyan
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构练习程序
风吹夏天的专栏
12-14 2164
今天朋友托我写一份程序，大二本科生的数据结构课程实验。要是以前的话，我肯定要定义图的邻接表结构，图的输入输出操作，图的遍历，写了很多代码。但是现在也仅仅越简洁越实用越好，这可能是由于时过境迁，人的心境也就变了。问题描述：图的路径遍历要比结点遍历具有更为广泛的应用。写一个路径遍历算法，求出从结点L到结点I中途不过结点K的所有简单路径。（图的存储结构没有要求）
【数据结构 C++】线性表（二）链式存储
qq_45397526的博客
03-28 813
链式存储与顺序存储有一些不同的地方，而且比顺序存储要难。 在了解链式存储之前，我们先回顾一下指针。 链式存储一、指针1、什么是指针2、指针变量1）、定义指针变量：int *p；2）、程序中的*p（除定义外）3、指针与数组1）、指针与数组名2）、指针数组二、链表1、链表定义2、头结点3、链表实现1）、定义节点类2）、定义链表类3）、构造函数4）、析构函数5）、返回链表的长度6）、返回链表i处的节点值...
数据结构之线性表-01
weixin_42923777的博客
01-19 707
线性表 线性表是计算机程序设计活动中最经常用到的一种操作对象，也是数据结构中最简单，做基本和最重要的结构形式之一。实际上，线性表结构在很多领域，尤其是在程序设计语言和程序设计过程中大量使用，并非一个陌生概念。 线性表的定义 线性表是由n(n>=0)个属于同一个数据对象的数据元素，a1,a2,……an-1,an组成的有限序列。当1<i<n时，ai的直接前驱元素为ai-1,ai的直接后继数据为ai+1.也就是说，除表中的第1个数据元素a1没有前驱元素及最后一个数据元素an没有后继元素外，其他的
c语言链表上机实验答案,数据结构全部上机实验及答案.doc
weixin_33946505的博客
05-18 472
数据结构全部上机实验及答案淮海工学院数据结构实验指导书计算机软件教研室实验1线性表的抽象数据类型的实现实验目的1)掌握线性表的顺序存储结构和链式存储结构；2)熟练掌握顺序表和链表基本算法的实现；3)掌握利用线性表数据结构解决实际问题的方法和基本技巧；4)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序，提交程序清单及及相关实验数据与运行结果)；5)按时提交实验报告。实验环境计算机、C语言...
栈和队列练习—奇偶数输出
Fiverya的博客
03-26 3258
编写一个程序，任意输入n个100以内的数，将它们的奇数和偶数分别存入链队为Q1和Q2中，然后配对输出链队Q1、Q2中的值，直到任一队列为空为止。 #include<iostream> #include<queue> using namespace std; int main() { queue<int>Q1,Q2; i...
栈和队列（练习）
CCCC_CSDN_LI的博客
05-17 388
括号匹配问题 public static boolean isValid(String s) { Stack<Character> stack = new Stack<>(); for (int i = 0; i < s.length(); i++) { char ch = s.charAt(i); if (ch == '(' || ch == '[' || ch == '{') {
数据结构练习题Word版 + PDF版
06-20
数据结构练习题 习题 1 绪论 1.1单项选择题 1. 数据结构是一门研究非数值计算的程序设计问题中,数据元素的① 、数据信息在计算机中的② 以及一组相关的运算等的课程。 ① A．操作对象 Ｂ．计算方法 Ｃ．逻辑结构 Ｄ...
数据结构习题
11-21
在这个“数据结构习题”压缩包中，我们很可能会找到一系列帮助深入理解数据结构概念和技巧的练习题。 数据结构主要分为四大类：线性结构（如数组、链表）、树形结构（如二叉树、堆）、图结构和散列结构。在实际编程...
数据结构练习题及上机题目&参考答案
07-17
"数据结构练习题及上机题目&参考答案" 本资源提供了数据结构领域内的各种练习题和参考答案，涵盖了数据结构的基本概念、逻辑结构、存储结构、算法分析等方面的知识点。通过这些练习题和参考答案，读者可以更好地...
数据结构练习题含参考答案
07-17
数据结构练习题含参考答案
期末考试-数据结构练习题
08-19
数据结构期末考试练习题 数据结构是计算机科学中研究非数值计算的程序设计问题中计算机的操作对象、逻辑存储、数据映象之间的结构和运算等的学科。数据结构被形式地定义为（K，R），其中 K 是有限集合，R 是 K 上的...
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 1485
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构：栈
2301_79601095的博客
07-23 1220
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 412
对于二分搜索的理论与实现的知识点学习。
数据结构（2）
m0_62881487的博客
07-23 1154
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
2024.7.24 作业
qq_64434282的博客
07-24 2055
【代码】2024.7.24 作业。
《数据结构1800题》基础回合总结——第1章 绪论
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-23 441
前言：《数据结构1800》这本书相信大家或多或少都有所耳闻，收录了诸多不同档次学校的考研真题，因为和汤老师的1800撞名所以备受调侃。这1800道题目里面有选择有填空，也有简答和一些编程题，总的来说质量良莠不齐——亦或说没什么性价比。因此无论考研还是备战期末或者面试的同学，当学有余力的时候，再去看本题集的内容~注：基础阶段，强烈建议不要学算法题，这玩意对于大部分人的水平来说非常耽误效率——ACM佬不在此行列。因此本次刷题相当于基础阶段，只针对除了算法设计的一切基础题~答案如下：答案如下：答案如下： 这一部分
数据结构和算法入门
weixin_67852890的博客
07-25 1568
链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成。每个节点包含两部分：元素值（Element Value）和指向下一个节点的指针（Pointer）。链表可以分为多种类型，如单向链表、双向链表、循环链表等。元素在存储上并不连续。队列是一种基础且广泛应用的线性数据结构，它模拟了现实生活中的排队现象，遵循“先进先出”（First-In-First-Out, FIFO）原则。
期末考试-数据结构练习题及解析
期末考试-数据结构练习题是一种考试类型，用于测试学生对数据结构的理解和应用能力。题型预测包括选择题、判断题，以及用图表解答的练习题、算法设计题或综合解答分析题。为了方便学生自学、练习和参考，题目部分...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值