数据结构线性表(一)

数据结构之线性表(一)

线性表

• 是数据结构中最简单且常用的一种结构

• 它由相同的数据类型的n个元素组成的有限序列

• 按照存储结构,可以分为 顺序表和链表两种

  顺序表

  主要特点是可以进行随机访问,可以通过表头元素的地址和元素的下标在O(1)的时间复杂度找到指定元素,主要介绍***构造,插入,扩容,查找,删除,遍历***这些操作

  • 特点 顺序表是用一组地址连续的储存单元依次存储数据元素,元素在逻辑和物理位置上是相邻的
  • 缺点: 插入和删除要移动大量的元素从而保持逻辑和物理上的连续性.

  • 构造顺序表

    1. 定义顺序链表的构造体类型

       typedef struct Vector {
                  
       	int size,length; //size用来存链表的大小,length存元素的长度
       	int *data;//data指针用来指向内存上开辟的空间.
       }Vector
       

       2. 初始化顺序链表被在堆上为其分配空间

          void init(Vector *vector,int size) {
                       
              vector->size = size;
              vector->length = 0;
              vector->data = (int *)malloc(sizeof(int)*size);//data指针指向malloc开辟的size个int类型的内存空间
          }
          
          int main() {
                       
              Vector *a = (Vector *)malloc(sizeof(Vector));//定义一个Vector类型的a指针,并为他指向一个Vector类型的内存空间.
              init(a, 100);//初始化a让其data数据域有100个int的大小.
              
              return 0;
          }
          

          3.当用完顺序链表别忘了清除,小心内存泄漏

          void clear(Vector *vector) {
                       
              free(vector->data);//释放data数据域
              free(vector);//别忘记释放vector指针
          }
          
          int main() {
                       
              Vector *a = (Vector *)malloc(sizeof(Vector));//定义一个Vector类型的a指针,并为他指向一个Vector类型的内存空间.
              init(a, 100);//初始化a让其data数据域有100个int的大小.
              clear(a);//释放a及他的数据域;
              return 0;
          }
          
          

          4. 插入操作咳咳

             话不多说直接上代码

             int insert(Vector *vector, int loc, int value) {
                              
             if (loc < 0|| loc > vector->length) {
                              
               return -1;//如果插入太短小,或者超过了元素总长,错误
             }
             if (vector->length >= vector->size) {
                              
               return -1;//如果元素已满,无法插入
             }
             for (int i = vector->length; i > loc; --i){
                              
               vector->data[i] = vector->data[i-1];
               //插入的时候要从后往前移动元素;
             }
             vector->data[loc] = value;//移到插入点loc,更新data[loc]
             vector->length++;
             return 0;
             }
             
             

          5. 顺序链表的扩容(当当前元素满了==size的时候,扩容)

             • 思路:我们要定义一个指针存存放(指向)旧的数据域,然后再利用malloc函数开阔一个更大的数据域,最后将就数据域上的数据存到新开辟的数据域上

               void expend(Vector *vector) {
                                 
                   int *old_data = vector->data;//赶紧存旧的地址,里面有我们是数据;
                   vector->size = vector->size*2;
                   vector->data = (int *)malloc(sizeof(int)*vector->size);
                   //这时候数据域指针更新了,我们有了一个更大的空间
                   for(int i = 0; i < vector->length; i++) {
                                 
                       vector->data[i] = old_data[i];
                       //把我们原来的数据放到新的内存空间里;
                   }
                   free(old_data);
                   //清理原来的数据域,避免内存泄漏了;   
               }
               

          6. 顺序链表的查找,删除和遍历的算法流程

             • 1. 查找

                  代码实现 (暴力找盆友,一个一个往后找就VANS了)

                  int search(Vector *vector, int value) {
                                       
                  for(int i = 0; i < vector->length; ++i) {
                                       
                    if(vector->data[i] == value)
                        return i;
                  }
                  	return -1;//找了一圈没找到直接爆炸;
                  }
                  

             • 2. 删除

                  代码实现 (先判断合法否,然后直接让删除下标后面的元素往前挪)

                  int delete_node(Vector *vector, int index) {
                                       
                  if (index < 0 || index >= vector->length){
                                       
                    return -1;//不合法直接-1;
                  }
                  for (int i = index+1; i < vector->length; ++i) {
                                       
                    vector->data[i-1] = vector->data[i];//index位置后的元素前移一格.
                  }
                  vector->length--;
                  return 1;  
                  }
                  

             • 3. 遍历

                  遍历不用爷多说了吧,按顺序表的存储顺序依次输出元素

                  void print(Vector *vector) {
                                       
                  for (int i = 0; i < vector->length; ++i) {
                                       
                    i!=0 && printf(" ");
                  	printf("%d", vector->data[i]);//输出元素data[i];
                  }
                  }
                  

总结 : 以上是线性表中顺序链表的基本操作,顾名思义啊,顺序表就是数据的存储单元是连续的,按顺序来的,下一节我们学习链表的基本操作.