数据结构之－链表、栈的实现及题目

GitHub : https://github.com/hanxloop/c_dev_library

前几天码了链表和栈，栈有数组实现和链表实现，自己跑了书上的示例，能跑的通，开心，接口、实现和测试分离，实现后我会补充一些使用这些代码完成的练习题目。

0.错误提示

该文件打印程序运行时出错信息。

1 #include <stdio.h>
2 #include <stdlib.h>
3
4 #define Error( Str )        FatalError( Str )
5 #define FatalError( Str )   fprintf( stderr, "%s\n", Str ), exit( 1 )

fatal.h

１. 链表

  1 /*list.c*/
  2
  3 #include "list.h"
  4 #include <stdlib.h>
  5 #include "fatal.h"
  6
  7 struct Node  {
  8   ElementType Element;
  9   Position    Next;
 10 };
 11
 12 List MakeEmpty( List L )  {
 13   if( L != NULL )
 14     DeleteList( L );
 15
 16   L = malloc( sizeof( struct Node ) );
 17   if( L == NULL )    FatalError( "Out of memory!" );
 18   L->Next = NULL;
 19
 20   return L;
 21 }
 22
 23 int IsEmpty( List L )  {
 24   return L->Next == NULL;
 25 }
 26
 27 int IsLast( Position P, List L )  {
 28   return P->Next == NULL;
 29 }
 30
 31 Position Find( ElementType X, List L )  {
 32   Position P;
 33   P = L->Next;
 34
 35   while( P != NULL && P->Element != X )
 36     P=Advance(P);          //P = P->Next; OK
 37
 38   return P;
 39 }
 40
 41
 42
 43
 44 void Delete( ElementType X, List L )  {
 45   Position P, TmpCell;
 46
 47   P = FindPrevious( X, L );
 48
 49   if( !IsLast( P, L ) )  {
 50     TmpCell = P->Next;
 51     P->Next = TmpCell->Next;
 52     free( TmpCell );
 53   }
 54 }
 55
 56 Position FindPrevious( ElementType X, List L )
 57 {
 58   Position P;
 59   P = L;
 60
 61   while( P->Next != NULL && P->Next->Element != X )
 62     P = P->Next;
 63
 64   return P;
 65 }
 66
 67
 68 void Insert( ElementType X, List L, Position P )  {
 69   Position TmpCell;
 70
 71   TmpCell = malloc( sizeof( struct Node ) );
 72   if( TmpCell == NULL )
 73     FatalError( "Out of space!!!" );
 74
 75   TmpCell->Element = X;
 76   TmpCell->Next = P->Next;
 77   P->Next = TmpCell;
 78 }
 79
 80
 81
 82
 83 void DeleteList( List L ) {
 84   Position P, Tmp;
 85   P = L->Next;
 86   L->Next = NULL;
 87
 88   while( P != NULL ) {
 89     Tmp = P->Next;
 90     //Tmp = Tmp->Next;    OK
 91     free( P );
 92     P = Tmp;
 93   }
 94 }
 95
 96
 97 Position Header( List L )  {
 98   return L;
 99 }
100
101 Position First( List L )  {
102   return L->Next;
103 }
104
105 Position Advance( Position P )  {
106   return P->Next;
107 }
108
109 ElementType Retrieve( Position P )  {
110   return P->Element;
111 }

list.h

  1 /*list.c*/
  2
  3 #include "list.h"
  4 #include <stdlib.h>
  5 #include "fatal.h"
  6
  7 struct Node  {
  8   ElementType Element;
  9   Position    Next;
 10 };
 11
 12 List MakeEmpty( List L )  {
 13   if( L != NULL )
 14     DeleteList( L );
 15
 16   L = malloc( sizeof( struct Node ) );
 17   if( L == NULL )    FatalError( "Out of memory!" );
 18   L->Next = NULL;
 19
 20   return L;
 21 }
 22
 23 int IsEmpty( List L )  {
 24   return L->Next == NULL;
 25 }
 26
 27 int IsLast( Position P, List L )  {
 28   return P->Next == NULL;
 29 }
 30
 31 Position Find( ElementType X, List L )  {
 32   Position P;
 33   P = L->Next;
 34
 35   while( P != NULL && P->Element != X )
 36     P=Advance(P);          //P = P->Next; OK
 37
 38   return P;
 39 }
 40
 41
 42
 43
 44 void Delete( ElementType X, List L )  {
 45   Position P, TmpCell;
 46
 47   P = FindPrevious( X, L );
 48
 49   if( !IsLast( P, L ) )  {
 50     TmpCell = P->Next;
 51     P->Next = TmpCell->Next;
 52     free( TmpCell );
 53   }
 54 }
 55
 56 Position FindPrevious( ElementType X, List L )
 57 {
 58   Position P;
 59   P = L;
 60
 61   while( P->Next != NULL && P->Next->Element != X )
 62     P = P->Next;
 63
 64   return P;
 65 }
 66
 67
 68 void Insert( ElementType X, List L, Position P )  {
 69   Position TmpCell;
 70
 71   TmpCell = malloc( sizeof( struct Node ) );
 72   if( TmpCell == NULL )
 73     FatalError( "Out of space!!!" );
 74
 75   TmpCell->Element = X;
 76   TmpCell->Next = P->Next;
 77   P->Next = TmpCell;
 78 }
 79
 80
 81
 82
 83 void DeleteList( List L ) {
 84   Position P, Tmp;
 85   P = L->Next;
 86   L->Next = NULL;
 87
 88   while( P != NULL ) {
 89     Tmp = P->Next;
 90     //Tmp = Tmp->Next;    OK
 91     free( P );
 92     P = Tmp;
 93   }
 94 }
 95
 96
 97 Position Header( List L )  {
 98   return L;
 99 }
100
101 Position First( List L )  {
102   return L->Next;
103 }
104
105 Position Advance( Position P )  {
106   return P->Next;
107 }
108
109 ElementType Retrieve( Position P )  {
110   return P->Element;
111 }

list.c

testlist.c

2. 链栈

 1 /* stackli.h */
 2
 3 #ifndef STACK_H
 4 #define STACK_H
 5
 6 struct Node;
 7 typedef int ElementType;
 8 typedef struct Node *PtrToNode;
 9 typedef PtrToNode Stack;
10
11 int IsEmpty( Stack S );
12 Stack CreateStack( void );
13 void DisposeStack( Stack S );
14 void MakeEmpty( Stack S );
15 void Push( ElementType X, Stack S );
16 ElementType Top( Stack S );
17 void Pop( Stack S );
18
19 #endif

stackli.h

 1 /* stackli.c */
 2
 3 #include "stackli.h"
 4 #include "fatal.h"
 5 #include <stdlib.h>
 6
 7 struct Node  {
 8   ElementType Element;
 9   PtrToNode   Next;
10 };
11
12
13 int IsEmpty( Stack S )  {
14   return S->Next == NULL;
15 }
16
17
18
19 Stack  CreateStack( void )  {
20   Stack S;
21
22   S = malloc( sizeof( struct Node ) );
23   if( S == NULL )
24     FatalError( "Out of space!!!" );
25   S->Next = NULL;
26   MakeEmpty( S );
27   return S;
28 }
29
30 void  MakeEmpty( Stack S )  {
31   if( S == NULL )
32     Error( "Must use CreateStack first" );
33   else
34     while( !IsEmpty( S ) )
35       Pop( S );
36 }
37
38
39 void  DisposeStack( Stack S )  {
40   MakeEmpty( S );
41   free( S );
42 }
43
44
45 void  Push( ElementType X, Stack S )  {
46   PtrToNode TmpCell;
47
48   TmpCell = malloc( sizeof( struct Node ) );
49   if( TmpCell == NULL )
50     FatalError( "Out of space!!!" );
51   else   {
52       TmpCell->Element = X;
53       TmpCell->Next = S->Next;
54       S->Next = TmpCell;
55     }
56 }
57
58
59
60 ElementType  Top( Stack S )  {
61   if( !IsEmpty( S ) )
62     return S->Next->Element;
63   Error( "Empty stack" );
64   return 0;
65 }
66
67
68 void  Pop( Stack S )  {
69   PtrToNode FirstCell;
70
71   if( IsEmpty( S ) )
72     Error( "Empty stack" );
73   else {
74       FirstCell = S->Next;
75       S->Next = FirstCell->Next;
76       free( FirstCell );
77     }
78 }

stackli.c

 1 /* teststkl.c */
 2
 3 #include <stdio.h>
 4 #include "stackli.c"
 5
 6 int main( )
 7 {
 8     Stack S;
 9     int i;
10
11     S = CreateStack( );
12     for( i = 0; i < 10; i++ )
13         Push( i, S );
14
15     while( !IsEmpty( S ) )
16     {
17         printf( "%d\n", Top( S ) );
18         Pop( S );
19     }
20
21     DisposeStack( S );
22     return 0;
23 }

teststackli.c

3. 数组栈

 1 /* stackar.h */
 2
 3 #ifndef _Stack_h
 4 #define _Stack_h
 5
 6 typedef int ElementType;
 7 struct StackRecord;
 8 typedef struct StackRecord *Stack;
 9
10 int IsEmpty( Stack S );
11 int IsFull( Stack S );
12 Stack CreateStack( int MaxElements );
13 void DisposeStack( Stack *S );
14 void MakeEmpty( Stack S );
15 void Push( ElementType X, Stack S );
16 ElementType Top( Stack S );
17 void Pop( Stack S );
18 ElementType TopAndPop( Stack S );
19
20 #endif

stackar.h

 1 /* stackar.c */
 2
 3 #include "stackar.h"
 4 #include "fatal.h"
 5 #include <stdlib.h>
 6
 7 #define EmptyTOS ( -1 )
 8 #define MinStackSize ( 5 )
 9
10 struct StackRecord   {
11   int Capacity;
12   int TopOfStack;
13   ElementType *Array;
14 };
15
16
17 int IsEmpty( Stack S )  {
18   return S->TopOfStack == EmptyTOS;
19 }
20
21
22 int IsFull( Stack S )  {
23   return S->TopOfStack == S->Capacity - 1;
24 }
25
26
27 Stack  CreateStack ( int MaxElements )  {
28   Stack S;
29
30   if( MaxElements < MinStackSize )
31     Error( "Stack size is too small" );
32
33   S = malloc( sizeof( struct StackRecord ) );
34   if( S == NULL )
35     FatalError( "Out of space!!!" );
36
37   S->Array = malloc( sizeof( ElementType ) * MaxElements );
38   if( S->Array == NULL )
39     FatalError( "Out of space!!!" );
40   S->Capacity = MaxElements;
41   MakeEmpty( S );
42
43   return S;
44 }
45
46
47 void  MakeEmpty( Stack S )  {
48   S->TopOfStack = EmptyTOS;
49 }
50
51 void  DisposeStack( Stack *S )  {
52   if( S != NULL )   {
53     free( (*S)->Array );
54     free( *S );
55   }
56 }
57
58
59 void  Push( ElementType X, Stack S )  {
60   if( IsFull( S ) )
61     Error( "Full stack" );
62   else
63     S->Array[ ++S->TopOfStack ] = X;
64 }
65
66
67
68 ElementType  Top( Stack S )  {
69   if( !IsEmpty( S ) )
70     return S->Array[ S->TopOfStack ];
71   else {
72     Error( "Empty stack" );
73     return 0;  /* Return value used to avoid warning */
74   }
75 }
76
77 void  Pop( Stack S )  {
78   if( IsEmpty( S ) )
79     Error( "Empty stack" );
80   else
81     S->TopOfStack--;
82 }
83
84
85 ElementType  TopAndPop( Stack S )  {
86   if( !IsEmpty( S ) )
87     return S->Array[ S->TopOfStack-- ];
88   Error( "Empty stack" );
89   return 0;
90 }

stackar.c

 1 /*teststka.c  */
 2
 3 #include <stdio.h>
 4 #include "stackar.c"
 5
 6 int main()  {
 7   Stack S;
 8   int i;
 9
10   S = CreateStack( 12 );
11   for( i = 0; i < 10; i++ )
12     Push( i, S );
13
14   while( !IsEmpty( S ) )   {
15     printf( "%d\n", Top( S ) );
16     Pop( S );
17   }
18
19   DisposeStack( &S );
20   return 0;
21 }

teststka.c

时间： 2024-10-16 19:21:44

数据结构之－链表、栈的实现及题目的相关文章

数据结构实验之栈：行编辑器

数据结构实验之栈:行编辑器题目描述一个简单的行编辑程序的功能是:接受用户从终端输入的程序或数据,并存入用户的数据区. 由于用户在终端上进行输入时,不能保证不出差错,因此,若在编辑程序中,“每接受一个字符即存入用户数据区”的做法显然不是最恰当的.较好的做法是,设立一个输入缓冲区,用以接受用户输入的一行字符,然后逐行存入用户数据区.允许用户输入出差错,并在发现有误时可以及时更正.例如,当用户发现刚刚键入的一个字符是错的时,可补进一个退格符"#",以表示前一个字符无效: 如果发现当前

顺序栈与链表栈的实现

栈是一种常见的数据结构,它虽然有栈顶和栈底之分,但它只能从一端操作(插入或删除),从而是一种"先进后出"的操作模式.向栈内进数据称为压栈(Push),从栈里取出数据叫出栈(POp).例如压栈顺序为1.2.3.4.5,着出栈的顺序为5.4.3.2.1(只考虑一次性出栈的情况). 栈按照存储的方式,又分为顺序栈和链表栈.顺序栈基于数组实现,所以顺序栈存储数据的内存是连续的,在创建栈时规定好栈的大小,这样对内存的使用效率并不高.而链式栈则是采用了链表来实现,其元素的存储地址是不连续的,而且是

SDUT OJ 1479 数据结构实验之栈：行编辑器

数据结构实验之栈:行编辑器 Time Limit: 1000ms Memory limit: 65536K 有疑问?点这里^_^ 题目描述一个简单的行编辑程序的功能是:接受用户从终端输入的程序或数据,并存入用户的数据区. 由于用户在终端上进行输入时,不能保证不出差错,因此,若在编辑程序中,“每接受一个字符即存入用户数据区”的做法显然不是最恰当的.较好的做法是,设立一个输入缓冲区,用以接受用户输入的一行字符,然后逐行存入用户数据区.允许用户输入出差错,并在发现有误时可以及时更正.例如,当

数据结构与算法--栈、队列(队列)

Hello,everybody.我们又见面了.今天我们来学习一下队列这个数据结构,let's Go,开始我们的征程吧. 首先,举两个生活中的常见例子.相信大家,在用电脑工作娱乐时,都会碰到这样的现象.当我们点击程序或进行其他操作时,电脑处于死机状态.正当我们准备Reset时,它突然像打了鸡血似的,突然把刚才我们的操作,按顺序执行了一遍.之所以会出现这个现象,是因为操作系统的多个程序,需要通过一个管道输出,而按先后顺序排队造成的. 还有有个例子,在我们打客服热线时,有时会出现等待的现象.当其他客户

数据结构与算法-栈和队列

一.简介众所周知,线性表是数据结构的基础,通常有两种实现方式:数组和链表.栈和队列是最常用的数据结构,它们基于线性表实现. 二.栈定义:栈是限定仅在表尾进行插入和删除操作的线性表,即FILO. 栈被经常类比于弹夹,即先被压如弹夹的子弹最后被打出.根据线性表的实现方式得知,栈的实现方式有两种:数组实现和链表实现. 栈的数组实现: package basic.data_structure.cha01; /** * 栈:先进后出(FILO),只允许在栈顶操作元素 * 栈的基本操作: * 初始化栈.

数据结构-复杂链表的复杂

题目:请实现函数ComplexListNode* Clone(ComplexListNode* pHead),复杂一个复杂链表.在复杂链表中,每个节点除了有一个Next指针指向下一个节点外,还有一个Sibling指向链表中的任意节点或者NULL. 分析:第一反应是先复制Next,再复制Sibling.但是这种方式需要两次遍历.时间性不是很好.所以利用一个长链表方式解决时间效率. /* 剑指offer面试题26 */ #include <iostream> #include <cstri

数据结构实验之栈三：后缀式求值

数据结构实验之栈三:后缀式求值 Time Limit: 1000ms Memory limit: 65536K 有疑问?点这里^_^ 题目描述对于一个基于二元运算符的后缀表示式(基本操作数都是一位正整数),求其代表的算术表达式的值. 输入输入一个算术表达式的后缀式字符串,以'#'作为结束标志. 输出求该后缀式所对应的算术表达式的值,并输出之. 示例输入 59*684/-3*+# 示例输出 57 提示基本操作数都是一位正整数! 来源示例程序 #include <stdio.h>

数据结构实验之栈二：一般算术表达式转换成后缀式

数据结构实验之栈二:一般算术表达式转换成后缀式 Time Limit: 1000ms Memory limit: 65536K 有疑问?点这里^_^ 题目描述对于一个基于二元运算符的算术表达式,转换为对应的后缀式,并输出之. 输入输入一个算术表达式,以'#'字符作为结束标志. 输出输出该表达式转换所得到的后缀式. 示例输入 a*b+(c-d/e)*f# 示例输出 ab*cde/-f*+ 提示来源示例程序由一般是求后缀式: 1.设立暂时存放运算符的栈: 2.设表达式的结束符为"#

数据结构实验之栈一：进制转换(栈的应用)

数据结构实验之栈一:进制转换 Time Limit: 1000ms Memory limit: 65536K 有疑问?点这里^_^ 题目描述输入一个十进制整数,将其转换成对应的R(2<=R<=9)进制数,并输出. 输入第一行输入需要转换的十进制数: 第二行输入R. 输出输出转换所得的R进制数. 示例输入 1279 8 示例输出 2377 提示来源示例程序后台数据太水,按理说应该考虑零的情况,但是你不判断零也是对的. #include <stdio.h> #i

数据结构实验之栈四：括号匹配(栈)

数据结构实验之栈四:括号匹配 Time Limit: 1000ms Memory limit: 65536K 有疑问?点这里^_^ 题目描述给你一串字符,不超过50个字符,可能包括括号.数字.字母.标点符号.空格,你的任务是检查这一串字符中的( ) ,[ ],{ }是否匹配. 输入输入数据有多组,处理到文件结束. 输出如果匹配就输出"yes",不匹配输出"no" 示例输入 sin(20+10) {[}] 示例输出 yes no 提示来源 ma6174