大学IT网 - 最懂大学生的IT学习网站! QQ资料交流群:367606806
当前位置:大学IT网 > 算法技巧 > 数据结构与算法基本程序合集

数据结构与算法基本程序合集(1)

关键词:数据结构算法基本程序  阅读(2767) 赞(55)

[摘要]本文是数据结构与算法基本程序合集,与大家分享。

数据结构与算法基本程序目录

一、    线性表及其操作

1、    尾插法建立一个单链表,并按顺序输出

2、    单链表的元素查找,按内容查找

3、    元素插入操作

4、    按内容元素删除操作

5、    按位置删除元素

6、    建立双向链表

7、    单链表就地逆置

8、    约瑟夫环问题

二、    栈及其操作

1、    建立堆栈

2、    进栈与出栈

3、    栈的应用,括号匹配

三、    队及其操作

1、    链队列的建立

2、    入队和出队

3、    循环队列建立

4、    循环队列的入队和出队操作

四、    串及其操作

1、    串的朴素匹配

五、    树(二叉树)及其操作

1、    二叉排序树

2、    哈夫曼编码

六、    排序

1、    冒泡排序

2、    直接选择排序法


一、线性表及其操作

/*尾插法建立一个单链表,并按顺序输出*/
 
#define NULL 0            /*宏定义*/
typedef struct node        /*定义结点类型的数据结构*/
{
    char c;            /*数据域,类型为字符型*/
    struct node *next;    /*指针域,类型为本结构体类型*/
}*L;            /*类型重定义,即Node和*L和struct node等价*/
 
main()
{
    L l,p,q;        /*用指针类型定义三个结点类型的指针*/
    char ch;
    l=(L)malloc(sizeof(L));    /*分配内存空间*/
    l->c='\0';            /*为头结点的数据域赋值,值为空*/
    l->next=NULL;            /*指明下一个结点目前不存在*/
    q=l;                /*q为游动指针,链表结点的连结要用*/
    printf("Input a character:\n");
    scanf("%c",&ch);
    getchar();        //此语句用来吸收键盘输入的回车符,没有其它含义
    while(ch!='!')            /*输入!表示输入结束*/
    {
        p=(L)malloc(sizeof(L));    /*为新输入的数据分配内存空间*/
        p->c=ch;
        p->next=NULL;            /*新输入的结点在链表的最后,即它的后面没有其它元素*/
        q->next=p;            /*q用于将上一个元素链接至当前新元素*/
        q=p;                /*q自己移到当前最后一个元素,以备继续链接所用*/
        scanf("%c",&ch);
        getchar();
    }
    q=l;                /*输入整个链表前,先将q移到链表头,l一般不动*/
    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素,则将该元素的数据输出*/
    {
        printf("%c-->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/
        q=q->next;            /*完成该元素的输出后,q移至下一个元素重复输出操作*/
    }
}
 

//All copyright are preserved bycobby
/*单链表的元素查找,按内容查找*/
 

#define NULL 0            /*宏定义*/
typedef struct node        /*定义结点类型的数据结构*/
{
    char c;            /*数据域,类型为字符型*/
    struct node *next;    /*指针域,类型为本结构体类型*/
}*L;            /*类型重定义,即Node和*L和struct node等价*/
 
main()
{
    L l,p,q;        /*用指针类型定义三个结点类型的指针*/
    char ch;
    int n;
    l=(L)malloc(sizeof(L));    /*分配内存空间*/
    l->c='\0';            /*为头结点的数据域赋值,值为空*/
    l->next=NULL;            /*指明下一个结点目前不存在*/
    q=l;                /*q为游动指针,链表结点的连结要用*/
    printf("Input a character:\n");
    scanf("%c",&ch);
    getchar();
    while(ch!='!')            /*输入!表示输入结束*/
    {
        p=(L)malloc(sizeof(L));    /*为新输入的数据分配内存空间*/
        p->c=ch;
        p->next=NULL;            /*新输入的结点在链表的最后,即它的后面没有其它元素*/
        q->next=p;            /*q用于将上一个元素链接至当前新元素*/
        q=p;                /*q自己移到当前最后一个元素,以备继续链接所用*/
        scanf("%c",&ch);
        getchar();
    }
    q=l;                /*输入整个链表前,先将q移到链表头,l一般不动*/
    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素,则将该元素的数据输出*/
    {
        printf("%c-->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/
        q=q->next;            /*完成该元素的输出后,q移至下一个元素重复输出操作*/
    }
 
    /*--------以上为建立一个单链表-------------*/
 

    printf("\nInput a character you wanna find\n");
    scanf("%c",&ch);
    printf("\nthe character you wanna find is %c\n",ch);
    q=l->next;        /*q移至头结点的后一个元素,即实际第一个数据点*/
    n=1;    //位置计数器
    while(q!=NULL)        /*若q不为空,即该结点存在*/
    {
        if(q->c==ch)    /*字符匹配*/
            printf("character found in position %d\n",n);
        q=q->next;    /*移至下一个元素继续查找*/
        n++;
    }
}
 

//All copyright are preserved bycobby
/*元素插入操作*/
 
#define NULL 0            /*宏定义*/
typedef struct node        /*定义结点类型的数据结构*/
{
    char c;            /*数据域,类型为字符型*/
    struct node *next;    /*指针域,类型为本结构体类型*/
}Node,*L;            /*类型重定义,即Node和*L和struct node等价*/
 
main()
{
    L l,p,q;        /*用指针类型定义三个结点类型的指针*/
    char ch;
    int pos,n;
    l=(L)malloc(sizeof(Node));    /*分配内存空间*/
    l->c='\0';            /*为头结点的数据域赋值,值为空*/
    l->next=NULL;            /*指明下一个结点目前不存在*/
    q=l;                /*q为游动指针,链表结点的连结要用*/
    printf("Input a character:\n");
    scanf("%c",&ch);
    getchar();
    while(ch!='!')            /*输入!表示输入结束*/
    {
        p=(L)malloc(sizeof(Node));    /*为新输入的数据分配内存空间*/
        p->c=ch;
        p->next=NULL;            /*新输入的结点在链表的最后,即它的后面没有其它元素*/
        q->next=p;            /*q用于将上一个元素链接至当前新元素*/
        q=p;                /*q自己移到当前最后一个元素,以备继续链接所用*/
        scanf("%c",&ch);
        getchar();
    }
    q=l;                /*输入整个链表前,先将q移到链表头,l一般不动*/
    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素,则将该元素的数据输出*/
    {
        printf("%c-->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/
        q=q->next;            /*完成该元素的输出后,q移至下一个元素重复输出操作*/
    }
 
    /*以上为建立一个单链表*/
 
    printf("Input the character and its position, such as s,3\n\n");
    scanf("%c,%d",&ch,&pos);
    q=l;
    n=1;
    while(n!=pos&&q->next!=NULL)        /*未找到插入位置,且后面还有元素*/
    {
        q=q->next;
        n++;
    }
    /*退出循环后,要么找到插入位置,要么表已到最后,输入的插入位置过大*/
 
    if(n<pos)    /*表已读完,仍未找到插入位置*/
        printf("\n\nincorrect position, insert failed\n\n");
    else        /*找到插入位置*/
    {
        /*将进行插入操作*/
        p=(L)malloc(sizeof(Node));    /*给新输入的数据分配内存空间*/
        p->c=ch;
        p->next=q->next;
        q->next=p;
    }
 
    /*操作完成,然后输出新表*/
    
    q=l;                /*输入整个链表前,先将q移到链表头,l一般不动*/
    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素,则将该元素的数据输出*/
    {
        printf("%c-->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/
        q=q->next;            /*完成该元素的输出后,q移至下一个元素重复输出操作*/
    }
}
 

//All copyright are preserved bycobby
/*按内容元素删除操作*/
 
#include<malloc.h>
#include<stdio.h>
 
#define NULL 0            /*宏定义*/
typedef struct node        /*定义结点类型的数据结构*/
{
    char c;            /*数据域,类型为字符型*/
    struct node *next;    /*指针域,类型为本结构体类型*/
}Node,*L;            /*类型重定义,即Node和*L和struct node等价*/
 
main()
{
    L l,p,q;        /*用指针类型定义三个结点类型的指针*/
    char ch;
    int n;
    l=(L)malloc(sizeof(Node));    /*分配内存空间*/
    l->c='\0';            /*为头结点的数据域赋值,值为空*/
    l->next=NULL;            /*指明下一个结点目前不存在*/
    q=l;                /*q为游动指针,链表结点的连结要用*/
    printf("Input a character:\n");
    scanf("%c",&ch);
    getchar();
    while(ch!='!')            /*输入!表示输入结束*/
    {
        p=(L)malloc(sizeof(Node));    /*为新输入的数据分配内存空间*/
        p->c=ch;
        p->next=NULL;            /*新输入的结点在链表的最后,即它的后面没有其它元素*/
        q->next=p;            /*q用于将上一个元素链接至当前新元素*/
        q=p;                /*q自己移到当前最后一个元素,以备继续链接所用*/
        scanf("%c",&ch);
        getchar();
    }
    q=l;                /*输入整个链表前,先将q移到链表头,l一般不动*/
    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素,则将该元素的数据输出*/
    {
        printf("%c-->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/
        q=q->next;            /*完成该元素的输出后,q移至下一个元素重复输出操作*/
    }
 
    /*以上为建立单链表*/
 
    printf("input the character you wanna delete\n\n");
    scanf("%c",&ch);
    printf("the element you wanna delete is %c\n\n",ch);
    q=l->next;
    p=l;
    n=1;
 
    while(q!=NULL&&q->c!=ch)
    {
        p=q;
        q=q->next;
        n++;
    }
    /*退出循环时可能找到指定元素,也可能表读完,需要进一步判断*/
    
    if(q==NULL)
        printf("element not found, delete failed\n\n");
    else
        p->next=q->next;
 
    q=l->next;                /*输入整个链表前,先将q移到链表头,l一般不动*/
    while(q!=NULL)        /*若q所指向的元素后面还有其它元素,则将该元素的数据输出*/
    {
        printf("%c-->",q->c);    /*q->next->c表示q所指向的下一个元素的数据*/
        q=q->next;            /*完成该元素的输出后,q移至下一个元素重复输出操作*/
    }
}
 
/*按位置删除元素*/
 
#define NULL 0            /*宏定义*/
typedef struct node        /*定义结点类型的数据结构*/
{
    char c;            /*数据域,类型为字符型*/
    struct node *next;    /*指针域,类型为本结构体类型*/
}Node,*L;            /*类型重定义,即Node和*L和struct node等价*/
 
main()
{
    L l,p,q;        /*用指针类型定义三个结点类型的指针*/
    char ch;
    int pos,n;
    l=(L)malloc(sizeof(Node));    /*分配内存空间*/
    l->c='\0';            /*为头结点的数据域赋值,值为空*/
    l->next=NULL;            /*指明下一个结点目前不存在*/
    q=l;                /*q为游动指针,链表结点的连结要用*/
    printf("Input a character:\n");
    scanf("%c",&ch);
    getchar();
    while(ch!='!')            /*输入!表示输入结束*/
    {
        p=(L)malloc(sizeof(Node));    /*为新输入的数据分配内存空间*/
        p->c=ch;
        p->next=NULL;            /*新输入的结点在链表的最后,即它的后面没有其它元素*/
        q->next=p;            /*q用于将上一个元素链接至当前新元素*/
        q=p;                /*q自己移到当前最后一个元素,以备继续链接所用*/
        scanf("%c",&ch);
        getchar();
    }
    q=l;                /*输入整个链表前,先将q移到链表头,l一般不动*/
    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素,则将该元素的数据输出*/
    {
        printf("%c-->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/
        q=q->next;            /*完成该元素的输出后,q移至下一个元素重复输出操作*/
    }
 
    /*以上为建立单链表*/
 
    printf("Input the position\n");
    scanf("%d",&pos);
    p=l;
    n=1;
    while(p->next!=NULL&&n!=pos)
    {
        p=p->next;
        n++;
    }
    /*退出循环后,可能找到删除的元素位置,可能表读完,需要进一步判断*/
    if(n==pos)    /*删除位置找到,删除该位置上的元素*/
    {
        p->next=p->next->next;
        //free(p);
    }
    else
        printf("incorrect position, delete failed\n");
 
    q=l;                /*输入整个链表前,先将q移到链表头,l一般不动*/
    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素,则将该元素的数据输出*/
    {
        printf("%c-->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/
        q=q->next;            /*完成该元素的输出后,q移至下一个元素重复输出操作*/
    }
}
 
//建立双向链表
 
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
 
#define NULL 0
 
typedef struct dlnode
{
    char ch;
    struct dlnode *pri,*next;
}dnode,*dl;
 
main()
{
    dl l,p,q;
    char c;
    l=(dl)malloc(sizeof(dnode));
    l->ch='\0';
    l->next=NULL;
    l->pri=NULL;
    q=l;
 
    printf("输入字符建立双向链表\n");
    scanf("%c",&c);
    getchar();
    
    while(c!='!')
    {
        p=(dl)malloc(sizeof(dnode));
        p->ch=c;
        p->pri=q;
        p->next=NULL;
        q->next=p;
        q=p;
        scanf("%c",&c);
        getchar();
    }
    q=l;
    while(q->next!=NULL)
    {
        q=q->next;
        printf("%c-->",q->ch);
    }
    
    printf("\n");
    while(q->pri!=NULL)
    {
        printf("%c-->",q->ch);
        q=q->pri;
    }
    printf("\n");
}
«上一页1234...7下一页»


相关评论