数据结构学习（一）

1.数据结构：计算机存储、组织数据的方式，指相互之间存在一种或者多种特定关系的数据元素的集合。算法：解决一个问题的步骤过程，将输入数据转化为输出结果。

2.算法时间复杂度和空间复杂度。时间一去不复返，空间可重复利用。以空间换取时间。

3.表

3.1顺序表

#include <string.h>
#include <stdio.h>
#include<stdlib.h>
//顺序表练习
typedef int SLDataType;
//静态顺序表 静态特点：满了不让插入   缺点：给多少合适呢  小了不够用   大了浪费
typedef struct SeqList{ 
  SLDataType *a;//动态开辟的数组
  int size;//表示数组存储了多少个数据
  int capacity;//数组实际能存储的空间容量的大小
}SL;
//顺序表插入数据->头插、头删、尾插、尾删、中间插、中间删
//接口函数-->命名风格跟着STL走
void SeqListInit(SL* ps){
    ps->a=NULL;
    ps->size=0;
    ps->capacity=0;
};
void SeqListCheckCapacity(SL* ps){//如果没有空间或者不足 ，则进行扩容
  if(ps->size==ps->capacity){
    SLDataType NewCapacity=(ps->capacity>=0)? ps->capacity+1:1;
    SLDataType* temp=(SLDataType*)realloc(ps->a,NewCapacity*sizeof(SLDataType));//使用完后记得释放空间 free
    if(temp==NULL){
        printf("realloc fail\n");
        exit(-1);
    }
    ps->a=temp;
    ps->capacity=NewCapacity;
  }
};
void SeqListPushBack(SL* ps,SLDataType x){//末尾添加元素
  SeqListCheckCapacity(ps);
  //最简单的 可以直接填写到里面
  ps->a[ps->size]=x; 
  ps->size++;
};
void SeqListPopBack(SL* ps,int x){
    if(ps->size-x<=0)
      x=ps->size;
    for (int i=1;i<=x;i++)
      ps->a[ps->size-i]=0;
    ps->size-=x;
    ps->capacity-=x;
};
void SeqListPushFront(SL* ps,SLDataType x){
  SeqListCheckCapacity(ps);
  int end=ps->size-1;
  while(end>=0){
    ps->a[end+1]=ps->a[end];
    end--;
  }
  ps->a[0]=x; 
};
void SeqListPopFront(SL* ps,SLDataType x);

void SeqListDestory(SL* ps){
    free(ps->a);
    ps->a=NULL;
    ps->size=ps->capacity=0;
};
//...
int SeqListFind(SL* ps,SLDataType x){
  int i=0;
  int j=0;
  for(;i<ps->size;i++){
      if(x==ps->a[i])
      return i+1;
      j++;
  }
  if(j==ps->size)
    return -1;
}
void TestSL(SL* ps,SLDataType x){
    SeqListPushBack(ps,x);
};
int main()
 {
    SL b,*p;
    p=&b;
    SLDataType x=10;
    SeqListInit(p);
    for (int i=0;i<10;i++)
      TestSL(p,i);
    for (int i=0;i<p->capacity;i++)
      printf("%d\n",p->a[i]);
    SeqListPopBack(p,3);
    SeqListPushFront(p,-100);
    for (int i=0;i<p->capacity;i++)
      printf("%d\n",p->a[i]);
    printf("p的位置在%d",SeqListFind(p,5));
    SeqListDestory(p);
    system("pause");
 };  

顺序表缺陷：（1）空间不够了要扩容，增容是要付出代价的（本地扩还好，异地扩代价大）（2）避免频繁扩容，满了基本都是扩2倍，可能会导致一定的空间浪费（3）顺序表要求数据从开始位置连续存储，那么我们在头部或者中间位置插入删除数据，我们就需要挪动数据，效率不高。

针对顺序表的缺陷，就设计出的链表

#include <string.h>
#include <stdio.h>
#include<stdlib.h>
typedef int SlistNodeData;
typedef struct SListNode{
  SlistNodeData data;
  struct SListNode* next;
} SLN;
void SListprint(SLN* Phead){
    SLN* cur=Phead;
    while(cur!=NULL){
      printf("%d\n",cur->data);
      cur=cur->next; 
    };
};
SLN* FindBack(SLN* Phead){
    SLN* tail=Phead;
    while(tail->next!=NULL)
      tail=tail->next; 
    return tail;
};

void SLNPushBack(SLN* Phead,SlistNodeData x){
    SLN* tail=FindBack(Phead);
    SLN* back=(SLN*)realloc(tail->next,sizeof(SLN));
    if(back==NULL){
      exit(-1);
    }
    back->data=x;
    back->next=NULL;
    tail->next=back;
};

int main()
 {
    SLN one,two,three;
    one.data=1;
    two.data=2;
    one.next=&two; 
    two.next=&three;
    three.data=3;
    three.next=NULL;
    SListprint(&one);
    SLNPushBack(&one,4000);
    SListprint(&one);
    system("pause"); 
 };