对线性结构的总复习

PS：主要就是将线性结构的代码实现再回顾一遍

经过一段时间线性结构的学习，想着总结一下这段时间的学习，主要就是分为几个方面，对线性结构的最开始的认知，以及在后面进行的线性结构的一些基础应用。

1.线性顺序表

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

typedef struct SqList {
    int *pBase;
    int length;
    int listsize;
}*PSQLIST;


void init(PSQLIST pArr);
bool emptyArr(PSQLIST pArr);
void traverse(PSQLIST pArr);
bool fullArr(PSQLIST pArr);
bool append(PSQLIST pArr,int val);
bool insert(PSQLIST pArr,int pos,int val);
bool deleteAyy(PSQLIST pArr,int pos,int *val);

int main(void) {

    //如果直接使用PSQLIST进行定义的话，所初始化的话就不是一个完整的数组了，而是一个地址所以要先使用SqList定义一个数组
    int val;
    SqList Arr;
    init(&Arr);
    traverse(&Arr);
    append(&Arr,1);
    append(&Arr,2);
    append(&Arr,3);
    append(&Arr,4);
    traverse(&Arr);
    insert(&Arr,3,3333);
    traverse(&Arr);
    deleteAyy(&Arr,3,&val);
    printf("删除掉的数是:%d
",val);
    traverse(&Arr);
    return 0;
}

//初始化一个数组
void init(PSQLIST pArr) {
    int len;
    printf("请输入数组的个数:");
    scanf("%d",&len);
    printf("
");
    pArr->pBase = (int*)malloc(sizeof(int)*len);

    if(NULL == pArr->pBase) {
        printf("内存分配失败!
");
        exit(-1);
    } else {
        pArr->length = len;
        pArr->listsize = 0;
    }
}

void traverse(PSQLIST pArr) {
    if(emptyArr(pArr)) {

    } else {
        for(int i=0; i<pArr->listsize; i++) {
            printf("%d  ",pArr->pBase[i]);
        }
    }
    printf("
");
}
//判断数组是否为空
bool emptyArr(PSQLIST pArr) {
    if(0 == pArr->listsize) {
        printf("数组为空 !
");
        return true;
    } else {
        return false;
    }
}
//判断一个数组是否已满
bool fullArr(PSQLIST pArr) {
    if(pArr->length == pArr->listsize) {
        printf("数组已满!
");
        return true;
    } else {
        return false;
    }
}
//向数组中追加元素
bool append(PSQLIST pArr,int val) {
    if(fullArr(pArr)) {
        return false;
    } else {
        pArr->pBase[pArr->listsize] = val;
        pArr->listsize++;
        return true;
    }
}
//向数组中插入元素
bool insert(PSQLIST pArr,int pos,int val) {
    if(pos < 1 || pos > pArr->listsize) {
        printf("没有符合的位置!
");
        return false;
    }


    if(fullArr(pArr)) {
        return false;
    }

    for(int i=pArr->listsize-1; i>=pos-1; i--) {
        pArr->pBase[i+1] = pArr->pBase[i];
    }
    pArr->pBase[pos-1] = val;
    pArr->listsize++;
    return true;


}
bool deleteAyy(PSQLIST pArr,int pos,int *val) {

    if( pos < 1 || pos > pArr->listsize-1) {
        printf("插入的位置错误!
");
        return false;
    }
    if(emptyArr(pArr)) {
        return false;
    } else {

        *val = pArr->pBase[pos-1];

        for(int i =pos; i<pArr->listsize; i++) {
            pArr->pBase[i-1] = pArr->pBase[i];
        }

        pArr->listsize--;
        return true;
    }
}

2.线性链表　　

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

//先定义结点的类型
typedef struct Node {
    int data;

    struct Node* pNext;

} NODE,*PNODE;
PNODE createList();
void traverse(PNODE pHead);
bool emptyList(PNODE pHead);
void sortList(PNODE pHead);


int main(void) {
    PNODE pHead = NULL;//先定义一个无实际意义的指针
    pHead = createList();
    traverse(pHead);
    sortList(pHead);
    traverse(pHead);

    return 0;
}
PNODE createList() {
    //首先，弄出一个头结点
    PNODE pHead = NULL;
    pHead = (PNODE)malloc(sizeof(NODE));
    if(NULL == pHead) {
        printf("内存分配失败!
");
        exit(-1);
    }
    pHead->pNext = NULL;        //如果需要使用头插法的话 就必须要将指向第一个有效元素的指针定为空
    int len;
    printf("请输入需要的参数len=");
    scanf("%d",&len);
    printf("
");
    PNODE pNew;
    PNODE pTail = pHead;
    int val;
    for(int i=0; i<len; i++) {
        printf("请输入值:");
        scanf("%d",&val);
        pNew = (PNODE)malloc(sizeof(NODE));
        pNew->pNext=NULL;
        pNew->data = val;
        //尾插法
        //    pTail->pNext = pNew;
        //    pNew->pNext = NULL;
        //    pTail = pNew;
        //头插法
        pNew->pNext = pHead->pNext;
        pHead->pNext = pNew;
    }
    return pHead;


}
void traverse(PNODE pHead) {
    PNODE p = pHead->pNext;
    while(NULL != p) {
        printf("%d  ",p->data);
        p = p->pNext;
    }
    printf("
");
    return;
}
bool emptyList(PNODE pHead) {
    if(NULL == pHead->pNext) {
        printf("链表为空!
");
        return true;
    } else {
        return false;
    }
}
int lengthList(PNODE pHead) {
    PNODE p = pHead->pNext;
    int length;
    while(NULL != p) {
        length++;
        p = p->pNext;
    }
    return length;
}
// 对链表进行排序
void sortList(PNODE pHead) {
    int i,j,t;
    int len = lengthList(pHead);
    PNODE p,q;

    //i和j控制循环次数  p和q控制指针的移动
    for(i=0,p=pHead->pNext; i<len-1; i++, p=p->pNext) {
        for(j=i+1,q=p->pNext; j<len; j++,q=q->pNext) {
            if(p->data>q->data) {
                t = p->data;
                p->data = q->data;
                q->data = t;
            }
        }
    }
    return;

}

3.栈的实现

 　　栈的思想主要就是一个链表设置了只能在一个口子进行删除或者是添加，这个动作就是被叫做压栈和出栈。

　　代码实现：

　　

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


//使用链表去是实现栈
typedef struct Node {
    int data;
    struct Node * pNext;
} NODE,*PNODE;
//定义栈需要的参数
typedef struct Stack {
    PNODE pTop;
    PNODE pBottom;
} STACK,*PSTACK;

void init(PSTACK pS);
void push(PSTACK pS,int val);
void traverse(PSTACK pS);
bool emptyStack(PSTACK pS);
bool pop(PSTACK pS,int *val);
void clearStack(PSTACK pS);

int main(void) {

    int val;
    STACK S;
    init(&S);
    push(&S,1);
    push(&S,2);
    push(&S,3);
    push(&S,4);
    traverse(&S);
    if(pop(&S,&val)) {
        printf("出栈的数是%d
",val);
    }
    traverse(&S);
    clearStack(&S);
    traverse(&S);
    return 0;
}

void init(PSTACK pS) {
    pS->pTop = (PNODE)malloc(sizeof(NODE));
    if(NULL == pS->pTop) {
        printf("动态内存分配失败!
");
        exit(-1);
    } else {
        pS->pBottom = pS->pTop;
        pS->pTop->pNext = NULL;
    }
    return;
}
void traverse(PSTACK pS) {
    PNODE p = pS->pTop;
    while(p!=pS->pBottom) {
        printf("%d  ",p->data);
        p = p->pNext;
    }
    printf("
");
    return;

}

//压栈也就是使用头插法
void push(PSTACK pS,int val) {

    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    if(NULL == pNew->pNext) {
        printf("内存分配失败!
");
        exit(-1);
    }
    pNew->pNext = NULL;
    pNew->data = val;
    pNew->pNext = pS->pTop;
    pS->pTop = pNew;
    return;
}
//判断一个栈是不是空战主要就是使用bottom和Top是否相等
bool emptyStack(PSTACK pS) {
    if(pS->pTop == pS->pBottom) {
        printf("空栈
");
        return true;
    } else {
        return false;
    }
}
//出栈
bool pop(PSTACK pS,int *val) {
    if(emptyStack(pS)) {
        printf("栈为空
");
        return false;
    } else {
        PNODE p = pS->pTop;
        *val = p->data;
        pS->pTop = p->pNext;
        free(p);
        p = NULL;
        return true;
    }
}
// 清空里面的栈
void clearStack(PSTACK pS) {
    if(emptyStack(pS)) {
        return;
    } else {
        PNODE p;
        p = pS->pTop;
        PNODE q = NULL;
        while (p!=pS->pBottom) {
            q = p->pNext;
            free(p);
            p = q;
        }
        pS->pTop = pS->pBottom;
    }
}

4.队列

队列这里我们所指的就是循环数组队列。主要是基本操作的使用。

代码演示

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

typedef struct Queue {
    int *pBase;
    int front;
    int rear;
} QUEUE,*PQUEUE;

void init(PQUEUE pQ);
bool enQueue(PQUEUE pQ,int val);
bool fullQueue(PQUEUE pQ);
bool emptyQueue(PQUEUE pQ);
bool outQueue(PQUEUE pQ,int *val);
bool traverse_Queue(PQUEUE pQ);

int main(void) {
    int val;
    QUEUE pQ;
    init(&pQ);
    enQueue(&pQ,1);
    enQueue(&pQ,2);
    enQueue(&pQ,3);
    if(traverse_Queue(&pQ)) {
        printf("为空!
");
    }
    if(outQueue(&pQ,&val)) {
        printf("出队成功!出队的值为%d!
",val);
    } else {
        printf("为空!
");
    }
    if(traverse_Queue(&pQ)) {
        printf("为空!
");
    }
    return 0;

    return 0;
}

void init(PQUEUE pQ) {
    pQ->pBase = (int *)malloc(sizeof(int)*6);
    pQ->front = 0;
    pQ->rear = 0;
}

bool traverse_Queue(PQUEUE pQ) {
    if(emptyQueue(pQ)) {
        return true;
    } else {
        int i = pQ->front;
        while(i != pQ->rear) {
            printf("%d   ",pQ->pBase[i]);
            i = (i+1)%6;
        }
        printf("
");
        return false;
    }
}


//入队
bool enQueue(PQUEUE pQ,int val) {
    if(fullQueue(pQ)) {
        return false;
    } else {
        pQ->pBase[pQ->rear] = val;
        pQ->rear = (pQ->rear+1)%6;
        return true;
    }
}
//判断是不是已经满了
bool fullQueue(PQUEUE pQ) {
    if(((pQ->rear+1)%6 == pQ->front)) {
        return true;
    } else {
        return false;
    }
}
//判空
bool emptyQueue(PQUEUE pQ) {
    if(pQ->front == pQ->rear) {
        return true;
    } else {
        return false;
    }
}
//出栈
bool outQueue(PQUEUE pQ,int *val) {
    if(emptyQueue(pQ)) {
        printf("栈表为空!
");
        return false;
    } else {
        *val = pQ->pBase[pQ->front];
        pQ->front = (pQ->front+1)%6;
        return true;
    }
}

 PS：总结，对于线性结构，就是能使用一根线将之穿起来的结果，主要就是着一些基本的操作了。如果在上述代代码中发现了错误或者是问题，请@楼主。