01.第二章，程序笔记

基本操作

 

 

 

初始化一个顺序表

#include <iostream>
using namespace std;
#include <stdio.h>
#define Maxsize 10     //定义一个最大长度

typedef struct{

    int data[Maxsize];  //静态数组存放数据
    int length;         //顺序表的当前长度
    
}SL;   //顺序表的类型定义


//基本操作 -- 初始化一个顺序表
void InitList(SL &L){  //参数是SL型 面向对象的语言格式

    for (int i = 0; i < 10; i++)
    L.data[i] = 0;
    
    L.length = 0;   //顺序表初始化当前长度为零
}

int main()
{
    SL L;         //声明一个顺序表
    InitList(L);  //初始化顺序表

    //现在可以操作顺序表了


    return 0;
}

 

初始化操作细节问题（vc可以运行）

/*
注意相比上一个程序，这个程序中初始化一个顺序表那个函数，没有初始化数据，
因为我以后使用存数据的时候就将数据盖住了原来的数据，
这样前面的数据就不用初始化就被更改成我想要的了，那么后面那些脏数据怎么办
好办！！
我通过读取数据的时候将i循环设计成读到L.length，这样将不会再去读取没有使用的数据地址上的值，*/

#include <stdio.h>
#define Maxsize 10        //定义最大长度

typedef struct{
    int data[Maxsize];    //定义一个静态数组存放元素
    int length;           //顺序表当前长度
}SL;                      //顺序表的类型定义

//初始化一个顺序表，
void InitList(SL &L)
{
    L.length = 0;  //只是初始化开始长度，但是没有初始化数据，
                    //这样如果打印的话就会发现一个系统以前用这个地址存放的数据
                    //但是对我们来说是没有用的，
    //但是这个初始化长度不能省略，这个是我们读多少个数据的关键，
}

int main (){
    SL L;
    InitList(L);

    for (int i = 0; i <Maxsize ; i++)  //这里是对data数组的访问数据，但是访问的是整个数组的所有地址的，
                                        //有时候只是使用了前5个地址，存了五个数据，后面的不用访问，
                                        //所以应该让 i的判断条件是i <L.length 
                                        //即我当前实际使用了多少数据，访问这些地址就够了，别超过了去读那些零或者是系统脏数据
        printf("data[%d]=%d\n",i,L.data[i]);
    
    return 0;
}

 

 

ok，以上是静态分配，即开始锁定了大小，之后将不能改变，

若想改变则使用动态分配，动态分配不像静态分配，现在需要我们自己开辟空间，malloc

顺序表通过 动态分配（vc可以运行）

//顺序表动态分配

//malloc 和free 的函数头文件
#include<stdlib.h>
#include <stdio.h>

#define Initsize 10     //默认的最大长度

typedef struct {
    int *data;    //指示动态分配数组的指针
    int Maxsize;  //顺序表最大长度
    int length;   //顺序表当前长度
}SL;

void InitList(SL &L){
//使用malloc函数申请一片连续的储存空间，大小是，初始大小乘以4b。
    L.data = (int *)malloc(Initsize*sizeof(int));
    L.length = 0;
    L.Maxsize = Initsize;
}


//增加动态数组的长度,增加类型是SL的数组L的长度，多加上len
void InceraseSize(SL &L,int len){

//定义一个指针变量指向第一个值的指针，防止下一步把L.data指针重新分配后找不到数据
    int *p = L.data;
    
    //现在要一片重新分配的（最大长度加上想要增加的长度）*4b的大小空间
    L.data = (int *)malloc((L.Maxsize+len)*sizeof(int));

    //把数据赋值到新的数据地址里面
    for(int i = 0; i <L.length ; i++){
        L.data[i] = p[i];         //指针p起到了作用
    }
    
    L.Maxsize = L.Maxsize + len;   //最大长度增加len

    //将p中的数据释放
    free(p);
    

}

int main(){

    SL L;  //声明一个顺序表

    InitList(L);//初始化顺序表
    
    
//可以随便插入几个元素了
    L.length = 3;
    L.data[0] = 111;
    L.data[1] = 222;
    L.data[2] = 333;
    
    printf("我变长以前\n");
for (int i = 0; i<L.Maxsize; i++)    
    printf("the  %d value:  %d\n",i+1,L.data[i]);
    printf("\n");

    InceraseSize(L,5);
    printf("我变长以后\n");
for (i = 0; i<L.Maxsize; i++)    
    printf("the  %d value:  %d\n",i+1,L.data[i]);
    

    return 0 ;
}

 

 

顺序表的基本操作，插入（静态数组）（C++在线编译器可运行）

//顺序表基本操作--插入

#include <stdio.h>

#define Maxsize 10     //默认的最大长度

typedef struct{
    int data[Maxsize];//静态数组存放数据
    int length=0;       //顺序表当前长度
    
}SL;

//插入操作，给L这个列表第i个元素的位置插入e这个数据
//即需要将第i以及之后的元素后移一个
bool ListInsert(SL &L, int i,int e){

    //判断i是否有效，
    if(i<1||i>L.length+1){
        return false;
    }
    if(L.length>=Maxsize)
        return false;
    
    //将第i个元素往后移动一位
    for(int j = L.length; j>=i ; j--)
        L.data[j]=L.data[j-1];
    
    L.data[i-1] = e;
    
    L.length++;
    
    return true;
}


int main(){

    SL L;
    
    ListInsert(L,1,11111);
    ListInsert(L,2,22222);
    ListInsert(L,3,33333);
    ListInsert(L,4,44444);
    ListInsert(L,5,55555);
    ListInsert(L,6,66666);
        ListInsert(L,7,77777);
    ListInsert(L,8,88888);
    ListInsert(L,9,99999);

    //细节读取列表时，使用的是当前列表长度
    for(int i=0;i<L.length;i++)
    {
        printf("%d\n",L.data[i]);
    }
    
    printf("在L的第一个位置插入5555\n");
    if(ListInsert(L,1,5555))
        printf("成功插入！\n");
    for(int i=0;i<L.length;i++)
        printf("%d\n",L.data[i]);
    
    
return 0;
}

 

按位置查找

 按数值查找（c++在线编译器可运行）

//顺序表基本操作--插入

#include <stdio.h>

#define Maxsize 10     //默认的最大长度

typedef struct{
    int data[Maxsize];//静态数组存放数据
    int length=0;       //顺序表当前长度
    
}SL;

//插入操作，给L这个列表第i个元素的位置插入e这个数据
//即需要将第i以及之后的元素后移一个
bool ListInsert(SL &L, int i,int e){

    //判断i是否有效，
    if(i<1||i>L.length+1){
        return false;
    }
    if(L.length>=Maxsize)
        return false;
    
    //将第i个元素往后移动一位
    for(int j = L.length; j>=i ; j--)
        L.data[j]=L.data[j-1];
    
    L.data[i-1] = e;
    
    L.length++;
    
    return true;
}


//删除操作 
bool ListDelete(SL &L, int i, int &e){
    //检验是否能够达到删除的条件
    if(i<1||i>L.length)
        return false;
    e = L.data[i-1];
    
    //将第i位置之后的数据往前移动一位
    for (int j=i;j<L.length;j++)
        L.data[j-1]=L.data[j];
    L.length--;
    return true;
    
}


//查找操作
//按位置查找 GetElem(L,i)
int GetElem(SL L,int i){
    return(L.data[i-1]);
}
//按值查找
int LocateElem(SL L,int e)
{
    for (int i = 0;i<L.length;i++)
    {
        if(e == L.data[i])
            return i+1;    
    }
    return 0;
}

int main(){

    SL L;
    
    //用于存放删除的数据
    int e=-1;
    
    ListInsert(L,1,11111);
    ListInsert(L,2,22222);
    ListInsert(L,3,33333);
    ListInsert(L,4,44444);
    ListInsert(L,5,55555);
    ListInsert(L,6,66666);
    ListInsert(L,7,77777);
    ListInsert(L,8,88888);
    ListInsert(L,9,99999);

    //ListDelete(L,9,e);
    //删除第九位上的元素，并把删除的元素赋给变量e
    if(ListDelete(L,11,e))
        printf("我删了个元素，他是第“%d”位的“%d”",9,e);
    else
        printf("你必然是非法的删除操作\n");
    
    
    //细节读取列表时，使用的是当前列表长度
    for(int i=0;i<L.length;i++)
    {
        printf("【%d】--%d\n",i+1,L.data[i]);
    }
    
    printf("在L的第一个位置插入5555\n");
    if(ListInsert(L,1,5555))
        printf("成功插入！\n");
    for(int i=0;i<L.length;i++)
         printf("【%d】--%d\n",i+1,L.data[i]);
    
    //查找第一位的数据打印出来
    printf("我查找的第1位数据是%d\n",GetElem(L,2));
    
    //查找 L 里面有没有55555，如果有在第几位
    if(LocateElem(L,55555)){
        printf("找到了我要查找的值 在第%d\n位",LocateElem(L,55555))    ;
    }else{
        printf("没有找到你要查找的值哦！");
        
    }
    
return 0;
}