程式師世界 >> 編程語言 >> C語言 >> C >> 關於C >> 一些可運行的C語言數據結構代碼

一些可運行的C語言數據結構代碼

編輯：關於C

網上有很多C語言數據結構代碼；有的不能運行；下面是一些能運行的，和運行截圖；備用一下；

1 隊列

#include
#include
  
#define QUEUE_SIZE 50  
  
typedef struct SeqQueue  
{  
    int data[QUEUE_SIZE];  
    int front;  
    int rear;  
  
}Queue;  
  
Queue *InitQueue()  
{  
    Queue *q = (Queue *)malloc(sizeof(Queue));  
    if(q == NULL)  
    {  
        printf("Malloc failed!\n");  
        exit(-1);  
    }  
    q->front = 0;  
    q->rear = 0;  
  
    return q;  
}  
  
int IsFull(Queue *q)  
{  
    return ((q->rear+1)%QUEUE_SIZE == q->front);  
}  
  
int IsEmpty(Queue *q)  
{  
    return (q->front == q->rear);  
}  
  
void Enqueue(Queue *q,int n)  
{  
    if(IsFull(q))  
    {  
        return;  
    }  
    q->data[q->rear] = n;  
    q->rear = (q->rear+1)%QUEUE_SIZE;  
}  
  
int Dequeue(Queue *q)  
{  
    if(IsEmpty(q))  
    {  
        return 0;  
    }  
  
    int tmp = q->data[q->front];  
    q->front = (q->front+1)%QUEUE_SIZE;  
    return tmp;  
}  
  
void main()  
{  
    Queue *q = InitQueue();  
    int i;  
    for(i=0;i<10;i++)  
    {  
        Enqueue(q,i*i);  
    }  
  
    while(!IsEmpty(q))  
    {  
        int data = Dequeue(q);  
        printf("%d-->",data);  
    }  
}

2 棧

#include 
#include 
#include 

//    定義一個節點的結構
typedef struct node
{
    int member;            //數據域
    struct node * pNext;//指針域
}Node,*pNode;

//    定義一個棧結構
typedef struct stack
{
    pNode Top;            //棧頂
    pNode Bottom;        //棧底
}Stack,* pStack;

void InitStack(pStack );        //    初始化棧的函數
bool Push(pStack ,int);            //    進行壓棧操作的函數
void TraverseStack(pStack );    //    遍歷棧函數
bool Empty(pStack );            //    判斷棧是否為空的函數
int Pop(pStack );                //    進行出棧操作的函數
void Clear(pStack );            //    清空棧的函數

int main(void)
{
    Stack s;                        //    定義一個棧
    int i;
    int num;
    int data;                        //    臨時保存用戶輸入的數據
    int re_num;                        //    保存Pop函數的返回值
    InitStack(&s);
    printf("你想輸入幾個數據啊：");
    scanf("%d",&num);
    for (i = 0;i < num;i++)
    {
        printf("第 %d 個數：",i+1);
        scanf("%d",&data);
        if (Push(&s,data))                //    調用Push函數
        {
            continue;
        }
        else
        {
            printf("進行進棧操作失敗！\n");
            exit(-1);
        }
    }
    TraverseStack(&s);                //    調用遍歷函數
    printf("你想去掉幾個數啊: ");
    scanf("%d",&data);
    printf("你去掉的數字是：");
    for (i = 0; i < data;i++)
    {
        re_num = Pop(&s);            //    調用Pop函數，並把返回值賦給re_num;
        printf("%d ",re_num);
    }
    printf("看看刪除後還有啥：");
    TraverseStack(&s);
    printf("\n");
    Clear(&s);                        //    調用清空棧函數
    printf("遍歷下看看棧清空沒····\n");
    TraverseStack(&s);
    printf("\n");
    return 0;
}

//    進行棧的初始化的函數
void InitStack(pStack ps)
{
    ps->Top = (pNode)malloc(sizeof(Node));        //    分配內存空間給棧頂
    if (NULL == ps->Top)
    {
        printf("動態分配內存失敗\n");
        exit(-1);
    }
    else
    {
        ps->Bottom = ps->Top;                    //    使棧底也指向棧頂空間
        ps->Top->pNext = NULL;                    //    棧頂指針置為NULL；
    }
    return ;
}

//    進行進棧操作的函數
bool Push(pStack ps,int data)
{
    pNode pNew = (pNode)malloc(sizeof(Node));    //    定義一個新節點，並分配內存空間
    if (NULL == pNew)
    {
        return false;
    }
    pNew->member = data;                        //    把要進棧的數據賦給新節點的member成員
    pNew->pNext = ps->Top;                        //    使新節點的指針指向棧頂
    ps->Top = pNew;                                //    把新節點作為新棧頂

    return true;
}

//    遍歷棧的函數
void TraverseStack(pStack ps)
{
    pNode pNew = ps->Top;
    while(pNew!= ps->Bottom)                //    只要棧頂不等於棧底，循環
    {
        printf("%d ",pNew->member);            //    打印棧頂的成員member
        pNew = pNew->pNext;                //    棧頂指針向下移動一次
    }
    return ;
}

//    判斷棧是否為空
bool Empty(pStack ps)
{
    if(ps->Top == ps->Bottom)    //    棧頂等於棧底，不就是棧中沒數據麼
    {
        return true;
    }
    else
    {
        return false;
    }
}

//    進行出棧操作函數
int Pop(pStack ps)
{
    pNode pSwap = NULL;            
    int return_val;
    if (Empty(ps))                //判斷棧是否為空，為空就不能進行出棧操作
    {
        exit(-1);
    }
    else
    {
        return_val = ps->Top->member;    //    把棧頂的成員member的值賦給return_val做為函數返回值
        pSwap = ps->Top;                //    使pSwap指向棧頂
        ps->Top = ps->Top->pNext;        //    使棧頂指向棧頂下一個節點
        free(pSwap);                    //    釋放以前的棧頂空間
        return return_val;
    }
}

//    清空棧的函數
void Clear(pStack ps)
{
    pNode pNew = NULL;
    
    while (ps->Top != ps->Bottom)        //    棧頂和棧底不等，循環
    {
        pNew = ps->Top;                    //    使一個新節點和棧頂指向同一空間
        ps->Top = ps->Top->pNext;        //    使棧頂指向棧頂的下一個節點
        free(pNew);                        //    釋放掉以前的棧頂空間
    }
    return ;
}

3 樹

#include
#include

typedef	int	ElemType;			//數據類型
typedef	int		Status;			//返回值類型

//定義二叉樹結構
typedef struct BiTNode{
  ElemType	data;					//數據域
  struct BiTNode	*lChild, *rChlid;	//左右子樹域
}BiTNode, *BiTree;

//先序創建二叉樹
Status CreateBiTree(BiTree *T)
{
  ElemType ch;
  ElemType temp;

  scanf("%d", &ch);
  temp = getchar();

  if (-1 == ch)
    *T = NULL;
  else
  {
    *T = (BiTree)malloc(sizeof(BiTNode));
    if (!(*T))
      exit(-1);

    (*T)->data = ch;
    printf("輸入%d的左子節點：", ch);
    CreateBiTree(&(*T)->lChild);
    printf("輸入%d的右子節點：", ch);
    CreateBiTree(&(*T)->rChlid);
  }

  return 1;
}

//先序遍歷二叉樹
void TraverseBiTree(BiTree T)
{
  if (NULL == T)
    return ;
  printf("%d ", T->data);
  TraverseBiTree(T->lChild);
  TraverseBiTree(T->rChlid);

}

//中序遍歷二叉樹
void InOrderBiTree(BiTree T)
{
  if (NULL == T)
    return ;
  InOrderBiTree(T->lChild);
  printf("%d ", T->data);
  InOrderBiTree(T->rChlid);

}

//後序遍歷二叉樹
void PostOrderBiTree(BiTree T)
{
  if (NULL == T)
    return ;
  PostOrderBiTree(T->lChild);
  PostOrderBiTree(T->rChlid);
  printf("%d ", T->data);

}


//二叉樹的深度

int TreeDeep(BiTree T)
{
  int deep = 0;
  if(T)
  {
    int leftdeep = TreeDeep(T->lChild);
    int rightdeep = TreeDeep(T->rChlid);
    deep = leftdeep>=rightdeep?leftdeep+1:rightdeep+1;
  }
  return deep;
}

//求二叉樹葉子結點個數

int Leafcount(BiTree T,int &num)
{  
  if(T)
  {
    if(T->lChild ==NULL &&T->rChlid==NULL)	
      num++;
    Leafcount(T->lChild,num);
    Leafcount(T->rChlid,num);

  }
  return num;
}
//主函數
int main(void)
{
  BiTree T;
  BiTree *p = (BiTree*)malloc(sizeof(BiTree));
  int deepth,num=0 ;
  printf("請輸入第一個結點的值,-1表示沒有葉結點:\n");
  CreateBiTree(&T);
  printf("先序遍歷二叉樹:\n");
  TraverseBiTree(T);
  printf("\n");
  printf("中序遍歷二叉樹:\n");
  InOrderBiTree(T);
  printf("\n");
  printf("後序遍歷二叉樹:\n");
  PostOrderBiTree(T);
  printf("\n");
  deepth=TreeDeep(T);
  printf("樹的深度為:%d",deepth);
  printf("\n");
  Leafcount(T,num);
  printf("樹的葉子結點個數為:%d",num);
  printf("\n");
  return 0;
}

4 圖

#include 
#include 
#include 
#define MAX 20   //圖可以存儲的最大節點數為20；
struct tnode
{
    struct tnode * next;//指向下一個臨節點
    int data;//存放鄰節點在數組中的位置
};
struct node
{
    int valu;//存放節點的值
    struct tnode * link;//指向鄰節點
};
struct picture
{
    struct node nd[MAX];    //聲明一個節點數組
    int count;  //圖中的節點數
    char a; //建立的圖的類型
};
struct picture * createpicture();
int search(struct picture *p,int value);//查找value在nd數組中的位置
void bfs(struct picture * q,int i,int visit[]); //廣度優先遍歷
void dfs(struct picture * q,int i,int visit[]);//深度優先遍歷
void traversedfs(struct picture *p);
void traversebfs(struct picture *p);
int main()
{
    char a;
    struct picture *p;
    p=createpicture();
    while(1)
    {
        getchar();
        printf("現在將對圖進行遍歷，若使用廣度優先遍歷，請輸入a,若使用深度優先遍歷請輸入b，清屏請輸入c,退出請輸入d:\n");
        scanf("%c",&a);
        if(a=='a')
        {
        printf("深度優先遍歷如下：\n");
        traversebfs(p);
        }
        if(a=='b')
        {
        printf("廣度優先遍歷如下：\n");
        traversedfs(p);
        }
        if(a=='c')
        system("cls");
        if(a=='d')
        exit(0);
    }
    return 0;
}
struct picture * createpicture()
{
    int i,j,k,l;//l中存放返回的節點在數組中的位置
    char a;
    struct picture *p;
    p=(struct picture *)malloc(sizeof(struct picture));
    struct tnode * t;
    printf("請輸入你要建立的圖中的節點數以及圖的類型(a表示無向圖b表示有向圖):\n");
    scanf("%d %c",&i,&a);
    p->count=i;
    p->a=a;
    printf("請依次輸入各節點的值(每輸完一個節點的值按回車結束)：\n");
    for(i=0;icount;i++)
    {
        scanf("%d",&j);
        p->nd[i].valu=j;
        p->nd[i].link=NULL;
    }
    for(i=0;icount;i++)
    {
        printf("輸入與數據值為%d的節點相鄰的節點的數據值(每輸完一個節點的值按回車結束),若不再含有相鄰的值請輸入-1\n",p->nd[i].valu);
        while(1)
        {
            scanf("%d",&k);
            if(k==-1)
                break;
            l=search(p,k);
            if(l!=-1)
            {
                t=(struct tnode *)malloc(sizeof(struct tnode));
                t->data=l;
                t->next=p->nd[i].link;
                p->nd[i].link=t;
            }
            else
                printf("無此數據值!\n");
            //getchar();
        }
    }
    return p;
}
int search(struct picture *p,int value)
{
    int i;
    for(i=0;icount;i++)
    {
        if(value==p->nd[i].valu)
        {
            return i;
        }
    }
    return -1;
}
void traversedfs(struct picture *p)
{
    int i;
    int visit[MAX];//申明一個標志數組,將其初始值置為0,0表示該節點未被訪問過，1表示該節點被訪問過
    for(i=0;icount;i++)
    {
        visit[i]=0;
    }
    for(i=0;icount;i++)
    {
        if(visit[i]==0)
        {
            dfs(p,i,visit);
        }
    }
    //getchar();
}
void dfs(struct picture * q,int i,int visit[])//i表示數組的下標值visit的下標與p中的下標是一一對應的關系
{
    struct tnode * w;
    printf("%d\n",q->nd[i].valu);
    visit[i]=1;
    w=q->nd[i].link;
    while(w!=NULL)
    {
        if(visit[w->data]==0)
        {
            dfs(q,w->data,visit);
        }
        else
        {
            w=w->next;
        }
    }   
}
void traversebfs(struct picture *p)
{
    int i;
    int visit[MAX];//申明一個標志數組,將其初始值置為0,0表示該節點未被訪問過，1表示該節點被訪問過
    for(i=0;icount;i++)
    {
        visit[i]=0;
    }
    for(i=0;icount;i++)
    {
        if(visit[i]==0)
        {
            bfs(p,i,visit);
        }
    }
    //getchar();
}
void bfs(struct picture * q,int i,int visit[])
{
    struct tnode *w;
    int a[MAX];//聲明一個隊列
    int f,r;
    int v;
    f=r=0;
    visit[i]=1;
    printf("%d\n",q->nd[i].valu);
    a[r]=i;
    r++;//進行入隊操作
    while(f!=r)
    {
        v=a[f];
        f++;//岀隊操作
        w=q->nd[v].link;
        while(w!=NULL)
        {
            if(visit[w->data]==0)
            {
            visit[w->data]=1;
            printf("%d\n",q->nd[w->data].valu);
            a[r]=w->data;
            r++;
            }
            w=w->next;
        }
    }
}