目录
 
函数分析
 
代码
 
全部代码
 
截图
 
算法可视化
 

函数分析
 
QuickSort(SqList &L,int low,high) 参数：顺序表L，待排最小下标，待排最大下标 功能：排序（默认升序）空间复杂度：O(1) 时间复杂度：O(nlog2n)-O(n) 稳定性：不稳定
 
代码
 
//快速排序分割函数
int Partition(SqList &L,int low,int high)
{	
	int pivotekey = L.data[low]; //保存枢轴
	while (low<high)
	{
		while (low < high&&L.data[high] >= pivotekey) --high;
		L.data[low] = L.data[high];
		while (low < high&&L.data[low] <= pivotekey) ++low;
		L.data[high] = L.data[low];
	}
	L.data[low] = pivotekey;
	PrintList(L);
	return low;
}
// 快速排序 升序
void QuickSort(SqList &L, int low, int high)
{
	if (low < high)
	{
		int pivotloc = Partition(L,low,high);
		QuickSort(L,low,pivotloc-1);
		QuickSort(L, pivotloc + 1, high);
	}
}
 
全部代码
 
/*
Project: quick_sort(冒泡排序)
Date:    2021/03/15
Author:  Frank Yu
QuickSort(SqList &L,int low,high) 参数：顺序表L，待排最小下标，待排最大下标 功能：排序（默认升序）空间复杂度：O(1) 时间复杂度：O(nlog2n)-O(n)
稳定性：不稳定
思想:取第一个作为枢轴，从右侧找到小于枢轴的放到左边，左侧找到大于枢轴的放到右边，一趟后左侧均小于枢轴，右侧均大于枢轴，递归排序子表。
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>
#define MaxSize 100
#define ElemType int
#define Status int
using namespace std;
//顺序表数据结构
typedef struct
{
	ElemType data[MaxSize];//顺序表元素
	int length;            //顺序表当前长度
}SqList;
//***************************基本操作函数*******************************//
//初始化顺序表函数，构造一个空的顺序表 
Status InitList(SqList &L)
{
	memset(L.data, 0, sizeof(L));//初始化数据为0
	L.length = 0;                //初始化长度为0
	return 0;
}
//创建顺序表函数 初始化前n个数据
bool CreatList(SqList &L, int n)
{
	if (n<0 || n>MaxSize)false;//n非法
	for (int i = 1; i<n + 1; i++)//L[0]作为哨兵
	{
		scanf("%d", &L.data[i]);
		L.length++;
	}
	return true;
}
//插入函数 位置i插入数据 i及之后元素后移  1=<i<=length+1 
bool InsertList(SqList &L, int i, ElemType e)
{
	if (i<1 || i>L.length + 1) //判断位置是否有效
	{
		printf("位置无效！！！\n");
		return false;
	}
	if (L.length + 1 >= MaxSize)//判断存储空间是否已满
	{
		printf("当前存储空间已满！！！\n");
		return false;
	}
	for (int j = L.length + 1; j >= i; j--)//位置i及之后元素后移
	{
		L.data[j] = L.data[j - 1];
	}
	L.data[i] = e;
	L.length++;
	return true;
}
//删除函数 删除位置i的元素 i之后的元素依次前移
bool ListDelete(SqList &L, int i)
{
	if (i<1 || i>L.length)//判断位置是否有效
	{
		printf("位置无效！！！\n");
		return false;
	}
	for (int j = i + 1; j <= L.length; j++)//位置i之后元素依次前移覆盖
	{
		L.data[j - 1] = L.data[j];
	}
	L.length--;
	return true;
}
//查找函数 按位置从小到大查找第一个值等于e的元素 并返回位置
int LocateElem(SqList L, ElemType e)
{
	for (int i = 1; i<L.length + 1; i++)//从低位置查找
	{
		if (L.data[i] == e)
			return i;
	}
	return 0;
}
//********************************功能函数*****************************************//
//输出功能函数 按位置从小到大输出顺序表所有元素
void PrintList(SqList L)
{
	printf("当前顺序表所有元素:");
	for (int i = 1; i<L.length + 1; i++)
	{
		printf("%d ", L.data[i]);
	}
	printf("\n");
}
//创建顺序表函数
void Create(SqList &L)
{
	int n; bool flag;
	printf("请输入要创建的顺序表长度(>1):");
	scanf("%d", &n);
	printf("请输入%d个数（空格隔开）:", n);
	flag = CreatList(L, n);
	if (flag) {
		printf("创建成功！\n");
		PrintList(L);
	}
	else printf("输入长度非法！\n");
}
//插入功能函数 调用InsertList完成顺序表元素插入 调用PrintList函数显示插入成功后的结果
void Insert(SqList &L)
{
	int place; ElemType e; bool flag;
	printf("请输入要插入的位置(从1开始)及元素:\n");
	scanf("%d%d", &place, &e);
	flag = InsertList(L, place, e);
	if (flag)
	{
		printf("插入成功！！！\n");
		PrintList(L);
	}
}
//删除功能函数 调用ListDelete函数完成顺序表的删除 调用PrintList函数显示插入成功后的结果
void Delete(SqList &L)
{
	int place; bool flag;
	printf("请输入要删除的位置(从1开始):\n");
	scanf("%d", &place);
	flag = ListDelete(L, place);
	if (flag)
	{
		printf("删除成功！！！\n");
		PrintList(L);
	}
}
//查找功能函数 调用LocateElem查找元素
void Search(SqList L)
{
	ElemType e; int flag;
	printf("请输入要查找的值:\n");
	scanf("%d", &e);
	flag = LocateElem(L, e);
	if (flag)
	{
		printf("该元素位置为:%d\n", flag);
	}
	else
		printf("未找到该元素！\n");
}
//快速排序分割函数
int Partition(SqList &L,int low,int high)
{	
	int pivotekey = L.data[low]; //保存枢轴
	while (low<high)
	{
		while (low < high&&L.data[high] >= pivotekey) --high;
		L.data[low] = L.data[high];
		while (low < high&&L.data[low] <= pivotekey) ++low;
		L.data[high] = L.data[low];
	}
	L.data[low] = pivotekey;
	PrintList(L);
	return low;
}
// 快速排序 升序
void QuickSort(SqList &L, int low, int high)
{
	if (low < high)
	{
		int pivotloc = Partition(L,low,high);
		QuickSort(L,low,pivotloc-1);
		QuickSort(L, pivotloc + 1, high);
	}
}

//菜单
void menu()
{
	printf("********1.创建            2.插入*********\n");
	printf("********3.删除            4.查找*********\n");
	printf("********5.快速排序        6.输出*********\n");
	printf("********7.退出\n");
}
int main()
{
	SqList L; int choice;
	InitList(L);
	while (1)
	{
		menu();
		printf("请输入菜单序号：\n");
		scanf("%d", &choice);
		if (7 == choice) break;
		switch (choice)
		{
		case 1:Create(L); break;
		case 2:Insert(L); break;
		case 3:Delete(L); break;
		case 4:Search(L); break;
		case 5:QuickSort(L,1,L.length); break;
		case 6:PrintList(L); break;
		default:printf("输入错误！！！\n");
		}
	}
	return 0;
}
 
截图
 
 
算法可视化
 
https://algorithm-visualizer.org/divide-and-conquer/quicksort
 
 更多数据结构实现：数据结构严蔚敏版的实现（含全部代码）
 
有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。

代码比较简单，没有完全按照严蔚敏版《数据结构（C语言版）》上39页到43页上的要求，只是实现了简单功能，且此代码输入多项式时只能按升幂的顺序输入（因为没有写多项式排序的函数）
 个人感觉此代码短小精悍，且易理解，看懂了的话可以尝试完全按照书上的要求自己写代码。
 
直接上代码：
 
#include<stdio.h>
#include<stdlib.h>

#define LEN sizeof(Poly)

typedef struct term{
	float coef;  //系数 
	int expn;	 //指数 
	struct term *next;
}Poly,*Link;

void CreatePolyn(Link *p,int m);
void PrintPolyn(Link p);
int cmp(Link p1, Link p2);
Link AddPolyn(Link pa, Link pb); 

int main()
{
	Link P1,P2;
	int L1,L2;
	printf("请输入第一个多项式的项数：");
	scanf("%d",&L1);
	CreatePolyn(&P1,L1);
	printf("第一个多项式为：");
	PrintPolyn(P1);
	printf("请输入第二个多项式的项数：");
	scanf("%d",&L2);
	CreatePolyn(&P2,L2);
	printf("第二个多项式为：");
	PrintPolyn(P2); 
	printf("\n");
	printf("两个一元多项式相加的结果为：");
	PrintPolyn(AddPolyn(P1, P2));
}

void CreatePolyn(Link *p,int m)//*p是双重指针，用此意在改变指针 
//创建多项式（带头结点），基础：动态链表的创建 
{
	Link r,s;
	int i;
	*p=(Link)malloc(LEN);
	r=*p;
	for(i=0;i<m;i++)
	{
		s=(Link)malloc(LEN);
		printf("输入系数和指数（以空格隔开）:");
		scanf("%f %d", &s->coef, &s->expn);
		r->next=s;
		r=s;
	}
	r->next=NULL; 
}

void PrintPolyn(Link p)
//打印显示多项式，基础：遍历链表 
{
	Link s;
	s = p->next;
	while(s)
	{
	        printf("%.2f X^%d", s->coef, s->expn);
            s = s->next;
            if(s!=NULL)  //是正数则用'+'连接两项，是负数则直接用负数的负号'-'连接两项 
                if(s->coef>=0) printf("+");
	}
	printf("\n");
}
int cmp(Link a, Link b)
//比较两项的指数的大小，并返回特定的值。 
{
	if (a->expn<b->expn) return  -1;
	else if(a->expn == b->expn) return  0;
	else return 1;
}
Link AddPolyn(Link pa, Link pb)//pa, pb是两个指向头结点的指针
//两个多项式相加得一个新多项式，并且返回新多项式的头结点的指针  
{
	Link newp, p, q, s, pc;
	float sum;
	p = pa->next; //p指向pa的第一个元素
	q = pb->next; //q指向pb的第一个元素
	newp=(Link)malloc(LEN); //pc指向新多项式pc的头结点
	pc = newp;
	while(p&&q){
		switch(cmp(p, q))
		{
			case -1:   //若指数：p<q,则将p所指结点链入头结点为newp的链表中，且p向后遍历 
				s = (Link)malloc(LEN); 
				s->coef = p->coef;
				s->expn = p->expn;
				pc->next = s;
				pc = s;
				p = p->next;
				break;
			case 0://若比较两项的指数相等，则将两项系数相加后得到的项放入头结点为newp的链表中 ，且p,q同时向后遍历 
				sum = p->coef+q->coef; 
				if(sum!=0.0)//若两项系数相加为0，则不放入头结点为newp的链表中 
				{
					s = (Link)malloc(LEN);
					s->coef = sum;
					s->expn = p->expn;
					pc->next = s;
					pc = s;
				}
				p = p->next;
				q = q->next;
				break;
			case 1:   //若指数：q<p,则将q所指结点链入头结点为newp的链表中，且q向后遍历 
				s = (Link)malloc(LEN);
				s->coef = q->coef;
				s->expn = q->expn;
				pc->next = s;
				pc = s;
				q = q->next;
				break;
		}
	}
	while(p) //若p所在链表还有剩余项，直接将剩余项依次链入头结点为newp的链表中
	{
		s = (Link)malloc(LEN);
		s->coef = p->coef;
		s->expn = p->expn;
		pc->next = s;
		pc = s;
		p = p->next;
	}
	while(q)//若q所在链表还有剩余项，直接将剩余项依次链入头结点为newp的链表中 
	{
		s = (Link)malloc(LEN);
		s->coef = q->coef;
		s->expn = q->expn;
		pc->next = s;
		pc = s;
		q = q->next;
	}
	pc->next = NULL;
	return newp; //返回新多项式的首地址
}

 
代码仅供参考，如若有错误，请大家指出改正。

原文转载来自：https://www.linuxidc.com/Linux/2014-04/99735.htm
 
　数据结构与算法分析：C语言描述（原书第2版）是《data structures and algorithm analysis in c》一书第2版的简体中译本。原书曾被评为20世纪顶尖的30部计算机著作之一，作者mark allen weiss在数据结构和算法分析方面卓有建树，他的数据结构和算法分析的著作尤其畅销，并受到广泛好评．已被世界500余所大学用作教材。
 
　　在本书中，作者更加精炼并强化了他对算法和数据结构方面创新的处理方法。通过c程序的实现，着重阐述了抽象数据类型的概念，并对算法的效率、性能和运行时间进行了分析。
 
 
数据结构与算法分析：C语言描述（原书第2版） PDF下载：
 
百度网盘免费下载地址： http://pan.baidu.com/s/1pJ59aMv
 
或者：
 
免费下载地址在 http://linux.linuxidc.com/
 
用户名与密码都是www.linuxidc.com
 
具体下载目录在 /2014年资料/4月/8日/数据结构与算法分析：C语言描述（原书第2版） PDF+源代码+习题答案
 
下载方法见 http://www.linuxidc.com/Linux/2013-07/87684.htm
 
 
 
　　全书特点如下：
 
　　 ●专用一章来讨论算法设计技巧，包括贪婪算法、分治算法、动态规划、随机化算法以及回溯算法
 
　　 ●介绍了当前流行的论题和新的数据结构，如斐波那契堆、斜堆、二项队列、跳跃表和伸展树
 
　　 ●安排一章专门讨论摊还分析，考查书中介绍的一些高级数据结构
 
　　 ●新开辟一章讨论高级数据结构以及它们的实现，其中包括红黑树、自顶向下伸展树。treap树、k-d树、配对堆以及其他相关内容
 
　　 ●合并了堆排序平均情况分析的一些新结果
 
　　本书是国外数据结构与算法分析方面的标准教材，介绍了数据结构(大量数据的组织方法)以及算法分析(算法运行时间的估算)。本书的编写目标是同时讲授好的程序设计和算法分析技巧，使读者可以开发出具有最高效率的程序。 本书可作为高级数据结构课程或研究生一年级算法分析课程的教材，使用本书需具有一些中级程序设计知识，还需要离散数学的一些背景知识。
 
　　《数据结构与算法分析：C语言描述（原书第2版）》讨论数据结构和算法分析。数据结构主要研究组织大量数据的方法，而算法分析则是对算法运行时间的评估。随着计算机的速度越来越快，对于能够处理大量输入数据的程序的需求变得日益急切。可是，由于在输入量很大的时候，程序的低效率现象变得非常明显，因此这又要求对效率问题给予更仔细的关注。通过在实际编程之前对算法的分析，学生可以决定一个特定的解法是否可行。例如，学生在本书中将读到一些特定的问题并看到精心的实现方法是如何把对大量数据的时间限制从16年减至不到1秒的。因此，若无运行时间的阐释，就不会有算法和数据结构的提出。
 
　　《数据结构与算法分析：C语言描述（原书第2版）》是国外数据结构与算法分析方在的标准教材，介绍了数据结构（大量数据的组织方法）以及算法分析（算法运行时间的估算）。本书的编写目标是同时廛授好的程序设计和算法分析技巧，使读者可以开发出具有最高效率的程序。
 
本书可作为高级数据结构课程或研究生一年级算法分析课程的教材，使用本书需具有一些中级程序设计知识，还需要离散数学的一些背景知识。
 
　　随着速度的不断提高和存储容量的持续增长，计算机的功能日益强大，从而处理数据和解决问题的规模和复杂程度与日俱增。这不仅带来了需要认真研究的新课题，而且突出了原有数据结构和算法效率低下的缺点。程序的效率问题不是由于计算机功能的强大而受到冷落，相反地，倒是被人们提到前所未有的重视程度，因为大型问题的解决所涉及到的大容量存储和高速度运算容不得我们对效率有丝毫的忽视。本书正是在阐述数据结构基本概念的同时深入地分析了算法的效率。
 

 目录
 出版者的话
 专家指导委员会
 译者序
 前言
 第1章 引论
 第2章 算法分析
 第3章 表、栈和队列
 第4章 树
 第5章 散列
 第6章 优先队列（堆）
 第7章 排序
 第8章 不相交集ADT
 第9章 图论算法
 第10章 算法设计技巧
 第11章 摊还分析
 第12章 高级数据结构及其实现索引

目录
 
函数分析
 
代码
 
全部代码
 
结果截图
 

函数分析
 
下标从小到大，相邻依次比较，直到最后两个被比较，每次比较，若为逆序，则交换，以上为一趟冒泡排序。
 使用一个标记，有交换时标记，若一趟下来没有需要交换的，则停止。
 
void BubbleSort(SqList &L) 参数：顺序表L，时间复杂度O(n^2)，空间复杂度O(1)，稳定性：稳定
 
代码
 
//冒泡排序 升序排序
void BubbleSort(SqList &L)
{
	int m = L.length - 1;
	int flag = 1;
	while (m > 0 && flag == 1)
	{
		flag = 0;
		for (int j = 1; j <= m; j++)
			if (L.data[j] > L.data[j + 1])
			{
				flag = 1;
				int temp = L.data[j];
				L.data[j] = L.data[j + 1];
				L.data[j + 1] = temp;
			}
		--m;
	}
}
 
全部代码
 
/*
Project: bubble_sort(冒泡排序)
Date:    2021/03/15
Author:  Frank Yu
BubbleSort(SqList &L) 参数：顺序表L 功能：排序（默认升序）空间复杂度：O(1) 时间复杂度：O(n方)
稳定性：稳定
思想:下标从小到大，相邻依次比较，直到最后两个被比较，每次比较，若为逆序，则交换，以上为一趟冒泡排序。
使用一个标记，有交换时标记，若一趟下来没有需要交换的，则停止。
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>
#define MaxSize 100
#define ElemType int
#define Status int
using namespace std;
//顺序表数据结构
typedef struct
{
	ElemType data[MaxSize];//顺序表元素
	int length;            //顺序表当前长度
}SqList;
//***************************基本操作函数*******************************//
//初始化顺序表函数，构造一个空的顺序表 
Status InitList(SqList &L)
{
	memset(L.data, 0, sizeof(L));//初始化数据为0
	L.length = 0;                //初始化长度为0
	return 0;
}
//创建顺序表函数 初始化前n个数据
bool CreatList(SqList &L, int n)
{
	if (n<0 || n>MaxSize)false;//n非法
	for (int i = 1; i<n + 1; i++)//L[0]作为哨兵
	{
		scanf("%d", &L.data[i]);
		L.length++;
	}
	return true;
}
//插入函数 位置i插入数据 i及之后元素后移  1=<i<=length+1 
bool InsertList(SqList &L, int i, ElemType e)
{
	if (i<1 || i>L.length + 1) //判断位置是否有效
	{
		printf("位置无效！！！\n");
		return false;
	}
	if (L.length + 1 >= MaxSize)//判断存储空间是否已满
	{
		printf("当前存储空间已满！！！\n");
		return false;
	}
	for (int j = L.length + 1; j >= i; j--)//位置i及之后元素后移
	{
		L.data[j] = L.data[j - 1];
	}
	L.data[i] = e;
	L.length++;
	return true;
}
//删除函数 删除位置i的元素 i之后的元素依次前移
bool ListDelete(SqList &L, int i)
{
	if (i<1 || i>L.length)//判断位置是否有效
	{
		printf("位置无效！！！\n");
		return false;
	}
	for (int j = i + 1; j <= L.length; j++)//位置i之后元素依次前移覆盖
	{
		L.data[j - 1] = L.data[j];
	}
	L.length--;
	return true;
}
//查找函数 按位置从小到大查找第一个值等于e的元素 并返回位置
int LocateElem(SqList L, ElemType e)
{
	for (int i = 1; i<L.length + 1; i++)//从低位置查找
	{
		if (L.data[i] == e)
			return i;
	}
	return 0;
}
//********************************功能函数*****************************************//
//输出功能函数 按位置从小到大输出顺序表所有元素
void PrintList(SqList L)
{
	printf("当前顺序表所有元素:");
	for (int i = 1; i<L.length + 1; i++)
	{
		printf("%d ", L.data[i]);
	}
	printf("\n");
}
//创建顺序表函数
void Create(SqList &L)
{
	int n; bool flag;
	printf("请输入要创建的顺序表长度(>1):");
	scanf("%d", &n);
	printf("请输入%d个数（空格隔开）:", n);
	flag = CreatList(L, n);
	if (flag) {
		printf("创建成功！\n");
		PrintList(L);
	}
	else printf("输入长度非法！\n");
}
//插入功能函数 调用InsertList完成顺序表元素插入 调用PrintList函数显示插入成功后的结果
void Insert(SqList &L)
{
	int place; ElemType e; bool flag;
	printf("请输入要插入的位置(从1开始)及元素:\n");
	scanf("%d%d", &place, &e);
	flag = InsertList(L, place, e);
	if (flag)
	{
		printf("插入成功！！！\n");
		PrintList(L);
	}
}
//删除功能函数 调用ListDelete函数完成顺序表的删除 调用PrintList函数显示插入成功后的结果
void Delete(SqList &L)
{
	int place; bool flag;
	printf("请输入要删除的位置(从1开始):\n");
	scanf("%d", &place);
	flag = ListDelete(L, place);
	if (flag)
	{
		printf("删除成功！！！\n");
		PrintList(L);
	}
}
//查找功能函数 调用LocateElem查找元素
void Search(SqList L)
{
	ElemType e; int flag;
	printf("请输入要查找的值:\n");
	scanf("%d", &e);
	flag = LocateElem(L, e);
	if (flag)
	{
		printf("该元素位置为:%d\n", flag);
	}
	else
		printf("未找到该元素！\n");
}
//冒泡排序 升序排序
void BubbleSort(SqList &L)
{
	int m = L.length - 1;
	int flag = 1;
	while (m > 0 && flag == 1)
	{
		flag = 0;
		for (int j = 1; j <= m; j++)
			if (L.data[j] > L.data[j + 1])
			{
				flag = 1;
				int temp = L.data[j];
				L.data[j] = L.data[j + 1];
				L.data[j + 1] = temp;
			}
		--m;
		PrintList(L);
	}
	//PrintList(L);
}

//菜单
void menu()
{
	printf("********1.创建            2.插入*********\n");
	printf("********3.删除            4.查找*********\n");
	printf("********5.冒泡排序        6.输出*********\n");
	printf("********7.退出\n");
}
int main()
{
	SqList L; int choice;
	InitList(L);
	while (1)
	{
		menu();
		printf("请输入菜单序号：\n");
		scanf("%d", &choice);
		if (7 == choice) break;
		switch (choice)
		{
		case 1:Create(L); break;
		case 2:Insert(L); break;
		case 3:Delete(L); break;
		case 4:Search(L); break;
		case 5:BubbleSort(L); break;
		case 6:PrintList(L); break;
		default:printf("输入错误！！！\n");
		}
	}
	return 0;
}
 
结果截图
 
 
将PrintList(L);放在--m后可查看每一趟结果
 
 
 更多数据结构实现：数据结构严蔚敏版的实现（含全部代码）
 
有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。