数据结构（1）

最新推荐文章于 2022-10-05 23:05:06 发布

Z_JUN9

最新推荐文章于 2022-10-05 23:05:06 发布

阅读量249

点赞数

分类专栏：数据结构与算法文章标签：数据结构线性结构链表

本文链接：https://blog.csdn.net/qq_39944285/article/details/89520301

版权

数据结构与算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

数据结构

1 线性结构

1.1 多项式表示

（1）顺序存储结构直接表示

（2）采用顺序存储结构表示多项式的非零项

（3）采用链表结构来存储多项式的非零项

1.2 线性表的顺序存储实现

typedef  struct { 
ElementType  Data[MAXSIZE];   
 	int  Last;
} List;

1.3 线性表的链式存储实现

typedef struct LNode *List；
typedef  struct Node{ 
   ElementType  Data;   
   struct Node *Next;
} 

/*或者*/
typedef  struct Node{ 
   ElementType  Data;   
   struct Node *Next;
} List；

链表插入

List *Insert( ElementType X, int i, List *PtrL )
{       List  *p, *s;
        if ( i == 1 ) {     /* 新结点插入在表头 */
             s = (List *)malloc(sizeof(List)); /*申请、填装结点*/
             s->Data = X; 
             s->Next = PtrL;
             return s;      /*返回新表头指针*/
        }
        p = FindKth( i-1, PtrL );   /* 查找第i-1个结点 */
        if ( p == NULL ) {             /* 第i-1个不存在，不能插入 */
                 printf(＂参数i错＂);
                 return NULL; 
        }else {
                s = (List *)malloc(sizeof(List)); /*申请、填装结点*/
                s->Data = X; 
                s->Next = p->Next;     /*新结点插入在第i-1个结点的后面*/
                p->Next = s; 
                return PtrL;
       }

链表删除

List *Delete( int  i, List *PtrL )
{       List  *p, *s;
         if ( i == 1 ) {                 /* 若要删除的是表的第一个结点 */
               s = PtrL;                /*s指向第1个结点*/
               PtrL = PtrL->Next;     /*从链表中删除*/
               free(s);                 /*释放被删除结点 */
               return PtrL;
         }
         p = FindKth( i-1, PtrL );      /*查找第i-1个结点*/
         if ( p == NULL ) { 
                printf(“第%d个结点不存在”, i-1);     return NULL; 
        } else  if ( p->Next == NULL ){ 
                printf(“第%d个结点不存在”, i);      return NULL; 
        } else  {
               s = p->Next;             /*s指向第i个结点*/
               p->Next = s->Next;      /*从链表中删除*/
               free(s);                      /*释放被删除结点 */
               return PtrL;
       }
}

1.4 广义表和多重链表

广义表

typeset struct GNode{
     int Tag;  /*标志域：0表示该结点是单元素，1表示该结点是广义表 */
     union { /* 子表指针域Sublist与单元素数据域Data复用，即共用存储空间 */
        ElementType    Data;
        struct GNode *SubList; 
     } URegion;
     struct GNode *Next;   /* 指向后继结点 */
} GList;

广义表示意图
广义表结构示例
多重链表

#define MAXSIZE 50        /* 矩阵最大非0元素个数 */
typedef enum  { Head, Term } NodeTag;
typedef struct MatrixNode  *PtrMatrix;
typedef struct  TermNode {
	int  Row;
	int  Col;	
	ElementType  Value;
};
typedef struct  MatrixNode {
	PtrMatrix Down;
	PtrMatrix Right;
	NodeTag Tag;
	union {
		PtrMatrix  Next;
		TermNode  Term;
	}  URegion;
};
PtrMatrix  HeadNode [MAXSIZE];

多重链表图

1.5 堆栈

堆、栈、队列之间的区别是？
①堆是在程序运行时，而不是在程序编译时，申请某个大小的内存空间。即动态分配内存，对其访问和对一般内存的访问没有区别。
②栈就是一个桶，后放进去的先拿出来，它下面本来有的东西要等它出来之后才能出来。（后进先出）
③队列只能在队头做删除操作,在队尾做插入操作.而栈只能在栈顶做插入和删除操作。（先进先出）

1.5.1 栈的顺序存储实现

栈的顺序存储结构通常由一个一维数组和一个记录栈顶元素位置的变量组成。

#define MaxSize  <储存数据元素的最大个数>
typedef struct {
	ElementType Data[MaxSize];
	int Top;
} Stack;

入栈：

void Push( Stack *PtrS, ElementType item )
{
    if ( PtrS->Top == MaxSize-1 ) {
 printf(“堆栈满”);  return;
 }else {
  PtrS->Data[++(PtrS->Top)] = item;
      return;
    }
}

出栈

ElementType Pop( Stack *PtrS )
{
    if ( PtrS->Top == -1 ) {
           printf(“堆栈空”);
           return ERROR; /* ERROR是ElementType的特殊值，标志错误 */
    } else 
           return ( PtrS->Data[(PtrS->Top)--] );
}

例子：用一个数组实现两个堆栈，比较聪明的方法是使这两个栈分别从数组的两头开始向中间生长；当两个栈的栈顶指针相遇时，表示两个栈都满了。此时，最大化地利用了数组空间。

#define MaxSize <存储数据元素的最大个数>
struct DStack {
     ElementType Data[MaxSize];   
     int Top1;   /* 堆栈１的栈顶指针 */ 
     int Top2;   /* 堆栈２的栈顶指针 */
} S;
S.Top1 =  -1; 
S.Top2 = MaxSize;

void Push( struct DStack *PtrS, ElementType item, int Tag )
{  /* Tag作为区分两个堆栈的标志，取值为1和2 */
   if ( PtrS->Top2 – PtrS->Top1 == 1) {  /*堆栈满*/
printf(“堆栈满”);   return ;
   }
   if ( Tag == 1 ) /* 对第一个堆栈操作 */
      PtrS->Data[++(PtrS->Top1)] = item;
   else              /* 对第二个堆栈操作 */
      PtrS->Data[--(PtrS->Top2)] = item;
}
ElementType Pop( struct DStack *PtrS, int Tag )
{  /* Tag作为区分两个堆栈的标志，取值为1和2  */
  if ( Tag == 1 ) {  /* 对第一个堆栈操作  */
      if ( PtrS->Top1 == -1 ) { /*堆栈1空 */
     printf(“堆栈1空”);   return NULL;
      } else return PtrS->Data[(PtrS->Top1)--];
   } else {          /* 对第二个堆栈操作 */
      if ( PtrS->Top2 == MaxSize ) { /*堆栈2空 */
           printf(“堆栈2空”);  return NULL;
      } else  return PtrS->Data[(PtrS->Top2)++];
}
}

1.5.2 栈的链式存储实现

typedef struct Node{
	ElementType  Data;
	struct Node *Next;
} LinkStack; 
LinkStack *Top;

LinkStack *CreateStack() 
{  /* 构建一个堆栈的头结点，返回指针 */
   LinkStack *S;
   S = malloc( sizeof(struct Node ));
   S->Next = NULL;
   return S;
}
int IsEmpty( LinkStack *S )  
{  /*判断堆栈S是否为空，若为空函数返回整数1，否则返回0 */
 return ( S->Next == NULL );
}

void Push( ElementType item, LinkStack *S )    
{  /* 将元素item压入堆栈S  */
struct Node *TmpCell;
TmpCell = malloc( sizeof( struct Node ) );
TmpCell->Element = item;
TmpCell->Next = S->Next;
S->Next = TmpCell;
}

ElementType Pop( LinkStack *S )
{  /* 删除并返回堆栈S的栈顶元素 */
   struct Node *FirstCell;
ElementType TopElem;
if( IsEmpty( S ) ) {
printf(“堆栈空”);  return NULL;
} else {
FirstCell = S->Next; 
S->Next = FirstCell->Next;
TopElem = FirstCell ->Element;
free(FirstCell);
return TopElem;
}
}

1.6 队列

1.6.1 顺序存储实现

#define MaxSize  <储存数据元素的最大个数>
typedef  struct  {
	ElementType  Data[ MaxSize ];
	int  rear;
	int  front;
} Queue;

循环队列：
入队列

void AddQ( Queue *PtrQ, ElementType item)
{   
      if ( (PtrQ->rear+1) % MaxSize == PtrQ->front ) {
           printf(“队列满”);      
           return;
      }
      PtrQ->rear = (PtrQ->rear+1)% MaxSize;
      PtrQ->Data[PtrQ->rear] = item;
}

出队列

ElementType DeleteQ ( Queue *PtrQ )
{          
       if ( PtrQ->front == PtrQ->rear ) { 
             printf(“队列空”);
             return ERROR;
       }  else  {
            PtrQ->front = (PtrQ->front+1)% MaxSize;
            return  PtrQ->Data[PtrQ->front];
       }
}

1.6.2 链式存储实现

typedef struct Node{
      ElementType  Data;
      struct Node  *Next;
}QNode; 
typedef  struct {        /* 链队列结构  */
     QNode  *rear;      /* 指向队尾结点 */
     QNode  *front;     /* 指向队头结点 */
} LinkQueue;
LinkQueue  *PtrQ ;

不带头节点的链式队列出队

ElementType DeleteQ ( LinkQueue  *PtrQ )
{    Qnode  *FrontCell; 
      ElementType FrontElem;
 
      if  ( PtrQ->front == NULL) {
             printf(“队列空”);     return ERROR;
      } 
      FrontCell = PtrQ->front;
      if ( PtrQ->front == PtrQ->rear)     /* 若队列只有一个元素 */
             PtrQ->front = PtrQ->rear = NULL;   /* 删除后队列置为空 */
      else                     
             PtrQ->front = PtrQ->front->Next;
      FrontElem = FrontCell->Data;
      free( FrontCell );                            /* 释放被删除结点空间  */
      return  FrontElem;
}