C++ 学习示例 on chinese

顺序表的基本操作

Sun, 01 Apr 2012 00:00:00 +0800

顺序表的基本操作。

顺序表的基本操作

编写一个完整的程序，实现顺序表的建立、插入、删除、输出等基本运算。

建立一个顺序表，含有n个数据元素。
输出顺序表及顺序表的长度。
在顺序表中删除值为x的结点或者删除给定位置i的结点。
将顺序表就地逆置，即利用原表的存储空间将线性表（a1,a2,…,an）逆置为（an,an-1,…,a1）。
将顺序表按升序排序。
设顺序表中的数据元素递增有序，将x插入到顺序表的适当位置上，以保持该表的有序性。
将两个顺序有序表A和B合并为一个有序表C。
在主函数中设计一个简单的菜单，分别测试上述算法。

程序

#include<stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define OK 1
#define OVERFLOW -2
#define ERROR 0
typedef int ElemType;
typedef struct
{
    ElemType *elem;
    int length;
    int listsize;
} SqList;
int cmp(const void *a, const void *b)
{
    return *(int*)a - *(int*)b;
}

//创建一个空表
int InitList(SqList &L)
{
    L.elem = (ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType)); //分配空间

    if (!L.elem)
        return OVERFLOW;
    L.length = 0;
    L.listsize = LIST_INIT_SIZE;
    return OK;
}
//在创建的空表中插入数据
int ListInsert(SqList &L, int i, ElemType e)
{
    ElemType* newbase;
//ElemType* q;
    if (i < 0 ||
            i > L.length + 1)
        return ERROR;
    if (L.length >= L.listsize) //当前空间已满，增加新空间

    {
        newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));

        if (!newbase)
            return
                OVERFLOW;
        L.elem = newbase;
        L.listsize += LISTINCREMENT;

    }

    L.elem[i] = e;
//printf("%d ",L.elem[i]);
    L.length++;
    return OK;
}
//删除位置为i的节点
int ListDelete(SqList &L, int i)
{
    ElemType* p;
    ElemType* q;
    if (i < 0 ||
            i > L.length)
        return ERROR;
    p = &(L.elem[i - 1]);
//e=*p;
    q = L.elem + L.length - 1;
    for (++p; p <= q; p++)
        *(p - 1) = *p;
    L.length--;
    return OK;
}
//在顺序表中删除数据x
int DeleteX(SqList &L, int x)
{
    ElemType* p;
    int i;
    for (i = 0; i < L.length; i++)
        if (L.elem[i] == x)
        {
            break;
        }
    p = &L.elem[i];

//free(p);
    for (int
            j = i; j < L.length - 1; j++)
    {
        L.elem[j] = L.elem[j + 1];

    }
    L.length--;
    return OK;
}
//反转顺序表
int TurnArrond(SqList &L)//翻转顺序表
{
    ElemType* p;
    ElemType* q;
    int t;
    p = &(L.elem[0]);
    q = L.elem + L.length - 1;
    for (p; p < q; p++, q--)
    {
        t = *q;
        *q = *p;
        *p = t;
    }
    return OK;
}
//升序排列顺序表
int ABC(SqList &L)
{
    int a[10000];
    int i;
    for (i = 0; i < L.length; i++)
        a[i] = L.elem[i];
    qsort(a, L.length, sizeof(a[0]), cmp);

    for (i = 0; i < L.length; i++)
        L.elem[i] = a[i];
    return OK;
}
//把顺序表升序排列后插入元素e
int ListInsertABC(SqList &L, ElemType e)
{
    ElemType* newbase;
    int i, j;
    if (L.length + 1 >= L.listsize) //当前空间已满，增加新空间

    {
        newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));

        if (!newbase)
            return
                OVERFLOW;
        L.elem = newbase;
        L.listsize += LISTINCREMENT;

    }

    for (i = 0; i < L.length; i++)
        if (e < L.elem[i])

            break;

    for (j = L.length; j > i; j--)

    {
        L.elem[j] = L.elem[j - 1];

    }
    L.length++;
    L.elem[j] = e;
//printf("%d
    ",L.elem[i]);
    return OK;
}
//合并顺序表L，L1为L2
int MergeList(SqList L, SqList L1, SqList &L2)
{
    ElemType* pa;
    ElemType* pb;
    ElemType* pc;
    ElemType* pa_last;
    ElemType* pb_last;
    pa = L.elem;
    pb = L1.elem;
// L2.elem=pc;
    L2.listsize = L.listsize + L1.listsize;
    pc = L.elem = (ElemType*)malloc(L2.listsize *
                                    sizeof(ElemType));

    pa_last = L.elem + L.length - 1;
    pb_last = L1.elem + L1.length - 1;
    while (pa <= pa_last && pb <= pb_last)
    {
        if (*pa <= *pb)

            *pc++ = *pa++;

        else
            *pc++ = *pb++;

    }
    while (pa <= pa_last)
        *pc++ = *pa++;
    while (pb <= pb_last)
        *pc++ = *pb++;
    for (int
            i = 0; i < L2.length; i++)
        printf("%d ", L2.elem[i]);
    return OK;
}
//打印菜单
void printScreen()
{
//printf("1.建立一个顺序表，含有n个数据元素。\n");
    printf("1.输出顺序表L1及其长度\n");
    printf("2.删除给定位置i的结点\n");
    printf("3.在顺序表中删除值为x的结点\n");
    printf("4.逆置顺序表\n");
    printf("5.将顺序表按升序排序\n");
    printf("6.设顺序表中的数据元素递增有序，将x插入到顺序表的适当位置上，以保持该表的有序性\n");

    printf("7.将两个顺序有序表L和L1合并为一个有序表L2\n");
    printf("0.退出操作系统。\n");
    printf("请输入需要的操作序号：");
}
//输出顺序表L
void printSqList(SqList &L)
{
    int i;
    for (i = 0; i < L.length; i++)
        printf("%d ", L.elem[i]);
    printf("\n");
}
int main()
{
    SqList L, L1, L2;
    InitList(L);
    InitList(L1);
    InitList(L2);
    int n, e, muse, i, x;
    bool flag;
//建立第一个的顺序表
    printf("请输入第一个数据表的长度：");
    scanf("%d", &n);
    printf("请以次输入长度为%d的顺序表：", n);
    for (i = 0; i < n; i++)
    {
        scanf("%d", &e);

        ListInsert(L, i, e); //依次在第i个位置插入顺序表

    }
    printf("第一个顺序表的次序为：");
    printSqList(L);

//建立第二个顺序表
    printf("建立第二个顺序表，请输入要第二个建立数据表的长度：");
    scanf("%d", &n);
    printf("请以次输入长度为%d的顺序表：", n);
    for (i = 0; i < n; i++)
    {
        scanf("%d", &e);

        ListInsert(L1, i, e); //依次在第i个位置插入顺序表

    }
    printf("第二个顺序表的次序为：");
    printSqList(L1);

//打印菜单
    printScreen();
    scanf("%d", &muse);
    flag = true;
    while (1)
    {
        switch (muse)
        {
        case 0:
            flag = false;

            break;
        case 1:
            printf("顺序表的长度为：");

            printf("%d\n", L.length);

            break;
        case 2:
            printf("请输入要删除的节点：");

            scanf("%d", &i); //删除顺序表的节点

            if (ListDelete(L, i))

            {
                printf("删除成功！\n");

                printSqList(L);

            }
            else
                printf("删除失败！\n");

            break;
        case 3:
            printf("请输入要删除的节点x的值：");

            scanf("%d", &x);

            if (DeleteX(L, x))

            {
                printf("删除成功！\n顺序表为：");

                printSqList(L);

            }
            else
                printf("删除失败！\n");

            break;
        case 4:
            //逆序顺序表
            if (TurnArrond(L))

            {
                printf("逆序成功！\n");

                printf("顺序表的次序为：");

                printSqList(L);

            }
            else
                printf("逆序失败！\n");

            break;
        case 5:
            //顺序表升序排列

            if (ABC(L))

            {
                printf("顺序表升序排列成功！\n");

                printf("顺序表的次序为：");

                printSqList(L);

            }
            else
                printf("顺序表升序排列失败！\n");


            printf("请输入要插入的数据：");

            scanf("%d", &e);

            if (ListInsertABC(L, e))

            {
                printf("顺序插入成功！\n");

                printf("顺序表的次序为：");

                printSqList(L);

            }
            else
                printf("顺序插入失败！\n");

            break;
        case 6:
            ABC(L);
            printf("请输入要插入的数字x的值：");

            scanf("%d", &x);

            if (ListInsertABC(L, x))

            {
                printf("操作成功！\n");

                printf("顺序表的次序为：");

                printSqList(L);

            }
            else
                printf("操作失败！\n");
            break;
        case 7:
            if (MergeList(L, L1, L2))

            {
                printf("顺序表L，L1合并成功!\n");

                //printf("顺序表的次序为：");

                //printSqList(L2);

            }
            else
                printf("顺序表合并失败！\n");

            break;
        default:
            break;
        }
        if (!flag)
            break;
        printf("\n请输入你要的下一步操作序号：");

        scanf("%d", &muse);

    }

    if (L.elem)
        free(L.elem);
    if (L1.elem)
        free(L1.elem);
    if (L2.elem)
        free(L2.elem);

    return 0;
}

链表

Sat, 07 Apr 2012 00:00:00 +0800

链表源码

源码

# include <stdio.h>
# include <stdlib.h>  //包含了exit

//定义了一个数据类型，该数据类型的名字叫做struct Arr, 该数据类型含有三个成员， 分别是pBase, len, cnt;
struct Arr
{
    int *pBase;//存储的是数组的第一个元素的地址
    int len;//数组所能容纳的最大元素的个数
    int cnt;//当前数组有效元素的个数
};


void init_arr(struct Arr * pArr, int length);
bool append_arr(struct Arr * pArr, int val);//追加
bool insert_arr(struct Arr * pArr, int pos, int val);//pos的值从1开始
bool delete_arr(struct Arr * pArr, int pos, int * val);
int get();
bool is_empty(struct Arr * pArr);
bool is_full(struct Arr * pArr);
void sort_arr(struct Arr * pArr);
void show_arr(struct Arr * pArr);
void inversion_arr(struct Arr *pArr);


int main(void)
{
    struct Arr arr;
    int val;

    init_arr(&arr, 6);
//printf("%d\n", arr.len);
    show_arr(&arr);
    append_arr(&arr, 1);
    append_arr(&arr, 5);
    append_arr(&arr, -3);
    append_arr(&arr, 2);
    append_arr(&arr, 10);
    append_arr(&arr, -1);


    show_arr(&arr);

    printf("倒置之后的数组内容是：");
    inversion_arr(&arr);
    show_arr(&arr);

    sort_arr(&arr);
    show_arr(&arr);

    return 0;
}

void init_arr(struct Arr * pArr, int length)
{
    pArr->pBase = (int *)malloc(sizeof(int) * length);
    if (NULL == pArr->pBase)
    {
        printf("动态内存分配失败！\n");
        exit(-1);//终止整个函数
    }
    else
    {
        pArr->len = length;
        pArr->cnt = 0;
    }
    return ;
}

bool is_empty(struct Arr * pArr)
{
    if (pArr->cnt == 0)
        return true;
    else
        return false;
}

bool is_full(struct Arr * pArr)
{
    if (pArr->cnt == pArr->len)
        return true;
    else
        return false;
}

void show_arr(struct Arr * pArr)
{
    if ( is_empty(pArr) )
    {
        printf("数组为空!\n");
    }
    else
    {
        for (int i = 0; i < pArr->cnt; i++)
            printf("%d ", pArr->pBase[i]);
        printf("\n");
    }
}

bool append_arr(struct Arr * pArr, int val)
{
    if ( is_full(pArr) )
        return false;
    pArr->pBase[pArr->cnt] = val;
    pArr->cnt++;
    return true;
}

bool insert_arr(struct Arr * pArr, int pos, int val)
{
    int i;

    if (is_full(pArr))
        return false;

    if (pos < 1 || pos > pArr->cnt + 1)
        return false;

    for (i = pArr->cnt - 1; i >= pos - 1; i--)
    {
        pArr->pBase[i + 1] = pArr->pBase[i];
    }
    pArr->pBase[pos - 1] = val;
    (pArr->cnt)++;

    return true;
}

bool delete_arr(struct Arr * pArr, int pos, int *pVal)
{
    if (is_empty(pArr))
        return false;
    if (pos < 1 || pos > pArr->cnt)
        return false;

    *pVal = pArr->pBase[pos - 1];
    for (int i = pos; i < pArr->cnt; i++)
        pArr->pBase[i - 1] = pArr->pBase[i];

    (pArr->cnt)--;
    return true;
}

void inversion_arr(struct Arr *pArr)
{
    int i = 0;
    int j = pArr->len - 1;

    int t;

    while (i < j)
    {
        t = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = t;
        i++;
        j--;
    }

    return ;
}

void sort_arr(struct Arr * pArr)
{
    int i, j, t;

    for (i = 0; i < pArr->cnt; i++)
    {
        for (j = i + 1; j < pArr->cnt; j++)
        {
            if (pArr->pBase[i] > pArr->pBase[j])
            {
                t = pArr->pBase[i];
                pArr->pBase[i] = pArr->pBase[j];
                pArr->pBase[j] = t;
            }
        }
    }

}

C++ 单链表的基本操作

Thu, 21 Jun 2012 00:00:00 +0800

C++ 单链表的基本操作

实验二：单链表的基本操作

编写一个完整的程序，实现单链表的建立、插入、删除、输出等基本操作。

（1）建立一个带头结点的单链表。

（2）计算单链表的长度，然后输出单链表。

栈和队列的基本操作

Thu, 21 Jun 2012 00:00:00 +0800

实验四：栈和队列的基本操作

实验四：栈和队列的基本操作

采用链式存储实现栈的初始化、入栈、出栈操作。
采用顺序存储实现栈的初始化、入栈、出栈操作。
采用链式存储实现队列的初始化、入队、出队操作。
采用顺序存储实现循环队列的初始化、入队、出队操作。
在主函数中设计一个简单的菜单，分别测试上述算法。

综合训练：

C++ 二叉树的基本操作

Thu, 21 Jun 2012 00:00:00 +0800

C++ 二叉树的基本操作

实验五：二叉树的基本操作

（1）输入字符序列，建立二叉链表。
（2）先序、中序、后序遍历二叉树:递归算法。
（3）中序遍历二叉树:非递归算法。（最好也能实现先序、后序非递归算法）
（4）求二叉树的高度。
（5）求二叉树的叶子个数。
（6）借助队列实现二叉树的层次遍历。
（7）在主函数中设计一个简单的菜单，分别调试上述算法。

源码

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define LIST_INT_SIZE 100
#define LISTINCREMENT 10
int dep, count = 0;
typedef int Status;
typedef char TElemType;
typedef struct BiTNode
{
    TElemType data;
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;
//建立二叉树
Status CreateBiTree(BiTree &T)
{
    char ch;
    getchar();
    scanf("%c", &ch);
    if (ch == ' ' || ch == '\n')
    {
        T = NULL;
        return ERROR;
    }
    else
    {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        printf("请输入%c的左孩子：", T->data);
        CreateBiTree(T->lchild);
        printf("请输入%c的右孩子：", T->data);
        CreateBiTree(T->rchild);
        return OK;
    }
}
//主菜单
void print()
{
    printf("\n菜单如下：\n");
    printf("1 . 输入字符序列，建立二叉链表\n");
    printf("2 . 先序、中序、后序遍历二叉树:递归算法\n");
    printf("3 . 先序、中序、后序遍历二叉树:非递归算法\n");
    printf("4 . 求二叉树的高度 \n");
    printf("5 . 求二叉树的叶子个数\n");
    printf("6 . 借助队列实现二叉树的层次遍历\n");
    printf("0 . EXIT\n请选择操作序号：");
}
//先序、中序、后序遍历二叉树:递归算法
void print2()
{
    printf("\n递归算法遍历二叉树，菜单如下：\n");
    printf("1.先根遍历\n");
    printf("2.中序遍历\n");
    printf("3.后续遍历\n");
    printf("0.退出\n");
    printf("请输入二级菜单选择:");
}
Status Visit(BiTree T)
{
    if (T)
    {
        printf("%c ", T->data);
        return OK;
    }
}
Status PrintElement(TElemType e)
{
    printf(" %c ", e);
    return OK;
}
//先序
Status PreOrderTraverse(BiTree T, Status (*Visit)(TElemType e))
{
    if (T)
    {
        if (Visit(T->data))
            if (PreOrderTraverse(T->lchild, Visit))
                if (PreOrderTraverse(T->rchild, Visit))
                    return OK;
        return ERROR;
    }
    else
        return OK;
}
//中序
Status MidOrderTraverse(BiTree T, Status (*Visit)(TElemType e))
{
    if (T)
    {
        if (MidOrderTraverse(T->lchild, Visit))
            if (Visit(T->data))
                if (MidOrderTraverse(T->rchild, Visit))
                    return OK;
        return ERROR;
    }
    else
        return OK;
}
//后序
Status LastOrderTraverse(BiTree T, Status (*Visit)(TElemType e))
{
    if (T)
    {
        if (LastOrderTraverse(T->lchild, Visit))
            if (LastOrderTraverse(T->rchild, Visit))
                if (Visit(T->data))
                    return OK;
        return ERROR;
    }
    else
        return OK;
}
//求树的叶子的个数,和打印出叶子
Status LeafNumTree(BiTree T)
{
    int lnum, rnum;
    if (T != NULL)
    {
        if (T->lchild == NULL && T->rchild == NULL)
            return 1;
        else
        {
            lnum = LeafNumTree(T->lchild);
            rnum = LeafNumTree(T->rchild);
            return lnum + rnum;
        }
    }
    return 0;
}
//求二叉树的高度
Status BiTreeDepth(BiTree T)
{
    int l, r;
    if (T)
    {
        l = BiTreeDepth(T->lchild);
        r = BiTreeDepth(T->rchild);
        if (l >= r)
            dep += l;
        else dep += r;
    }
    else
        return 1;
}
//先序、中序、后序遍历二叉树:非递归算法
void print3()
{
    printf("\n非递归算法遍历二叉树，菜单如下：\n");
    printf("1.先根遍历\n");
    printf("0.退出\n");
    printf("请输入二级菜单选择:");
}
typedef struct QueueNode
{
    BiTree e;
    struct QueueNode *next;
} QueueNode, *QueuePtr;                 //定义队列结点结构
typedef struct
{
    QueuePtr front;
    QueuePtr rear;
} LinkQueue;
//栈的顺序存储表示
typedef struct
{
    BiTNode *base;   //栈底指针
    BiTNode *top;    //栈顶指针
    int   stacksize; //当前已分配的存储空间
} SqStack;
//初始化一个带头结点的队列
void InitQueue(LinkQueue &q)
{
    q.front = q.rear = (QueuePtr)malloc(sizeof(QueueNode));
    q.front->next = NULL;
}
//入队列
void enqueue(LinkQueue &q, BiTree p)
{
    QueuePtr s;
    int first = 1;
    s = (QueuePtr)malloc(sizeof(QueueNode));
    s->e = p;
    s->next = NULL;
    q.rear->next = s;
    q.rear = s;
}
//出队列
void dequeue(LinkQueue &q, BiTree &p)
{
    char data;
    QueuePtr s;
    s = q.front->next;
    p = s->e ;
    data = p->data;
    q.front->next = s->next;
    if (q.rear == s)
        q.rear = q.front;
    free(s);
    printf("%c\t", data);
}
//判断队列是否为空
Status queueempty(LinkQueue q)
{
    if (q.front->next == NULL)
        return 1;
    return 0;
}
//按层次遍历树中结点
void Traverse(BiTree T)
{
    LinkQueue q;
    BiTree p;
    InitQueue(q);
    p = T;
    enqueue(q, p);
    while (queueempty(q) != 1)
    {
        dequeue(q, p);
        if (p->lchild != NULL)
            enqueue(q, p->lchild);
        if (p->rchild != NULL)
            enqueue(q, p->rchild);
    }
    printf("\n");
}
//建立一个空栈
void InitStack(SqStack &S)
{
    S.base = (BiTree)malloc(LIST_INT_SIZE * sizeof(BiTNode));
    if (!S.base)
        exit(OVERFLOW );//存储分配失败
    S.top = S.base;
    S.stacksize = LIST_INT_SIZE;
}
//压入栈
void Push(SqStack & S, BiTree p)
{
    if (S.top - S.base >= S.stacksize) //满栈，追加存储结构
    {
        S.base = (BiTree)realloc(S.base, (S.stacksize + LISTINCREMENT) * sizeof(BiTNode));
        if (!S.base)  exit(OVERFLOW ); //存储分配失败
        S.top = S.base + S.stacksize;
        S.stacksize += LISTINCREMENT;
    }
    *(++S.top) = *p;
}
//退出栈
bool Pop(SqStack &S, BiTree &p)
{
    if ( S.top == S.base)
    {
        printf("空栈\n");
        return false;
    }
    p = (BiTree)malloc( sizeof(BiTNode));
    *p = *S.top;
    --S.top;
    return true;
}
//判断是否是空栈
bool StackEmpty(SqStack &S)
{
    if ( S.top == S.base)
        return true;
    else
        return  false ;
}
Status InOrderTraverAndCountLeaf(BiTree &T, Status(* Vist)(TElemType e))
{
    int j = 0, count = 0;
    BiTree p;
    p = (BiTNode *)malloc( sizeof(BiTNode)); //关键一步
    p = T;
    SqStack s;
    InitStack(s);
    while (p || !StackEmpty(s))
    {
        if (p)
        {
            Push(s, p); //如果p为非空，将p压入栈
            if (!(p->lchild) && !(p->rchild))
                ++count;//记录叶子节点数
            p = p->lchild;
        }//if
        else
        {
            Pop(s, p); //如果p为空，则p退栈
            Vist(p->data);
            p = p->rchild;
        }//else
    }//while
    return  count;
}
int main()
{
    int n, ncase;
    int count;
    bool f, f1, f2, f3;
    BiTree T;
    TElemType e;
    print();
    while (scanf("%d", &n) != EOF)
    {
        f = true;
        switch (n)
        {
        case 1:
            printf("输入空格或回车表示此结点为空结束\n请输入头结点：");
            if (CreateBiTree(T))
                printf("二叉树建立成功!\n");
            else
                printf("二叉树建立失败!\n");
            break;
        case 2:
            print2();
            while (scanf("%d", &ncase) != EOF)
            {
                f1 = true;
                switch (ncase)
                {
                case 1:
                    printf("先序遍历顺序为：");
                    if (PreOrderTraverse(T, PrintElement))
                        printf("先序遍历成功!\n");
                    else
                        printf("先序遍历失败!\n");
                    break;
                case 2:
                    printf("中序遍历顺序为：");
                    if (MidOrderTraverse(T, PrintElement))
                        printf("中序遍历成功!\n");
                    else
                        printf("中序遍历失败!\n");
                    break;
                case 3:
                    printf("后序遍历顺序为：");
                    if (LastOrderTraverse(T, PrintElement))
                        printf("后序遍历成功!\n");
                    else
                        printf("后序遍历失败!\n");
                    break;
                case 0:
                    f1 = false;
                    break;
                default :
                    printf("输入错误，请重新输入!\n");
                }
                if (!f1)
                    break;
                print2();
            }
            break;
        case 3:
            print3();
            while (scanf("%d", &ncase) != EOF)
            {
                f2 = true;
                switch (ncase)
                {
                case 1:
                    InOrderTraverAndCountLeaf(T, PrintElement);
                    break;
                case 0:
                    f2 = false;
                    break;
                default :
                    printf("输入错误，请重新输入!\n");
                }
                if (!f2)
                    break;
                print3();
            }
            break;
        case 4:
            dep = 0;
            BiTreeDepth(T);
            printf("二叉树的高度为：%d\n", dep - 1);
            break;
        case 5:
            count = LeafNumTree(T);
            printf("二叉树的叶子个数为：%d\n", count);
            break;
        case 6:
            printf("按层次遍历的顺序为:\n");
            Traverse(T);
            printf("\n");
            break;
        case 0:
            f = false;
            break;
        default:
            printf("输入错误，请重新输入!\n");
            break;
        }
        if (!f)
        {
            printf("退出程序...\n");
            break;
        }
        print();
    }
    return 0;
}

图的基本操作

Thu, 21 Jun 2012 00:00:00 +0800

实验七：图的基本操作

实验七：图的基本操作

键盘输入数据，建立一个有向图的邻接表。
输出该邻接表。
在有向图的邻接表的基础上计算各顶点的度，并输出。
以有向图的邻接表为基础实现输出它的拓扑排序序列。
采用邻接表存储实现无向图的深度优先遍历。
采用邻接表存储实现无向图的广度优先遍历。
采用邻接矩阵存储实现无向图的最小生成树的PRIM算法。
采用邻接矩阵存储一个有向图，输出单源点到其它顶点的最短路径。
在主函数中设计一个简单的菜单，分别调试上述算法。

综合训练：为计算机专业设计教学计划：4个学年，每学年2个学期，开设50门课程，每学期所开课程门数尽量均衡，课程的安排必须满足先修关系。

C++ 哈夫曼编码

Thu, 21 Jun 2012 00:00:00 +0800

哈夫曼编码

实验六：哈夫曼编码

已知某系统在通信联络中只可能出现8种字符，其概率分别为0.05，0.29，0.07，0.08，0.14，0.23，0.03，0.11，试设计哈夫曼编码。

C++ 排序的基本操作

Thu, 21 Jun 2012 00:00:00 +0800

C++ 排序的基本操作，实现简单选择排序、直接插入排序和冒泡排序；希尔排序；快速排序；堆排序；链式存储实现简单选择排序、直接插入排序和冒泡排序

实验八：排序的基本操作

输入一组关键字序列分别实现下列排序:

C++ 双向链表的基本操作

Thu, 21 Jun 2012 00:00:00 +0800

双向链表的基本操作

实验三：双向链表的基本操作

利用尾插法建立一个双向链表。
遍历双向链表。
实现双向链表中删除一个指定元素。
在非递减有序双向链表中实现插入元素e仍有序算法。
判断双向链表中元素是否对称若对称返回1否则返回0。
设元素为正整型,实现算法把所有奇数排列在偶数之前。
在主函数中设计一个简单的菜单调试上述算法。

源码

#include <stdio.h>
#include <stdlib.h>
#define ERROR       -1
#define OK      1
#define OVERFLOW    -2
typedef int ElemType;
typedef int Status;
typedef struct DuLNode {
    ElemType    data;
    struct DuLNode  *prior;
    struct DuLNode  *next;
}DuLNode, * DuLinkList;
/* 创建双链表 */
Status InsertDuLinkList_real( DuLinkList L )
{
    int n, i, c;
    printf( "请输入要创建双链表的长度n=" );
    scanf( "%d", &n );
    DuLinkList p, dl;
    dl = L;
    printf( "请依次输入数据：" );
    for ( i = 0; i < n; i++ )
    {
        if ( !(p = (DuLinkList) malloc( sizeof(DuLNode) ) ) )
            return(OVERFLOW);
        scanf( "%d", &c );
        p->data     = c;
        dl->next    = p;
        p->prior    = dl;
        p->next     = L;
        L->prior    = p;
        dl      = p;
    }
    return(OK);
}


/* 遍历双链表 */
Status pDuLinkList( DuLinkList L )
{
    DuLinkList dl;
    dl = L->next;
    while ( dl->next != L )
    {
        printf( "%d ", dl->data );
        dl = dl->next;
    }
    printf( "%d\n", dl->data );
    return(OK);
}


DuLinkList GetElemP_DuL( DuLinkList L, ElemType i )
{
    DuLinkList dl;
    dl = L->next;
    while ( dl != L )
    {
        if ( dl->data == i )
            return(dl);
    }
    return(NULL);
}


/* 双链表的删除,实现双向链表中删除一个指定元素 */
Status LinkDelete_Dul( DuLinkList L, int i )
{
    DuLinkList p;
    if ( !(p = GetElemP_DuL( L, i ) ) )
        return(ERROR);
    p->prior->next =
        p->next;
    p->next->prior =
        p->prior;
    free( p );
    return(OK);
}


Status GetLengthOfDL( DuLinkList L )
{
    int     n = 0;
    DuLinkList  dl;
    dl = L->next;
    while ( dl != L )
    {
        n++;
        dl = dl->next;
    }
    return(n);
}


/* 实现双链表的指定位置的删除 */
Status LinkDelete_Dd( DuLinkList L, int i )
{
    if ( i > GetLengthOfDL( L ) || i < 1 )
    {
        printf( "删除下标非法!\n" );
        return(ERROR);
    }
    DuLinkList  dl;
    int     n = 1;
    dl = L->next;
    while ( n < i )
    {
        n++;
        dl = dl->next;
    }
/* p = dl->prior; */
    dl->prior->next =
        dl->next;
    dl->next->prior =
        dl->prior;
    free( dl );
    return(OK);
}


/* 排序 */
Status sortDuLinkList( DuLinkList L )
{
    int n = GetLengthOfDL( L );
/* printf("%d",n); */
    int     t;
    DuLinkList  p;
    for ( int i = 1; i < n; i++ )
    {
        p = L->next;
        for ( int j = 0; j < n - i; j++ )
        {
            if ( p->data >
                 p->next->data )
            {
                t   = p->data;
                p->data =
                    p->next->data;
                p->next->data = t;
            }
            p = p->next;
        }
    }
    return(OK);
}


/* 插入 */
Status InsertDuL( DuLinkList L, int n )
{
/* printf("dd"); */
    DuLinkList p, dl;
    if ( !(dl = (DuLinkList) malloc( sizeof(DuLNode) ) ) )
        return(OVERFLOW);
    p       = L->next;
    dl->data    = n;
    while ( p->data < n )
        p = p->next;
    printf( "%d", p->data );
    p->prior->next  = dl;
    dl->prior   = p->prior;
    p->prior    = dl;
    dl->next    = p;
    return(OK);
}


/* 判断双链表是否对称 */
Status isReturnDuL( DuLinkList L )
{
    DuLinkList p, q;
    p   = L->next;
    q   = L->prior;
    int n = GetLengthOfDL( L );
    if ( n % 2 )
    {
        while ( p->data == q->data && p != q )
        {
            p = p->next; q = q->prior;
        }
        if ( q == p )
            return(1);
        else
            return(0);
    }else{
        while ( p->data == q->data && p->next != q )
        {
            p = p->next; q = q->prior;
        }
        if ( p->data == q->data )
            return(1);
        else
            return(0);
    }
}


/* 实现算法把所有奇数排列在偶数之前 */
Status inLawSort( DuLinkList L )
{
    DuLinkList  p, dl, p1;
    int     i, n = GetLengthOfDL( L );
    i   = 0;
    p   = L->next;
    dl  = L->prior;
    while ( i < n )
    {
        if ( (p->data) % 2 != 0 )
        {
            i++;
            p = p->next;
        }else  {
            p1      = p->next;
            p->next->prior  =
                p->prior;
            p->prior->next =
                p->next;
            p->next     = L;
            p->prior    = dl;
            dl->next    = p;
            L->prior    = p;
            dl      = p;
            p       = p1;
            i++;
        }
    }
    return(OK);
}


void print()
{
    printf( "欢迎测试双链表,菜单如下：\n" );
    printf( "1.运用尾差法创建双链表\n" );
    printf( "2.遍历双向链表\n" );
    printf( "3.实现双链表删除一个指定元素\n" );
    printf( "4.在非递减有序双向链表中实现插入元素e仍有序\n" );
    printf( "5.判断双向链表中元素是否对称若对称返回1否则返回0\n" );
    printf( "6.实现算法把所有奇数排列在偶数之前\n" );
    printf( "0.EXIT\n" );
    printf( "请选择操作序号：" );
}


int main()
{
    DuLinkList  L;
    Status      e, ch, n;
    bool        flag = true;
    L       = (DuLinkList) malloc( sizeof(DuLNode) );
    L->prior    = NULL;
    L->next     = NULL;
    print();
    while ( scanf( "%d", &ch ) != EOF )
    {
        switch ( ch )
        {
        case 0:
            flag = false;
            break;
        case 1:
            if ( InsertDuLinkList_real( L ) )
                printf( "创建成功！\n" );
            else
                printf( "创建失败!\n" );
            break;
        case 2:
            if ( pDuLinkList( L ) )
                printf( "遍历成功!\n" );
            else
                printf( "遍历失败!\n" );
            break;
        case 3:
            printf( "请选择删除方式：1.删除指定元素  2.删除制定下标\n" );
            printf( "请输入选择序号e=" );
            scanf( "%d", &e );
            switch ( e )
            {
            case 1:
                printf( "请输入指定元素n=" );

                scanf( "%d", &n );

                if ( LinkDelete_Dul( L, n ) )

                    printf( "指定元素已删除!\n" );
                else

                    printf( "指定元素删除失败!\n" );
                break;
            case 2:
                printf( "请输入指定下标n=" );
                scanf( "%d", &n );
                if ( LinkDelete_Dd( L, n ) )

                    printf( "指定下标删除成功!\n" );
                else

                    printf( "指定下标删除失败!\n" );
            }
            break;
        case 4:
            printf( "按非递减排序双链表!\n" );
            sortDuLinkList( L );
            pDuLinkList( L );
            printf( "请输入插入的元素n=" );
            scanf( "%d", &n );
            if ( InsertDuL( L, n ) )
                printf( "插入成功!\n" );
            else
                printf( "插入失败!\n" );
            break;
        case 5:
            if ( isReturnDuL( L ) )
                printf( "1\n" );
            else
                printf( "0\n" );
            break;
        case 6:
            if ( inLawSort( L ) )
            {
                printf( "奇前偶后排序成功!\n" );
                pDuLinkList( L );
            }else
                printf( "奇前偶后排序失败!\n" );
            break;
        default:
            printf( "输入错误！\n" );
        }
        if ( !flag )
            break;
    }
    return(0);
}

顺序表的基本操作

Thu, 21 Jun 2012 00:00:00 +0800

实验一：顺序表的基本操作。

实验一：顺序表的基本操作

编写一个完整的程序，实现顺序表的建立、插入、删除、输出等基本运算。

建立一个顺序表，含有n个数据元素。
输出顺序表及顺序表的长度。
在顺序表中删除值为x的结点或者删除给定位置i的结点。
将顺序表就地逆置，即利用原表的存储空间将线性表（a1,a2,…,an）逆置为（an,an-1,…,a1）。
将顺序表按升序排序。
设顺序表中的数据元素递增有序，将x插入到顺序表的适当位置上，以保持该表的有序性。
将两个顺序有序表A和B合并为一个有序表C。
在主函数中设计一个简单的菜单，分别测试上述算法。

源码

#include<stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define OK 1
#define OVERFLOW -2
#define ERROR 0
typedef int ElemType;
typedef struct
{
    ElemType *elem;
    int length;
    int listsize;
} SqList;
int cmp(const void *a, const void *b)
{
    return *(int*)a - *(int*)b;
}
//创建一个空表
int InitList(SqList &L)
{
    L.elem = (ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType)); //分配空间
    if (!L.elem)
        return OVERFLOW;
    L.length = 0;
    L.listsize = LIST_INIT_SIZE;
    return OK;
}
//在创建的空表中插入数据
int ListInsert(SqList &L, int i, ElemType e)
{
    ElemType* newbase;
//ElemType* q;
    if (i < 0 || i > L.length + 1)
        return ERROR;
    if (L.length >= L.listsize) //当前空间已满，增加新空间
    {
        newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
        if (!newbase)
            return OVERFLOW;
        L.elem = newbase;
        L.listsize += LISTINCREMENT;
    }
    L.elem[i] = e;
//printf("%d ",L.elem[i]);
    L.length++;
    return OK;
}
//删除位置为i的节点
int ListDelete(SqList &L, int i)
{
    ElemType* p;
    ElemType* q;
    if (i < 0 || i > L.length)
        return ERROR;
    p = &(L.elem[i - 1]);
//e=*p;
    q = L.elem + L.length - 1;
    for (++p; p <= q; p++)
        *(p - 1) = *p;
    L.length--;
    return OK;
}
//在顺序表中删除数据x
int DeleteX(SqList &L, int x)
{
    ElemType* p;
    int i;
    for (i = 0; i < L.length; i++)
        if (L.elem[i] == x)
        {
            break;
        }

    p = &L.elem[i];

//free(p);

    for (int j = i; j < L.length - 1; j++)
    {

        L.elem[j] = L.elem[j + 1];
    }

    L.length--;

    return OK;
}
//反转顺序表
int TurnArrond(SqList &L)//翻转顺序表
{
    ElemType* p;
    ElemType* q;
    int t;
    p = &(L.elem[0]);
    q = L.elem + L.length - 1;
    for (p; p < q; p++, q--)
    {
        t = *q;
        *q = *p;
        *p = t;
    }
    return OK;
}
//升序排列顺序表
int ABC(SqList &L)
{
    int a[10000];
    int i;
    for (i = 0; i < L.length; i++)
        a[i] = L.elem[i];
    qsort(a, L.length, sizeof(a[0]), cmp);
    for (i = 0; i < L.length; i++)
        L.elem[i] = a[i];
    return OK;
}
//把顺序表升序排列后插入元素e
int ListInsertABC(SqList &L, ElemType e)
{
    ElemType* newbase;
    int i, j;
    if (L.length + 1 >= L.listsize) //当前空间已满，增加新空间
    {
        newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
        if (!newbase)
            return OVERFLOW;
        L.elem = newbase;
        L.listsize += LISTINCREMENT;
    }
    for (i = 0; i < L.length; i++)
        if (e < L.elem[i])
            break;


    for (j = L.length; j > i; j--)
    {

        L.elem[j] = L.elem[j - 1];
    }

    L.length++;

    L.elem[j] = e;

//printf("%d ",L.elem[i]);

    return OK;
}
//合并顺序表L，L1为L2
int MergeList(SqList L, SqList L1, SqList &L2)
{
    ElemType* pa;
    ElemType* pb;
    ElemType* pc;
    ElemType* pa_last;
    ElemType* pb_last;
    pa = L.elem;
    pb = L1.elem;
//
    L2.elem = pc;
    L2.listsize = L.listsize + L1.listsize;
    pc = L.elem = (ElemType*)malloc(L2.listsize * sizeof(ElemType));
    pa_last = L.elem + L.length - 1;
    pb_last = L1.elem + L1.length - 1;
    while (pa <= pa_last &&
            pb <= pb_last)
    {
        if (*pa <= *pb)
            *pc++ = *pa++;
        else
            *pc++ = *pb++;
    }
    while (pa <= pa_last)
        *pc++ = *pa++;
    while (pb <= pb_last)
        *pc++ = *pb++;
    for (int i = 0; i < L2.length; i++)
        printf("%d ", L2.elem[i]);
    return OK;
}
//打印菜单
void printScreen()
{
//printf("1.建立一个顺序表，含有n个数据元素。\n");
    printf("1.输出顺序表L1及其长度\n");
    printf("2.删除给定位置i的结点\n");
    printf("3.在顺序表中删除值为x的结点\n");
    printf("4.逆置顺序表\n");
    printf("5.将顺序表按升序排序\n");
    printf("6.设顺序表中的数据元素递增有序，将x插入到顺序表的适当位置上，以保持该表的有序性\n");
    printf("7.将两个顺序有序表L和L1合并为一个有序表L2\n");
    printf("0.退出操作系统。\n");
    printf("请输入需要的操作序号：");
}
//输出顺序表L
void printSqList(SqList &L)
{
    int i;
    for (i = 0; i < L.length; i++)
        printf("%d ", L.elem[i]);
    printf("\n");
}
int main()
{
    SqList L, L1, L2;
    InitList(L);
    InitList(L1);
    InitList(L2);
    int n, e, muse, i, x;
    bool flag;
//建立第一个的顺序表
    printf("请输入第一个数据表的长度：");
    scanf("%d", &n);
    printf("请以次输入长度为%d的顺序表：", n);
    for (i = 0; i < n; i++)
    {
        scanf("%d", &e);
        ListInsert(L, i, e); //依次在第i个位置插入顺序表
    }
    printf("第一个顺序表的次序为：");
    printSqList(L);
//建立第二个顺序表
    printf("建立第二个顺序表，请输入要第二个建立数据表的长度：");
    scanf("%d", &n);
    printf("请以次输入长度为%d的顺序表：", n);
    for (i = 0; i < n; i++)
    {
        scanf("%d", &e);
        ListInsert(L1, i, e); //依次在第i个位置插入顺序表
    }
    printf("第二个顺序表的次序为：");
    printSqList(L1);
//打印菜单
    printScreen();
    scanf("%d", &muse);
    flag = true;
    while (1)
    {
        switch (muse)
        {
        case 0:
            flag = false;
            break;
        case 1:
            printf("顺序表的长度为：");
            printf("%d\n", L.length);
            break;
        case 2:
            printf("请输入要删除的节点：");
            scanf("%d", &i); //删除顺序表的节点
            if (ListDelete(L, i))
            {
                printf("删除成功！\n");
                printSqList(L);
            }
            else
                printf("删除失败！\n");
            break;
        case 3:
            printf("请输入要删除的节点x的值：");
            scanf("%d", &x);
            if (DeleteX(L, x))
            {
                printf("删除成功！\n顺序表为：");
                printSqList(L);
            }
            else
                printf("删除失败！\n");
            break;
        case 4:
//逆序顺序表
            if (TurnArrond(L))
            {
                printf("逆序成功！\n");
                printf("顺序表的次序为：");
                printSqList(L);
            }
            else
                printf("逆序失败！\n");
            break;
        case 5:
//顺序表升序排列
            if (ABC(L))
            {
                printf("顺序表升序排列成功！\n");
                printf("顺序表的次序为：");
                printSqList(L);
            }
            else
                printf("顺序表升序排列失败！\n");
            printf("请输入要插入的数据：");
            scanf("%d", &e);
            if (ListInsertABC(L, e))
            {
                printf("顺序插入成功！\n");
                printf("顺序表的次序为：");
                printSqList(L);
            }
            else
                printf("顺序插入失败！\n");
            break;
        case 6:
            ABC(L);
            printf("请输入要插入的数字x的值：");
            scanf("%d", &x);
            if (ListInsertABC(L, x))
            {
                printf("操作成功！\n");
                printf("顺序表的次序为：");
                printSqList(L);
            }
            else printf("操作失败！\n");
            break;
        case 7:
            if (MergeList(L, L1, L2))
            {
                printf("顺序表L，L1合并成功!\n");
//printf("顺序表的次序为：");
//printSqList(L2);
            }
            else
                printf("顺序表合并失败！\n");
            break;
        default:
            break;
        }
        if (!flag)
            break;
        printf("\n请输入你要的下一步操作序号：");
        scanf("%d", &muse);
    }
    if (L.elem)
        free(L.elem);
    if (L1.elem)
        free(L1.elem);
    if (L2.elem)
        free(L2.elem);
    return 0;
}

MFC中如何用ADO连接SQL Server 2005

Mon, 07 Jan 2013 00:00:00 +0800

MFC中如何用ADO连接SQL Server 2005

VC++ ADO连接数据库

第一步:(以下语句插入相应的文件中,ADOConn.h,可能代码中已经有了)

#import"C:\Program Files\Common Files\System\ado\msado15.dll"no_namespace rename("EOF","adoEOF")rename("BOF","adoBOF")

第二步:

MFC使用ADO连接SQL Server数据库

Mon, 07 Jan 2013 00:00:00 +0800

MFC使用ADO连接SQL Server数据库

步骤

首先，要用#import语句来引用支持ADO的组件类型库(*.tlb)，其中类型库可以作为可执行程序(DLL、EXE等)的一部分被定位在其自身程序中的附属资源里，如：被定位在msado15.dll的附属资源中，只需要直接用 #import引用它既可。可以直接在Stdafx.h文件中加入下面语句来实现：

#import "c:/program files/common
files/system/ado/msado15.dll" no_namespace rename("EOF", "adoEOF")

其中路径名可以根据自己系统安装的ADO支持文件的路径来自行设定。当编译器遇到#import语句时，它会为引用组件类型库中的接口生成包装类，#import语句实际上相当于执行了API涵数LoadTypeLib()。#import语句会在工程可执行程序输出目录中产生两个文件，分别为*.tlh(类型库头文件)及*.tli(类型库实现文件)，它们分别为每一个接口产生智能指针，并为各种接口方法、枚举类型，CLSID等进行声明，创建一系列包装方法。语句no_namespace说明ADO对象不使用命名空间，rename (“EOF”, “adoEOF”)说明将ADO中结束标志EOF改为adoEOF，以避免和其它库中命名相冲突。

VC6 MFC中ClassView视图中无法显示某个类的问题

Tue, 08 Jan 2013 00:00:00 +0800

VC6 MFC中ClassView视图中无法显示某个类的问题

说明

在用VC6 MFC编写界面程序时，添加一个对话框资源并向工程中添加该对话框资源对应的类时，发现在工程源代码文件夹以及FileView视图中都能看见对话框类的定义，然而在ClassView视图中却无法看到该类的定义，此现象为VC6 MFC的bug，解决该问题可以考虑用如下两种方法。

rose生成C++源代码

Thu, 10 Jan 2013 00:00:00 +0800

步骤

需要先设置类的语言，否则前功尽弃。。。。

设置方法：Tools->Options->Notation->把Default的Analysis换成ANSI C++

解决问题

Fri, 29 Mar 2013 00:00:00 +0800

解决问题

步骤

在发布网站的时候，遇到了这个问题，在网上找了找，解决了自己的问题，但是找的时候很杂，为了方便以后的开发，总结如下：

打开控制面板–管理工具–Internet

信息服务(IIS)管理器，选择默认网站，在右边的“管理网站”栏里选择“高级设置…”，将“应用程序池”修改为“ASP.NET v4.0 ”。

C++ 学习示例 on chinese

顺序表的基本操作

顺序表的基本操作

程序

链表

源码

C++ 单链表的基本操作

实验二：单链表的基本操作

栈和队列的基本操作

实验四：栈和队列的基本操作

C++ 二叉树的基本操作

实验五：二叉树的基本操作

源码

图的基本操作

实验七：图的基本操作

C++ 哈夫曼编码

实验六：哈夫曼编码

C++ 排序的基本操作

实验八：排序的基本操作

C++ 双向链表的基本操作

实验三：双向链表的基本操作

源码

顺序表的基本操作

实验一：顺序表的基本操作

源码

MFC中如何用ADO连接SQL Server 2005

VC++ ADO连接数据库

MFC使用ADO连接SQL Server数据库

步骤

VC6 MFC中ClassView视图中无法显示某个类的问题

说明

rose生成C++源代码

步骤

解决 问题

步骤

解决问题