資料結構考試大綱要求

life4711發表於2014-11-14
資料結構
/**
單連結串列的有關操作（Shubao Lv）
⑴隨機產生或鍵盤輸入一組元素，建立一個帶頭結點的單向連結串列（無序）。
⑵遍歷單向連結串列。
⑶把單向連結串列中元素逆置（不允許申請新的結點空間）。
⑽在主函式中設計一個簡單的選單，分別除錯上述演算法。

*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <iostream>
#include <malloc.h>
using namespace std;
struct note
{
    int num;
    note *next;
};
note *h;
///建立單連結串列
void creatLink()
{
    printf("輸入0結束(第一個數不能為0)\n");
    note *p1,*p2;
    p1=(struct note *)malloc(sizeof(struct note));
    h=NULL;
    p1->next=NULL;
    scanf("%d",&p1->num);
    h=p1;
    p2=p1;
    p1=(struct note *)malloc(sizeof(struct note));
    p2->next=p1;
    int x;
       scanf("%d",&x);
    while(x)
    {
        p1->num=x;
        p2=p1;
        p1=(struct note *)malloc(sizeof(struct note));
        p2->next=p1;
        scanf("%d",&x);
    }
    p2->next=NULL;
}
///遍歷單連結串列
void bianli()
{
    note *p;
    for(p=h;p!=NULL;p=p->next)
        printf("%d ",p->num);
    puts("");
}
///倒置單連結串列
void daozhi()
{
    note *pre,*cur,*nex;
    pre=h;
    cur=h->next;
    nex=NULL;
    while(cur!=NULL)
    {
        nex=cur->next;
        cur->next=pre;
        pre=cur;
        cur=nex;
    }
    h->next=NULL;
    h=pre;
    bianli();
}
int main()
{
    creatLink();
    /*srand(time(NULL));
    int n=rand()%255+1;*/
    bianli();
    daozhi();
    return 0;
}



 
/**
棧和佇列的基本操作（Shubao Lv）
⑴採用鏈式儲存實現棧的初始化、入棧、出棧操作。
⑵採用順序儲存實現棧的初始化、入棧、出棧操作。
⑶採用鏈式儲存實現佇列的初始化、入隊、出隊操作。
⑷採用順序儲存實現迴圈佇列的初始化、入隊、出隊操作。
⑸在主函式中設計一個簡單的選單，分別測試上述演算法。
*⑹綜合訓練：①利用棧實現表示式求值演算法。

*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#define INIT_SIZE 100
#define INCREASEMENT 10
using namespace std;

const int INF = -0xfffffff;

struct Strack
{
    int *top;///棧頂的指標
    int *base;///棧底的指標
    int stracksize;
    void init()///棧的初始化
    {
        base=(int *) malloc(INIT_SIZE * sizeof(int ));///分配記憶體
        top=base;
        stracksize = INIT_SIZE;
    }
    int Top() ///返回棧頂元素
    {
        if(top==base)
            return INF;
        return *(top-1);
    }
    bool pop() ///刪除棧頂元素
    {
        if(top==base)
            return false;
        top--;
        return true;
    }
    void push(int x) ///棧頂插入元素
    {
        if(top-base>=stracksize) ///如果記憶體不夠重新分配記憶體
        {
            base=(int *)realloc(base,(stracksize+INCREASEMENT)*(sizeof(int )));
            top=base+stracksize;
            stracksize+=INCREASEMENT;
        }
        *top++=x;
    }
    bool empty() ///判斷棧是否為空
    {
        if(top==base)
            return true;
        return false;
    }
}s;
struct Queue
{
    int *top;///隊頂的指標
    int *base;///隊底的指標
    int queuesize;
    void init()///隊的初始化
    {
        base=(int *) malloc(INIT_SIZE * sizeof(int ));///分配記憶體
        top=base;
        queuesize = INIT_SIZE;
    }
    int Top() ///返回隊頂元素
    {
        if(top==base)
            return INF;
        return *top;
    }
    bool pop() ///刪除隊頂元素
    {
        if(top==base)
            return false;
        top++;
        return true;
    }
    void push(int x) ///隊頂插入元素
    {
        if(base-top>=queuesize) ///如果記憶體不夠重新分配記憶體
        {
            base=(int *)realloc(base,(queuesize+INCREASEMENT)*(sizeof(int )));
            base=top+queuesize;
            queuesize+=INCREASEMENT;
        }
        *base++=x;
    }
    bool empty() ///判斷隊是否為空
    {
        if(top==base)
            return true;
        return false;
    }
}q;
int main()
{
    ///==============棧的部分================
    int x;
    s.init();
    cout<< "1、進棧：\n(輸入要進棧的元素，以0結束)\n";
    while(1)
    {
        int x;
        scanf("%d",&x);
        if(x==0)
            break;
        s.push(x);
    }
    cout<<"出棧：\n";
    while(!s.empty())
    {
        printf("%d ",s.Top());
        s.pop();
    }
    puts("");
    ///============佇列的部分================
    q.init();
    cout<< "\n2、入隊：\n(輸入要入隊的元素，以0結束)\n";
    while(1)
    {
        int x;
        scanf("%d",&x);
        if(x==0)
            break;
        q.push(x);
    }
    cout<<"出隊：\n";
    while(!q.empty())
    {
        printf("%d ",q.Top());
        q.pop();
    }
    puts("");
    return 0;
}








 
<pre class="cpp" name="code">#include <iostream>

using namespace std;

int main()
{
    cout << "Hello world!" << endl;
    return 0;
}
/**
二叉樹的有關操作（Shubao Lv）
⑴輸入字元序列，建立二叉連結串列。
⑵中序遍歷二叉樹：遞迴演算法。
⑶中序遍歷二叉樹：非遞迴演算法。（最好也能實現先序，後序非遞迴演算法）
（4）正則二叉樹是二叉樹中不存在子樹個數為一的結點，即節點的度為2.
 判斷一棵樹是正則二叉樹的演算法
⑼在主函式中設計一個簡單的選單，分別除錯上述演算法。

*/
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
using namespace std;
#define NULL 0
#define N 10
int sum;
struct node
{
    int data;
    node *lchild,*rchild;
};
node *creat_tree()
{
    node *t;
    int x;
    cin >> x;
    if(x!=0)
    {
        t=new node;
        t->data=x;
        t->lchild=creat_tree();
        t->rchild=creat_tree();
    }
    else
        t=NULL;
    return t;
}
///遞迴先序遍歷二叉樹
void preorder(node *t)
{
    if(t)
    {
        cout << t->data<<" ";
        preorder(t->lchild);
        preorder(t->rchild);
    }
}

///非遞迴先序遍歷演算法
void preorder1(node *t)
{
    node * s[N],*p;
    int top;
    top=0;
    p=t;
    while(p || top>0)
    {
        while(p)
        {
            cout<<p->data<<" ";
            top++;
            s[top]=p;
            p=p->lchild;
        }
        if(top>0)
        {
            p=s[top];
            --top;
            p=p->rchild;
        }
    }
}
///非遞迴中序遍歷二叉樹
void inorder(node *t)
{
    node *p,*s[N];
    int top;
    top=0;
    p=t;
    while(p || top>0)
    {
        while(p)
        {
            top++;
            s[top]=p;
            p=p->lchild;
        }
        if(top>0)
        {
            p=s[top];
            top--;
            cout<<p->data<<" ";
            p=p->rchild;
        }
    }
}
///二叉樹後根非遞迴演算法
void pasorder1(node *t)
{
    struct
    {
        node *pp;
        int tag;
    } ss[N];
    int top;
    node *p;
    top=0;
    p=t;
    while(p || top>0)
    {
        while(p)
        {
            top++;
            ss[top].tag=0;
            ss[top].pp=p;
            p=p->lchild;
        }
        if(top>0)
            if(ss[top].tag==0)
            {
                ss[top].tag=1;
                p=ss[top].pp;
                p=p->rchild;
            }
            else
            {
                p=ss[top].pp;
                cout<<p->data<<" ";
                top--;
                p=NULL;
            }
    }
}
///遞迴演算法判斷是否是正則二叉樹
void count_leaf(node *t)
{
    if(t)
    {
        if((t->lchild!=NULL && t->rchild==NULL)||(t->lchild==NULL && t->rchild!=NULL))
            sum=0;
        count_leaf(t->lchild);
        count_leaf(t->rchild);
    }
}
int main()
{
    int num;
    node *t;
    t=creat_tree();
    cout << "前序遍歷：\n";
    preorder(t);
    cout <<endl;
    cout << " 中序遍歷：\n";
    inorder(t);
    cout <<endl;
    /**pasorder1(t);
    cout <<endl;
    preorder1(t);
    cout <<endl;*/
    cout <<"是否為正則二叉樹:\n";
    sum=1;
    count_leaf(t);
    if(sum)
       cout<<"YES\n";
    else
        cout <<"NO\n";
    return 0;
}
/**
1
2
4
0
0
5
0
0
3
6
0
0
7
0
0

1
2
4
0
0
0
3
5
0
0
6
0
0
*/




            




相關文章