c.链表学习笔记

单链表

单链表文章
（1）malloc函数主要作用是分配一块长度为size的内存空间。void *malloc(unsigned int size);其中，size就是要分配的内存空间大小字节。使用时最好先检查一下是否分配成功，否则返回null，可以保证程序的正确运行。使用完分配后的空间要利用free函数及时释放。
（2）free函数主要作用是将内存空间释放。void free (void *p); 其中，参数p指向要释放的内存空间。不能使用已经被free函数释放的内存空间

关于malloc：

malloc分配的内存大小至少为size参数所指定的字节数

malloc的返回值是一个指针，指向一段可用内存的起始地址

多次调用malloc所分配的地址不能有重叠部分，除非某次malloc所分配的地址被释放掉

malloc应该尽快完成内存分配并返回（不能使用NP-hard的内存分配算法）

实现malloc时应同时实现内存大小调整和内存释放函数（realloc和free）

创建链表

typedef struct student{
	int score;
	struct student *next;
} LinkList;

初始化一个链表，n为链表节点个数。

LinkList *creat(int n){
	LinkList *head, *node, *end;//定义头节点，普通节点，尾部节点；
	head = (LinkList*)malloc(sizeof(LinkList));//分配地址
	end = head;         //若是空链表则头尾节点一样
	for (int i = 0; i < n; i++) {
		node = (LinkList*)malloc(sizeof(LinkList));
		scanf("%d", &node->score);
		end->next = node;
		end = node;
	}
	end->next = NULL;//结束创建
	return head;
}

头插法

 char ch='y';
      people   *e,*p;
		static  int  j;//在链表结尾加一个NULL

      while(ch=='y'||ch=='Y')//头插法

      {
               p=(people* )malloc(sizeof(people));//新节点

      printf("输入姓名：\n");
      scanf("%s",p->name);
      printf("输入QQ\n");
      scanf("%s",p->QQ);
      printf("输入phone\n");
      scanf("%s",p->phone);//对新节点p进行输入数据

 		e=head;//存放头地址
		head=p;//将新结点插入队头
		p->next=e;//将头地址放在新节点之后
	//getchar（）；//吃掉缓冲区留下的回车键
     fflush(stdin);//吃掉缓冲区留下的回车键
      printf("\n请问是否继续注册?(Y/N)");
      scanf("%c",&ch);
          
          if(j==1)//在链表尾部加一个NULL的办法
        {
            head->next=NULL;
            j++;
        }
      }

fflush(stdin);
尾插法

void TailCraeteList(LinkList head,int n)
{
	LinkList *p,*r;
    int i;
    srand(time(0));    //初始化随机数种子
	head = (LinkList  *)malloc(sizeof(LNode));
	r = head;
	for(i = 0;i < n;i++)
	{
		p = (LinkList*)malloc(sizeof(LNode));    //生产新结点 
		p ->data = rand()%100 + 1;              //生产两位随机数100,三位就是1000 
		r ->next = p;        //将表尾终端结点的指针指向新结点 
		r = p;      //将当前的新结点定义为表尾的尾结点 
	}
	r->next = NULL;		 //当前链表结束 
} 

修改链表节点值

void change(LinkList *list,int n) {//n为第n个节点
	LinkList *t = list;
	int i = 0;
	while (i < n && t != NULL) {
		t = t->next;
		i++;
	}
	if (t != NULL) {
		puts("输入要修改的值");
		scanf("%d", &t->score);
	}
	else {
		puts("节点不存在");
	}
}

删除链表节点
删除链表的元素也就是把前节点的指针域越过要删除的节点指向下下个节点。即：p->next = q->next;然后放出q节点的空间，即free(q);

if（！a）//当a为NULL时if条件成立进入if语句，当a为除0外的任意值时，if条件不成立
{printf（“abd”）；
}

void delectpeople()
{
    people *p=head,*temp=head;//p为要删除的节点，temp为p的上一个节点
    int n,z,i=1;
    printf("请输入想要删除的序号\n");
    putout();
    scanf("%d",&n);
    if(n==1)
    {
        head=head->next;//如果要删除第一个则进入这个if
    }
   
    else
    {

           while(i<n)
       {
        temp=p;
        p=p->next;
        i++;
            if(!p)
            {
            printf("没有这个序号");
            break;
            }

        }
    }
   
    if(p)
    {
        temp->next=p->next;
        free(p);
        printf("删除成功！");
    }

}

插入链表节点
插入节点就是用插入前节点的指针域链接上插入节点的数据域，再把插入节点的指针域链接上插入后节点的数据域。根据图，插入节点也就是：e->next = head->next; head->next = e;
增加链表节点用到了两个结构体指针和一个int数据。

void insert(LinkList *list, int n) {
	LinkList *t = list, *in;
	int i = 0;
	while (i < n && t != NULL) {
		t = t->next;
		i++;
	}
	if (t != NULL) {
		in = (LinkList*)malloc(sizeof(LinkList));
		puts("输入要插入的值");
		scanf("%d", &in->score);
		in->next = t->next;//填充in节点的指针域，也就是说把in的指针域指向t的下一个节点
		t->next = in;//填充t节点的指针域，把t的指针域重新指向in
	}
	else {
		puts("节点不存在");
	}
}

输出链表

        while (h->next != NULL) {
		h = h->next;
		printf("%d  ", h->score);
	}

顺序表

顺序表逻辑上相邻的元素在物理上也是相邻的。每一个数据元素的存储位置都和线性表的起始位置相差一个和数据元素在线性表中的位序成正比的常数。只要确定了第一个元素的起始位置，线性表中的任一个元素都可以随机存取，因此，线性表的顺序存储结构是一种随机存取的存储结构。由于C语言的数组具有随机存储特别，因此采用数组来描述顺序表。如下所示：

typedef struct{
    DataType list[ListSize];
    int length;
}SeqList;

其中，DateType表示数据元素类型（int），list用于存储线性表中的数据元素，length用来表示线性表中数据元素的个数，SeqList是结构体类型名。定义一个顺序表代码：SeqList L; 指向顺序表的指针：SeqList *L;

顺序表的基本运算如下：

（1）初始化线性表：

void InitList（SeqList *L）{
    L ->length =0; // 把线性表的长度设为0
}

(2）线性表非空判断:

int ListEmpty(SeqList L){
    if(L.length ==0)
        return 1;
    else
        return 0;
}

（3）按序号查找：

int GetElem(SeqList L,int i,DataType *e){
//查找线性表中第i个元素，查找成功将该值返回给e，并返回1表示成功，反正返回-1表失败。
    if(i<1||i>L.length)
        return -1;
 
    *e = L.list[i-1];
 
    return 1;
}

(4)按内容查找：

int LocateElem(SeqList L,DataType e){
//查找线性表中元素值为e的元素
    int i;
    for (i = 0 ; L.length ;i++)
        if(L.list[i] == e)
        return i+1;
 
    return 0;//找不到返回0
}

（5）插入操作：

//在顺序表的第i个位置插入元素e，成功返回1，失败返回-1，顺序表满了返回0
int InsertList(SeqList *L,int i ,DataType e){
 
    int j;
    if(i<1|| i> L->length+1）{
        return -1;
    }
    else if(L->length >= ListSize){
        return 0;
    }else{
        for(j=L->length ; j >=i ;j--){
            L->list[j] = L ->list[j-1];
        }
        L->list[i-1] =e ;//插入元素到i个位置
        L->length =L->length+1;
        return 1;
    }
}

(6）删除操作：

int DeleteList(SeqList *L,int i ,DataType *e){
 
    int j;
    if(L->length<=0){
        return 0;
    }
    else if(i<1||i>L-length){
        return -1;
    }else{
        *e = L ->list[i-1];
        for(j=i;j<=L->length-1;j++){
            L->list[j-1] =L->length[j];
        }
        L->length = L->length-1;
        return 1;
     }
}

链表顺序表详解