数据结构笔记二

		
预习：
	结构和指针：
	
		计算机存储和处理数据基本上都放在内存中，如何管理呢？？ 
			用变量对应一块内存。
	
		变量-----代表  一块内存
		
		
		
		int i = 1;
		int j = 5;

		i,j分别对应一块内存
		
		变量类型----决定内存的大小。
		
		int i = 1;//4个字节
		char c = 'c'; //1个字节
		
		变量类型--简单类型和复合类型
		简单类型：int  char float double 
		复合类型：结构、联合和枚举
		
		
		布尔类型--C89没有布尔类型，但在c99加入了_Bool类型(强加的类型)
		
	结构是什么？
		
		多个数据放在一起，构成了结构。结构其实就是一片连续的内存，可以存放任意数量的任意类型的数据。
		
		一般来说，多个不同类型的相关数据放在一起的办法就是结构。
	
		struct Emp{//员工的数据封在结构中
			int num;//员工编号
			char  name[20];//员工的姓名
		};
		
		struct Emp 作为一个类型出现，这个类型包括所有的成员。在C语言中，此类型为struct Emp,sturct不能省。
		
		struct Emp emp 其实就是结构对应的一块内存，在这块内存中，成员从上到下依次排列。（有对齐和补齐的字节数：注意）
		
		
		结构的地址需要&取一下。	
		指针、数组、字符串不需要&。
		
		
		取结构的成员有两种常见的方式：
		
		(1)(结构的使用)
		struct Emp emp;
		emp.num = 1;
		
		(2)（结构指针的使用）
		struct Emp* pe = malloc(sizeof(struct Emp));
		pe->num = 1;
		
  1 #include <stdio.h>
  2 
  3 struct Emp{
  4     int id;//4
  5     char name[18];//18?20>
  6     int age;//4
  7 };
  8 
  9 int main()
 10 {
 11     struct Emp emp;
 12     printf("size=%d\n",sizeof(emp));//28,age有对齐
 13     printf("emp=%p\n",emp);//-1代表错误地址 warning.
 14     printf("emp=%p\n",&emp);//正确
 15     printf("emp.id=%p\n",&emp.id);//结构的地址与第一个元素的地址相同的
 16     printf("emp.name=%p\n",emp.name);//字符串不需要加&取地址
 17     printf("emp.age=%p\n",&emp.age);
 18     return 0;
 19 }
		
		
指针：
		int  fa(){
			int y = 200;
			return y;
		}
		int main()
		{
			int x = 100;//希望x能够把fa()结果返回
			x = fa();
		}
	

	一般来说，变量名 代表的是 一块内存，但在使用时，变量名 是无法直接获取的。
	
	变量等于内存中的数据。而想获取变量对应的内存地址需要用&，这种变量地址的类型就是指针。
	
	
	
	int x = 1;
	x就相当于1
	int * pi = &x;
	pi就是x的地址，而不是1.
	pi也是一个变量，也对应一块内存。
	
	
	pi 代表的是x的地址，如果想取x的数据，用*pi，就是1.
	pi和&x都是x的地址;  
	*pi和x都是x的数据;
	
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 void fa(int x,int *pi){
  4     printf("x=%d\n",x);//x = 100
  5     printf("pi=%p,*pi=%d\n",pi,*pi);//pi = 地址, *pi 100
  6     x = 200;
  7     *pi = 200;
  8 
  9 }
 10 int main()
 11 {
 12     int a = 100;
 13     int b = 100;
 14     int * pb = &b;
 15     printf("pb =%p\n",pb);
 16     fa(a,pb);
 17     printf("a=%d,b=%d\n",a,b);//a =100; b =200
 18     return 0;
 19 }


 
数据结构之队列Queue：----应用非常广泛（OS里面的消息队列；网络编程 ）

	队列的特点：
	
		先进（压入push）先出（弹出pop），后进后出。
		
	
	void fa(){
		int a;
		if (a>5){
			int b;
		}//b出栈
	}//a出栈
	----先进后出 
	
	int main(){
		int c;
		fa();
		fb();
	}
	变量定义的顺序：c,a,b   出栈顺序b,a,c 
	
	----每一个函数都有一个函数栈
	
	所有函数都是使用栈存储数据的（函数栈），只要数据需要排队的都是需要队列。

	
	队列包括一个队首和一个队尾，放入元素在队尾的后面并以新元素为新的队尾，
取出的元素就是队首并把下一个元素作为新的队首。


基于顺序表（数组）的队列 下标要循环利用，到最大值以后就要回到0，放入时找队尾下标，取出找队首下标


	（圆）数组有5个元素，下标为0-4;
	一开始没有数据时，队首和队尾下标都是0开始;
	没有人出队时，队首的下标就是0;
	放入第1个元素10时，队首下标不变0，队尾下标后移至1;
	放入第2个元素20时，队首元素10下标不变0,第2个元素为20下标为1，队尾下标后移至2;
	放入第3个元素30时，30下标为2队尾下标为3
	放入第4个元素40时，40下标为3队尾下标为4
	放入第5个元素50时，50下标为4队尾下标为0了----数组满了。队列满了。
	
	当队首和队尾重合在一起时，如果不是空的就是满的。
	
	
	移除元素第一个元素时，10出队，队首下标指向1了，队尾下标不变。
	进入一个元素60时，60进队，队首下标指向1了，队尾下标也指向1了。---数组和队列又满了
	
	数组实现队列的时候一定要考虑  下标回零 的问题。
	
	
	struct Queue{
		int * arr;//数组的首地址
		size_t cap;//数组的长度  容量
		size_t front;//队首前端、对手下标
		size_t rear;//队列后端、队尾下标
		size_t size;//队列中元素的个数，为了区分front和rear所处位置相同时
	};
	
	运算结构： 
		创建和销毁
		入队和出队
		判空和判满
		查看元素个数
		查看队首不能查看队尾
qa.h 		
  1 #ifndef _QA_H
  2 #define _QA_H
  3 #include <sys/types.h>
  4 typedef struct Queue{
  5     int * arr;//数组的首地址
  6     size_t cap;//数组的容量，数组的长度
  7     size_t front;//队首下标
  8     size_t rear;//队尾下标
  9     size_t size;//真实存在的元素的数量
 10 }QUEUE;
 11 //初始化队列函数
 12 void queue_init(QUEUE* queue,size_t cap);
 13 //回收队列函数
 14 void queue_deinit(QUEUE* queue);
 15 //判断队满
 16 int queue_full(QUEUE* queue);
 17 //判断队空
 18 int queue_empty(QUEUE* queue);
 19 //入队函数
 20 void queue_push(QUEUE* queue,int data);
 21 //出队函数
 22 int queue_pop(QUEUE* queue);
 23 //查看队首函数
 24 int queue_front(QUEUE* queue);
 25 //查看队列大小函数
 26 size_t queue_size(QUEUE* queue);
 27 #endif
		
qa.c
  1 #include <stdlib.h>
  2 #include "qa.h"
  3 //初始化队列函数
  4 void queue_init(QUEUE* queue,size_t cap){
  5     queue->arr = malloc(sizeof(int)*cap);
  6     queue->cap = cap;
  7     queue->front = 0;
  8     queue->rear = 0;
  9     queue->size = 0;
 10 }
 11 //回收队列函数
 12 void queue_deinit(QUEUE* queue){
 13     free(queue->arr);
 14     queue->arr = NULL;
 15     queue->cap = 0;
 16     queue->front = 0;
 17     queue->rear = 0;
 18     queue->size = 0;
 19 }
 20 //判断队满
 21 int queue_full(QUEUE* queue){
 22     return queue->size >= queue->cap;
 23 }
 24 //判断队空
 25 int queue_empty(QUEUE* queue){
 26     return !queue->size;
 27 }
 28 //入队函数
 29 void queue_push(QUEUE* queue,int data)
 30 {//判断队尾下标是否到达最大值，如果是最大值了就回0;还要判断是否满;---在这里没判断满，在应用时要判断满。
 31     if (queue->rear >= queue->cap) queue->rear = 0;//下标增加
 32     queue->arr[queue->rear] = data;//数据放队尾
 33     queue->rear++;//队尾后移
 34     queue->size++;//元素数量加
 35 }
 36 //出队函数
 37 int queue_pop(QUEUE* queue){
 38     if (queue->front >= queue->cap) queue->front = 0;
 39     queue->size--;//元素的数量减少
 40     //int temp = queue-> arr[queue->front];
 41     //queue->size--;//元素的数量减少
 42     //return temp;
 43     return queue->arr[queue->front++];
 44 }
 45 //查看队首函数
 46 int queue_front(QUEUE* queue){
 47     if (queue->front >= queue->cap) queue->front = 0;
 48     return queue->arr[queue->front];
 49 }
 50 //查看队列大小函数
 51 size_t queue_size(QUEUE* queue){
 52     return queue->size;
 53 }
 54 
   
-------------------------------------------------------------------------
测试用例1：
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include "qa.h"
  4 int main()
  5 {
  6         QUEUE  queue;
  7         queue_init(&queue,5);
  8         int i;
  9         if (!queue_full(&queue)){
 10                 for (i=0;i<5;i++)
 11                 {
 12                         queue_push(&queue,i);
 13                 }
 14         }
 15         printf("size=%d\n",queue_size(&queue));
 16         if (!queue_empty(&queue)){
 17                 for (i=0;i<5;i++)
 18                 {
 19                         printf("%d\n",queue_pop(&queue));
 20                 }
 21         }
 22         printf("size=%d\n",queue_size(&queue));
 23         queue_deinit(&queue);
 24 
 25         return 0;
 26 }
~                     

--------------------------------------------------------------------
测试用例2：
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include "qa.h"
  4 int main(){
  5         QUEUE  queue;
  6         queue_init(&queue,5);
  7         int i;
  8         for (i=0;i<20;i++){
  9                 if (queue_full(&queue))
 10                 {
 11                         printf("size=%d\n",queue_size(&queue));
 12                         printf("pop %d\n",queue_pop(&queue));
 13                         printf("size=%d\n",queue_size(&queue));
 14                 }
 15                 else
 16                 {
 17                         printf("size=%d\n",queue_size(&queue));
 18                         queue_push(&queue,i);
 19                         printf("insert %d\n",i);
 20                         printf("size=%d\n",queue_size(&queue));
 21                 }
 22         }
 23         printf("size=%d\n",queue_size(&queue));
 24         if (!queue_empty(&queue)){
 25                 for (i=0;i<5;i++){
 26                         printf("%d\n",queue_pop(&queue));
 27                 }
 28         }
 29         printf("size=%d\n",queue_size(&queue));
 30         queue_deinit(&queue);
 31         return 0;
 32 }

 ----------------------------------------------------------------------
 测试用例3：
  1 #include <stdlib.h>
  2 #include <stdio.h>
  3 #include "qa.h"
  4 
  5 int main()
  6 {
  7 
  8     QUEUE queue;//创建队列
  9 
 10     queue_init(&queue,5);
 11 
 12     int i;
 13     for(i=0;i<5;i++){
 14         if (!queue_full(&queue))//如果队列不满就加
 15         {
 16             queue_push(&queue,i);
 17         }   
 18     }
 19 
 20     printf("size = %d\n",queue_size(&queue));
 21     //queue.front = 0;
 22     while(!queue_empty(&queue)){
 23 
 24         printf("%d\n",queue_pop(&queue));
 25     
 26     }
 27     queue_deinit(&queue);
 28 }
 

-------------------------------------------------------------------------   

	
基于链表式的队列  没有满，只有判断空。

	动态分配、前后指针、注意判空
	
	链表式的队列 需要两个结构：节点 和 队列
	
		struct QueueNode{
			int data; //数据
			struct QueueNode * next;//下一个节点的地址
		};
		
		struct Queue{
			struct QueueNode* front;//队首节点
			struct QueueNode* rear;//队尾节点
		};
	
		放入队列 找 队尾节点，弹出队列找队首节点。

		
空队列没有节点： 队首指针和队尾指针都是空的，节点是空的;
		
一开始队列front和rear都是NULL。
放入第一个元素时，front和rear都指向第一个元素，再放入时，front不变，改变的是rear的指向和原来的rear的next。
（放入第二个元素时，front的指针不变，队尾的指针要变;）（队尾的next总是为null。）

出队时，改变front，指向next并释放节点内存，但删除最后一个时，rear也要改成NULL。

----------------------------------------------------------------------------
ql.h

  1 #ifndef _QL_H
  2 #define _QL_H
  3 #include <sys/types.h>
  4 typedef struct QueueNode{//链式表的节点
  5     int data;//数据
  6     struct QueueNode * next;//下一个元素的地址
  7 }QUEUE_NODE;
  8 typedef struct Queue{//队列
  9     QUEUE_NODE *front;//队首节点地址 负责出队
 10     QUEUE_NODE *rear;//队尾节点地址 负责入队
 11 }QUEUE;
 12 void queue_init(QUEUE* queue);//初始化为空
 13 void queue_deinit(QUEUE* queue);//释放节点后删除
 14 int queue_empty(QUEUE* queue);//判断是否为空
 15 void queue_push(QUEUE* queue,int data);//入队
 16 int queue_pop(QUEUE* queue);//出队
 17 int queue_front(QUEUE* queue);//队首查看
 18 size_t queue_size(QUEUE* queue);//取元素数量
 19 #endif

 --------------------------------------------------------------------------
 ql.c 
 
  1 #include <stdlib.h>
  2 #include "ql.h"
  3 static QUEUE_NODE* create_node(int data){
  4     QUEUE_NODE* node = malloc(sizeof(QUEUE_NODE));
  5     node->data = data;
  6     node->next = NULL;//队列的新节点next必须为NULL,都是加在队尾的
  7     return node;
  8 }
  9 static QUEUE_NODE* destroy_node(QUEUE_NODE * node){
 10     QUEUE_NODE * next = node->next;//node->next当前队首节点指向的下一个节点，将会变成新的队首。
 11     free(node);//释放当前节点
 12     return next; //返回新的队首的地址
 13 }
 14 void queue_init(QUEUE * queue){//初始化为空
 15     queue->front = NULL;
 16     queue->rear = NULL;
 17 }
 18 void queue_deinit(QUEUE * queue){//释放节点后删除
 19     while(queue->front)
 20         queue->front = destroy_node(queue->front);
 21     queue->rear = NULL;
 22 
 23 }
 24 int queue_empty(QUEUE* queue){//判断是否为空
 25     return (!queue->front) && (!queue->rear);
 26 
 27 }
 28 void queue_push(QUEUE* queue,int data){//入队（需要深刻理解）
 29     QUEUE_NODE* node = create_node(data)
 30     if (queue->rear)//不是第一个
 31         queue->rear->next = node;//改的是原先的队尾的next
 32     else//是第一个
 33         queue->front = node;
 34     queue->rear = node;
 35 }
 36 int queue_pop(QUEUE* queue){//出队
 37     int data = queue->front->data;
 38     queue->front = destroy_node(queue->front);
 39     if (!queue->front) queue->rear = NULL;
 40     return data;
 41 }
 42 int queue_front(QUEUE* queue){//队首查看
 43     return queue->front->data;
 44 
 45 }
 46 size_t queue_size(QUEUE* queue){//取元素数量
 47     size_t size = 0;
 48     QUEUE_NODE* node;
 49     for (node = queue->front;node;node=node->next)
 50     {
 51         size++;
 52     }
 53     return size;
 54 }

 
 --------------------------------------------------------------
  1 #include <stdlib.h>
  2 #include <stdio.h>
  3 #include "ql.h"
  4 
  5 int main()
  6 {
  7 
  8     QUEUE queue;//创建队列
  9 
 10     queue_init(&queue);
 11 
 12     int i;
 13 
 14     for(i=0;i<5;i++){
 15 
 16             queue_push(&queue,i);
 17     }
 18 
 19     printf("size = %d\n",queue_size(&queue));
 20 
 21     //queue.front = 0;
 22     while(!queue_empty(&queue)){
 23 
 24         printf("%d\n",queue_pop(&queue));
 25 
 26     }
 27 
 28     queue_deinit(&queue);
 29 }

 --------------------------------------------------------------