大三秋季数据结构课程代码整理

数据结构课程代码的整理，代码主要是朱明老师布置的习题:)．

//课本为«数据结构－使用C语言»，作者:朱战立．

  

2-11：编写一个逐个输出顺序表中所有数据元素的算法

int ListPrint(SeqList L)
{
    int i;
    if(L.size == 0) {
        printf("表列为空\n");
        return 0;
    }
    for(i=0;i<(L.size);i++) {
        printf("%d ",L.list[i]);
    }
    puts("");
    return 1;
}

 

2-13：线性表定位操作ListFind(L,x)的功能是：在线性表L中查找是否存在数据元素x，如果存在，返回线性表中与x值相等的第一个数据元素的序号（序号编号从0开始），如果不存在，返回-1．要求编写顺序表的定位操作算法．

int ListFind(SeqList L,DataType x)
{
    int id=-1,i;
    for(i=0;i<L.size;i++) {
        if(L.list[i]==x) {
            id = i;
            break;
        }
    }
    return id;
}

 

2-16：编写算法实现顺序表的就地逆置，即要求利用原顺序表的存储单元，把数据元素序列$(a_{0},a_{1},...,a_{n-1})$逆置为$(a_{n-1},...,a_{1},a_{0})$.

void ListInverse(SeqList *L)
{
    int i,j;
    DataType t;
    for(i=0,j=(L->size)-1;i<j;i++,j--) {
        t = L->list[i];
        L->list[i] = L->list[j];
        L->list[j] = t;
    }
}

 

2-17:编写算法实现单链表的逆置，要求把单链表la中的数据元素序列$(a_{0},a_{1},...,a_{n-1})$逆置为$(a_{n-1},...,a_{1},a_{0})$，并把逆置后的数据元素存储到单链表lb中

void ListInverse2(SLNode* la,SLNode* lb)
{
    SLNode *p,*q;
    p = la->next;
    while(p!=NULL) {
        ListInsert(lb,0,p->data);
        p = p->next;
    }
}

 

2-18：编写算法实现单链表的就地逆置，即要求利用原单链表的结点空间，把数据元素序列$(a_{0},a_{1},...,a_{n-1})$逆置为$(a_{n-1},...,a_{1},a_{0})$．

void ListInverse1(SLNode *head)
{
    SLNode *p = head->next,*q;
    head->next = NULL;
    while(p!=NULL) {
        q = p;
        p = p->next;
        q->next = head->next;
        head->next = q;
    }

}

 

2-20:

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define MaxSize 1000
typedef int DataType;
typedef struct Node
{
    DataType data;
    struct Node* next;
}SLNode;
void ListInitiate(SLNode* *head)
{
    *head = NULL;
}
int ListLength(SLNode *head)
{
    SLNode *p = head;
    int size = 0;
    while(p != NULL) {
        p = p->next;
        size++;
    }
    return size;
}
int ListInsert(SLNode* *head,int i,DataType x)
{
    SLNode *p,*q;
    int j=0;
    p = *head;

    if(i==0) {
        if((q = (SLNode *)malloc(sizeof(SLNode)))==NULL) exit(1);
        q->data = x;
        q->next = p;
        *head = q;
        return 1;
    }

    while(p!=NULL && j<i-1) {
        p = p->next;
        j++;
    }

    if(j != i-1) {
        printf("插入位置参数错！\n");
        return 0;
    }

    if((q = (SLNode *)malloc(sizeof(SLNode)))==NULL) exit(1);
    if(p==NULL) {
        printf("插入位置参数错！\n");
        return 0;
    }

    q->next = NULL;
    q->data = x;
    q->next = p->next;
    p->next = q;
    return 1;
}
int ListDelete(SLNode* *head,int i,DataType *x)
{
    SLNode *p,*s;
    int j=0;
    p = *head;

    if(p==NULL) {
        printf("删除位置参数错！\n");
        return 0;
    }

    if(i==0) {
        *head = p->next;
        *x = p->data;
        free(p);
        return 1;
    }

    while((p!=NULL) && (p->next!=NULL) && (j<i-1)) {
        p = p->next;
        j++;
    }
    if(j != i-1) {
        printf("删除位置参数错！\n");
        return 0;
    }

    s = p->next;

    if(s==NULL) {
        printf("删除位置参数错！\n");
        return 0;
    }
    *x = s->data;
    p->next = s->next;
    free(s);
    return 1;
}
void Destroy(SLNode* *head)
{
    SLNode *p,*q;
    p = *head;
    while(p!=NULL) {
        q = p;
        p = p->next;
        free(q);
    }
    *head = NULL;
}
void ListPrint(SLNode *head)
{
    SLNode *p = head;
    while(p!=NULL) {
        printf("%d ",p->data);
        p=p->next;
    }
    puts("");
}
int main()
{
    SLNode *head;
    ListInitiate(&head);
    int a[10]={100,8,4,3,6,5,4,7,8,9};
    int i;
    for(i=0;i<10;i++) {
        ListInsert(&head,i,a[i]);
    }

    /*DataType x;
    if(ListDelete(&head,0,&x)) {
        printf("%d\n",x);
    }*/
    ListInsert(&head,10,799);


    ListPrint(head);
    Destroy(&head);

    return 0;
}

 

2-22:

#include <stdio.h>
#define MaxSize 15
typedef int DataType;
typedef struct
{
    DataType list[MaxSize];
    int size;
}OrdList;
void ListInitiate(OrdList *L)
{
    L->size = 0;
}
int ListLength(OrdList L)
{
    return L.size;
}
int ListInsert(OrdList *L,DataType x)
{
    if(L->size >= MaxSize) {
        printf("表列已满无法插入！\n");
        return 0;
    }
    if(L->size == 0) {
        L->list[0]=x;
        L->size ++;
        return 1;
    }
    int n = L->size;
    int i,l=-1,r=n;
    while(r-l>1) {
        int mid = (l+r)>>1;
        if(mid == -1) break;
        if((L->list[mid])<=x) {
            l = mid;
        }
        else {
            r = mid;
        }
    }
    for(i=n;i>r;i--) {
        L->list[i] = L->list[i-1];
    }
    L->list[r]=x;
    L->size ++;
    return 1;
}

int ListDelete(OrdList *L,DataType x)
{
    int i,n=L->size;
    if(n<=0) {
        printf("表列已空无数据元素可删！\n");
        return 0;
    }
    int l=0,r=n;
    while(r-l>1) {
        int mid = (l+r)>>1;
        if(L->list[mid] <= x) {
            l = mid;
        }
        else {
            r = mid;
        }
    }
    if(L->list[l] != x) {
        printf("列表中并没有%d\n",x);
        return 0;
    }

    for(i=l;i<n-1;i++) {
        L->list[i] = L->list[i+1];
    }
    L->size --;
    return 1;
}
int ListGet(OrdList L,int i,DataType *x)
{
    int j,n=L.size;
    if(n<=0) {
        printf("表列为空无元素可取！\n");
        return 0;
    }
    if(i<0 || i>=n) {
        printf("参数i不合法！\n");
        return 0;
    }
    *x = L.list[i];
    return 1;
}

int ListPrint(OrdList L)
{
    int i;
    if(L.size == 0) {
        printf("表列为空\n");
        return 0;
    }
    for(i=0;i<(L.size);i++) {
        printf("%d ",L.list[i]);
    }
    puts("");
    return 1;
}
int ListMerge(OrdList L1,OrdList L2,OrdList *L3)
{
    int i,n1 = L1.size, n2 = L2.size;
    if(n1 + n2 > MaxSize) {
        printf("合并后序列长度超出最大限制，合并失败\n");
        return 0;
    }

    for(i=0;i<n1;i++) {
        L3->list[i] = L1.list[i];
    }
    L3->size = n1;
    for(i=0;i<n2;i++) {
        ListInsert(L3,L2.list[i]);
    }
    return 1;
}
int main()
{
    OrdList sq,sq1,sq2;
    ListInitiate(&sq);
    ListInitiate(&sq1);
    ListInitiate(&sq2);

    int i,x,n1,n2;
    printf("请输入要在表列１中插入元素的个数：\n");
    scanf("%d",&n1);
    printf("请输入%d个插入的元素：\n",n1);
    for(i=0;i<n1;i++) {
        scanf("%d",&x);
        ListInsert(&sq1,x);
    }
    printf("请输入要在表列２中插入元素的个数：\n");
    scanf("%d",&n2);
    printf("请输入%d个插入的元素：\n",n2);
    for(i=0;i<n2;i++) {
        scanf("%d",&x);
        ListInsert(&sq2,x);
    }
    puts("");
    printf("表列１：\n");
    ListPrint(sq1);
    printf("表列２：\n");
    ListPrint(sq2);


    ListMerge(sq1,sq2,&sq);
    printf("表列１，２的合并序列：\n");
    ListPrint(sq);

    /*ListDelete(&sq,100);
    ListPrint(sq);*/

    /*if(ListGet(sq,9,&x)) {
        printf("%d\n",x);
    }*/


    return 0;
}

 

3-11:

typedef struct
{
    DataType queue[MaxQueueSize];
    int rear;
    int front;
    int tag;
}SeqCQueue;

void QueueInitiate(SeqCQueue *Q)
{
    Q->front=0;
    Q->rear=0;
    Q->tag=0;
}

int QueueNotEmpty(SeqCQueue Q)
{
    if(Q.rear==Q.front && Q.tag==0) return 0;
    return 1;
}

int QueueAppend(SeqCQueue *Q,DataType x)
{
    if(Q->rear == Q->front && Q->tag==1) {
        printf("队列已满无法插入！\n");
        return 0;
    }
    Q->queue[Q->rear] = x;
    Q->rear = (Q->rear + 1)%MaxQueueSize;
    Q->tag = 1;
    return 1;
}

int QueueDelete(SeqCQueue *Q,DataType *d)
{
    if(Q->rear==Q->front && Q->tag==0) {
        printf("队列已空无数据元素出队列！\n");
        return 0;
    }
    *d = Q->queue[Q->front];
    Q->front = (Q->front + 1)%MaxQueueSize;
    Q->tag = 0;
    return 1;
}

int QueueGet(SeqCQueue Q,DataType *d)
{
    if(Q.rear==Q.front && Q.tag==0) {
        printf("队列已空无元素可取！\n");
        return 0;
    }
    *d = Q.queue[Q.front];
    return 1;
}

 

3-12:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef char DataType;
#include "LinStack.h"
#include "LinQueue.h"

void HuiWen(char str[])
{
    LQueue myQueue;
    LSNode *myStack;
    char x,y;
    int i,length;
    length = strlen(str);
    QueueInitiate(&myQueue);
    StackInitiate(&myStack);

    for(int i=0;i<length;i++) {
        QueueAppend(&myQueue,str[i]);
        StackPush(myStack,str[i]);
    }

    while(QueueNotEmpty(myQueue) && StackNotEmpty(myStack)) {
        if(QueueDelete(&myQueue,&x) && StackPop(myStack,&y) && x!=y) {
            printf("%s不是回文!\n",str);
            Destroy(myStack);Destroyq(myQueue);
            return ;
        }
    }
    if(QueueNotEmpty(myQueue) || StackNotEmpty(myStack)) {
        printf("%s不是回文!\n",str);
        Destroy(myStack);Destroyq(myQueue);
        return ;
    }
    printf("%s是回文！\n",str);
    Destroy(myStack);Destroyq(myQueue);
}

int main()
{
    char str1[]="ABCDEDCBA";
    char str2[]="ABCDEDCAB";

    HuiWen(str1);
    HuiWen(str2);

    return 0;
}

 

3-13:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef char DataType;
#include "LinStack.h"

void HuiWen(char str[])
{
    LSNode *myStack1,*myStack2;
    char x,y;
    int i,length;
    length = strlen(str);
    StackInitiate(&myStack1);
    StackInitiate(&myStack2);

    for(int i=0;i<length;i++) {
        StackPush(myStack1,str[i]);
        StackPush(myStack2,str[length-1-i]);
    }


    while(StackNotEmpty(myStack1) && StackNotEmpty(myStack2)) {
        if(StackPop(myStack1,&x) && StackPop(myStack2,&y) && x!=y) {
            printf("%s不是回文!\n",str);
            Destroy(myStack1);Destroy(myStack2);
            return ;
        }
    }
    if(StackNotEmpty(myStack1) || StackNotEmpty(myStack2)) {
        printf("%s不是回文!\n",str);
        Destroy(myStack1);Destroy(myStack2);
        return ;
    }
    printf("%s是回文！\n",str);
    Destroy(myStack1);Destroy(myStack2);
}

int main()
{
    char str1[]="ABCDEDCBA";
    char str2[]="ABCDEDCAB";

    HuiWen(str1);
    HuiWen(str2);

    return 0;
}

 

3-15:

typedef struct
{
    DataType list[MaxSize];
    int front;
    int rear;
}BSeqCQueue;

void QueueInitiate(BSeqCQueue *Q)
{
    Q->front = Q->rear = 0;
}

int QueueNotEmpty(BSeqCQueue Q)
{
    if(Q.rear == Q.front) {
        return 0;
    }
    return 1;
}

int QueueAppendFront(BSeqCQueue *Q,DataType x)
{
    if((Q->rear + 1)%MaxSize == Q->front) {
        printf("队列已满无法插入！\n");
        return 0;
    }
    Q->front = (Q->front + MaxSize - 1)%MaxSize;
    Q->list[Q->front] = x;
    return 1;
}

int QueueAppendRear(BSeqCQueue *Q,DataType x)
{
    if((Q->rear + 1)%MaxSize == Q->front) {
        printf("队列已满无法插入！\n");
        return 0;
    }
    Q->list[Q->rear] = x;
    Q->rear = (Q->rear + 1)%MaxSize;
    return 1;
}

int QueueDeleteFront(BSeqCQueue *Q,DataType *d)
{
    if(Q->front == Q->rear) {
        printf("队列已空无数据元素出队列！\n");
        return 0;
    }
    *d = Q->list[Q->front];
    Q->front = (Q->front + 1)%MaxSize;
    return 1;
}

int QueueDeleteRear(BSeqCQueue *Q,DataType *d)
{
    if(Q->front == Q->rear) {
        printf("队列已空无数据元素出队列！\n");
        return 0;
    }
    Q->rear = (Q->rear + MaxSize - 1)%MaxSize;
    *d = Q->list[Q->rear];

    return 1;
}

 

4-13:

#include <stdio.h>
#define MaxSize 100
#include "String.h"

int Compare(String S,String T)
{
    int i;
    for(i=0;;i++) {
        if(S.length==i && T.length==i) return 0;
        if(S.length==i) return -1;
        if(T.length==i) return 1;

        if(S.str[i]<T.str[i]) return -1;
        if(S.str[i]>T.str[i]) return 1;
    }
}

int main()
{
    int x,i;
    String S1 = {"Data ",5};
    String S2 = {"Structure",9};

    //Insert(&S2,0,S1);
    x = Compare(S1,S2);

    Print(S1);Print(S2);
    printf("%d\n",x);
    return 0;
}

 

4-15:

#include <stdio.h>
#define MaxSize 100
#include "String.h"

int Replace(String *S,int start,String T,String V)
{
    if(start<0 || start> S->length) {
        return 0;
    }

    int i,j,k,flag=0;
    String K;

    for(i=0,j=0;i<start;i++,j++) {
        K.str[j] = S->str[i];
    }
    for(i=start;i<S->length;) {

        for(k=0;k<T.length;k++) {
            if(i+k>=S->length) break;
            if(S->str[i+k] != T.str[k]) break;
        }

        if(k!=T.length) {
            if(j>=MaxSize) return 0;
            K.str[j++] = S->str[i++];
        }
        else {
            flag=1;
            i+=T.length;
            for(k=0;k<V.length;k++) {
                if(j>=MaxSize) return 0;
                K.str[j++] = V.str[k];
            }
        }
    }
    if(!flag) return 0;

    K.length = j;
    *S = K;
    return 1;

}

int main()
{
    int x;
    String S={"Keynman, Feynman and Teynman!",29};
    String T={"man",3};
    String V={"hhh",3};

    x=Replace(&S,0,T,V);
    Print(S);
    printf("%d\n",x);

    return 0;
}

 

4-16:

#include <stdio.h>
#define MaxSize 100
#include "String.h"

int Delete1(String *S,char ch)
{//T(n)=O(n)
    int i,j;
    for(i=0;i<S->length;i++) {
        if(S->str[i]==ch) {
            for(j=i+1;j<S->length;j++) {
                S->str[j-1] = S->str[j];
            }
            S->length--;
            return 1;
        }
    }
    return 0;
}

int Delete2(String *S,char ch)
{//T(n)=O(n)
    int i,j;
    String K = *S;
    for(i=0,j=0;i<K.length;i++) {
        if(K.str[i]==ch) continue;
        S->str[j++] = K.str[i];
    }
    S->length = j;
    if(S->length == K.length) return 0;
    return 1;
}

int main()
{
    int x;
    String S={"Keynman is COOOOOOL!",20};

    x=Delete1(&S,'n');
    Print(S);
    printf("%d\n",x);

    x=Delete2(&S,'O');
    Print(S);
    printf("%d\n",x);

    return 0;
}

 

5-15:

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

int **Make2DArray(int row,int col)
{
    int **a,i;
    if((a = (int**)malloc(row*sizeof(int*)))==NULL) exit(0);
    for(i=0;i<row;i++) {
        if((a[i] = (int *)malloc(col*sizeof(int)))==NULL) exit(0);
    }
    return a;
}
void Diliver2DArray(int **a,int row)
{
    int i;
    for(i=0;i<row;i++) free(a[i]);
    free(a);
}

int main()
{
    int **A,i,j;
    A = Make2DArray(7,7);
    for(i=0;i<7;i++) {
        for(j=0;j<7;j++) {
            A[i][j]=0;
        }
    }
    A[0][5]=5;A[1][3]=9;A[3][2]=19;
    A[3][5]=5;A[4][5]=5;A[5][1]=22;
    A[5][5]=33;A[6][5]=5;

    for(i=0;i<7;i++) {
        for(j=0;j<7;j++) {
            printf("%4d",A[i][j]);
        }
        puts("");
    }

    Diliver2DArray(A,7);
    return 0;
}

 

6-9:

#include <stdio.h>

/*
    sum(1) = a[0];
    sum(n) = sum(n-1) + a[n-1]; (n>1);
*/

int sum(int a[],int n)
{
    if(n==1) return a[0];
    return a[n-1] + sum(a,n-1);
}

int main()
{
    int a[]={1,2,3,4,5,6};
    int x = sum(a,6);
    printf("%d\n",x);

    return 0;
}

 

6-10:

#include <stdio.h>

/*
    prod(1) = a[0];
    prod(n) = prod(n-1) * a[n-1]; (n>1);
*/

int prod(int a[],int n)
{
    if(n==1) return a[0];
    return a[n-1]*prod(a,n-1);
}
int main()
{
    int a[]={1,2,3,4,5};
    int x = prod(a,5);
    printf("%d\n",x);

    return 0;
}

 

6-11:

#include <stdio.h>
int Fmax(int a[],int n)
{
    if(n==1) return a[0];
    int x = Fmax(a,n-1);
    return a[n-1]>x?a[n-1]:x;
}
int main()
{
    int a[]={1,4,3,5,5,22,55,-1,0};
    int x = Fmax(a,9);
    printf("%d\n",x);

    return 0;
}

 

6-12:

#include <stdio.h>

void Print1(int n)
{
    if(n==1) {
        printf("%4d\n",n);
        return ;
    }
    Print1(n-1);
    int i;
    for(i=0;i<n;i++) {
        printf("%4d",n);
    }
    putchar('\n');
}
void Print2(int n)
{
    int i,j;
    for(i=1;i<=n;i++) {
        for(j=1;j<=i;j++) {
            printf("%4d",i);
        }
        putchar('\n');
    }
}
int main()
{
    printf("(1):\n");
    Print1(10);

    printf("\n(2):\n");
    Print2(10);

    return 0;
}

 

7.层次遍历

#include <stdio.h>
#include <stdlib.h>
typedef char DType;
#include "BiTree.h"
typedef BiTreeNode* DataType;
#include "LinQueue.h"

void Visit(DType item)
{
    printf("%c ",item);
}

void LevelOrder(BiTreeNode *root,void Visit(DType item))
{
    LQueue Q;
    QueueInitiate(&Q);
    QueueAppend(&Q,root);
    while(QueueNotEmpty(Q)) {
        BiTreeNode *p;
        QueueDelete(&Q,&p);
        if(p!=root) Visit(p->data);
        if(p->leftChild!=NULL) QueueAppend(&Q,p->leftChild);
        if(p->rightChild!=NULL) QueueAppend(&Q,p->rightChild);
    }
    Destroyq(Q);
    return ;
}

int main()
{
    BiTreeNode *root,*p;
    Initiate(&root);
    p = InsertLeftNode(root,'A');
    p = InsertLeftNode(p,'B');
    p = InsertLeftNode(p,'D');
    p = InsertRightNode(p,'G');
    p = InsertRightNode(root->leftChild,'C');
    InsertLeftNode(p,'E');
    InsertRightNode(p,'F');

    LevelOrder(root,Visit);

    Destroy(&root);

    return 0;
}