顺序表,链表,顺序栈,链栈,顺序队列,链栈
一、顺序表
1.1 顺序表定义
# include <stdio.h>
# include <malloc.h>
# define MAX_SIZE 100
typedef struct
{
int data[ MAX_SIZE] ;
int length;
} SqList;
1.2 在顺序表第i个位置插入元素e
void ListInsert ( SqList * L, int i, int e)
{
if ( i < 1 || i > L-> length + 1 )
{
return ;
}
if ( L-> length >= MAX_size)
{
return ;
}
for ( int j = L-> length; j >= i; j-- )
{
L-> data[ j] = L-> data[ j - 1 ] ;
}
L-> data[ i - 1 ] = e;
L-> length++ ;
}
1.3 在顺序表删除第i个元素
void ListDelete ( SqList * L, int i, int * e)
{
if ( i < 1 || i > L-> length)
{
return ;
}
( * e) = L-> data[ i - 1 ] ;
for ( int j = i; j < L-> length; j++ )
{
L-> data[ j - 1 ] = L-> data[ j] ;
}
L-> length-- ;
}
1.4 在顺序表查找第1个值为e的元素
int LocateElem ( SqList L, int e)
{
for ( int i = 0 ; i < L. length; i++ )
{
if ( L. data[ i] == e)
{
return i + 1 ;
}
}
return 0 ;
}
1.5 在顺序表获取第i个元素的值赋值给e
int GetElem ( SqList L, int i, int * e)
{
if ( i < 1 || i > L. length)
{
return 0 ;
}
( * e) = L. data[ i - 1 ] ;
return 1 ;
}
二、链表
2.1 单链表
2.1.1 单链表定义
typedef struct LNode {
int data;
struct LNode * next;
} LNode, * LinkList;
2.1.2 单链表初始化
void InitList ( LinkList * L)
{
( * L) = ( LinkList) malloc ( sizeof ( LNode) ) ;
( * L) -> next = NULL ;
}
2.1.3 单链表头插法建表
void CreateListHead ( LinkList * L)
{
LinkList p;
int n, x;
printf ( "请输入链表的长度:" ) ;
scanf ( "%d" , & n) ;
int i;
for ( i = 0 ; i < n; i++ )
{
p = ( LinkList) malloc ( sizeof ( LNode) ) ;
printf ( "请输入第%d个元素:" , i + 1 ) ;
scanf ( "%d" , & x) ;
p-> data = x;
p-> next = ( * L) -> next;
( * L) -> next = p;
}
}
2.1.4 单链表尾插法建表
void CreateListTail ( LinkList * L)
{
LinkList p, r;
int n, x;
printf ( "请输入链表的长度:" ) ;
scanf ( "%d" , & n) ;
int i;
r = ( * L) ;
for ( i = 0 ; i < n; i++ )
{
p = ( LinkList) malloc ( sizeof ( LNode) ) ;
printf ( "请输入第%d个元素:" , i + 1 ) ;
scanf ( "%d" , & x) ;
p-> data = x;
r-> next = p;
r = p;
}
r-> next = NULL ;
}
2.1.5 单链表查找第i个位置元素
void ListGet ( LinkList * L, int i, int * e)
{
LinkList p;
int j;
p = ( * L) ;
j = 0 ;
while ( p && j < i)
{
p = p-> next;
j++ ;
}
if ( ! p || j > i)
{
return ;
}
( * e) = p-> data;
}
2.1.6 单链表第i个位置前插入元素
void ListPreInsert ( LinkList * L, int i, int e)
{
LinkList p, s;
int j;
p = ( * L) ;
j = 1 ;
while ( p && j < i)
{
p = p-> next;
j++ ;
}
if ( ! p || j > i)
{
return ;
}
s = ( LinkList) malloc ( sizeof ( LNode) ) ;
s-> data = e;
s-> next = p-> next;
p-> next = s;
}
2.1.7 单链表第i个位置后插入元素
void ListPostInsert ( LinkList * L, int i, int e)
{
LinkList p, s;
int j;
p = ( * L) ;
j = 0 ;
while ( p && j < i)
{
p = p-> next;
j++ ;
}
if ( ! p || j > i)
{
return ;
}
s = ( LinkList) malloc ( sizeof ( LNode) ) ;
s-> data = e;
s-> next = p-> next;
p-> next = s;
}
2.1.8 单链表删除第i个元素
void ListDelete ( LinkList * L, int i, int * e)
{
LinkList p, q;
int j;
p = ( * L) ;
j = 1 ;
while ( p-> next && j < i)
{
p = p-> next;
j++ ;
}
if ( ! ( p-> next) || j > i)
{
return ;
}
q = p-> next;
p-> next = q-> next;
( * e) = q-> data;
free ( q) ;
}
2.1.9 单链表查找第1个与e相等的值
int ListLocate ( LinkList * L, int e)
{
LinkList p;
int j;
p = ( * L) ;
j = 0 ;
while ( p && p-> data != e)
{
p = p-> next;
j++ ;
}
if ( ! p)
{
return - 1 ;
}
return j;
}
2.1.10 单链表的长度
int ListLength ( LinkList * L)
{
LinkList p;
int j;
p = ( * L) ;
j = 0 ;
while ( p)
{
p = p-> next;
j++ ;
}
return j;
}
2.2 双链表
2.2.1 双链表的定义
typedef struct DNode {
int data;
struct DNode * prior;
struct DNode * next;
} DNode, * DLinkList;
2.2.2 双链表初始化
void InitDList ( DLinkList * L)
{
( * L) = ( DLinkList) malloc ( sizeof ( DNode) ) ;
( * L) -> prior = NULL ;
( * L) -> next = NULL ;
}
2.2.3 双链表头插法建表
void CreateDListF ( DLinkList * L)
{
DLinkList p;
int i, n, x;
printf ( "请输入双链表的长度:" ) ;
scanf ( "%d" , & n) ;
for ( i = 0 ; i < n; i++ )
{
p = ( DLinkList) malloc ( sizeof ( DNode) ) ;
printf ( "请输入第%d个元素:" , i + 1 ) ;
scanf ( "%d" , & x) ;
p-> data = x;
p-> next = ( * L) -> next;
if ( ( * L) -> next)
{
( * L) -> next-> prior = p;
}
( * L) -> next = p;
p-> prior = ( * L) ;
}
}
2.2.4 双链表尾插法建表
void CreateDListR ( DLinkList * L)
{
DLinkList p, r;
int i, n, x;
printf ( "请输入双链表的长度:" ) ;
scanf ( "%d" , & n) ;
( * L) = ( DLinkList) malloc ( sizeof ( DNode) ) ;
( * L) -> prior = NULL ;
( * L) -> next = NULL ;
r = ( * L) ;
for ( i = 0 ; i < n; i++ )
{
p = ( DLinkList) malloc ( sizeof ( DNode) ) ;
printf ( "请输入第%d个元素:" , i + 1 ) ;
scanf ( "%d" , & x) ;
p-> data = x;
r-> next = p;
p-> prior = r;
r = p;
}
r-> next = NULL ;
}
2.2.5 双链表查找第i个元素(等同单链表)
2.2.6 双链表第i个元素后插入元素
void DListInsert ( DLinkList * L, int i, int e)
{
DLinkList p, s;
int j;
p = ( * L) ;
j = 0 ;
while ( p && j < i)
{
p = p-> next;
j++ ;
}
if ( ! p || j > i)
{
return ;
}
s = ( DLinkList) malloc ( sizeof ( DNode) ) ;
s-> data = e;
s-> next = p-> next;
if ( p-> next)
{
p-> next-> prior = s;
}
p-> next = s;
s-> prior = p;
}
2.2.7 双链表删除第i个元素
void DListDelete ( DLinkList * L, int i)
{
DLinkList p;
int j;
p = ( * L) ;
j = 0 ;
while ( p && j < i)
{
p = p-> next;
j++ ;
}
if ( ! p || j > i)
{
return ;
}
p-> prior-> next = p-> next;
if ( p-> next)
{
p-> next-> prior = p-> prior;
}
free ( p) ;
}
三、栈
3.1 顺序栈
3.1.1 顺序栈的定义
# include <stdio.h>
# include <malloc.h>
# define MAX_SIZE 100
typedef struct {
int data[ MAX_SIZE] ;
int top;
} SqStack;
3.1.2 顺序栈初始化
void InitStack ( SqStack * S)
{
S-> top = - 1 ;
}
3.1.3 顺序栈判断栈空
int StackEmpty ( SqStack S)
{
if ( S. top == - 1 )
{
return 1 ;
}
else
{
return 0 ;
}
}
3.1.4 顺序栈进栈
int Push ( SqStack * S, int x)
{
if ( S-> top == MAX_SIZE - 1 )
{
return 0 ;
}
S-> top++ ;
S-> data[ S-> top] = x;
return 1 ;
}
3.1.5 顺序栈出栈
int Pop ( SqStack * S, int * x)
{
if ( S-> top == - 1 )
{
return 0 ;
}
* x = S-> data[ S-> top] ;
S-> top-- ;
return 1 ;
}
3.1.6 顺序栈取栈顶元素
int GetTop ( SqStack S, int * x)
{
if ( S. top == - 1 )
{
return 0 ;
}
* x = S. data[ S. top] ;
return 1 ;
}
3.2 链栈
3.2.1 链栈定义
typedef struct StackNode {
int data;
struct StackNode * next;
} StackNode, * LinkStackPtr;
3.2.2 链栈初始化
void InitStack ( LinkStackPtr * S)
{
* S = ( LinkStackPtr) malloc ( sizeof ( StackNode) ) ;
( * S) -> next = NULL ;
}
3.2.3 链栈判空
int StackEmpty ( LinkStackPtr S)
{
if ( S-> next== NULL )
{
return 1 ;
}
else
{
return 0 ;
}
}
3.2.4 链栈进栈
int Push ( LinkStackPtr * S, int x)
{
LinkStackPtr p;
p = ( LinkStackPtr) malloc ( sizeof ( StackNode) ) ;
p-> data = x;
p-> next = ( * S) -> next;
* S = p;
return 1 ;
}
3.2.5 链栈出栈
int Pop ( LinkStackPtr * S, int * x)
{
LinkStackPtr p;
if ( * S == NULL )
{
return 0 ;
}
p = ( * S) -> next;
* S = ( * S) -> next;
* x = p-> data;
free ( p) ;
return 1 ;
}
3.2.6 链栈取栈顶元素
int GetTop ( LinkStackPtr S, int * x)
{
if ( S-> next == NULL )
{
return 0 ;
}
* x = S-> next-> data;
return 1 ;
}
四、队列
4.1 顺序队列
4.1.1 顺序队列的定义
typedef struct {
int data[ MAX_SIZE] ;
int front;
int rear;
} SqQueue;
4.1.2 顺序队列的初始化
void InitQueue ( SqQueue * Q)
{
Q-> front = Q-> rear = 0 ;
}
4.1.3 顺序队列判空
int QueueEmpty ( SqQueue Q)
{
if ( Q. front == Q. rear)
{
return 1 ;
}
else
{
return 0 ;
}
}
4.1.4 顺序(循环)队列入队
int EnQueue ( SqQueue * Q, int x)
{
if ( ( Q-> rear + 1 ) % MAX_SIZE == Q-> front)
{
return 0 ;
}
Q-> data[ Q-> rear] = x;
Q-> rear = ( Q-> rear + 1 ) % MAX_SIZE;
return 1 ;
}
4.1.5 顺序(循环)队列出队
int DeQueue ( SqQueue * Q, int * x)
{
if ( Q-> front == Q-> rear)
{
return 0 ;
}
* x = Q-> data[ Q-> front] ;
Q-> front = ( Q-> front + 1 ) % MAX_SIZE;
return 1 ;
}
4.1.6 顺序队列取队头元素
int GetHead ( SqQueue Q, int * x)
{
if ( Q. front == Q. rear)
{
return 0 ;
}
* x = Q. data[ Q. front] ;
return 1 ;
}
4.2 链队
4.2.1 链队定义
typedef struct QNode {
int data;
struct QNode * next;
} QNode, * QueuePtr;
typedef struct {
QNode * front;
QNode * rear;
} LinkQueue;
4.2.2 链队初始化
void InitQueue ( LinkQueue * Q)
{
Q-> front = Q-> rear = ( QueuePtr) malloc ( sizeof ( QNode) ) ;
Q-> front-> next = NULL ;
}
4.2.3 链队判空
int QueueEmpty ( LinkQueue Q)
{
if ( Q. front == Q. rear)
{
return 1 ;
}
else
{
return 0 ;
}
}
4.2.4 链队入队
int EnQueue ( LinkQueue * Q, int x)
{
QueuePtr p;
p = ( QueuePtr) malloc ( sizeof ( QNode) ) ;
p-> data = x;
p-> next = NULL ;
Q-> rear-> next = p;
Q-> rear = p;
return 1 ;
}
4.2.5 链队出队
int DeQueue ( LinkQueue * Q, int * x)
{
QueuePtr p;
if ( Q-> front == Q-> rear)
{
return 0 ;
}
p = Q-> front-> next;
* x = p-> data;
Q-> front-> next = p-> next;
if ( Q-> rear == p)
{
Q-> rear = Q-> front;
}
free ( p) ;
return 1 ;
}
4.2.6 链队取队头元素
int GetHead ( LinkQueue Q, int * x)
{
if ( Q. front == Q. rear)
{
return 0 ;
}
* x = Q. front-> next-> data;
return 1 ;
}