Mu_Muxi_的博客

顺序表的特点优点：1.实现简单2.支持随机（下标）访问缺点：1.插入数据时间复杂度O（n）,但是尾插O（1）2.删除数据O（n），但是尾删O（1）该顺序表由dsqlist.h + dsqlist.cpp + main.cpp 组成dsqlist.h文件//头文件,存放数据结构和函数的声明#pragma once//预防头文件被重复引用,每个头文件必须在最上面写这一句//书上使用 typedef int ElemType;typedef struct DsqList{

带头结点单链表最后一个节点的next值为NULL(结尾标识)头结点:一个标识,不存放数据,不参与具体运算数据节点:存放数据,第一个数据节点的下标为0优点:在已知位置插入数据时间复杂度O(1) 在已知位置删除数据时间复杂度O(1)缺点:查找数据O(n),不支持随机访问该顺序表由list.h + list.cpp + main.cpp 组成list.h文件#pragma oncetypedef int ElemType;typedef struct Node{ .

链表中最常用的两种循环需要前驱信息,例如插入,删除等 for(p=plist;p->next!=NULL;p=p->next);遍历数据节点,例如,长度,Show,查找等for(p=plist->next;p!=NULL;p=p->next);具体应用可看其他文章（例如：单链表文章中，实现不同操作时的for语句选择）...

后续的链表都是基于单链表的基础上修改的，所以必须要掌握单链表该双向链表由list.h + list.cpp + main.cpp 组成重点：头插 尾插 按值删除（多级指针，要判断）dlist.h文件#pragma once //预防头文件重定义//.h放定义和声明//带头结点的双向链表:不循环，尾节点的后继为空，头结点的前驱为空typedef struct DNode{ int data;//数据域 struct DNode* next;//后继指针 struct DNod

该循环链表由clist.h +clist.cpp + main.cpp 组成clist.h文件 #pragma once//循环链表:尾部节点的next指向头节点,形成一个环;//带头节点typedef struct CNode{ int data; struct CNode* next;}CNode,*CList;//初始化void InitList(CList plist);//头插bool Insert_head(CList plist, int val);/.

静态链表（用顺序表模拟链表）包含两条链,一条为有效数据链表,一条为空闲节点链表有效数据链表为带头结点的循环链表，且头结点在0号下标空闲数据链表为带头结点的循环链表，且头结点在1号下标注意：添加一条空闲节点链表的目的是让插入数据时找空闲节点的时间复杂度为O(1)该静态链表由slist.h和slist.cpp和main.cpp组成slist.h文件#pragma once#define MAXSIZE 10typedef struct SNode{ int data;//

只实现了初始化、头插、尾插、按值删、判空、输出的功能nolist.h文件#pragma oncetypedef struct NNode{ int data; struct NNode* next;}NNode,*NList;void InitList(NList* pplist);//和之前不一样，pplist是二级指针static NNode* BuyNode(int val);bool Insert_Head(NList* pplist, int val);bool

#include<stdio.h>#define NONE -1#define m 16#define p 13//除留余数法的除数，一般是比m小的最大素数H(key)=key mod ptypedef struct Hash{ int key;//关键字 //InfoType otherinfo;//其他数据项}Hash, HashTable[m];void InitHashTable(HashTable ht){ for (int i = 0; i < m;

构造哈希函数的方法选择：除留余数法由经验得知∶一般情况下，可以选p为质数或不包含小于20的质因数的合数处理哈希冲突的方法：链地址法哈希表（除留余数+链地址法）代码#include<stdio.h>#include<assert.h>#include<malloc.h>#define m 13typedef struct DataType{ int key; //InfoType otherinfo;}DataType;typed

本文件为不定长顺序栈，能自动扩容栈：后进先出，后来的反而需要先服务（访问受限的线性表）栈分为顺序栈和链式栈栈只能在一端进行插入和删除，插入删除的这一端称为栈顶（表尾），另一端称为栈底（表头）顺序栈的栈顶在尾部，因为顺序表在尾部操作的时间复杂度为O(1)本文件由三个文件构成: lstack.h 、 lstack.cpp 、 main.cpp顺序栈和顺序表十分相似，是访问受限的顺序表lstack.h 头文件//顺序栈#pragma once#incl.

本文件为链式栈，利用带头结点的单链表实现栈顶：入栈和出栈，栈顶在表头（入栈和出栈的时间复杂度为O(1)）本链式栈由三个文件构成 lstack.h 、 lstack.cpp 、 main.cpp需要注意的是，因为单链表头插和头删时间复杂度为O(1) , 顺序栈在表尾进行插入删除的时间复杂度为O(1)所以链式栈与顺序栈不同的是：链式栈的栈顶在 表头 ，栈底在 表尾lstack.h 头文件#pragma oncetypedef struct LSNode{ i.

队列：队头删除，队尾插入顺序队列顺序队列的结构设计成环形的原因：为了使出队时间复杂度为O(1) ,为了解决队列“假溢出”问题这样环形结构的好处就是：只要队列没有真正的满，永远不会溢出注意：为什么要浪费一个空间？ 是 为了区分空和满队头==队尾为空 、 队尾往后一步是队头为满环形结构front和rear不能直接++本文件依旧由三个部分组成 queue.h、queue.cpp、main.cppqueue.h头文件#pragma once#include

链式队列链式队列，带头节点，队头为第一个数据节点，队尾在最后一个数据节点头节点为一个队头指针、一个队尾指针，增加队尾指针可让入队时间复杂度为O(1)由三个文件 lqueue.h、lqueue.cpp、main.cpp组成lqueue.h头文件#pragma oncetypedef struct LPNode//数据节点{ int data;//数据域 struct LPNode* next;//后继指针}LPNode;typedef struct HNode//链式队列

//从当前位置开始，从后往前找比当前数字小的，插入到这个小的数字的后面//在找的过程中，如果发现一个比当前数字大的，同时将这个数字往后移动//////基本有序：选直接插入#include<stdlib.h>#include<stdio.h>void InsertSort(int* arr, int len){ /*if (len <= 1) return;*/ int i, j; for (i = 1; i < len; i++) { in

//希尔排序：直接插入排序越有序越快是希尔排序的一个理论基础//算法描述：间隔式分组，利用直接插入排序，缩小分组再排序，直到缩为一组//不稳定：因为有跳跃式的交换数据//时间复杂度O（n^1.3~n^1.5）#include<stdio.h>//一趟希尔排序void Shell(int *arr,int len,int gap){ int i, j; for (i = gap; i < len; i++)//是i++ { int a = arr[i]; fo

#include<stdio.h>void BubbleSort(int* arr, int len){ int tmp; for (int i = 0; i < len-1; i++)//排序len-1次 { for (int j = 0; j < len - i - 1; j++)//小心j+1越界 { if (arr[j] > arr[j + 1]) { tmp = arr[j + 1]; arr[j + 1] = arr[

/*快速排序（考试重点）一次划分（考试重点）*/#include<stdio.h>#include<stdlib.h>#include<assert.h>int Partition(int* arr, int low, int high)//一次划分：时间复杂度O(n)，空间复杂度O(1){ int tmp = arr[low]; while (low < high) { while (low < high && ar

#include<stdio.h>/*选择排序：每次都从待排序中找到最小值和待排序的第一个交换*/void SelectSort(int* arr, int len)//时间O（n^2）空间O（1）,不稳定{ int tmp; int minIndex;//最小值下标 for (int i = 0; i < len - 1; i++) { minIndex = i; for (int j = i + 1; j < len; j++) { if(

#include<stdio.h>//堆调整 O（log n）void HeapAdjust(int* arr, int start, int end){ int tmp=arr[start]; for (int i = 2*start+1; i <= end; i=2*i+1) { if (i < end && arr[i] < arr[i + 1])//有右孩子，并且左孩子的值小于右孩子 { i ++ ; }//i一定是左右孩子

#include<stdio.h>#include<stdlib.h>#include<assert.h>/*归并排序：将两段有序的数据合并成一段有序的数据，直到所有的数据有序（二路归并）*///一次归并，gap为归并段的长度static void Merge(int* arr, int len, int gap)//一次归并时间复杂度O（n）{ int low1 = 0; int high1 = low1 + gap - 1; int low2

基数排序（桶排序） 低位优先#include<stdio.h>#include"lqueue.h"//获取最大值得位数int GetFigur(int* arr, int len){ if (len < 1) return -1; int max = arr[0]; for (int i = 1; i < len; i++) { max = max > arr[i] ? max : arr[i]; } int count = 0; whi

//a b c a b c d a b c d a b c d e a b c//-1 0 0 0 1 2 3 0 1 2 3 0 1 2 3 0 0 1 2 //a b a c d a b c a b c d e//-1 0 0 1 0 0 1 2 0 1 2 0 0 //a

本文采用循环单链表写约瑟夫环，点击可直接链接到之前发的"clist.h"头文件#include<stdio.h>#include<assert.h>#include<stdlib.h>#include"clist.h"约瑟夫环函数int JosephRing(CList plist){ assert(plist != NULL); if (plist == NULL || plist->next == plist) { retur

排序1.算法描述2.代码实现3.效率分析(时间复杂度,空间复杂度,稳定性)稳定性:针对关键字相同的数据(相同的数字),排序前如果A在A’的前面,排完序后还能保证A在A’的前面,则算法稳定,否则不稳定通俗的来讲就是不跳跃的交换数据就是稳定的目录1.插入排序2.希尔排序3.冒泡排序4.快速排序递归写法非递归写法5.选择排序6.堆排序7.归并排序8.基数排序/桶排序第"9"个排序:链表排序测试1.插入排序也叫简单插入排序或者直接插入排序算法描述:从当前位置开始,从后往前找比当前数字小的,插入到这