数据结构伪代码转化成为可执行源代码

1、数据结构伪代码转化为源代码尊重原作者的劳动，我只是个学习者，见此文章，感觉很有用，愿与大家一起分享 -百度文库：桔紫蓝*/ -*/ 出自： 编程中国  */ 作者： cobby    E-mail：jiaxuanyao1982    QQ：51160333*/ 时间： 2007-10-26  编程论坛首发*/ 声明： 尊重作者劳动，转载请保留本段文字*/ -前言：这些是前几年我在大专教书时，数据结构课程中给学生写的学习例程，对于初学者有一定帮助。在此收集到一起，当个共享贴贡献

2、给广大网友和编程爱好者。一般程序都不难也不大，并且所有例程均有较详细注释，适合自学。中间有一个“哈夫曼编码”，程序较大，希望能给大家一点启示。以下所有程序均在VC+6.0开发环境中调试通过，运行正常。有任何疑问可以“另外”发贴讨论。更多内容请访问我的博客。自认为本贴内容充实，对网友会所很大帮助，请版主或者管理员置顶加精，谢谢。数据结构与算法基本程序目录一、    线性表及其操作1、    尾插法建立一个单链表，并按顺序输出2、    单链表的元素查找，按内容查找3、 

3、;   元素插入操作4、    按内容元素删除操作5、    按位置删除元素6、    建立双向链表7、    单链表就地逆置8、    约瑟夫环问题二、    栈及其操作1、    建立堆栈2、    进栈与出栈3、  

4、0; 栈的应用，括号匹配三、    队及其操作1、    链队列的建立2、    入队和出队3、    循环队列建立4、    循环队列的入队和出队操作四、    串及其操作1、    串的朴素匹配五、    树（二叉树）及其操作1、   

5、 二叉排序树2、    哈夫曼编码六、    排序1、    冒泡排序2、    直接选择排序法一、线性表及其操作/All copyright are preserved by cobby/*尾插法建立一个单链表，并按顺序输出*/#define NULL 0            /*宏定义*/typedef

6、 struct node        /*定义结点类型的数据结构*/    char c;            /*数据域，类型为字符型*/    struct node *next;    /*指针域，类型为本结构体类型*/*L;   

7、0;        /*类型重定义，即Node和*L和struct node等价*/main()    L l,p,q;        /*用指针类型定义三个结点类型的指针*/    char ch;    l=(L)malloc(sizeof(L);    /*分配内存空间*/

8、    l->c='0'            /*为头结点的数据域赋值，值为空*/    l->next=NULL;            /*指明下一个结点目前不存在*/    q=l;  

9、;              /*q为游动指针，链表结点的连结要用*/    printf("Input a character:n");    scanf("%c",&ch);    getchar();       &

10、#160;/此语句用来吸收键盘输入的回车符，没有其它含义    while(ch!='!')            /*输入!表示输入结束*/            p=(L)malloc(sizeof(L);    /*为新输入的数据分配内存空间*/ 

11、       p->c=ch;        p->next=NULL;            /*新输入的结点在链表的最后，即它的后面没有其它元素*/        q->next=p;   

12、0;        /*q用于将上一个元素链接至当前新元素*/        q=p;                /*q自己移到当前最后一个元素，以备继续链接所用*/        scanf(&

13、quot;%c",&ch);        getchar();        q=l;                /*输入整个链表前，先将q移到链表头，l一般不动*/    while(q->next!=NUL

14、L)        /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/            printf("%c->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/       &

15、#160;q=q->next;            /*完成该元素的输出后，q移至下一个元素重复输出操作*/    /All copyright are preserved bycobby/*单链表的元素查找，按内容查找*/#define NULL 0            /*宏定义*/typedef str

16、uct node        /*定义结点类型的数据结构*/    char c;            /*数据域，类型为字符型*/    struct node *next;    /*指针域，类型为本结构体类型*/*L;    &#

17、160;       /*类型重定义，即Node和*L和struct node等价*/main()    L l,p,q;        /*用指针类型定义三个结点类型的指针*/    char ch;    int n;    l=(L)malloc(sizeof(L); &#

18、160;  /*分配内存空间*/    l->c='0'            /*为头结点的数据域赋值，值为空*/    l->next=NULL;            /*指明下一个结点目前不存在*/  &

19、#160; q=l;                /*q为游动指针，链表结点的连结要用*/    printf("Input a character:n");    scanf("%c",&ch);    getchar();   

20、; while(ch!='!')            /*输入!表示输入结束*/            p=(L)malloc(sizeof(L);    /*为新输入的数据分配内存空间*/        p-&

21、gt;c=ch;        p->next=NULL;            /*新输入的结点在链表的最后，即它的后面没有其它元素*/        q->next=p;           &

22、#160;/*q用于将上一个元素链接至当前新元素*/        q=p;                /*q自己移到当前最后一个元素，以备继续链接所用*/        scanf("%c",&ch);   

23、0;    getchar();        q=l;                /*输入整个链表前，先将q移到链表头，l一般不动*/    while(q->next!=NULL)       &

24、#160;/*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/            printf("%c->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/        q=q->next;    

25、60;       /*完成该元素的输出后，q移至下一个元素重复输出操作*/        /*-以上为建立一个单链表-*/    printf("nInput a character you wanna findn");    scanf("%c",&ch);    printf

26、("nthe character you wanna find is %cn",ch);    q=l->next;        /*q移至头结点的后一个元素，即实际第一个数据点*/    n=1;    /位置计数器    while(q!=NULL)      

27、60; /*若q不为空，即该结点存在*/            if(q->c=ch)    /*字符匹配*/            printf("character found in position %dn",n);     &

28、#160;  q=q->next;    /*移至下一个元素继续查找*/        n+;    /All copyright are preserved bycobby/*元素插入操作*/#define NULL 0            /*宏定义*/typedef struct no

29、de        /*定义结点类型的数据结构*/    char c;            /*数据域，类型为字符型*/    struct node *next;    /*指针域，类型为本结构体类型*/Node,*L;    

30、60;       /*类型重定义，即Node和*L和struct node等价*/main()    L l,p,q;        /*用指针类型定义三个结点类型的指针*/    char ch;    int pos,n;    l=(L)malloc(sizeof(Node);&#

31、160;   /*分配内存空间*/    l->c='0'            /*为头结点的数据域赋值，值为空*/    l->next=NULL;            /*指明下一个结点目前不存在*/ &

32、#160;  q=l;                /*q为游动指针，链表结点的连结要用*/    printf("Input a character:n");    scanf("%c",&ch);    getchar();  

33、;  while(ch!='!')            /*输入!表示输入结束*/            p=(L)malloc(sizeof(Node);    /*为新输入的数据分配内存空间*/       

34、 p->c=ch;        p->next=NULL;            /*新输入的结点在链表的最后，即它的后面没有其它元素*/        q->next=p;         

35、0;  /*q用于将上一个元素链接至当前新元素*/        q=p;                /*q自己移到当前最后一个元素，以备继续链接所用*/        scanf("%c",&ch);  &

36、#160;     getchar();        q=l;                /*输入整个链表前，先将q移到链表头，l一般不动*/    while(q->next!=NULL)     

37、0;  /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/            printf("%c->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/        q=q->next;   

38、         /*完成该元素的输出后，q移至下一个元素重复输出操作*/        /*以上为建立一个单链表*/    printf("Input the character and its position, such as s,3nn");    scanf("%c,%d",&ch,&

39、;pos);    q=l;    n=1;    while(n!=pos&&q->next!=NULL)        /*未找到插入位置，且后面还有元素*/            q=q->next;    

40、;    n+;        /*退出循环后，要么找到插入位置，要么表已到最后，输入的插入位置过大*/    if(n<pos)    /*表已读完，仍未找到插入位置*/        printf("nnincorrect position, insert failednn"); 

41、;   else        /*找到插入位置*/            /*将进行插入操作*/        p=(L)malloc(sizeof(Node);    /*给新输入的数据分配内存空间*/   

42、0;    p->c=ch;        p->next=q->next;        q->next=p;        /*操作完成，然后输出新表*/        q=l;   

43、;             /*输入整个链表前，先将q移到链表头，l一般不动*/    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/           

44、60;printf("%c->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/        q=q->next;            /*完成该元素的输出后，q移至下一个元素重复输出操作*/    /All cop

45、yright are preserved bycobby/*按内容元素删除操作*/#include<malloc.h>#include<stdio.h>#define NULL 0            /*宏定义*/typedef struct node        /*定义结点类型的数据结构*/    char c; 

46、           /*数据域，类型为字符型*/    struct node *next;    /*指针域，类型为本结构体类型*/Node,*L;            /*类型重定义，即Node和*L和struct node等价*/main()   &

47、#160;L l,p,q;        /*用指针类型定义三个结点类型的指针*/    char ch;    int n;    l=(L)malloc(sizeof(Node);    /*分配内存空间*/    l->c='0'     &

48、#160;      /*为头结点的数据域赋值，值为空*/    l->next=NULL;            /*指明下一个结点目前不存在*/    q=l;              &

49、#160; /*q为游动指针，链表结点的连结要用*/    printf("Input a character:n");    scanf("%c",&ch);    getchar();    while(ch!='!')            

50、;/*输入!表示输入结束*/            p=(L)malloc(sizeof(Node);    /*为新输入的数据分配内存空间*/        p->c=ch;        p->next=NULL;    &

51、#160;       /*新输入的结点在链表的最后，即它的后面没有其它元素*/        q->next=p;            /*q用于将上一个元素链接至当前新元素*/        q=p;   &

52、#160;            /*q自己移到当前最后一个元素，以备继续链接所用*/        scanf("%c",&ch);        getchar();        q=l; 

53、60;              /*输入整个链表前，先将q移到链表头，l一般不动*/    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/          &

54、#160; printf("%c->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/        q=q->next;            /*完成该元素的输出后，q移至下一个元素重复输出操作*/    

55、    /*以上为建立单链表*/    printf("input the character you wanna deletenn");    scanf("%c",&ch);    printf("the element you wanna delete is %cnn",ch);    q=l->next; 

56、   p=l;    n=1;    while(q!=NULL&&q->c!=ch)            p=q;        q=q->next;        n+;

57、60;       /*退出循环时可能找到指定元素，也可能表读完，需要进一步判断*/        if(q=NULL)        printf("element not found, delete failednn");    else     

58、0;  p->next=q->next;    q=l->next;                /*输入整个链表前，先将q移到链表头，l一般不动*/    while(q!=NULL)        /*若q所指向的元素后面还有其它元素，

59、则将该元素的数据输出*/            printf("%c->",q->c);    /*q->next->c表示q所指向的下一个元素的数据*/        q=q->next;          

60、  /*完成该元素的输出后，q移至下一个元素重复输出操作*/    /All copyright are preserved bycobby/*按位置删除元素*/#define NULL 0            /*宏定义*/typedef struct node        /*定义结点类型的数据结构*/  &#

61、160; char c;            /*数据域，类型为字符型*/    struct node *next;    /*指针域，类型为本结构体类型*/Node,*L;            /*类型重定义，即Node和*L和struct node等价*/ma

62、in()    L l,p,q;        /*用指针类型定义三个结点类型的指针*/    char ch;    int pos,n;    l=(L)malloc(sizeof(Node);    /*分配内存空间*/    l->c='0'

63、0;           /*为头结点的数据域赋值，值为空*/    l->next=NULL;            /*指明下一个结点目前不存在*/    q=l;         

64、0;      /*q为游动指针，链表结点的连结要用*/    printf("Input a character:n");    scanf("%c",&ch);    getchar();    while(ch!='!')       &#

65、160;    /*输入!表示输入结束*/            p=(L)malloc(sizeof(Node);    /*为新输入的数据分配内存空间*/        p->c=ch;        p->next=NUL

66、L;            /*新输入的结点在链表的最后，即它的后面没有其它元素*/        q->next=p;            /*q用于将上一个元素链接至当前新元素*/       &#

67、160;q=p;                /*q自己移到当前最后一个元素，以备继续链接所用*/        scanf("%c",&ch);        getchar();     

68、0;  q=l;                /*输入整个链表前，先将q移到链表头，l一般不动*/    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/     

69、0;      printf("%c->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/        q=q->next;            /*完成该元素的输出后，q移至下一个元素重复输出操

70、作*/        /*以上为建立单链表*/    printf("Input the positionn");    scanf("%d",&pos);    p=l;    n=1;    while(p->next!=NULL&&n!=pos

71、)            p=p->next;        n+;        /*退出循环后，可能找到删除的元素位置，可能表读完，需要进一步判断*/    if(n=pos)    /*删除位置找到，删除该位置上的元素*/

72、60;           p->next=p->next->next;        /free(p);        else        printf("incorrect position, delete fai

73、ledn");    q=l;                /*输入整个链表前，先将q移到链表头，l一般不动*/    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/  

74、          printf("%c->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/        q=q->next;            /*完

75、成该元素的输出后，q移至下一个元素重复输出操作*/    /建立双向链表#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define NULL 0typedef struct dlnode    char ch;    struct dlnode *pri,*next;dnode,*dl;main()    dl l,p,q; &#

76、160;  char c;    l=(dl)malloc(sizeof(dnode);    l->ch='0'    l->next=NULL;    l->pri=NULL;    q=l;    printf("输入字符建立双向链表n");   &

77、#160;scanf("%c",&c);    getchar();        while(c!='!')            p=(dl)malloc(sizeof(dnode);        p->ch=c; 

78、;       p->pri=q;        p->next=NULL;        q->next=p;        q=p;        scanf("%c"

79、,&c);        getchar();        q=l;    while(q->next!=NULL)            q=q->next;        p

80、rintf("%c->",q->ch);            printf("n");    while(q->pri!=NULL)            printf("%c->",q->ch);  

81、60;     q=q->pri;        printf("n");/单链表就地逆置#define NULL 0            /*宏定义*/typedef struct node        /*定义结点类型的数据结构*/&#

82、160;   char c;            /*数据域，类型为字符型*/    struct node *next;    /*指针域，类型为本结构体类型*/Node,*L;            /*类型重定义，即Node和*L和struc

83、t node等价*/main()    L l,p,q,r;        /*用指针类型定义三个结点类型的指针*/    char ch;    l=(L)malloc(sizeof(Node);    /*分配内存空间*/    l->c='0'    

84、        /*为头结点的数据域赋值，值为空*/    l->next=NULL;            /*指明下一个结点目前不存在*/    q=l;             

85、   /*q为游动指针，链表结点的连结要用*/    printf("Input a character:n");    scanf("%c",&ch);    getchar();    while(ch!='!')          

86、0; /*输入!表示输入结束*/            p=(L)malloc(sizeof(Node);    /*为新输入的数据分配内存空间*/        p->c=ch;        p->next=NULL;   

87、         /*新输入的结点在链表的最后，即它的后面没有其它元素*/        q->next=p;            /*q用于将上一个元素链接至当前新元素*/        q=p;  

88、              /*q自己移到当前最后一个元素，以备继续链接所用*/        scanf("%c",&ch);        getchar();        q=l;&#

89、160;               /*输入整个链表前，先将q移到链表头，l一般不动*/    while(q->next!=NULL)        /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/         

90、   printf("%c->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/        q=q->next;            /*完成该元素的输出后，q移至下一个元素重复输出操作*/   

91、;     printf("n");    /以上完成了单链表的创建    q=l->next;    p=q->next;    r=p->next;    q->next=NULL;    while(r!=NULL)   

92、0;        p->next=q;        q=p;        p=r;        if(r->next!=NULL)    /r后面还有结点，则逆置继续    

93、60;       r=r->next;        else            break;        r->next=q;    l->next=r;  &#

94、160;     /头结点指向最后一个结点    q=l;                /*输入整个链表前，先将q移到链表头，l一般不动*/    while(q->next!=NULL)        /*若q所指向的元

95、素后面还有其它元素，则将该元素的数据输出*/            printf("%c->",q->next->c);    /*q->next->c表示q所指向的下一个元素的数据*/        q=q->next;       

96、;     /*完成该元素的输出后，q移至下一个元素重复输出操作*/        printf("n");/约瑟夫环问题#include<stdio.h>#include<malloc.h>typedef struct lnode    int num;    struct lnode *next;node,*L;main() &#

97、160;  int amount,start,circle,n,c;    L p,l,q;    printf("一共有几个人围成一圈？n");    scanf("%d",&amount);    getchar();    printf("从第几个开始计数？n");   &#

98、160;scanf("%d",&start);    getchar();    printf("每几人一次循环？n");    scanf("%d",&circle);    getchar();    l=(L)malloc(sizeof(node);     

99、0;  /头结点    l->next=NULL;    l->num=0;    q=l;    n=0;    while(n+<amount)            p=(L)malloc(sizeof(node); 

100、0;      p->next=NULL;        p->num=n;        q->next=p;        q=p;        q->next=l->next;

101、60;       /形成循环链表    /以上完成了单向循环链表的建立    p=l->next;    q=l;    n=1;    while(n+<start)            p=

102、p->next;        q=q->next;        /退出循环时p,q分别位于指定位置    /接下去进行周期性结点删除，直到链表只余一个结点为止    n=1;        /n计算被删除的结点的数量，当n=amount-1时删除结束 &

103、#160;  while(n+<amount)            c=1;    /c作为循环临时变量        while(c+<circle)              

104、60;     p=p->next;            q=q->next;                /删除当前p指向的结点        printf("删

105、除结点%dt",p->num);        q->next=p->next;        p=p->next;        printf("n最后剩下%dn",p->num);二、栈及其操作/All copyright are preserved bycobby/*建立堆栈*/#includ

106、e<stdio.h>#include<malloc.h>#define NULL 0typedef struct node    char ch;    struct node *next;Snode,*stack;main()    stack s,top,p;    char ch;        s=(stack)malloc(

107、sizeof(Snode);    s->ch='0'    s->next=NULL;        /*建立栈底指针*/    top=s;    scanf("%c",&ch);    getchar();    &#

108、160;   while(ch!='!')            p=(stack)malloc(sizeof(Snode);        p->ch=ch;        p->next=top;     &

109、#160;  top=p;        scanf("%c",&ch);        getchar();        while(top->next!=NULL)           &#

110、160;printf("%c->",top->ch);        top=top->next;        printf("n");/All copyright are preserved bycobby/*进栈与出栈*/#include<stdio.h>#include<malloc.h>#define NULL 0typedef struct n

111、ode    char ch;    struct node *next;Snode,*stack;main()    stack s,top,p;    char ch;    int choice;        s=(stack)malloc(sizeof(Snode);   

112、60;s->ch='!'    s->next=NULL;        /*建立栈底指针*/    top=s;    scanf("%c",&ch);    getchar();        while(ch!=

113、9;!')            p=(stack)malloc(sizeof(Snode);        p->ch=ch;        p->next=top;        top=p;  

114、      scanf("%c",&ch);        getchar();        while(p->next!=NULL)    /此处p可用top代替           

115、0;printf("%c->",p->ch);        p=p->next;        printf("n");    /*以上建立了一个堆栈*/    printf("进栈或出栈？输入“1”为进栈，输入“2”为出栈，其它则退出程序n");  

116、0; scanf("%d",&choice);    getchar();    while(choice=1|choice=2)    /若不是输入1或2，则不做任何操作            if(choice=1)        

117、60;           /*进栈*/            printf("n输入要入栈的元素n");            scanf("%c",&ch);   &#

118、160;        getchar();                        p=(stack)malloc(sizeof(Snode);          

119、0; p->ch=ch;            p->next=top;            top=p;                else if(choice=2)&#

120、160;                   if(top->next!=NULL)                top=top->next;        

121、;    else                            printf("栈已清空n");             

122、;   exit();                        /*出栈*/                /printf("%c->",

123、top->ch);        p=top;        while(p->next!=NULL)                    printf("%c->",p->ch); 

124、           p=p->next;                printf("n");        printf("进栈或出栈？输入“1”为进栈，输入“2”为出栈，其它则退出程序n");&#

125、160;       scanf("%d",&choice);        getchar();    /All copyright are preserved bycobby/栈的应用，括号匹配#include<stdio.h>#include<malloc.h>#define NULL 0typedef struct node  

126、  char ch;    struct node *next;snode,*stack;main()    stack s,top,p;    char *string,ch100=""    s=(stack)malloc(sizeof(snode);        /建立栈底元素   

127、; s->ch='0'    s->next=NULL;    top=s;    printf("输入一个含括号的四则运算表达式：n");    scanf("%s",ch);    string=ch;    while(*string!='0') &

128、#160;          if(*string='('|*string=''|*string='')    /遇到左括号，入栈                    p=(stack)malloc(sizeo

129、f(snode);            p->ch=*string;            p->next=top;            top=p;      &

130、#160;         else if(*string=')'|*string=''|*string='')    /遇到右括号                    if(*string=')')&#

131、160;               if(top->ch='(')    /括号匹配                    top=top->next;  &#

132、160;             else                                   

133、0;printf("小括号不匹配");                    exit(0);                        

134、;    else if(*string='')                if(top->ch='')    /括号匹配                &#

135、160;   top=top->next;                else                           

136、;         printf("中括号不匹配");                    exit(0);               

137、             else                if(top->ch='')    /括号匹配           &#

138、160;        top=top->next;                else                      

139、;              printf("大括号不匹配");                    exit(0);