目前进度到：链队列。
README.md
README.md
# 1.线性表
```
typedef struct sqlist
{
int *data;
int length;
int listsize;
}sqnode;//表头
```
# 2.链表
```
typedef struct LNode{
int data;
struct LNode* next;
}lnode;
```
# 3.双链表
```
typedef struct DNode{
int data;
struct DNode *next;//下一个节点 后驱节点
struct DNode *pr;//上一个节点 前驱节点
}dnode;
```
# 4.循环链表
```
typedef struct CNode{
int data;
struct CNode *next;
}cnode;
```
# 5.循环双链表
```
typedef struct CDNode{
int data;
struct CDNode *next;//下一个节点 后驱节点
struct CDNode *pr;//上一个节点 前驱节点
}cdnode;
```
# 6.静态链表
```
typedef struct slink{
int data;
int cur;
}StaticLink[SIZE];
```
# 7.顺序栈
```
typedef struct stack{
int* base;
int top;
int stracksize;
}seqStack;
```
# 8.链栈
```
typedef struct node{
int data;
struct node* next;
}linkStack;
```
# 9.循环队列
```
typedef struct circleQueue{
int* base; //数据地址
int front; //头指针
int rear; //尾指针
}cirQueue;
```
# 10.链队列
```
typedef struct LinkQueueNode{
int data;
struct LinkQueueNode* next;
}lqnode;
typedef struct LinkQueue{
lqnode* front;
lqnode* rear;
}lqueue;
```1、顺序表
//
// DS01_sqlist.c
// MacC_Learn01
//
// Created by Remoo on 2022/9/6.
//
// Xcode Dev
//
#include <stdio.h>
#include <stdlib.h>
#define INITSIZE 10
typedef struct
{
int *data;
int length;
int listsize;
}sqlist;//表头
void initlist(sqlist *L);
int getlen(sqlist *L);
int getelem(sqlist *L,int i, int *e);
void list(sqlist *L);
int insert(sqlist *L,int i,int x);
int SeqListErase(sqlist* sl, int pos);
int main(void)
{
sqlist sq_list;
int x;
int *elem=(int *)malloc(sizeof(int));
initlist(&sq_list);
//此时sq_list的data已经存储了malloc出来的内存首地址
printf("input datas(-1:end):");
scanf("%d",&x);
int i=1;
while(x!=-1)
{
insert(&sq_list,i,x);
i++;
scanf("%d",&x);
}
printf("目前顺序表元素如下:\n");
list(&sq_list);
int index,x0;
printf("在第几位序插入什么元素：\n");
scanf("%d %d",&index,&x0);
if(insert(&sq_list,index,x0))
list(&sq_list);
else
printf("插入失败!");
printf("取第几个元素：\n");
int n;
scanf("%d",&n);
if(getelem(&sq_list,n,elem))
printf("取出的元素是：%d\n",*elem);
else
printf("取出失败!");
printf("删除第几个元素：\n");
int d;
scanf("%d",&d);
if(SeqListErase(&sq_list,d))
list(&sq_list);
else
printf("删除失败！");
free(sq_list.data);
free(elem);
return 0;
}
/* 1.初始化操作(创建一个空的顺序表L) */
void initlist(sqlist *L)
{
L->data=(int *)malloc(sizeof(int)*INITSIZE);/* 申请存储空间*/
L->length=0; /* 初始长度为0 */
L->listsize=INITSIZE; /* 容量为初始量 */
}
/* 2. 求表长操作 */
int getlen(sqlist *L)
{return(L->length);}
/* 3. 取元素操作 */
int getelem(sqlist *L,int i, int *e)
{
if(i<1||i>L->length) return 0;
*e = L->data[i-1];
return 1;
}
/* 4.输出操作(输出顺序表L的各数据元素值) */
void list(sqlist *L)
{
int i;
for(i=0;i<L->length;i++)
printf("%5d ",L->data[i]);
printf("\n");
}
/* 5. 插入操作(在顺序表L中的第i个位序上插入一个值为x的数据元素) */
int insert(sqlist *L,int i,int x)
{
int j;
if(i<1||i>L->length+1) return 0; // 参数i不合理,返回0
if(L->length==L->listsize) // 存储空间不够，增加一个存储空间
{
L->data=(int *)realloc(L->data,(L->listsize+1)*sizeof(int));
L->listsize++; // 增加一个存储空间长度
}
for(j=L->length-1;j>=i-1;j--)
L->data[j+1]=L->data[j]; // 将序号为i及之后的数据元素后移一位
L->data[i-1]=x; // 在序号i处放入x
L->length++; // 顺序表长度增1
return 1; // 插入成功,返回1
}
int SeqListErase(sqlist* sl, int pos){
if(pos > sl->length)return 0;
for (int i = pos; i < sl->length; i++){
sl->data[i - 1] = sl->data[i];
}
sl->length--;
return 1;
}2、单向链表
//
// DS002_LNode.c
// DataStructure
//
// Created by Remoo on 2022/9/17.
//
// Xcode Dev
//
#include <stdio.h>
#include <stdlib.h>
typedef struct LNode{
int data;
struct LNode* next;
}lnode;
//基本操作
lnode* CreateLNode(int n);
int GetLinkLength(lnode *head);
int GetValue(lnode *head,int index);
int FindIndex(lnode *head,int value);
int Delete(lnode *head,int index);
int InsertValue(lnode *head,int index,int value);
void PrintLink(lnode *head);
//涉及算法
int Turn(lnode *head);
int main(void){
int temp=0;int value=0;
printf("输入_初始化元素（10个）:");
lnode* test=CreateLNode(10);
printf("%d",test->data);
PrintLink(test);
printf("元素数量:%d\n",GetLinkLength(test));
Turn(test);
PrintLink(test);
printf("输入_位序：");
scanf("%d",&temp);
value = GetValue(test,temp);
printf("\n取得值：%d\n",value);
printf("输入_元素：");
scanf("%d",&temp);
value = FindIndex(test,temp);
printf("\n取得位序：%d\n",value);
printf("输入_待删除位序：");
scanf("%d",&temp);
if(Delete(test,temp))printf("\nsucceed");else printf("\nfaild!");
PrintLink(test);
printf("输入_待插入位序、数值：");
scanf("%d %d",&temp,&value);
if(InsertValue(test,temp,value))printf("\nsucceed");else printf("\nfaild!");
PrintLink(test);
}
//创建单链表
lnode *CreateLNode(int n){
lnode* p_head,*p_next,*p_loop;
int i;
p_next=p_head=(lnode*)malloc(sizeof(lnode));
for (i=1; i<=n; i++) {
p_loop=(lnode*)malloc(sizeof(lnode));
scanf("%d",&p_loop->data);
p_next->next=p_loop;
p_next=p_loop;
}
p_next->next=NULL;
return p_head;
}
//取得链表长度
int GetLinkLength(lnode *head){
lnode *p;int n;
n=0;
p=head->next;
while(p!=NULL){
n++;p=p->next;
}
return n;
}
//取得元素值
int GetValue(lnode *head,int index){
lnode *p;int j;
if(index<1)return 0;
j=1;p=head->next;
while(p!=NULL&&j<index){
p=p->next;j++;
}
if(p==NULL)return 0;
return p->data;
}
//查找元素索引
int FindIndex(lnode *head,int value){
int i = 1;
lnode *p_temp = head->next;
while(p_temp!=NULL&&p_temp->data!=value){
p_temp=p_temp->next;i++;
}
return i;
}
//删除元素
int Delete(lnode *head,int index){
lnode *p_1,*p_2;int j;
if(index<1&&index>GetLinkLength(head))
return 0;
p_1=head;j=0;
while(p_1->next!=NULL&&j<index-1){
p_1=p_1->next;j++;
}
p_2=p_1->next;
p_1->next=p_2->next;
free(p_2);
return 1;
}
//插入元素
int InsertValue(lnode *head,int index,int value){
lnode *p_1,*p_new;int j;
if(index<1)return 0;
p_1=head;j=0;
while(p_1!=NULL&&j<index-1){
p_1=p_1->next;j++;
}
if(p_1==NULL)return 0;
p_new=(lnode*)malloc(sizeof(lnode));
p_new->data=value;
p_new->next=p_1->next;
p_1->next=p_new;
return 1;
}
//打印链表
void PrintLink(lnode *head){
lnode *p;int index;
p=head->next;index=1;printf("\n");
while(p!=NULL){
printf("%3d:%-3d\t",index,p->data);
p=p->next;index++;
}
printf("\n");
}
//逆置元素
int Turn(lnode *head){
lnode *p,*q;
p=head->next;
head->next=NULL;
while(p!=NULL){//断头，然后头连屁股。重复。
q=p->next;
p->next=head->next;
head->next=p;
p=q;
}
return 1;
}3、双链表
//
// DS03_DNode.c
// DS03_DNode
//
// Created by Remoo on 2022/9/26.
//
// Xcode Dev
//
#include <stdio.h>
#include <stdlib.h>
typedef struct DNode{
int data;
struct DNode *next;//下一个节点 后驱节点
struct DNode *pr;//上一个节点 前驱节点
}dnode;
//基本操作
dnode* CreateDNode(int n);
int Insert(dnode *head,int index,int value);
int Delete(dnode *head,int index);
void PrintLink(dnode *head);//与LNode一样,只是增加了逆向输出的功能
int GetLinkLength(dnode *head);//与LNode一样
int GetValue(dnode *head,int index);//与LNode一样
int FindIndex(dnode *head,int value);//与LNode一样
//算法1
void Move(dnode *head);
int main() {
int temp=0;
dnode* test=CreateDNode(5);
PrintLink(test);
printf("元素数量:%d\n",GetLinkLength(test));
PrintLink(test);
printf("输入_待删除位序：");
scanf("%d",&temp);
if(Delete(test,temp))printf("\nsucceed");else printf("\nfaild!");
PrintLink(test);
}
//把所有大于等于0的数放在负数的前面
/*
分析：现将p赋值为位序1的地址，q赋值为链表尾部地址。
p从左向右寻找最近的非负数，q从右向左寻找负数，然后两者交换。循环上述操作。
*/
void Move(dnode *head){
dnode *p,*q;int temp;
p=head->next;
for (q=head; q->next!=NULL; q=q->next);//直接将q移动到节点的尾部
while(p!=q){
while(p!=q&&p->data>=0)p=p->next;
while(p!=q&&q->data<0)q=q->pr;
if(p!=q){
temp=p->data;
p->data=q->data;
q->data=temp;
}
}
}
//创建双链表
/*
分析：双链表的结构与单链表类似，只是多了一个前驱节点。
*/
dnode* CreateDNode(int n){
dnode *head,*p,*q;int i;
p=head=(dnode*)malloc(sizeof(dnode));//先给头节点指针、位序1的指针开辟内存空间
for(i=1;i<=n;i++){
q=(dnode*)malloc(sizeof(dnode));
scanf("%d",&q->data);
q->pr=p;
p->next=q;
p=q;
}
p->next=head->pr=NULL;//两端节点置空
return head;
}
//取得链表长度
/*
分析：与单链表一致。
*/
int GetLinkLength(dnode *head){
dnode *p;int n;
n=0;
p=head->next;
while(p!=NULL){
n++;p=p->next;
}
return n;
}
/*
分析：与单链表一致。
*/
int GetValue(dnode *head,int index){
dnode *p;int j;
if(index<1)return 0;
j=1;p=head->next;
while(p!=NULL&&j<index){
p=p->next;j++;
}
if(p==NULL)return 0;
return p->data;
}
/*
分析：与单链表一致。
*/
int FindIndex(dnode *head,int value){
int i = 1;
dnode *p_temp = head->next;
while(p_temp!=NULL&&p_temp->data!=value){
p_temp=p_temp->next;i++;
}
return i;
}
//删除链表
/*
分析：先确定删除位置i的合理性，包括输入值要大于等于1且小于链表长度。
其次将指针定位到需要删除的节点位序上。然后取出前驱节点和后驱节点。
将上一个节点的next地址赋值给下一个节点的pr，奖下一个节点的pr赋值给上一个节点的next。
最后free需要删除的节点即可。
*/
int Delete(dnode *head,int index){//index输入的是位序
dnode *n;int i;
if(index<1||index>GetLinkLength(head))return 0;
n=head;i=0;
while(n->next!=NULL&&i!=index){
n=n->next;i++;
}//现在n已经指到了index的位置了
n->pr->next=n->next;
n->next->pr=n->pr;
free(n);
return 1;
}
//插入元素
/*
首先判断输入i合理性，包括输入值要大于等于1且小于链表长度。
其次将指针n指向位序i。
创建malloc一个new节点，data赋值对应内容value。
new节点的后驱节点是原位序为i的地址，new的前驱节点是原位序为i的前驱节点。
然后将原位序为i的前驱节点的后驱节点改为new的地址，将原位序为i的前驱节点改为new的地址。
*/
int Insert(dnode *head,int index,int value){
dnode *n,*new;int i;
if(index<1&&index>GetLinkLength(head))return 0;
n=head;i=0;
while(n->next!=NULL&&i!=index){
n=n->next;i++;
}//现在n已经指到了index的位置了
new=(dnode*)malloc(sizeof(dnode));
new->data=value;
new->next=n;
new->pr=n->pr;
n->pr->next=new;//这一行需要小心
n->pr=new;
return 1;
}
//打印链表
void PrintLink(dnode *head){
dnode *p;int index;
p=head;index=0;printf("\n顺序输出：");
while(p->next!=NULL){
p=p->next;index++;
printf("\n%3d:%-3d\t%p\t%p\t%p",index,p->data,p->pr,p,p->next);
}
printf("\n逆序输出：");
while(p!=head){
printf("%3d:%-3d\t",index,p->data);
p=p->pr;index--;
}
printf("\n");
}4、循环单向链表
//
// main.c
// DS04_circleList
//
// Created by Remoo on 2022/9/27.
//
// Xcode Dev
//
#include <stdio.h>
#include <stdlib.h>
typedef struct CNode{
int data;
struct CNode *next;
}cnode;
//基本算法
cnode *CreateList(int n);
int GetLinkLength(cnode *head);
int GetValue(cnode *head,int index);
int FindIndex(cnode *head,int value);
int Delete(cnode *head,int index);
int InsertValue(cnode *head,int index,int value);
void PrintLink(cnode *head);
//创建循环链表
cnode *CreateCNode(int n){
cnode *head,*p,*s;
int i;
p=head=(cnode*)malloc(sizeof(cnode));
for(i=1;i<=n;i++){
s=(cnode*)malloc(sizeof(cnode));
scanf("%d",&s->data);
p->next=s;
p=s;
}
p->next=head;//尾巴指向头部，即为循环单链表。其余和单链表一致。
return head;
}
//取得链表长度
int GetLinkLength(cnode *head){
cnode *p;int n;n=0;
p=head->next;
while(p!=head){//只有这一个地方与单链表相异
n++;p=p->next;
}
return n;
}
//取元素操作
int GetValue(cnode *head,int index){
cnode *p;int j;
if(index<1)return 0;
j=1;p=head->next;
while(p!=head&&j<index){//这里与单链表相异
p=p->next;j++;
}
if(p==head)return 0;//这里与单链表相异
return p->data;
}
//查找元素索引
int FindIndex(cnode *head,int value){
int i = 1;
cnode *p_temp = head->next;
while(p_temp!=head&&p_temp->data!=value){//这里与单链表相异
p_temp=p_temp->next;i++;
}
return i;
}
//删除元素
int Delete(cnode *head,int index){
cnode *p_1,*p_2;int j;
if(index<1&&index>GetLinkLength(head))
return 0;
p_1=head;j=0;
while(p_1->next!=head&&j<index-1){//这里与单链表相异
p_1=p_1->next;j++;
}
p_2=p_1->next;
p_1->next=p_2->next;
free(p_2);
return 1;
}
//插入元素
int InsertValue(cnode *head,int index,int value){
cnode *p_1,*p_new;int j;
if(index<1&&index>GetLinkLength(head))return 0;
p_1=head;j=0;
while(p_1->next!=head&&j<index-1){//这里与单链表相异
p_1=p_1->next;j++;//将p_1指到index
}
p_new=(cnode*)malloc(sizeof(cnode));
p_new->data=value;
p_new->next=p_1->next;
p_1->next=p_new;
return 1;
}
//打印链表
void PrintLink(cnode *head){
cnode *p;int index;
p=head->next;index=1;printf("\n");
while(p!=head){//这里与单链表相异
printf("%3d:%-3d\t",index,p->data);
p=p->next;index++;
}
printf("\n");
}
int main() {
int temp=0;int value=0;
printf("输入_初始化元素（10个）:");
cnode* test=CreateCNode(10);
printf("%d",test->data);
PrintLink(test);
printf("元素数量:%d\n",GetLinkLength(test));
printf("输入_位序：");
scanf("%d",&temp);
value = GetValue(test,temp);
printf("\n取得值：%d\n",value);
printf("输入_元素：");
scanf("%d",&temp);
value = FindIndex(test,temp);
printf("\n取得位序：%d\n",value);
printf("输入_待删除位序：");
scanf("%d",&temp);
if(Delete(test,temp))printf("\nsucceed");else printf("\nfaild!");
PrintLink(test);
printf("输入_待插入位序、数值：");
scanf("%d %d",&temp,&value);
if(InsertValue(test,temp,value))printf("\nsucceed");else printf("\nfaild!");
PrintLink(test);
}5、循环双头链表
//
// main.c
// DS05_CDNode
//
// Created by Remoo on 2022/9/27.
//
#include <stdio.h>
#include <stdlib.h>
typedef struct CDNode{
int data;
struct CDNode *next;//下一个节点 后驱节点
struct CDNode *pr;//上一个节点 前驱节点
}cdnode;
//基本操作
cdnode* CreateDNode(int n);
int Insert(cdnode *head,int index,int value);
int Delete(cdnode *head,int index);
void PrintLink(cdnode *head);//与LNode一样,只是增加了逆向输出的功能
int GetLinkLength(cdnode *head);//与LNode一样
int GetValue(cdnode *head,int index);//与LNode一样
int FindIndex(cdnode *head,int value);//与LNode一样
//算法1
void Move(cdnode *head);
int main() {
int temp=0;
cdnode* test=CreateDNode(5);
PrintLink(test);
printf("元素数量:%d\n",GetLinkLength(test));
Insert(test,2,100);
PrintLink(test);
printf("输入_待删除位序：");
scanf("%d",&temp);
if(Delete(test,temp))printf("\nsucceed");else printf("\nfaild!");
PrintLink(test);
}
//创建双链表
/*
分析：双链表的结构与单链表类似，只是多了一个前驱节点。
*/
cdnode* CreateDNode(int n){
cdnode *head,*p,*q;int i;
p=head=(cdnode*)malloc(sizeof(cdnode));//先给头节点指针、位序1的指针开辟内存空间
for(i=1;i<=n;i++){
q=(cdnode*)malloc(sizeof(cdnode));
scanf("%d",&q->data);
q->pr=p;
p->next=q;
p=q;
}
p->next=head;head->pr=p;//两端节点连首尾
return head;
}
//取得链表长度
/*
分析：与单链表一致。
*/
int GetLinkLength(cdnode *head){
cdnode *p;int n;
n=0;
p=head->next;
while(p!=head){
n++;p=p->next;
}
return n;
}
/*
分析：与单链表一致。
*/
int GetValue(cdnode *head,int index){
cdnode *p;int j;
if(index<1)return 0;
j=1;p=head->next;
while(p!=head&&j<index){
p=p->next;j++;
}
if(p==head)return 0;
return p->data;
}
/*
分析：与单链表一致。
*/
int FindIndex(cdnode *head,int value){
int i = 1;
cdnode *p_temp = head->next;
while(p_temp!=head&&p_temp->data!=value){
p_temp=p_temp->next;i++;
}
return i;
}
//删除链表
/*
分析：先确定删除位置i的合理性，包括输入值要大于等于1且小于链表长度。
其次将指针定位到需要删除的节点位序上。然后取出前驱节点和后驱节点。
将上一个节点的next地址赋值给下一个节点的pr，奖下一个节点的pr赋值给上一个节点的next。
最后free需要删除的节点即可。
*/
int Delete(cdnode *head,int index){//index输入的是位序
cdnode *n;int i;
if(index<1&&index>GetLinkLength(head))return 0;
n=head;i=0;
while(n->next!=head&&i!=index){
n=n->next;i++;
}//现在n已经指到了index的位置了
n->pr->next=n->next;
n->next->pr=n->pr;
free(n);
return 1;
}
//插入元素
/*
首先判断输入i合理性，包括输入值要大于等于1且小于链表长度。
其次将指针n指向位序i。
创建malloc一个new节点，data赋值对应内容value。
new节点的后驱节点是原位序为i的地址，new的前驱节点是原位序为i的前驱节点。
然后将原位序为i的前驱节点的后驱节点改为new的地址，将原位序为i的前驱节点改为new的地址。
*/
int Insert(cdnode *head,int index,int value){
cdnode *n,*new;int i;
if(index<1&&index>GetLinkLength(head))return 0;
n=head;i=0;
while(n->next!=head&&i!=index){
n=n->next;i++;
}//现在n已经指到了index的位置了
new=(cdnode*)malloc(sizeof(cdnode));
new->data=value;
new->next=n;
new->pr=n->pr;
n->pr->next=new;//这一行需要小心
n->pr=new;
return 1;
}
//打印链表
void PrintLink(cdnode *head){
cdnode *p;int index;
p=head->next;index=1;printf("\n顺序输出：");
while(p!=head){
printf("%3d:%-3d\t",index,p->data);
p=p->next;index++;
}
p=head->pr;
printf("\n逆序输出：");
while(p!=head){
printf("%3d:%-3d\t",index,p->data);
p=p->pr;index--;
}
printf("\n");
}6、静态链表
//
// main.c
// DS06_SNode
//
// Created by Remoo on 2022/9/28.
//
// Xcode Dev
//
#include <stdio.h>
#include <stdlib.h>
#define SIZE 5
//连续的一块内存空间
typedef struct {
int data;
int cur;
}StaticLink[SIZE];
void CreateList(StaticLink space){
int i;
for (i=0; i<SIZE-1; i++) {
space[SIZE].cur=i+1;
space[SIZE-1].cur=0;
}
}
int GetNode(StaticLink space){
int i;
i=space[0].cur;
if(i==0)return 0;
space[0].cur=space[i].cur;
return i;
}
void FreeNode(StaticLink space,int i){
space[i].cur=space[0].cur;space[0].cur=i;
}
void CreateLink(StaticLink space,int n){
int head,k,s,i;
k=head=GetNode(space);
for(i=1;i<=n;i++){
s=GetNode(space);
scanf("%d",&space[s].data);
space[k].cur=s;
k=s;
}
space[k].cur=0;
}
int GetLength(StaticLink space,int head){
int i,k;
k=space[head].cur;i=0;
while(k!=0){
i++;k=space[k].cur;
}
return i;
}
int GetValue(StaticLink space,int head,int i){
int j,k;
if(i<1)return 0;
j=0;k=head;
while(k!=0&&j<i){
j++;k=space[k].cur;
}
if(k==0)return 0;
return space[k].data;
}
int Insert(StaticLink space,int head,int i,int value){
int j,k,m;
if(i<1)return 0;
k=head;j=0;
while(k!=0&&j<i-1){
j++;k=space[k].cur;
}
if(k==0)return 0;
m=GetNode(space);
if(m!=0){
space[m].data=value;
space[m].cur=space[k].cur;
space[k].cur=m;
return 1;
}
else return 0;
}
int Delete(StaticLink space,int head,int i){
int j,k,m;
if(i<0)return 0;
k=head;j=0;
while(k!=0&&j<i-1){
j++;k=space[k].cur;
}
if(k==0)return 0;
m=space[k].cur;
space[k].cur=space[m].cur;
FreeNode(space, m);
return 1;
}
void Show(StaticLink space,int head){
int i;
i=space[head].cur;
while(i!=0){
printf("%4d",space[i].data);
i=space[i].cur;
}
printf("\n");
}
int main() {
}7、顺序栈
//
// main.c
// DS07_seqStack
//
// Created by Remoo on 2022/9/28.
//
#include <stdio.h>
#include <stdlib.h>
#define SIZE 20
/*
顺序栈：
栈的顺序储存。
同时利用一个变量记录当前栈顶的位置（下标或指针），称为栈顶指针。
栈顶是没有存或者可以直接被覆盖的内容！压栈直接压在栈顶处，然后栈顶指针再往上移动。
*/
typedef struct{
int* base;
int top;
int stracksize;
}seqStack;
//常规操作
seqStack* CreateStack(void);
int GetLength(seqStack* stack);
int GetTop(seqStack* stack);
void SaveOp(seqStack* stack);
void SaveOp(seqStack* stack);
int IsStackEmpty(seqStack* stack);
void Push(seqStack* stack,int value);
int Pop(seqStack* stack);
void ShowStack(seqStack* stack);
//算法 十进制整数m转换成n进制数。
void Conversion(seqStack* stack,int m,int n);
seqStack* CreateStack(void){
seqStack *stack;
stack=(seqStack*)malloc(sizeof(seqStack));
stack->base=(int*)malloc(SIZE*sizeof(int));
stack->top=0;
stack->stracksize=SIZE;
return stack;
}
//取得栈的长度
int GetLength(seqStack* stack){
return stack->top;
}
//得到栈顶的元素
int GetTop(seqStack* stack){
if(stack->top==0)return 0;//top等于0，则为空栈
return stack->base[stack->top-1];
}
//检查是否栈满 安全检查
void SaveOp(seqStack* stack){
if (stack->top >= stack->stracksize) {
stack->stracksize++;
stack->base=(int*)realloc(stack->base, (stack->stracksize)*sizeof(int));
}
}
int IsStackEmpty(seqStack* stack){
if(stack->top==0)return 1;
else return 0;
}
//压栈
void Push(seqStack* stack,int value){
SaveOp(stack);
stack->base[stack->top++]=value;
}
//删除 弹栈
int Pop(seqStack* stack){
if(IsStackEmpty(stack))return 0;
stack->top--;
return 1;
}
void ShowStack(seqStack* stack){
int i;
for (i=stack->top-1; i>=0; i--)
printf("%-4d",stack->base[i]);
printf("\n");
}
void ClearAll(seqStack* stack){
for (int i=0; i<=GetLength(stack); i++)
Pop(stack);
}
void Conversion(seqStack* stack,int m,int n){
while(m!=0){
Push(stack,m%n);m=m/n;
}
ShowStack(stack);
}
long Fac(seqStack* stack,int n){
long f=1;int x;
while(n>0){
Push(stack,n);
n--;
}
ShowStack(stack);
while(!IsStackEmpty(stack)){
x=GetTop(stack);
Pop(stack);
f *= x;
}
return f;
}
int main(){
seqStack* stack;
stack = CreateStack();
printf("%ld\n",Fac(stack,10));
Push(stack, 999);
ShowStack(stack);
}8、链栈
//
// main.c
// DS08_LStack
//
// Created by Remoo on 2022/9/30.
//
#include <stdio.h>
#include <stdlib.h>
typedef struct node{
int data;
struct node* next;
}linkStack;
//基本操作
linkStack* CreateStack(void);
int GetTop(linkStack* stack);
int Push(linkStack* stack,int value);
int Pop(linkStack* stack);
int IsEmptyStack(linkStack* stack);
void PrintStack(linkStack* head);
//算法
void TurnLink1(linkStack* s1,linkStack* s2);
int main() {
printf("DS08_linkStack \n");
linkStack *stack1,*stack2;
stack1 = CreateStack();
stack2 = CreateStack();
Push(stack1,11);Push(stack1,12);Push(stack1,13);
Push(stack2,21);Push(stack2,22);Push(stack2,23);
PrintStack(stack1);
PrintStack(stack2);
}
//初始化链栈 头节点的data不存储值
linkStack* CreateStack(void){
linkStack* stack;//定义linkStack指针类型
stack=(linkStack*)malloc(sizeof(linkStack));//为linkStack开辟内存空间，其大小是一个节点的大小
stack->next=NULL;//防止下一个节点为野指针，置NULL
return stack;//返回stack指针
}
//取得栈顶元素
int GetTop(linkStack* stack){
return stack->next->data;
}
//取得链栈长度
int GetStackLength(linkStack* head){
linkStack *p;int n;n=0;
p=head->next;
while(p!=NULL){
n++;p=p->next;
}
return n;
}
//压栈
int Push(linkStack* stack,int value){
linkStack* new_stack;//创建一个临时的节点
new_stack=(linkStack*)malloc(sizeof(linkStack));//开辟内存空间
if(!stack)return 0;//如果开辟失败，则Push函数返回0
new_stack->data=value;//新的节点的data数据域传入value
new_stack->next=stack->next;
stack->next=new_stack;//将新节点的next数据域设置为栈顶原next指针，将栈顶的next变成new_stack的地址。
return 1;
}
//出栈
int Pop(linkStack* stack){
linkStack* temp_stack;
if(stack->next==NULL)return 0;//如果栈空，就删除失败
temp_stack=stack->next;
stack->next=temp_stack->next;
free(temp_stack);
return 1;
}
//判断栈空
int IsEmptyStack(linkStack* stack){
if(stack->next==NULL)return 1;
else return 0;
}
//打印链表
void PrintStack(linkStack* head){
linkStack *stack;int index;
stack=head->next;index=1;printf("\n");
while(stack!=NULL){
printf("%3d:%-3d\t",index,stack->data);
stack=stack->next;index++;
}
printf("\n");
}
//逆置，把s1的元素Pop出，传给s2即可。
void TurnLink1(linkStack* s1,linkStack* s2){
int x;
while (s1->next!=NULL) {
x=GetTop(s1);
Pop(s1);
Push(s2,x);
}
}9、顺序队列
//
// main.c
// DS09_circleQueue
//
// Created by Remoo on 2022/10/7.
//
#include <stdio.h>
#include <stdlib.h>
#define NUM 3
typedef struct circleQueue{
int* base; //数据地址
int front; //头指针
int rear; //尾指针
}cirQueue;
cirQueue* CreateQueue(void);
int GetLength(cirQueue* cq);
int IsEmpty(cirQueue* cq);
int IsFull(cirQueue* cq);
int GetFrontValue(cirQueue* cq);
void In(cirQueue* cq,int value);
void Out(cirQueue* cq);
void ShowQueue(cirQueue* cq);
cirQueue* CreateQueue(void){
cirQueue* cq =(cirQueue*)malloc(sizeof(cirQueue));
cq->base=(int*)malloc(NUM*sizeof(int));
cq->front=cq->rear=0; //头指针，尾指针都赋值为0
return cq;
}
//获取队列长度
int GetLength(cirQueue* cq){
//此处有三种情况：
//1 front==rear
//2 rear>front
//3 rear<front rear已经循环了一波了
int rear = cq->rear;
int front = cq->front;
return (rear-front+NUM)%NUM;
}
int IsEmpty(cirQueue* cq){
if(cq->front==cq->rear)return 1;
else return 0;
}
int IsFull(cirQueue* cq){
if((cq->rear+1)%NUM==cq->front)return 1;
else return 0;
}
int GetFrontValue(cirQueue* cq){
if(IsEmpty(cq)){
printf("队列为空。");
return 0;
}
return cq->base[cq->front];
}
//入列
void In(cirQueue* cq,int value){
if(IsFull(cq)){
printf("队列满了！");
return;
}
cq->base[cq->rear]=value;
cq->rear=(cq->rear+1)%NUM;
}
//出列
void Out(cirQueue* cq){
if(IsEmpty(cq)){
printf("队列为空。");
return;
}
cq->front=(cq->front+1)%NUM;
}
void ShowQueue(cirQueue* cq){
int i = cq->front;
while(i!=cq->rear){
printf("%4d",cq->base[i]);
i=(i+1)%NUM;
}
}
int main(){
cirQueue* cq=NULL;
cq = CreateQueue();
In(cq,1);In(cq,2);
ShowQueue(cq);
Out(cq);
ShowQueue(cq);
}10、链队列
//
// main.c
// DS10_LinkQueue
//
// Created by Remoo on 2022/10/8.
//
#include <stdio.h>
#include <stdlib.h>
typedef struct LinkQueueNode{
int data;
struct LinkQueueNode* next;
}lqnode;
typedef struct LinkQueue{
lqnode* front;
lqnode* rear;
}lqueue;
lqueue* CreateQueue(void);
int GetLength(lqueue* lq);//求表长
int IsEmpty(lqueue* lq);
int GetFrontValue(lqueue* lq);
void In(lqueue* lq,int value);
void Out(lqueue* lq);
void Show(lqueue* lq);
lqueue* CreateQueue(void){
lqueue* lq = (lqueue*)malloc(sizeof(lqueue));
lq->front=lq->rear=(lqnode*)malloc(sizeof(lqnode));
lq->front->next=NULL;
return lq;
}
int GetLength(lqueue* lq){
int i;lqnode* p;
i=0; p = lq->front->next;
while(p!=NULL){
i++;p=p->next;
}
return i;
}
int IsEmpty(lqueue* lq){
if(lq->front==lq->rear)return 1;
else return 0;
}
int GetFrontValue(lqueue* lq){
if(IsEmpty(lq))return 0;
else return lq->front->next->data;
}
void In(lqueue* lq,int value){
lqnode* p = (lqnode*)malloc(sizeof(lqueue));
p->data=value;p->next=NULL;
lq->rear->next=p;
lq->rear=p;
}
void Out(lqueue* lq){
lqnode* p;
if(IsEmpty(lq))return;
p=lq->front->next;//先存储当前即将被删除的front->next
lq->front->next=p->next;
if(lq->rear==p)
lq->rear=lq->front;
free(p);
}
void Show(lqueue* lq){
lqnode* p;
p=lq->front->next;
while(p!=NULL){
printf("%4d",p->data);
p=p->next;
}
}
int main(){
lqueue* lq;
lq=CreateQueue();
In(lq,3);In(lq,2);In(lq,1);
Show(lq);
Out(lq);
Show(lq);
Out(lq);Out(lq);
Show(lq);
}
