结构体与共用体，链表的学习

结构体

定义

        C语言允许用户自己定义一种数据结构，称为结构体。

        声明一个结构体类型一般形式为：

                strcut  结构体名

                {

                        成员列表

                }；

struct Student
{
    int id;
    float score;
    char name[10];
}; //";"不能丢失

int main(void)
{
    int i;
    struct Student s;
    
    s.id = 1;
    s.score = 95.5;
    strcpy(s.name, "zhangsan");

    printf("%d, %f, %s\n", s.id, s.score, s.name);

    return 0;
}

也可以直接初始化为：

struct Student s = {1, 95.5, "zhangsan"};

struct Student s = {.score = 95.5, .name = "zhangsan"}; //部分初始化

结构体对齐原则

1. 结构体按照其最长成员大小对齐，意味着最终的大小必须是最长成员大小的整数倍；
2. 结构体成员按照结构体成员声明先后次序依次存放，并且每个成员的首字节放置的位置必须能够整除成员的字节数；
3. 如果结构体某个成员的字节数大于CPU的字节数，则最长按照CPU的字节数对齐；
4. 用预处理命令#pragma pack(n) 可以强制编译器按照指定的n来对齐，合法的n的数值分别是1、2、4、8、16。

结构体传参

struct Student
{
    int id;
    float score;
    char name[10];
};

void printStudent(struct Student *s) //打印
{
    printf("%d, %f, %s\n", s->id, s->score, s->name);
}

void printStudents(struct Student *s,int len) //遍历
{
    int i;
    for(i = 0;i < len;++i)
    {
      
        printStudent(s + i);
    }
}

void swap(struct Student *p1,struct Student *p2) //交换
{
    
    struct Student t;
    t = *p1;
    *p1 = *p2;
    *p2 = t;
}

void fn(struct Student *s) //用指针指向id对结构体中id的数值进行
{
    s->id += 10;
}

void revsers(struct Student *a, int len) //逆序
{
    int i;
    for(i = 0;i < len / 2;++i)
    {
        swap(a + i, a + len - i - 1);
    }
}

void sortByScore(struct Student *a, int len) //用结构体中的“score”排序
{
    int i, j;
    for(i = 0;i < len - 1;++i)
    {
        for(j = i + 1;j < len;++j)
        {
            if(a[i].score > a[j].score)
            {
                swap(a + i, a + j);
            }
        }
    }
}
void sortMoScore(struct Student *a, int len) //用结构体中的“name”排序
{
    int i, j;
    for(j = len -1;j > 0;--j)
    {
        for(i = 0;i < j;++i)
        {
            if(strcmp((a + i)->name, (a +i+1)->name) > 0)
            {
                swap(a+i, a+i+1);
            }
        }
    }
}

int namecmp(const void *p1, const void *p2) //调用qsort函数排序 
{
    struct Student *q1 = (struct Student *)p1;
    struct Student *q2 = (struct Student *)p2;
    return strcmp(q1->name, q2->name);

   // qsort(a, len, sizeof(a[0]), namecmp);

用指针处理链表

链表由若干节点组成，节点分为值域和指针域。

首节点来自栈区，其他的都来自堆，且每一个都不连续，无法通过＋1来访问下一个节点。

struct Node
{
	int data;
	struct Node *next;
};

void push_front(struct Node *pHead, int n) //头插
{
	struct Node *pNew = malloc(sizeof(struct Node));
	pNew->next = pHead->next;
	pHead->next = pNew;
	pNew->data = n;
}

void printList(struct Node *pHead) //遍历
{
	struct Node *p = pHead->next;
	while(p != NULL)
	{
		printf("%d\n", p->data);
		p = p->next;
	}
}

int size(struct Node *pHead) //计算有效节点
{
	struct Node *p = pHead->next;
	int counter = 0;
	while(p != NULL)
	{
		++counter;
		p = p->next;
	}
	return counter;
}

int isEmpty(struct Node *pHead) //判空
{
	//return size(pHead) == 0;
    return pHead->next == NULL;
}

int main(void)
{
	struct Node head = {0, NULL};
	printf("size = %d\n", size(&head));
	printf("isEmpty = %d\n", isEmpty(&head));
	push_front(&head, 1);
	push_front(&head, 2);
	push_front(&head, 3);
	push_front(&head, 4);
	printList(&head);

	printf("isEmpty = %d\n", isEmpty(&head));
	printf("size = %d\n", size(&head));
	return 0;
}