目录
1.线性表
2.顺序存储的线性表--顺序表
3.链式存储的线性表——链表
4.栈
5.队列
6.树
1.线性表
一个线性表是由有限个类型相同的数据元素组成。在这有限个数据元素中，数据元素构成一个有序的序列，除了第一个元素和最后一个元素外，其他元素有唯一的前驱元素和唯一的后继元素。
数据元素可以是原子类型，也可以是复合类型。
线性表主要分为两种，顺序存储结构和链式存储结构。
2.顺序存储的线性表--顺序表
顺序存储的线性表的数据域：
#define ListSize 100//建立线性表的长度
typedef int MyType;//建立自己的线性表想使用的类型
typedef struct
{
MyType list[ListSize];//数据存储部分
int length;//表示线性表当前长度
}SeqList;//线性表本体
线性表的初始化：
void InitList(SeqList *l)//线性表的初始化
{
l->length = 0;
}
判断线性表是否为空：
int ListEmpty(SeqList *l)//判断线性表是否为空
{
if(l->length==0)
return 1;//如果线性表为空则返回1
else
return 0;
}
为线性表指定位置插入元素：
int InsertList(SeqList *l,int i,MyType e)//往线性表里插入数据
{
int j;
if(i<1||i>l->length+1)
{
cout<<"您要插入的位置不合法！"<<endl;
return -1;//返回值-1表示操作不合法
}
else if(l->length==ListSize)
{
cout<<"线性表已满！"<<endl;
return 0;//返回值0表示无法插入
}
else
{
if(l->length==0)
{
l->list[0] = e;
l->length++;
return 1;
}
for(j=l->length;j>=i;j--)
{
l->list[j] = l->list[j-1];
}
l->list[j] = e;
l->length++;
return 1;//返回值1表示插入成功
}
}
按内容查找线性表：
int LocateElem(SeqList l,MyType e)//按内容查找
{
int i;
for(i=0;i<l.length;i++)
if(l.list[i]==e)
return i+1;
return 0;
}
按位置查找：
int GetElem(SeqList *l,int i,MyType *e)//按位置查找
{
if(i<1||i>l->length+1)
{
cout<<"您要查找的位置不合法！"<<endl;
return -1;//返回值-1表示操作不合法
}
*e = l->list[i-1];//将找到的元素放进变量e中
return 1;//返回1表示找到
}
删除指定元素：
int DeleteList(SeqList *l,int i,MyType *e)//删除指定元素
{
int j;
if(l->length<=0)
{
cout<<"空列表无法完成删除操作"<<endl;
return 0;
}
else if(i<1||i>l->length)
{
cout<<"删除位置不合法！"<<endl;
return -1;
}
else
{
*e = l->list[i-1];
for(j=i;j<l->length;j++)
{
l->list[j-1] = l->list[j];
}
l->length--;
return 1;
}
}
返回线性表的长度 ：
int ListLength(SeqList l)//返回线性表的长度
{
return l.length;
}
清空线性表：
void ClearList(SeqList *l) //清空线性表
{
l->length = 0;
}
显示全部线性表 ：
void PrintList(SeqList *l) //显示全部线性表
{
for(int i=0;i<l->length;i++)
cout<<l->list[i]<<" ";
cout<<endl;
}
3.链式存储的线性表——链表
typedef int DataType;
typedef struct Node
{
DataType data;//数据域（车厢运货的部分）
struct Node *next;//指针域（连接车厢的挂钩）
}ListNode,*LinkList;//ListNode是链表每个节点的类型，LinkList是指向链表节点的指针
LinkList L;//表示定义了一个链表。L实际是指向火车头
头结点（火车头的意思）
如果不带头结点链表，L = NULL;表示空链表
带头结点的链表，L->next = NULL;表示空链表
初始化链表：
void InitList(LinkList *head)//初始化链表 （本质是初始化火车头）
{
if((*head=(LinkList)malloc(sizeof(ListNode)))==NULL)//如果内存分配失败
exit(-1);//以错误结束程序
(*head)->next = NULL;//链表头（火车头）先为空
}
判断链表是否为空：
int ListEmpty(LinkList head)//判断链表是否为空
{
if(head->next==NULL)
return 1;//如果为空返回1，否则返回0
else
return 0;
}
按序号查找链表的节点：
ListNode *Get(LinkList head,int i)//按序号查找，找到链表里的第几个元素
{
ListNode *p;
int j;
if(ListEmpty(head))//要判断待查找的链表不能为空
return NULL;
if(i<1)//要查找的序号不能有误
return NULL;
j = 0;
p = head;
while(p->next!=NULL&&j<i)
{
p=p->next;
j++;
}
if(j==i)
return p;//成功返回指向该节点的指针
else
NULL:
}
ListNode *LocateElem(LinkList head,DataType e)//按内容查找
{
ListNode *p;
p = head->next;
while(p)
{
if(p->data!=e)
p=p->next;
else
break;
}
return p;
}
int LocatePos(LinkList head,DataType e)//定位
{
ListNode *p;
int i;
if(ListEmpty(head))
return 0;
p=head->next;
i=1;
while(p)
{
if(p->data==0)
return 1;
else
{
p=p->next;
i++;
}
}
if(!p)
return 0;
}
int InsertList(LinkList head,int i,DataType e)//插入
{
ListNode *p,*pre;
int j;
pre = head;
j=0;
while(pre->next!=NULL&&j<i-1)
{
pre=pre->next;
j++;
}
if(j!=i-1)
{
cout<<"插入位置错！"<<endl;
return 0;
}
if((p=(ListNode *)malloc(sizeof(ListNode)))==NULL)
exit(-1);
p->data=e;
p->next=pre->next;
pre->next = p;
return 1;
}
int DeleteList(LinkList head,int i,DataType *e)//删除指定位置的函数
{
ListNode *pre,*p;
int j;
pre = head;
j = 0;
while(pre->next!=NULL&&pre->next->next!=NULL&&j<i-1)
{
pre=pre->next;
j++;
}
if(j!=i-1)
{
cout<<"删除位置错误"<<endl;
return 0;
}
p=pre->next;
*e=p->data;
pre->next=p->next;
free(p);
return 1;
}
int ListLength(LinkList head)//返回链表长度
{
ListNode *p;
int count = 0;
p = head;
while(p->next!=NULL)
{
p=P->next;
count++;
}
return count;
}
void DestroyList(LinkList head)//销毁链表
{
ListNode *p,*q;
p = head;
while(p!=NULL)
{
q=p;
p=p->next;
free(q);
}
}
循环单链表：指最后一个节点（车厢）的next指向车头head
双向链表：每个节点都有两个指针，一个指向前面，一个指向后面
4.栈
#define StackSize 100
typedef int DataType;
typedef struct
{
DataType stack[StackSize];
int top;
} SeqStack;
void InitStack(SeqStack *S)//初始化栈
{
S->top = 0;
}
int StackEmpty(SeqStack S)//判断栈是否为空
{
if(S.top==0)
return 1;
else
return 0;
}
int GetTop(SeqStack S,DataType *e)//取出一个元素
{
if(S.top<=0)
{
cout<<"栈为空"<<endl;
return 0;
}
else
{
*e = S.stack[S.top-1];
return 1;
}
}
int PushStack(SeqStack *S,DataType e)//进栈操作
{
if(S->top>=StackSize)
{
cout<<"栈已满"<<endl;
return 0;
}
else
{
S->stack[S->top] = e;
S->top++;
return 1;
}
}
int PopStack(SeqStack *S,DataType *e) //出栈操作
{
if(S->top==0)
{
cout<<"栈为空"<<endl;
return 0;
}
else
{
S->top--;
*e = S->stack[S->top];
return 1;
}
}
int StackLength(SeqStack S)//返回栈长度
{
return S.top;
}
void ClearStack(SeqStack *S)//清空栈
{
S->top = 0;
}
int main()
{
SeqStack zhan;
InitStack(&zhan);//初始化栈
return 0;
}
5.队列
#define QueueSize 100
typedef int DataType;
typedef struct Squeue{
DataType queue[QueueSize];
int front,rear;
}SeqQueue;
void InitQueue(SeqQueue *SQ)//初始化队列
{
SQ->front = SQ->rear = 0;
}
int QueueEmpty(SeqQueue SQ)//判断列表是否为空
{
if(SQ.front==SQ.rear)
return 1;
else
return 0;
}
int EnterQueue(SeqQueue *SQ,DataType x)//入队操作
{
if(SQ->rear==QueueSize)
return 0;
SQ->queue[SQ->rear] = x;
SQ->rear++;
return 1;
}
int DeteleQueue(SeqQueue *SQ,DataType *e)//出队操作
{
if(SQ->front==SQ->rear)//判断是否为空
return 0;
else
{
*e = SQ->queue[SQ->front];
SQ->front++;
return 1;
}
}
int main()
{
SeqQueue dl;
InitQueue(&dl);
if(QueueEmpty(dl))
cout<<"队列暂时为空"<<endl;
EnterQueue(&dl,5);
int a;
DeteleQueue(&dl,&a);
cout<<a<<endl;
return 0;
}
6.树
树的结点：包含一个数据元素以及若干指向子树分支的信息。
结点的度：一个结点拥有子树的个数称为结点的度。
叶子结点：也称为终端结点，没有子树的结点也就是度为零的结点称为叶子结点。
分支结点：也称作非终端结点，度不为零的结点称为非终端结点。
孩子结点：一个结点的子树的根结点称为孩子结点。
双亲结点：也称为父节点，如果一个结点存在孩子结点，则该结点就称为孩子结点的双亲结点或者父结点。
子孙结点：在一个根节点的子树中的任何一个结点都称为该结点的子孙结点。
祖先结点：从根节点开始到达一个结点，所经过的所有分支结点，都称为该结点的祖先结点。
兄弟结点：一个双亲结点的所有孩子结点之间互相称作兄弟结点。
树的度：树中所有结点的度的最大值。
树的层次：从根节点开始，根节点为为第一层，根节点的孩子结点为第二层，以此类推，如果某一结点是第L层，则其他孩子结点位于第L+1层。
树的深度：也成为树的高度，树中所有结点的层次最大值称为树的深度。
有序树：如果树中各个子树的次序是有先后次序的，则称该树为有序树。
无序树：如果树中各个子树的次序是没有有先后次序的，则称该树为无序树。
森林：m课互不相交的树构成一个森林。
二叉树：一个结点最多有两个孩子结点。
满二叉树：每层结点都是满的称为满二叉树。
完全二叉树：如果一棵二叉树有n个结点，并且二叉树的n个结点的结构与满二叉树的前n个结点结构完全相同，则称这样的二叉树为完全二叉树。
二叉树的性质：
（1）在二叉树中，第m（m>=1）层上至多有2的m-1次方个结点（规定根节点为第一层）。
（2）深度为k（k>=1)的二叉树中至多有2的k次方减1个结点。
（3）对于任何一棵二叉树T，如果叶子结点总数为n0，度为2的结点总数为n2。，则有n0=n2+1
（4）如果完全二叉树有n个结点，则深度为不大于log以2为底n的对数的最大整数加1。
（5）如果完全二叉树有n个结点，按照从上到下，从左到右的顺序对二叉树对二叉树中的每个结点从1到n进行编号，则对于任意结点i有以下性质：
a.如果i=1，则序号i对应的结点就是根结点，该结点没有双亲结点。如果i>1，则序号为i的结点的双亲结点的序号为不大于i/2的最大整数；
b.如果2*i>n，则序号为i的结点没有左孩子结点；如果2*i<=n，则序号为i的结点的左孩子结点序号为2*i。
c.如果2*i+1>n，则序号为i的结点没有右孩子结点。如果2*i+1<=n，则序号为i的结点的右孩子结点的序号为2*i+1。
typedef int DataType;
typedef struct Node
{
struct Node *leftchild;//指向左孩子结点
struct Node *rightchild;//指向右孩子结点
DataType data;//数据域
}*BitTree,BitNode;
void InitBitTree(BitTree *T)//初始化二叉树
{
*T = NULL;
}
void DestroyBitTree(BitTree *T)//销毁（删除）二叉树
{
if(*T)//二叉树是否为空
{
if((*T)->leftchild)
DestroyBitTree(&(*T)->leftchild);
if((*T)->rightchild)
DestroyBitTree(&(*T)->rightchild);
free(*T);
*T = NULL;
}
}
void CreateBitTree(BitTree *T) //创建二叉树
{
DataType ch;
cin>>ch;
if(ch==0)
*T = NULL;
else
{
*T = (BitTree)malloc(sizeof(BitTree));
if(!(*T))
exit(-1);
(*T)->data = ch;
CreateBitTree(&(*T)->leftchild);
CreateBitTree(&(*T)->rightchild);
}
}
int InsertLeftChild(BitTree p,BitTree c)//二叉树的左插入操作
{
if(p)
{
c->rightchild = p->leftchild;
p->leftchild = c;
return 1;
}
return 0;
}
int InsertRightChild(BitTree p,BitTree c)//二叉树的右插入操作
{
if(p)
{
c->rightchild = p->rightchild;
p->rightchild = c;
return 1;
}
return 0;
}
BitTree Point(BitTree T,DataType e)//返回二叉树结点指针的操作
{
BitTree Q[MaxSize];// MaxSize大小自己定义
int front=0,rear=0;
BitNode *p;
if(T)
{
Q[rear]=T;
rear++;
while(front!=rear)
{
p=Q[front];
front++;
if(p->data==e)
return p;
if(p->leftchild)
{
Q[rear++]=p->leftchild;
}
if(p->rightchild)
{
Q[rear++]=p->rightchild;
}
}
}
return NULL;
}
DataType LeftChild(BitTree T,DataType e)//返回二叉树的结点的左孩子元素值操作
{
BitTree p;
if(T)
{
p = Point(T,e);
if(P&&P->leftchild)
return p->leftchild->data;
}
return ;
}
DataType RightChild(BitTree T,DataType e)//返回二叉树的结点的右孩子元素值操作
{
BitTree p;
if(T)
{
p = Point(T,e);
if(P&&P->rightchild)
return p->rightchild->data;
}
return ;
}
int DeleteLeftChild(BitTree p) //二叉树的左删除操作
{
if(p)
{
DestroyBitTree(&(p->leftchild));
return 1;
}
return 0;
}
int DeleteRightChild(BitTree p) //二叉树的左删除操作
{
if(p)
{
DestroyBitTree(&(p->rightchild));
return 1;
}
return 0;
}
int main()
{
BitTree T;
InitBitTree(&T);
return 0;
}
二叉树的遍历：
（1）先序遍历：
a.访问根结点
b.先序遍历左子树
c.先序遍历右子树
（2）中序遍历：
a.中序遍历左子树
b.访问根结点
c.中序遍历右子树
（3）后序遍历
a.后序遍历左子树
b.后序遍历右子树
c.访问根结点
===================================================
感谢您的点赞！愿每一位程序员少走弯路，每篇博客都是用心输出，希望能够得到您的认可！
2888
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
