排序算法简介

/*学习内容：冒泡排序（最基本的排序方法）选择排序（冒泡的优化）插入排序（在合适的位置插入合适的数据）
*//*排序分类：1.内部排序待需要进行排序的数据全部存放到内存中，再进行排序 2.外部排序在排序过程中，需要对外存进行访问待排序的数据数量很大，内存无法全部容纳所有的数据 
*/

冒泡排序

/*冒泡排序：---思路分析（以升序为例）在一排数据中，将第一个与第二个比较大小如果后面的数据比前面的小，就交换它们的位置（冒泡一次）然后比较第二个和第三个...直到比较第 n-1 个数据和第 n 个每一次比较都将较大的一个数据向后移动所以第 n 个是最大的所以就排好了一个数据（冒泡一趟）
*/# include <stdio.h>int main()
{// 定义一个无序一维数组int arr[] = { 5, 7, 9, 1, 6, 2, 4, 3, 0, 8 };// 遍历，打印数组printf("数组，排序前：\n");for (int i = 0; i < 10; i++){printf("%-3d", arr[i]);}// 冒泡排序（升序：由小到大）int temp;for (int i = 0; i < 9; i++){for (int j = 0; j < 9 - i; j++){if (arr[j] > arr[j + 1]){temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}// 展示排序后，数组当前的结果printf("数组，排序后：\n");for (int i = 0; i < 10; i++){printf("%-3d", arr[i]);}}

选择排序

/*选择排序：---思路分析（以升序为例）选择排序可以看作是冒泡排序的优化不再多次交换值，而是选择当前趟数的最大(或最小值)，最后再交换在 n 个数里，先找到最大的数，并且记录下标，然后将这个数与第 n 个数交换如果第 n 个数是最大的，那就不需要交换，重复比较，直到所有的数据排好序
*/# include <stdio.h>int main()
{// 定义一个无序一维数组int arr[] = { 5, 7, 9, 1, 6, 2, 4, 3, 0, 8 };// 遍历，打印数组printf("\n 数组，排序前：\n");for (int i = 0; i < 10; i++){printf("%-3d", arr[i]);}// 选择排序（升序：由小到大）---> 选择排序：选择一个你认为最大的数int temp;int maxIndex;for (int i = 9; i > 0; i--){maxIndex = 0;    // 每次我都认为第一个最大，选择第一个，并记录下第一个的序号for (int j = 0; j <= i; j++){if (arr[maxIndex] < arr[j]){maxIndex = j;}}if (maxIndex != i){temp = arr[i];arr[i] = arr[maxIndex];arr[maxIndex] = temp;}}// 展示排序后，数组当前的结果printf("\n 数组，排序后：\n");for (int i = 0; i < 10; i++){printf("%-3d", arr[i]);}}

插入排序

/*插入排序：---思路分析（以升序为例）以第一个数为基准，后面的所有数都向着第一个数的方向，插队前进（这种插队不能跳着插队，只能插完一个继续接着插，前提是满足条件才能插队）其本质原理：依靠数与数之间的“相对关系”，从而将其整体排好序！1.轮到第一个数发挥            第一个数无法插队，它只能站着不动，停止插队2.轮到第二个数发挥            它和前面的数比较大小，若满足条件，则插一个队，然后停止插队（即：最多能够插队1次）3.轮到第三个数发挥            和前面的数比较大小，若满足条件，则插一个队，再继续和前面的数比较大小，若满足条件，则再插一个队，然后停止插队（即：最多能够插队2次）4.轮到第四个数发挥            比较大小，若可以，插一个队，再继续比较大小，若可以，再插一个队......（即：最多能够插队3次）5.轮到第五个数发挥            ......（即：最多能够插队4次）6.轮到第六个数发挥            ......（即：最多能够插队5次）*/# include <stdio.h>int main()
{// 定义一个无序一维数组int arr[] = { 7, 5, 9, 1, 6, 2, 4, 3, 0, 8 };// 遍历，打印数组printf("\n 数组，排序前：\n");for (int i = 0; i < 10; i++){printf("%-3d", arr[i]);}// 插入排序（升序：由小到大） int temp = 0;for (int i = 1; i < 10; i++)    // 轮到第 ？个数发挥{for (int j = i - 1; j >= 0; j--)    // 【比较、插队】，再【比较、插队】，再再【比较、插队】......{if (arr[j + 1] < arr[j])    // 满足插队条件{temp = arr[j + 1];arr[j + 1] = arr[j];arr[j] = temp;}else   // 不满足插队条件{break;        // 没有达到"最多能插队的次数"，就停止插队了，请马上自我了断，不要再进行无意义的比较，从而提高效率}}}// 展示排序后，数组当前的结果printf("\n 数组，排序后：\n");for (int i = 0; i < 10; i++){printf("%-3d", arr[i]);}return 0;
}

线性表

/*1.线性表：---数据结构中最简单的一种存储结构，专门用于存储逻辑关系为"一对一"的数据 2.线性表存储结构，可细分为"顺序存储结构"和"链式存储结构"，即如下所示线性表：1.顺序表（顺序存储结构）2.链表（链式存储结构）3.存储的类型要求使用线性表存储的数据，如同向数组中存储数据那样要求数据类型必须一致线性表存储的数据，要么全部都是整型，要么全部都是字符串一半整型，另一半是字符串的一组数据无法使用线性表存储4.前驱与后继：一组数据中的每个个体被称为“数据元素”（简称为“元素”）1.前驱某一元素的左侧相邻元素称为“直接前驱”，位于此元素左侧的所有元素都统称为“前驱元素”2.后继某一元素的后侧相邻元素称为“直接后继”，位于此元素右侧的所有元素都统称为“后继元素”
*/

顺序表

/*顺序表:---它对数据的物理存储结构有要求顺序表存储数据时,会提前申请一块足够大小的内存然后将数据依次存储起来存储时做到数据元素之间不留一丝缝隙（即：连续）*/

初始化顺序表

# include <stdio.h>
# include <malloc.h>// 定义表格类型
typedef struct
{int* head;        // 指针，存储申请的内存首地址int length;        // 当前数据个数int size;        // 元素个数（最大容量）}Table;// 生成表格的函数
Table tableFunc()
{Table t;        // 定义一个变量 t ，其类型为“表格类型”// t 表格的初始化t.size = 5;                                // 表格最大容量（元素个数） = 5t.length = 0;                            // 表格当前数据个数（元素个数）= 0t.head = (int*)calloc(t.size,sizeof(int));    // 为表格开辟内存，并把内存首地址赋值给 t.head// 注意！上面的申请内存操作可能会出现申请失败的情况，返回值为 NULLif (!NULL){printf("申请内存失败，程序终止！\n");exit(0);}return t;    // 返回 t 表格
}int main()
{Table myTab = tableFunc();printf("%d \n", myTab.size);printf("%d \n", myTab.length);printf("%X \n", myTab.head);    // 内存地址一般用 %X 十六进制展示return 0;
}

顺序表的增删查改

/*顺序表元素：1.查（可以使用查找算法：  1.顺序查找    2.二分法查找）2.改3.增(增加到前面、中间、后面)------知识点补充：扩容函数：realloc(需要扩容的指针"*p",扩容后总的大小)4.删
*/

链表

/*1.链表：1.链表是通过指针，将不连续的内存连接起来，实现链式存储的2.内存实际上是不同时机申请的，地址不一定连续，但是可以通过指针联系起来3.链表是数据结构中线性表的一种，其中的每个元素实际上是一个“单独的结构体变量”，所有变量都“通过”每个元素中的“指针”连接在一起。4.以结构体为节点，将一个结构体看成“数据域”和“指针域”两个部分，“数据域”用于“存储数据”，“指针域”用于“连接下一个节点”，链表中每个结构体对象叫做节点，其中，第一个数据节点，叫做链表的“首元结点”。5.如果第一个节点不用于存储数据，只用于代表链表的起始点，则这个结点称为链表的“头结点”。2.链表特点：1.没有固定长度2.可以快速的插入和删除链表中的节点3.链表分很多种，单链表是其中最简单的一种（如下图）*/

单链表

/*<单链表>1.链表节点一般是自定义的结构体类型2.结构体一般包含两部分：数据、指针数据：当前节点里面需要的数据指针：指向下一个节点（最后一个节点置空 为“尾节点”） */

创建单链表

• 项目结构
  

• 源代码

// main.c# include <stdio.h>
# include "myList.h"int main()
{Node* pList=CreateList(5);    // 创建一个可以存储5个东西的链表，并将返回值“地址”赋值给变量 pListshowList(pList);    // 展示链表return 0;
}

// myList.c# include <stdio.h>
# include "myList.h"
# include <stdlib.h>    // 申请内存时候要用/*
创建链表
参    数：长度
返回值：头指针
*/
Node* CreateList(int length)
{// 判断长度if (length <= 0){printf("Length Error!\n");return NULL;}// 开始创建链表// 1.创建头指针和尾指针Node *phead, *ptail;phead = ptail = NULL;// 2.申请内存：头结点phead = (Node*)malloc(sizeof(Node));// 3.处理异常情况if (NULL == phead){perror("malloc failed!");exit(EXIT_FAILURE);}// 4.给头结点初值phead->pnext = NULL;    // 等价于 (*phead).pnext = NULL;phead->num = 0;// 5.尾指针ptail = phead;// 6.向头结点后面添加结点Node* p;DataType n;for (int i = 0; i < length; i++){// 6.1 申请一个结点，检测，给值p= (Node*)malloc(sizeof(Node));if (NULL == p){perror("malloc failed!");exit(EXIT_FAILURE);}p->pnext = NULL;printf("请输入数值>>>");scanf("%d", &n);p->num = n;// 6.2 将新申请的结点添加到链表中ptail->pnext = p;ptail = p;        // 更新尾结点}return phead;    // 9.返回头指针
}/*
遍历链表
参    数：头指针
返回值：空
*/
void showList(const Node* const p)
{// 从首元结点开始遍历，而不是头结点（因为我们不使用头结点去存储值）Node* temp = p->pnext;if (NULL == temp){printf("List is NULL!\n");return ;}printf("\n*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n");printf("当前链表数据：\n");while (temp){printf("%-5d", temp->num);temp = temp->pnext;}printf("\n*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n");
}

// myList.h#ifndef _MYLIST_    // 防止重复定义
#define    _MYLIST_typedef int DataType;    // 可以灵活改变数据类型struct node
{struct node* pnext;        // 指针域DataType num;            // 数据域
};typedef struct node Node;    // 给结构体类型取别名/*创建链表参    数：长度返回值：头指针
*/
Node* CreateList(int length);/*遍历链表参    数：头指针返回值：空
*/
void showList(const Node* const p);#endif    // _MYLIST_ 定义结束

单链表的查改增删

/*单链表的查、改、增、删1.查：确定查找方式，查找之后一般会返回“结点首地址”或者返回 NULL2.改：找到目标元素，直接修改该元素的值3.增：一定注意不能丢失指针指向4.删：记得释放内存*/

栈

/*栈的定义：---栈是一种只能从表的一端存储数据，且遵循“先进后出”原则的"线性存储结构"1.栈只能从一端(栈顶)取出，另一端(栈底)是封闭的2.在栈中，都必须从“栈顶”存储数据，且遵循“先进后出”原则入栈和出栈：1.入栈：将数据存到栈里面去 2.出栈：将数据从站里面取出来栈的实现方法：---栈：“特殊”的线性存储结构1.顺序表：顺序栈（顺序存储结构）2.链  表：链  栈（链式存储结构）*/

实现顺序栈

# include <stdio.h>/* 1.元素入栈 */
// 参  数：存储结构，栈顶 top，数据 value
// 返回值： top
int putEle(int* arr, int top, int value)
{arr[++top] = value;return top;
}/* 2.元素入栈 */
// 参  数：存储结构，栈顶 top
// 返回值： top
int takeEle(int* arr, int top)
{// 先判断if (top <= -1){printf("操作失败！空栈！\n");return -1;}printf("当前出栈元素的值：%d\n", arr[top]);top--;return top;
}int main()
{// 顺序表：为了理解简单化，我们使用列表int a[100];// top (记录栈顶)int top = -1;// 入栈(入5个)top = putEle(a, top, 1);top = putEle(a, top, 2);top = putEle(a, top, 3);top = putEle(a, top, 4);top = putEle(a, top, 5);// 出栈（出6个）top = takeEle(a, top);top = takeEle(a, top);top = takeEle(a, top);top = takeEle(a, top);top = takeEle(a, top);top = takeEle(a, top);return 0;
}

实现链栈

/*链栈：一般来说，我们将链表的“头结点”作为栈顶，“尾结点”作为栈底，这样的效率高一些（如图所示）注意事项：“头结点”是不断更新的，即“头结点”永远是“刚进来”的那个“尾结点”是不会更新的，即“尾结点”永远是“第一个进来”的那个---如果用另外一种方式：头结点”作为栈底，“尾结点”作为栈顶，这种方式，每次新的元素入栈，都要从栈底遍历一遍到栈顶，才能入栈成功将会遍历很多次，效率非常低下
*/

#include <stdio.h>
#include <stdlib.h>typedef struct Node
{int data;struct Node* pnext;}Node;// 入栈函数
Node* eleIn(Node* p, int num)
{Node* temp = (Node*)malloc(sizeof(Node));temp->data = num;temp->pnext = p;p=temp;printf("当前进栈元素的值：%d\n", num);return p;
}// 出栈函数
Node* eleOut(Node* p)
{if (p){Node* temp = p;printf("当前出栈元素的值：%d\n", temp->data);p = temp->pnext;free(temp);temp = NULL;}else{printf("栈是空的！\n");}return p;
}int main()
{Node* p = NULL;// 进栈(5次)p = eleIn(p, 1);p = eleIn(p, 2);p = eleIn(p, 3);p = eleIn(p, 4);p = eleIn(p, 5);printf("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n");// 出栈（6次）p = eleOut(p);p = eleOut(p);p = eleOut(p);p = eleOut(p);p = eleOut(p);p = eleOut(p);return 0;
}

队列

/*<队列>1. 什么是队列队列：两端“开口”要求：只能从一端进入队列，另一端出队列2.队头和队尾队头：数据出队列的一端队尾：数据进队列的一端 3.实现队列1.顺序表：顺序队列2.链表：链式队列*/

顺序队列

#include <stdio.h>// 进队函数
int eleIn(int* arr,int tail,int num)
{arr[++tail] = num;printf("当前进入队列元素的值：%d\n", num);return tail;
}// 出队（全部出队）
void allOut(int* arr, int head, int tail)
{while (head != tail){printf("当前离开队列元素的值：%d\n", arr[head++]);}printf("当前离开队列元素的值：%d\n", arr[head++]);
}int main()
{int a[10];    // 定义数组，用于存储数据int head = 0;int tail = -1;// 入队（进入5）tail = eleIn(a, tail, 1);tail = eleIn(a, tail, 2);tail = eleIn(a, tail, 3);tail = eleIn(a, tail, 4);tail = eleIn(a, tail, 5);printf("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n");// 出队（全出去）allOut(a, head, tail);return 0;
}

链式队列

#include <stdio.h>
#include <stdlib.h>// 创建结点类型
typedef struct QNode
{int data;struct QNode* pnext;
}QNode;// 生成“头结点”的函数
createQueue()
{QNode* temp = (QNode*)malloc(sizeof(QNode));temp->data = 0;temp->pnext = NULL;return temp;
}// 入队
eleIn(QNode* p, int num)    // 参数：（尾指针，要存储的数据）
{QNode* temp = (QNode*)malloc(sizeof(QNode));temp->data = num;printf("当前进入队列元素的值：%d\n", num);temp->pnext = NULL;p->pnext = temp;p = temp;return p ;
}// 出队
void eleOut(QNode* phead)
{if (phead->pnext)    // “头结点”存储的地址不为空{QNode* temp = phead->pnext;    // “头结点”后面的首元结点printf("当前离开队列元素的值：%d\n", temp->data);phead->pnext = temp->pnext;free(temp);temp = NULL;}else{printf("队列为空！\n");}// return ;
}int main()
{// 头指针和尾指针QNode* phead = NULL;QNode* ptail = NULL;// “上面的两针”都指向生成的“头结点”phead = ptail = createQueue();// 入队（进入5）ptail = eleIn(ptail, 1);ptail = eleIn(ptail, 2);ptail = eleIn(ptail, 3);ptail = eleIn(ptail, 4);ptail = eleIn(ptail, 5);printf("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n");// 出队（出去6）eleOut(phead);eleOut(phead);eleOut(phead);eleOut(phead);eleOut(phead);eleOut(phead);return 0;
}