1.顺序表
#ifndef DAHUASHUJUJIEGOU_H_
#define DAHUASHUJUJIEGOU_H_
#include <stdio.h>
#define MAXSIZE 20
typedef int ElemType;
typedef struct sqlist
{
ElemType data[MAXSIZE]; //顺序表中的元素
int length; //顺序表的长度
}SqList; //声明顺序表的类型
void InitList(SqList *); //初始化
void DestoryList(SqList *); //销毁顺序表
void ClearList(SqList*);//将链表清空
int ListEmpty (SqList); //判断是否为空
int ListLength(SqList);//顺序表的长度
int GetElem(SqList, int, ElemType*); //获取元素
int LocateElem(SqList , ElemType);//按照元素来查找
int ListInsert(SqList*, int, ElemType); // 在i位置之前放入元素
int ListDelete(SqList*,int, ElemType*); //删除i位置的元素，将值放在e中
void ListTraverse(SqList); //遍历顺序表，将值依次打印出来。
#endif // DAHUASHUJUJIEGOU_H_
#include "DaHuaShuJuJieGou.h"
void InitList(SqList *L) //初始化
{
int i = 0;
for(i = 0; i<MAXSIZE; i++)
{
L->data[i] = 0; //全部初始化为0
}
L->length = 0; //当前的为0
}
void DestoryList(SqList *L) //销毁顺序表,实际是销毁空间
{
//因为这是是数组，可以不用销毁系统自动
}
void ClearList(SqList* L)//将链表清空,将其初始化为0
{
int i = 0;
for(i = 0; i < L->length ; i++)
{
L->data[i] = 0;
}
L->length = 0;
}
int ListEmpty (SqList L)//判断是否为空
{
if(L.length > 0)
return 0; //不为空
else
return 1; //为空
}
int ListLength(SqList L)//顺序表的长度
{
return L.length; //直接返回数据中元素的个数
}
int GetElem(SqList L, int i, ElemType* e) //获取元素 ,将其保存在e中
{
if( i <= 0 || i > L.length )
return -1;
*e = L.data[i - 1]; // 第i个元素存放在 i - 1 的位置中
return 1;
}
int LocateElem(SqList L, ElemType e)//按照元素来查找,看看是否在数序表中
{
int i = 0;
for(i = 0 ; i < L.length ; i++)
{
if(L.data[i] == e)
return i+1; //返回的是第几个元素
}
return 0; //说明没有找到
}
int ListInsert(SqList*L, int i, ElemType e) //在i位置之前放入元素
{
int j = 0;
//这是在第i 个元素之前来插入元素
if(i <= 0 || i > L->length)
return -1; //说明位置i选择错误了
//来处理最后一个位置的元素
//如果满了就不能插入元素
if(L->length == MAXSIZE)
return -1 ; //说明满了 不能再插入元素了
//现在就可以处理插入数据了
//先把位置空出来
for(j = L->length - 1; j >= i -1; j--)
{
L->data[j+1] = L->data[j];//当前的位置后移一个
}
L->data[i - 1] = e;
L->length += 1;
return 1; //完成了
}
int ListDelete(SqList* L,int i , ElemType* e) //删除i位置的元素，将值放在e中
{
int j;
//如果顺序表中没有元素了 再删除 操作就是错误的
if(ListEmpty(*L))
return -1; // 错误
//再来看i 的位置
if(i <= 0 || i > L->length)
return -1;
//将i位置之后的元素依次往移动
*e = L->data[i - 1];
for( j = i-1 ; j < L->length; j++)
{
L->data[j] = L->data[j + 1];
}
L->length -= 1;
return 1;
}
void ListTraverse(SqList L)//遍历顺序表，将值依次打印出来。
{
//遍历元素
int i ;
for(i = 0 ; i < L.length; i++ )
{
printf("%d:%d\n",i+1,L.data[i]);
}
printf("\n");
}
#include "DaHuaShuJuJieGou.h"
int main()
{
int i , e,k;
int ModeSelect;
//定义一个顺序表
SqList MySqList;
//初始化顺序表
InitList(&MySqList);
//判读是顺序表是否为
if( ListEmpty(MySqList))
printf("顺序表是空的,请写入元素：\n\n\n\n");
else
printf("顺序表不是空的 \n");
printf("**************************开始**************************\n");
printf("请输入数字来选择模式:\n");
printf(" InitList 1 \n \
DestoryList 2 \n \
ClearList 3 \n \
ListEmpty 4 \n \
ListLength 5 \n \
GetElem 6 \n \
LocateElem 7 \n \
ListInsert 8 \n \
ListDelete 9 \n \
ListTraverse 10\n\
请输入：\n ");
MySqList.length = 2;
MySqList.data[0] = 0;
MySqList.data[1] = 1;
while(1)
{
scanf("%d" ,&ModeSelect);
switch(ModeSelect)
{
case 1:
InitList (&MySqList);
printf("请继续输入：\n");
break;
case 2:
printf("暂时未使用......");
printf("请继续输入：\n");
break;
case 3:
ClearList(&MySqList);
printf("请继续输入：\n");
break;
case 4:
if(ListEmpty(MySqList) )
printf("顺序表是空的\n");
else {
printf("顺序表不是空的\n");
}
printf("请继续输入：\n");
break;
case 5:
printf("顺序表的长度为:%d\n" ,ListLength(MySqList));
printf("请继续输入：\n");
break;
case 6:
printf("请输入第i的个位置：\n");
scanf("%d" , &i);
GetElem(MySqList,i, &e);
printf("获得第%d位置的元素为%d\n",i,e);
i = 0; e = 0;
printf("请继续输入：\n");
break;
case 7:
printf("请输入要查找的元素:\n");
scanf("%d" , &e);
i=LocateElem(MySqList, e);
if(i>0 )
printf("查找到的元素%d,在第%d的位置\n",e,i);
else
printf("没有找到这个元素\n");
e = 0; i = 0;
printf("请继续输入：\n");
break;
case 8:
printf("请输入要查入元素的位置:\n");
scanf("%d" , &i);
printf("请输入要插入的元素：\n");
scanf("%d" , &e);
if( (k=ListInsert(&MySqList,i,e))==1)
printf("插入成功\n");
if( k == -1)
printf("插入失败\n");
e = 0; i = 0;
printf("请继续输入：\n");
break;
case 9:
printf("请输入要删除的位置:\n");
scanf("%d" ,&i);
ListDelete(&MySqList, i , &e) ;
printf(" 删除位置的元素为 %d\n",e);
i = 0; e = 0;
printf("请继续输入：\n");
break;
case 10:
ListTraverse(MySqList);
printf("请继续输入：\n");
break;
default :
printf("错误\n");
printf("请继续输入：\n");
break;
}
}
return 0;
}
单链表
#ifndef DAHUASHUJUJIEGOU_H_
#define DAHUASHUJUJIEGOU_H_
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
typedef struct Node
{
ElemType data;
struct Node * next;
}Node, *LinkList;
void InitList(LinkList*); //初始化
void DestoryList(LinkList *); //销毁顺序表
void ClearList(LinkList*);//将链表清空
int ListEmpty (LinkList); //判断是否为空
int ListLength(LinkList);//顺序表的长度
int GetElem(LinkList, int, ElemType*); //获取元素
int LocateElem(LinkList , ElemType);//按照元素来查找
int ListInsert(LinkList*, int, ElemType); // 在i位置之前放入元素
int ListDelete(LinkList*,int, ElemType*); //删除i位置的元素，将值放在e中
void ListTraverse(LinkList); //遍历顺序表，将值依次打印出来。
//头插法建立链表
void CreatListHead(LinkList* , int );
// 尾插法建立链表
void CreatListTail(LinkList* , int );
#endif // DAHUASHUJUJIEGOU_H_
#include "DaHuaShuJuJieGou.h"
//头插法建立链表
void CreatListHead(LinkList *L, int n)
{
int i;
LinkList p;
//建立头结点
*L = (LinkList) malloc(sizeof(Node));
(*L)->next = NULL;
//现在开始循环建立
for(i = 0; i<n ; i++)
{
p = (LinkList) malloc(sizeof(Node));
p->data = 0;
//开始插入
p->next = (*L)->next;
(*L)->next = p;
}
}
// 尾插法建立链表
void CreatListTail(LinkList *L, int n)
{
//尾插法需要借助一个尾指针
int i;
LinkList p , r ; //present 现在的
//其余的步骤十分像
//第一步建立一个头指针
*L= (LinkList) malloc(sizeof(Node));
r = *L;
//然后开始循环建立
for(i = 0; i < n; i++)
{
p = (LinkList)malloc(sizeof(Node));
p -> data = 0;
//然后链接
r->next = p;
r = p;
}
r->next = NULL; //尾指针指向的结点的next 为 NULL;
}
void InitList(LinkList *L) //初始化
{
//来一个指针指向链表， 看其next是否为NULL
//如果不是NULL 就继续处理下一个
LinkList p = *L;
while(p->next != NULL)
{
p = p->next; //指向下一个结点
p->data =0;
}
}
void DestoryList(LinkList *L)//销毁顺序表
{
//销毁链表,就是delete 所malloc的空间
LinkList q , p = *L;//让p指向头结点
while(p!= NULL)
{
q = p->next; //q指向头结点的后续节点
delete p; //删除p
p = q; //pq同时指向后续节点
}
*L = NULL; //防止其成为野指针
}
void ClearList(LinkList*L)//将链表清空
{
LinkList p, q;
p = (*L) ->next;//p 指向第一个结点
while(p)
{
q = p->next; //先找到下一个
free(p); //释放p
p = q; //再同时指向同一个
}
}
int ListEmpty (LinkList L) //判断是否为空
{
//只需要判断头结点的next 是否是NULL
if(L->next == NULL)
printf("这是一个空的，只有头结点\n");
else{
printf("这不是一个空的");
}
}
int ListLength(LinkList L)//顺序表的长度
{
//判断其长度和遍历差不多
LinkList p;
int count = 0;
p = L;
while(p->next != NULL)
{
count ++;
p->next = p;
}
return count;
}
int GetElem(LinkList L, int i, ElemType* e) //获取元素
{
//单链表没有一个数组记录，链表中有多少个元素，
//所以只能自己一个一个慢慢找，如果超出了i的范围
//那么说明位置i 选择的不够好
//先来一个指向头结点
int count = 0;
LinkList p ;
p = L;
//现在开始循环
while(p->next != NULL && count < i)
{
p = p->next;//指向第一个结点
count++; //记下现在的第几个
}
//如果跳出了循环，接着就要自己判断一下,为什么跳出了循环
if(p->next == NULL || count > i)
{
return -1; //说明到结尾了，还没找的位置i
}
*e = p->data;
return 1; //表示成功了
}
int LocateElem(LinkList L , ElemType e) //按照元素来查找
{
//遍历链表与初始化是相同的道理
//先来一个指针 指向链表
LinkList p = L;
//然后根据next是否为空 来判读是否到了最后的位置
while(p->next != NULL)
{
p = p->next;
if(p->data == e)
{
return 1;
}
}
return 0; //没有找到.已经到头了
}
int ListInsert(LinkList* L, int i , ElemType e)// 在i位置之前放入元素
{
//找到i之前的位置
// 和之前的做法相同
//先来一个计数的 和 指针
LinkList p, q;
int count = 0;
p = *L;
while( p->next != NULL && count <i - 1)
{
p = p->next;
count ++;
}
//判断为何跳出了循环
if(p->next == NULL || count > i - 1) //说明第i个结点不存在
return -1; //说明失败了
//现在开始插入结点
q = (LinkList) malloc (sizeof(Node));
q->data = e;
q -> next = p->next; //先承接后边的
//再来链接前一个
p->next = q;
return 1;
}
int ListDelete(LinkList* L,int i, ElemType* e) //删除i位置的元素，将值放在e中
{
//删除i位置，主要的是找到i之前的那个位置
int j = 0; // 为什么要有这个j的值，还是因为没有一个数记录，整个数组中到底有
//几个元素
LinkList p , n;
p = *L;
while(p->next != NULL && j < i - 2)
{
p = p->next;
j++;
}
//如果跳出了循环，接着就要自己判断一下,为什么跳出了循环
if(p->next == NULL || j > i)
{
return -1; //说明到结尾了，还没找的位置i
}
n = p;
n = ( p->next )->next; //指向了要删除结点的之后
delete p->next; //删除这个结点
//然后拼接
p->next = n;
return 1;
}
void ListTraverse(LinkList L) //遍历顺序表，将值依次打印出来。
{
//遍历链表与初始化是相同的道理
//先来一个指针 指向链表
LinkList p = L;
//然后根据next是否为空 来判读是否到了最后的位置
while(p->next != NULL)
{
p = p->next;
printf("%d\n" , p->data);
}
}
#include "DaHuaShuJuJieGou.h"
int main()
{
int e;
LinkList MyLinkList1;
LinkList MyLinkList2;
//头插法建立链表
CreatListHead(&MyLinkList1 , 10);
//尾插法建立链表2
CreatListTail(&MyLinkList2 ,10);
printf("现在开始遍历链表1:\n");
ListTraverse(MyLinkList1);
printf("现在开始遍历链表2:\n");
ListTraverse(MyLinkList2);
//插入元素
ListInsert(&MyLinkList1, 2 ,100);
printf("现在开始遍历链表1:\n");
ListTraverse(MyLinkList1);
//插入元素
ListInsert(&MyLinkList2, 2 ,100);
printf("现在开始遍历链表2:\n");
ListTraverse(MyLinkList2);
//删除第一个位置的元素
ListDelete(&MyLinkList1, 1 ,&e);
printf("%d" , e);
printf("现在开始遍历链表1:\n");
ListTraverse(MyLinkList1);
ListDelete(&MyLinkList1, 10 ,&e);
printf("%d" , e);
printf("现在开始遍历链表1:\n");
ListTraverse(MyLinkList1);
return 0;
}
静态链表
#include <stdio.h>
//定义静态链表 (即 游标实现法)
#define ElemType int
#define MAXSIZE 1000
typedef struct
{
ElemType data;//数据
int cur; //游标 Cursor 为0 时表示无指向
}Component , StaticLinkList [MAXSIZE];
void InitList(StaticLinkList L);
int Malloc_SLL(StaticLinkList L);
int ListLength(StaticLinkList L);
int LinkInsert (StaticLinkList L , int i , ElemType e);
void Free_SSL(StaticLinkList L, int i);
int ListDelete(StaticLinkList L, int i);#include "DaHuaShuJuJieGou.h"
//静态链表的初始化
void InitList(StaticLinkList L)
{
//对静态链表初始化，想清楚，最初的时候是什么样子的
int i;
for(i = 0; i < MAXSIZE -1; i++ )//最后一个位置的游标特殊
{
L[i].cur = i + 1; //对游标进行初始化
}
//咋来处理最后一个游标
//这个游标指向第一个插入元素的位置.相当于头结点
L[MAXSIZE -1 ].cur = 0;
}
//返回下一次，可以放置的位置的下标
//哪里记录着当然是当然是数组0的位置的游标啊
//改完了这一次就，要把
int Malloc_SLL(StaticLinkList L)
{
int i ;
i = L[0].cur ;
if(L[0].cur) //不等于0 ，说明没到最后的位置
L[0].cur = L[i].cur;//这次的用了,所以就为下一次 做准备.
return i; //返回这一次的位置
}
//查看链表中有多少个元素，即求的是长度
int ListLength(StaticLinkList L)
{
//这次要明白 从哪里开始，从哪里结束的
//即第一个元素的下标和 最后一个元素的下标到底是什么
//先来一个返回值 即count
int count;
int i; // 再来一个存放下标
i = L[MAXSIZE-1].cur; //最后一个下标元素的位置 的游标放的是第一个插入值的位置
while(i) //找到了第一个，接下来就是看游标 是否为0 ，因为为0说明到了最后一个插入的元素
{
i= L[i].cur;//第一个插入位置的游标存放的是下一个的位置
count++;
//个数加1
}
return count ; //个数结束了
}
int LinkInsert (StaticLinkList L , int i , ElemType e)
{
int j ,k , l;
//首先是最后一个元素的下标
k = MAXSIZE - 1;
//首先判读要查入的位置是否在位置中
if(i < 1 || i > ListLength(L) + 1 )
return -1; //错误了
j = Malloc_SLL(L); //获取空闲的下标
if(j)
{
//将数据赋值给此分量
L[j].data = e;
//找到第i个元素之前的位置
for(l = 1; l<=i-1;l++)
{ k = L[k].cur; }
//然后连接起来。下一个位置的游标
//给新元素
L[j].cur = L[k].cur;
//然后把新元素的位置。给i-1的游标
L[k].cur = j;
return 1;
}
return -1;
}
void Free_SSL(StaticLinkList L, int i)
{
//把第一个元素cur值赋给要删除的分量的cur
L[i].cur = L[0].cur;
//把删除的分量下标赋给第一个元素的cur
L[0].cur = i;
}
int ListDelete(StaticLinkList L, int i)
{
int j , k;
//先判断要删除的位置是否合理
if(k < 1 || i > ListLength(L))
return -1;
k = MAXSIZE - 1; //通过K的游标获取第一个的位置的游标
for(j = 1; j <= i -1 ; j++)
k = L[k].cur;
//找的i - 1 的位置了
j = L[k].cur; //第i的位置
L[k].cur = L[j].cur;
Free_SSL(L,j);
return 1;
}
顺序栈
#include <stdio.h>
#define MAXSIZE 20
typedef int ElemType;
typedef struct
{
ElemType data[MAXSIZE];
int top; //用于栈顶的指针
} SqStack;
int Push(SqStack * , ElemType);
int Pop(SqStack * , ElemType*);
#include "DaHuaShuJuJieGou.h"
int Push(SqStack * S, ElemType e)
{
if(S->top == MAXSIZE-1)
return -1; //说明满了
S->top ++;
S->data[S->top] = e;
return 1; //说明完成了
}
int Pop(SqStack * S, ElemType* e)
{
//首先看看是不是空的
//如果是空的就可以不用再判断了
if(S->top == -1 )
return -1;
*e = S->data[S->top];
S->top --;
return 1;
}
#ifndef DAHUASHUJUJIEGOU_H_
#define DAHUASHUJUJIEGOU_H_
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 20
#define STACK_INIT_SIZE 100 //初始化的大小
#define STACKINCREMENT 10 //每次增长的大小
#define ElemType int
typedef struct Stack
{
ElemType *base;
ElemType *top;
int StackSize;
}SqStack;
int InitStack(SqStack*);
int Push(SqStack*, int );
int Pop(SqStack* ,int*);
int ClearStack(SqStack * );
int DestoryStack(SqStack *);
int StackLength(SqStack);
#endif // DAHUASHUJUJIEGOU_H_
#include "DaHuaShuJuJieGou.h"
int InitStack(SqStack *S)
{
//第一次初始化就要把分配初始化的空间大小
S->base = (ElemType*) malloc(STACK_INIT_SIZE * sizeof(ElemType));
if(!S->base) //分配失败了吗
return -1;
S->top = S->base; //同时指向栈底
S->StackSize = STACK_INIT_SIZE;// 说明栈的大小
return 1; //成功了
}
int Push(SqStack *S ,char e)
{
//push元素的时候，如果满了可以再接着分配空间
if(S->top - S->base >= S->StackSize)
{
S->base = (ElemType*) realloc(S->base,
(S->StackSize + STACKINCREMENT) *sizeof(ElemType));
if(!S->base) exit(0);
S->top = S->base + S->StackSize; //因为这是成功新分配的，所以就要重新指一次
S->StackSize = S->StackSize + STACKINCREMENT;
}
*(S->top) = e;
S->top ++;
}
int Pop(SqStack *S, char*e)
{
//既然是弹出元素，就要看是不是空的，如果是空的话 弹出肯定是失败的
if(S->base == S->top )
return -1; //栈是空的了
S->top--;
*e = *(S->top);
//*e = *--(S->top);
return 1;
}
int ClearStack(SqStack *S)
{
//清空一个栈，栈的元素还是有保留的， 栈的物理空间没有被破坏
S->top = S->base;
return 1;// 这就ok了
}
int DestoryStack(SqStack *S)
{
int len , i; //获取栈的长读， 从低向上进行删除
len = S->StackSize;
for(i = 0; i < len ; ++i)
{
free(S->base); //先从底部进行删除
S->base ++; //删除之后指向下一个
}
//全部删除之后
S->base = S->top = NULL; //防止出现野指针
S->StackSize = 0; //将其大小设定为0
}
int StackLength(SqStack S)
{
//返回栈的大小
return (S.top - S.base);
//画张图理解一下，就可以了
}
中缀表达式转后缀表达式
#include "DaHuaShuJuJieGou.h"
//中缀表达式转后缀表达式
int main()
{
SqStack s; //创建一个栈
char c,e; //c是输入的字符
InitStack(&s); //初始化栈
printf("请输入中缀表达式，以#作为结束符：\n");
scanf("%c",&c); //开始接受输入的字符
while(c != '#')
{
while(c>='0' && c<='9') //循环如果是数组就打印出去
{
printf("%c",c);//第一次的打印
scanf("%c" ,&c);//接着还输入
if(c < '0' || c > '9')
{
printf(" ");
}
}
if(')' == c)//如果遇到这个就要看（ 将其之前的弹出)
{
Pop(&s,&e);// 肯定有符号，所以可以弹出
while('(' != e )
{
printf("%c",e);
Pop(&s,&e);
}
}
else if('+' == c || c == '-' )//如果遇到这个需要判断优先级
//所以比较复杂一点
{
if(!StackLength(s))//如果是空的直接放进去
Push(&s , c);
else { //如果里面有符号，就要判断优先级，这是最复杂的
do
{
Pop(&s,&e); //所以弹出来要判断
if('(' == e)
{
Push(&s, e); //是符号（ 所以push进出
}
else{
printf("%c",e); //其它的要打印出来因为+最低，后来的要再里面，其他的+也弹出去
}
}while(StackLength(s) && e!='(');
Push(&s,c); //把加号push进去
}
}
else if( c=='*' || c=='/' || c=='(')
{
Push(&s,c);
}
else if(c=='#')
break;
else{
printf("出错：输入格式错误\n");
return -1;
}
scanf("%c",&c);
}
while(StackLength(s))
{
Pop(&s, &e);
printf("%c" ,e);
}
return 0;
}
后缀表达式的计算
#include "DaHuaShuJuJieGou.h"
//后缀表达式的运算
int main()
{
//从左到右遍历 ，如果是数字就进栈
//遇到符号，就将两个栈顶的数字出栈
//然后将结果再入栈
char c , res ,e;
SqStack s;
InitStack(&s);
printf("请输入后缀的表达式：\n");
scanf("%c",&c);
while(c != '#')
{
if(c>='0' && c<='9')
{
printf("%d\n",c);
Push(&s,c);
}
else if(c == '*'|| c=='/'||c=='+'||c=='-')
{
Pop(&s , &e);
res += e;
Pop(&s , &e);
res += e;
Push(&s , res);
}
scanf("%c",&c);
}
printf("%c\n", res);
return 0;
}
二进制转10进制
#include "DaHuaShuJuJieGou.h"
#include <math.h>
//二进制转十进制
int main()
{
SqStack s;
char c;
int len , i , sum= 0;
InitStack(&s);
//首先要初始化栈
printf("请输入二进制数，输入#符号做为结束标识符\n");
scanf("%c",&c);
while(c != '#')
{
Push(&s, c);
scanf("%c" , &c);
}
//输入完毕后
//把\n 从缓冲区中去掉
getchar();
len = StackLength(s);
printf("当前的容量是:%d \n" , len );
for(i=0 ;i < len ;i++ )
{
Pop(&s, &c);
sum = sum + (c-48)*pow(2,i);
}
printf("转化的十进制是：%d\n" ,sum);
return 0;
}
2进制转16进制
/*****************************/
/** 二进制/十六进制转换器 **/
/** By www.fishc.com 小甲鱼 **/
/*****************************/
int main()
{
ElemType c;
sqStack s1;
sqStack s2;
int len, i, j, sum = 0;
InitStack(&s1); // 初始化栈s1，用来存放二进制输入
printf("请输入二进制数，输入‘#’号表示结束！\n\n");
scanf("%c", &c);
while( c != '#' )
{
if( c=='0' || c=='1' ) // 检查输入是否二进制
Push(&s1, c);
scanf("%c", &c);
}
getchar(); // 把'\n'从缓冲区去掉
len = StackLen(s1);
InitStack(&s2); // 初始化栈s2，用来存放转换的八进制
for( i=0; i < len; i+=4 )
{
for( j=0; j < 4; j++ )
{
Pop( &s1, &c ); // 取出栈顶元素
sum = sum + (c-48) * pow(2, j);
if( s1.base == s1.top )
{
break;
}
}
switch( sum )
{
case 10: sum = 'A'; break;
case 11: sum = 'B'; break;
case 12: sum = 'C'; break;
case 13: sum = 'D'; break;
case 14: sum = 'E'; break;
case 15: sum = 'F'; break;
default: sum += 48;
}
Push( &s2, sum );
sum = 0;
}
printf("\n转化为十六进制数是: ");
while( s2.base != s2.top )
{
Pop( &s2, &c );
printf("%c", c);
}
printf("(H)\n");
return 0;
}
二进制转8进制
/*****************************/
/** 二进制/八进制转换器 **/
/** By www.fishc.com 小甲鱼 **/
/*****************************/
int main()
{
ElemType c;
sqStack s1;
sqStack s2;
int len, i, j, sum = 0;
InitStack(&s1); // 初始化栈s1，用来存放二进制输入
printf("请输入二进制数，输入‘#’号表示结束！\n\n");
scanf("%c", &c);
while( c != '#' )
{
if( c=='0' || c=='1' ) // 检查输入是否二进制
Push(&s1, c);
scanf("%c", &c);
}
getchar(); // 把'\n'从缓冲区去掉
len = StackLen(s1);
InitStack(&s2); // 初始化栈s2，用来存放转换的八进制
for( i=0; i < len; i+=3 )
{
for( j=0; j < 3; j++ )
{
Pop( &s1, &c ); // 取出栈顶元素
sum = sum + (c-48) * pow(2, j);
if( s1.base == s1.top )
{
break;
}
}
Push( &s2, sum+48 );
sum = 0;
}
printf("\n转化为八进制数是: ");
while( s2.base != s2.top )
{
Pop( &s2, &c );
printf("%c", c);
}
printf("(O)\n");
return 0;
}
队列的顺序存储
#ifndef DAHUASHUJUJIEGOU_H_
#define DAHUASHUJUJIEGOU_H_
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
#define MAXSIZE 100
typedef struct
{
ElemType *base;
int front;
int rear;
}cycleQueue; //循环队列
//初始化循环队列
int InitQueue(cycleQueue *);
//入循环队列
int InsertQueue(cycleQueue *, int);
//出循环队列
int DeleteQueue(cycleQueue *, int*);
#endif // DAHUASHUJUJIEGOU_H_
#include "DaHuaShuJuJieGou.h"
//初始化循环队列
int InitQueue(cycleQueue * Q)
{
Q->base = (ElemType *)malloc(MAXSIZE *sizeof(ElemType));
if(!Q->base)
return 0; //
Q->front = Q->rear = 0;
return 1;
}
//入循环队列
int InsertQueue(cycleQueue *q, int e)
{
if((q->rear + 1) %MAXSIZE == q->front)
{
return 0; // 说明已经满了
}
q->base[q->rear] = e;
q->rear = (q->rear + 1) %MAXSIZE;
return 1;
}
//出循环队列
int DeleteQueue(cycleQueue *q, int* e)
{
if(q->front == q->rear)
return 0;//说明是空的队列
*e = q->base[q->front];//元素出队列
q->front = (q->front + 1) %MAXSIZE;
return 1;
}
队列的链式存储
#ifndef DAHUASHUJUJIEGOU_H_
#define DAHUASHUJUJIEGOU_H_
typedef int ElemType;
typedef struct QNode
{
ElemType data;
struct QNode *next;
}QNode,*QueuePtr; //定义队列的结点
typedef struct
{
QueuePtr rear, front;
}LinkQueue; //定义队列的指针
int InitQueue(LinkQueue *);
int InsertQueue(LinkQueue *, ElemType );
int DeleteQueue( LinkQueue *, ElemType* );
#endif // DAHUASHUJUJIEGOU_H_
#include "DaHuaShuJuJieGou.h"
int InitQueue(LinkQueue * q)
{
q->front = q->rear = (QueuePtr)malloc(sizeof(QNode));
if(!=q->front)
return -1; //表示出错了
q->front->next = NULL; // 头结点为空
return 1;//创建成功
}
int InsertQueue(LinkQueue *q, ElemType e)
{
//首先是创建一个节点，然后并进去
QueuePtr newP = (QueuePtr) malloc(sizeof(QNode)) ;
if(!= newP)
return -1;
//承接元素
newP ->data = e;
newP ->next = NULL; //尾巴
//开始连接
p->rear->next = newP;
p->rear = newP;
return 1; //完成了
}
int DeleteQueue( LinkQueue*q , ElemType *e)
{
QueuePtr newP;
//因为是从头输出，就要先判断这里面还有没有元素
if(q->front == q->rear )
return -1; //说明这是一个空的
newP = p->front->next; //指向要删除的节点
*e = newP->data; //取出元素值
p->front->next = newP->next;//与头结点连接
if(p->rear == newP) //如果只有一个元素，就要把尾指针留下来
{
p->rear = p->front;
}
free(newP); //释放结点
retrn 1;//成功
}