数据结构 排序【简单排序（冒泡、插入）、希尔排序、堆排序、排序方法的综合比较、2套 排序汇总代码】
2024-04-29 17:16:16
目 录
第9章 排序（上）
9.1 简单排序（冒泡、插入）
1、前提
2、简单排序（冒泡排序）
3、简单排序（插入排序）
4、时间复杂度下界
9.2 希尔排序
9.3 堆排序
排序方法综合比较
排序汇总（1）
排序汇总（2）
第9章 排序（上）
9.1 简单排序（冒泡、插入）
1、前提
void X_Sort ( ElementType A[], int N )
- 大多数情况下，为简单起见，讨论从小大的整数排序
- N是正整数
- 只讨论基于比较的排序（> = < 有定义）
- 只讨论内部排序
- 稳定性：任意两个相等的数据， 排序前后的相对位置不发生改变
- 没有一种排序是任何情况下 都表现最好的
ElemnetType：所排元素类型；N：元素个数。10万数据量。
2、简单排序（冒泡排序）
void Bubble_Sort( ElementType A[], int N ) {for ( P=N-1; P>=0; P-- ) {flag = 0;for( i=0; i<P; i++ ) { /* 一趟冒泡 */if ( A[i] > A[i+1] ) {Swap(A[i], A[i+1]);flag = 1; /* 标识发生了交换 */}}if ( flag==0 ) break; /* 全程无交换 */}
}冒泡排序 优点：对 数组、链表，均可进行排序。
P=N-1：从最后的元素，开始往前比较。
对于7个数进行冒泡排序，最坏情况下需要进行的比较次数为 21 .
3、简单排序（插入排序）
void InsertionSort( ElementType A[], int N )
{ /* 插入排序 */int P, i;ElementType Tmp;for ( P=1; P<N; P++ ) {Tmp = A[P]; /* 取出未排序序列中的第一个元素*/for ( i=P; i>0 && A[i-1]>Tmp; i-- )A[i] = A[i-1]; /*依次与已排序序列中元素比较并右移*/A[i] = Tmp; /* 放进合适的位置 */}
}P=1：初始手中 就有 1张牌。
给定初始序列{34, 8, 64, 51, 32, 21}，冒泡排序和插入排序分别需要多少次元素交换才能完成?【冒泡9次,插入9次】
对一组包含10个元素的非递减有序序列，采用插入排序排成非递增序列，其可能的比较次数和移动次数分别是【45, 44】。
4、时间复杂度下界
序列{34, 8, 64, 51, 32, 21}中有多少逆序对？【9】
N：元素个数；I：逆序对个数。
9.2 希尔排序
void ShellSort( ElementType A[], int N )
{ /* 希尔排序 - 用Sedgewick增量序列 */int Si, D, P, i;ElementType Tmp;/* 这里只列出一小部分增量 */int Sedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0};for ( Si=0; Sedgewick[Si]>=N; Si++ ); /* 初始的增量Sedgewick[Si]不能超过待排序列长度 */for ( D=Sedgewick[Si]; D>0; D=Sedgewick[++Si] )for ( P=D; P<N; P++ ) { /* 插入排序*/Tmp = A[P];for ( i=P; i>=D && A[i-D]>Tmp; i-=D )A[i] = A[i-D];A[i] = Tmp;}
}希尔排序是稳定的。【错误】
9.3 堆排序
void Swap( ElementType *a, ElementType *b )
{ElementType t = *a; *a = *b; *b = t;
}void PercDown( ElementType A[], int p, int N )
{ /* 改编代码4.24的PercDown( MaxHeap H, int p ) *//* 将N个元素的数组中以A[p]为根的子堆调整为最大堆 */int Parent, Child;ElementType X;X = A[p]; /* 取出根结点存放的值 */for( Parent=p; (Parent*2+1)<N; Parent=Child ) {Child = Parent * 2 + 1;if( (Child!=N-1) && (A[Child]<A[Child+1]) )Child++; /* Child指向左右子结点的较大者 */if( X >= A[Child] ) break; /* 找到了合适位置 */else /* 下滤X */A[Parent] = A[Child];}A[Parent] = X;
}void HeapSort( ElementType A[], int N )
{ /* 堆排序 */int i;for ( i=N/2-1; i>=0; i-- )/* 建立最大堆 */PercDown( A, i, N );for ( i=N-1; i>0; i-- ) {/* 删除最大堆顶 */Swap( &A[0], &A[i] ); /* 见代码7.1 */PercDown( A, 0, i );}
}typedef struct HNode *Heap; /* 堆的类型定义 */struct HNode {ElementType *Data; /* 存储元素的数组 */int Size; /* 堆中当前元素个数 */int Capacity; /* 堆的最大容量 */};typedef Heap MaxHeap; /* 最大堆 */typedef Heap MinHeap; /* 最小堆 */#define MAXDATA 1000 /* 该值应根据具体情况定义为大于堆中所有可能元素的值 */MaxHeap CreateHeap( int MaxSize ){ /* 创建容量为MaxSize的空的最大堆 */MaxHeap H = (MaxHeap)malloc(sizeof(struct HNode));H->Data = (ElementType *)malloc((MaxSize+1)*sizeof(ElementType));//指向数组，下标从1开始，所以 是 MaxSize+1H->Size = 0;H->Capacity = MaxSize;H->Data[0] = MAXDATA; /* 定义"哨兵"为大于堆中所有可能元素的值*/return H;}bool IsFull( MaxHeap H ){return (H->Size == H->Capacity);}bool Insert( MaxHeap H, ElementType X ){ /* 将元素X插入最大堆H，其中H->Data[0]已经定义为哨兵 */int i;if ( IsFull(H) ) { printf("最大堆已满");return false;}i = ++H->Size; /* i指向插入后堆中的最后一个元素的位置 */for ( ; H->Data[i/2] < X; i/=2 )H->Data[i] = H->Data[i/2]; /* 上滤X */H->Data[i] = X; /* 将X插入 */return true;}#define ERROR -1 /* 错误标识应根据具体情况定义为堆中不可能出现的元素值 */bool IsEmpty( MaxHeap H ){return (H->Size == 0);}ElementType DeleteMax( MaxHeap H ){ /* 从最大堆H中取出键值为最大的元素，并删除一个结点 */int Parent, Child;ElementType MaxItem, X;if ( IsEmpty(H) ) {printf("最大堆已为空");return ERROR;}MaxItem = H->Data[1]; /* 取出根结点存放的最大值 *//* 用最大堆中最后一个元素从根结点开始向上过滤下层结点 */X = H->Data[H->Size--]; /* 注意当前堆的规模要减小 */for( Parent=1; Parent*2<=H->Size; Parent=Child ) {Child = Parent * 2;if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )Child++; /* Child指向左右子结点的较大者 */if( X >= H->Data[Child] ) break; /* 找到了合适位置 */else /* 下滤X */H->Data[Parent] = H->Data[Child];}H->Data[Parent] = X;return MaxItem;} /*----------- 建造最大堆 -----------*/void PercDown( MaxHeap H, int p ){ /* 下滤：将H中以H->Data[p]为根的子堆调整为最大堆 */int Parent, Child;ElementType X;X = H->Data[p]; /* 取出根结点存放的值 */for( Parent=p; Parent*2<=H->Size; Parent=Child ) {Child = Parent * 2;if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )Child++; /* Child指向左右子结点的较大者 */if( X >= H->Data[Child] ) break; /* 找到了合适位置 */else /* 下滤X */H->Data[Parent] = H->Data[Child];}H->Data[Parent] = X;}void BuildHeap( MaxHeap H ){ /* 调整H->Data[]中的元素，使满足最大堆的有序性 *//* 这里假设所有H->Size个元素已经存在H->Data[]中 */int i;/* 从最后一个结点的父节点开始，到根结点1 */for( i = H->Size/2; i>0; i-- )PercDown( H, i );}有个堆其元素在数组中的序列为：58，25，44，18，10，26，20，12。如果调用DeleteMax函数删除最大值元素，请猜猜看：程序中的for循环刚退出时变量parent的值是多少？【6】
建堆时，最坏情况下需要挪动元素次数是等于树中各结点的高度和。问：对于元素个数为12的堆，其各结点的高度之和是多少？【10】
在堆排序中，元素下标从0开始。则对于下标为i的元素，其左、右孩子的下标分别为：【2i+1, 2i+2】
排序方法综合比较
排序汇总（1）
#include <stdio.h>
#include <string.h>
#define MAXSIZE 100 /*参加排序元素的最大个数*//******************冒泡排序********************/
void maopao()
{int nums[MAXSIZE];int i, j, n, temp;int comnum = 0, movnum = 0;int num = 1;printf("您已进入冒泡排序\n");printf("请输入排序序列长度：");scanf("%d", &n);printf("请输入排序序列：");for (i = 0; i < n; i++)scanf("%d", &nums[i]);for (i = 0; i < n - 1; i++){for (j = 0; j < n - i - 1; j++){comnum++;if (nums[j] > nums[j + 1]){temp = nums[j];nums[j] = nums[j + 1];nums[j + 1] = temp;movnum++;}}printf("第%d趟排序结果：", num++);for (j = 0; j < n; j++){printf("%d ", nums[j]);}printf("\n");}printf("排序过程比较次数：%d\n排序过程移动次数：%d\n", comnum, movnum);printf("\n");return;
}
/************************************************//*****************折半插入排序*******************/
void zheban()
{int nums[MAXSIZE];int i, j, n, temp;int low, high, middle;int comnum = 0, movnum = 0;int num = 1;printf("您已进入折半插入排序\n");printf("请输入排序序列长度：");scanf("%d", &n);printf("请输入排序序列：");for (i = 0; i < n; i++){scanf("%d", &nums[i]);}for (i = 1; i < n; i++){low = 0; //有序数组的开头下标high = i - 1; //有序数组的末尾下标temp = nums[i]; //要被插入的数middle = 0;//查找要被插入的下标while (low <= high){middle = (low + high) / 2;if (temp < nums[middle]){high = middle - 1;}else{low = middle + 1;}comnum++;}//所有数右移,移完之后插入目标数for (j = i; j > low; j--){nums[j] = nums[j - 1];}//交换nums[i]与nums[low]的位置nums[low] = temp;movnum++;printf("第%d趟排序结果：", num++);for (j = 0; j < n; j++){printf("%d ", nums[j]);}printf("\n");}printf("排序过程比较次数：%d\n排序过程移动次数：%d\n", comnum, movnum);printf("\n");return;
}
/************************************************//*******************希尔排序*********************/
void shell()
{int i, j, k, n, dk, temp;int nums[MAXSIZE];int comnum = 0, movnum = 0;int num = 1;printf("您已进入希尔排序\n");printf("请输入排序序列长度：");scanf("%d", &n);printf("请输入排序序列：");for (i = 0; i < n; i++){scanf("%d", &nums[i]);}for (dk = n / 2; dk > 0; dk = dk / 2){for (i = 0; i < dk; i++){for (j = i + dk; j < n; j = j + dk){ //单独一次的插入排序if (nums[j] < nums[j - dk]){temp = nums[j]; //哨兵k = j - dk;while (k >= 0 && nums[k] > temp){nums[k + dk] = nums[k];k = k - dk;}nums[k + dk] = temp;movnum++;}comnum++;}}printf("第%d趟排序结果：", num++);for (i = 0; i < n; i++){printf("%d ", nums[i]);}printf("\n");}printf("排序过程比较次数：%d\n排序过程移动次数：%d\n", comnum, movnum);printf("\n");return;
}
/************************************************//*******************快速排序*********************/
int CN = 0;
int MN = 0;
int T = 1;
void Fswap(int nums[], int i, int j)
{int temp;temp = nums[i];nums[i] = nums[j];nums[j] = temp;MN++;
}int partition(int nums[], int low, int high, int n)
{int i;int pivotkey;pivotkey = nums[low];while (low < high) //以pivoekey为轴，将大于它的放在后边，小于它的放在前面{while (low < high && nums[high] >= pivotkey) //条件判断 low < high{high--;CN++;}Fswap(nums, low, high);while (low < high && nums[low] <= pivotkey){low++;CN++;}Fswap(nums, low, high);printf("第%d趟排序结果：", T++);for (i = 0; i < n; i++){printf("%d ", nums[i]);}printf("\n");}return low; //返回枢轴所在位置
}void quickSort(int nums[], int low, int high, int n)
{int pivot;if (low < high){pivot = partition(nums, low, high, n); //将nums[]一分为二quickSort(nums, low, pivot - 1, n); //对低子表递归排序quickSort(nums, pivot + 1, high, n); //对高子表递归排序}
}void kuaipai()
{int i, n;int nums[MAXSIZE];printf("您已进入快速排序\n");printf("请输入排序序列长度：");scanf("%d", &n);printf("请输入排序序列：");CN = 0;MN = 0;T = 1;for (i = 0; i < n; i++){scanf("%d", &nums[i]);}quickSort(nums, 0, n - 1, n);printf("排序过程比较次数：%d\n排序过程移动次数：%d\n", CN, MN);printf("\n");return;
}
/************************************************//********************堆排序**********************/
int HCN = 0;
int HMN = 0;
int H = 1;
void HeapAdjust(int nums[], int s, int n)
{int i, j;int temp;for (i = s; 2 * i + 1 < n; i = j){j = 2 * i + 1;if ((j < n - 1) && (nums[j] < nums[j + 1])){j++;HCN++;}if (nums[i] < nums[j]){temp = nums[i];nums[i] = nums[j];nums[j] = temp;HCN++;HMN++;}elsebreak;}
}//堆排序
void HeapSort(int nums[], int n)
{int i, j;int temp;for (i = n / 2 - 1; i >= 0; i--){HeapAdjust(nums, i, n);printf("第%d趟排序结果：", H++);for (j = 0; j < n; j++){printf("%d ", nums[j]);}printf("\n");}for (i = n - 1; i > 0; i--){temp = nums[i];nums[i] = nums[0];nums[0] = temp;HMN++;HeapAdjust(nums, 0, i);printf("第%d趟排序结果：", H++);for (j = 0; j < n; j++){printf("%d ", nums[j]);}printf("\n");}
}void duipai()
{int i, n;int nums[MAXSIZE];printf("您已进入堆排序\n");printf("请输入排序序列长度：");scanf("%d", &n);printf("请输入排序序列：");HMN = 0;HCN = 0;H = 1;for (i = 0; i < n; i++){scanf("%d", &nums[i]);}HeapSort(nums, n);printf("排序过程比较次数：%d\n排序过程移动次数：%d\n", HCN, HMN);printf("\n");return;
}
/************************************************//*****************直接插入排序*******************/
void zhicha()
{int nums[MAXSIZE];int i, j, n;int temp;int comnum = 0, movnum = 0;int num = 1;printf("您已进入直接插入排序\n");printf("请输入排序序列长度：");scanf("%d", &n);printf("请输入排序序列：");for (i = 0; i < n; i++){scanf("%d", &nums[i]);}for (i = 1; i < n; i++){if (nums[i] < nums[i - 1]){temp = nums[i];for (j = i - 1; j >= 0; j--){if (temp < nums[j]){nums[j + 1] = nums[j];comnum++;}else{break;comnum++;}}nums[j + 1] = temp;movnum++;}else{comnum++;continue;}printf("第%d趟排序结果：", num++);for (j = 0; j < n; j++){printf("%d ", nums[j]);}printf("\n");}printf("排序过程比较次数：%d\n排序过程移动次数：%d\n", comnum, movnum);printf("\n");
}
/************************************************//*****************简单选择排序*******************/
void jiandan()
{int nums[MAXSIZE];int i, j, n;int temp, t;int comnum = 0, movnum = 0;int num = 1;printf("您已进入简单选择排序\n");printf("请输入排序序列长度：");scanf("%d", &n);printf("请输入排序序列：");for (i = 0; i < n; i++){scanf("%d", &nums[i]);}for (i = 0; i < n; i++){temp = nums[i];t = i;for (j = i + 1; j < n; j++){if (nums[j] < temp){temp = nums[j];t = j;}comnum++;}temp = nums[i];nums[i] = nums[t];nums[t] = temp;movnum++;printf("第%d趟排序结果：", num++);for (j = 0; j < n; j++){printf("%d ", nums[j]);}printf("\n");}printf("排序过程比较次数：%d\n排序过程移动次数：%d\n", comnum, movnum);printf("\n");
}
/************************************************//********************主函数**********************/
int main()
{int n;while (1){printf(" 主菜单\n");printf("请选择排序算法\n");printf("冒泡排序法 1\n");printf("折半插入排序法 2\n");printf("希尔排序法 3\n");printf("快速排序法 4\n");printf("堆排序法 5\n");printf("直接插入排序法 6\n");printf("简单选择排序法 7\n");printf("退出 0\n");scanf("%d", &n);switch (n){case 1:maopao();continue;case 2:zheban();continue;case 3:shell();continue;case 4:kuaipai();continue;case 5:duipai();continue;case 6:zhicha();continue;case 7:jiandan();continue;default:break;}if (n == 0)break;}return 0;
}排序汇总（2）
#include <iostream>
#include <stdio.h>
#include <stdlib.h>using namespace std;#ifndef SQLIST_H_INCLUDED
#define SQLIST_H_INCLUDED#define MAXSIZE 20 //顺序表的最大长度
typedef int KeyType; //定义关键字类型为整型
typedef int InfoType;typedef struct
{KeyType key;InfoType otherinfp;
} RedType;typedef struct
{RedType r[MAXSIZE + 1]; //r[0]是哨兵的位置，防止数组越界int length;
} SqList;void menu();
void InSqList(SqList &sq);
void InsertSort(SqList &sq);void OutPrintSqList(SqList &L);void BInsertSort(SqList &L); //折半插入排序
void ShellSort(SqList &L, int dk[], int t); //希尔排序
void ShellInsert(SqList &L, int dk); //做一趟增量为dk的希尔排序
void BubbleSort(SqList &L); //冒泡排序int PartitionQ(SqList &L, int low, int high); //一趟快速排序，返回枢轴位置
void QSort(SqList &L, int low, int high);
void QuickSort(SqList &L); //快速排序void SelectSort(SqList &L); //简单选择排序//堆排序
void HeapAdjust(SqList &L, int s, int m);
void CreateHeap(SqList &L);
void HeapSort(SqList &L);//归并排序
void Merge(SqList R, SqList &T, int low, int mid, int high);
void Msort(SqList R, SqList &T, int low, int high);
void MergeSort(SqList &L);
#endif // SQLIST_H_INCLUDEDvoid menu()
{printf("---------------------------\n");printf("1---直接插入排序\n");printf("2---折半插入排序\n");printf("3---希尔排序\n");printf("4---冒泡排序\n");printf("5---快速排序\n");printf("6---简单选择排序\n");printf("7---堆排序\n");printf("8---归并排序\n");printf("0----退出\n");printf("----------------------------\n");
}void InSqList(SqList &sq)
{int i = 1;sq.length = 0;printf("请输入8个关键字:\n");for (; i <= 8; i++){printf("请输入第%d个关键字：\n", i);scanf("%d", &sq.r[i].key);sq.r[i].otherinfp = i;sq.length++;}
}void OutPrintSqList(SqList &sq)
{int i;printf("******************\n");for (i = 1; i <= sq.length; i++)printf("%d ", sq.r[i].key);printf("\n");
}void InsertSort(SqList &L)
{int i, j;for (i = 2; i <= L.length; i++){if (L.r[i].key < L.r[i - 1].key){L.r[0] = L.r[i];L.r[i] = L.r[i - 1];for (j = i - 2; L.r[0].key < L.r[j].key; j--)L.r[j + 1] = L.r[j];L.r[j + 1] = L.r[0];}}
}void BInsertSort(SqList &L)
{int i, j, low, high, mid;for (i = 2; i <= L.length; i++){L.r[0] = L.r[i];low = 1;high = i - 1;while (low <= high){mid = (low + high) / 2;if (L.r[0].key < L.r[mid].key)high = mid - 1;elselow = mid + 1;}for (j = i - 1; j >= high + 1; --j)L.r[j + 1] = L.r[j];L.r[j + 1] = L.r[0];}
}void ShellSort(SqList &L, int dk[], int t) //希尔排序
{int k;for (k = 0; k < t; k++)ShellInsert(L, dk[k]);
}//做一趟增量为dk的希尔排序
void ShellInsert(SqList &L, int dk)
{int i, j;for (i = dk + 1; i <= L.length; i++){if (L.r[i].key < L.r[i - dk].key) //需要将L.r[i]插入到有序增量子表{L.r[0] = L.r[i]; //暂存在L.r[0]for (j = i - dk; j > 0 && L.r[0].key < L.r[j].key; j -= dk) //记录后移，直到找到插入位置L.r[j + dk] = L.r[j];L.r[j + dk] = L.r[0]; //将r[0]即原r[i]，插入到正确位置}}
}//冒泡排序
void BubbleSort(SqList &L)
{int j, i, flag = 1;RedType t;j = L.length - 1;while (j > 0 && flag == 1){flag = 0;for (i = 1; i <= j; i++){if (L.r[i + 1].key < L.r[i].key){flag = 1;t = L.r[i];L.r[i] = L.r[i + 1];L.r[i + 1] = t;}}j--;}
}//快速排序
int PartitionQ(SqList &L, int low, int high) //一趟快速排序，返回枢轴位置
{//1.选枢轴int pivotkey = L.r[low].key;L.r[0] = L.r[low];while (low < high){while (low < high && pivotkey <= L.r[high].key)high--;L.r[low] = L.r[high];while (low < high && pivotkey >= L.r[low].key)low++;L.r[high] = L.r[low];}L.r[low] = L.r[0];return low;
}
void QSort(SqList &L, int low, int high)
{int pivotloc;if (low < high){pivotloc = PartitionQ(L, low, high); //以枢轴为支点将表分为两部分，返回数轴的位置QSort(L, low, pivotloc - 1); //递归左子表QSort(L, pivotloc + 1, high); //递归右子表}
}
void QuickSort(SqList &L)
{QSort(L, 1, L.length);
}//简单选择排序
void SelectSort(SqList &L)
{int i, j, k;RedType t;for (i = 1; i < L.length; i++){k = i;for (j = i + 1; j <= L.length; j++)if (L.r[j].key < L.r[k].key)k = j;if (k != i){t = L.r[i];L.r[i] = L.r[k];L.r[k] = t;}}
}//堆排序 调整堆
void HeapAdjust(SqList &L, int s, int m)
{RedType rc;int j;rc = L.r[s];for (j = 2 * s; j <= m; j *= 2){while (j < m && L.r[j].key < L.r[j + 1].key)j++; //s与左右孩子较大的比较，这是堆排序的性质决定的if (rc.key >= L.r[j].key)break;L.r[s] = L.r[j];s = j;}L.r[s] = rc;
}//建初堆
void CreateHeap(SqList &L)
{int n = L.length;int i;for (i = n / 2; i > 0; i--)HeapAdjust(L, i, n);
}//堆排序
void HeapSort(SqList &L)
{int i;RedType x;CreateHeap(L);for (i = L.length; i > 0; i--){x = L.r[1];L.r[1] = L.r[i];L.r[i] = x;HeapAdjust(L, 1, i - 1);}
}//归并排序
void Merge(SqList R, SqList &T, int low, int mid, int high)
{int i, j, k;i = low;j = mid + 1;k = low;while (i <= mid && j <= high){if (R.r[i].key <= R.r[j].key)T.r[k++] = R.r[i++];elseT.r[k++] = R.r[j++];}while (i <= mid)T.r[k++] = R.r[i++];while (j <= high)T.r[k++] = R.r[j++];
}
void Msort(SqList R, SqList &T, int low, int high)
{int mid;SqList S; //辅助存储空间if (low == high)T.r[low] = R.r[low];else{mid = (low + high) / 2;Msort(R, S, low, mid);Msort(R, S, mid + 1, high);Merge(S, T, low, mid, high);}
}
void MergeSort(SqList &L)
{Msort(L, L, 1, L.length);
}int main()
{SqList sq;int index;int dk[] = {5, 3, 1};while (1){menu();printf("请输入排序类型：\n");scanf("%d", &index);if (!index)return 0;//输入InSqList(sq);//输出OutPrintSqList(sq);switch (index){case 1:InsertSort(sq); //直接插入排序//输出break;case 2:BInsertSort(sq); //折半插入排序break;case 3:ShellSort(sq, dk, 3);break;case 4:BubbleSort(sq);break;case 5:QuickSort(sq);break;case 6:SelectSort(sq);break;case 7:HeapSort(sq);break;case 8:MergeSort(sq);break;}printf("排序后:\n");//输出OutPrintSqList(sq);printf("*************第4个49之前的位序是：%d**************\n", sq.r[4].otherinfp);system("pause");}return 0;
}数据结构 排序【简单排序（冒泡、插入）、希尔排序、堆排序、排序方法的综合比较、2套 排序汇总代码】相关推荐
- 排序入门的七种算法（冒泡—插入—希尔—堆—选择—归并—快速）
---------文中的部分代码思路参考自<大话数据结构>一书. 目录 冒泡排序 插入排序 希尔排序 堆排序 选择排序 归并排序 快速排序 冒泡排序 原始的冒泡排序是对整个序列相邻两数字间 ...
- MATLAB实现三种基本排序（选择+冒泡+插入）
选择排序 %% 选择排序 A=[2 4 6 7 1 9 5 3 8]; num_A=length(A);% A的长度 for i=1:num_A-1now =i;for j=i+1:num_Aif A ...
- python简单选择排序_Python实现冒泡，插入，选择排序简单实例
本文所述的Python实现冒泡,插入,选择排序简单实例比较适合Python初学者从基础开始学习数据结构和算法,示例简单易懂,具体代码如下: # -*- coding: cp936 -*-#python ...
- C++实现十大排序算法（冒泡，选择，插入，归并，快速，堆，希尔，桶，计数，基数）排序算法时间复杂度、空间复杂度、稳定性比较（面试经验总结）
排序算法分类 内部排序算法又分为基于比较的排序算法和不基于比较的排序算法,其分类如下: 比较排序: 直接插入排序 希尔排序 (插入) 冒泡排序 快速排序 (交换) 直接选择排序 ...
- 算法研究:插入类排序(简单插入,折半插入,希尔排序)
百度百科:有一个已经有序的数据序列,要求在这个已经排好的数据序列中插入一个数,但要求插入后此数据序列仍然有序,这个时候就要用到一种新的排序方法--插入排序法,插入排序的基本操作就是将一个数据插入到已经 ...
- 八大排序（一）：四种简单的排序（直接插入排序、希尔排序、冒泡排序、选择排序）
源码地址: https://github.com/TimePickerWang/aimed-at-offer/blob/master/java%E6%BA%90%E7%A0%81/Sort.java ...
- [ 数据结构 -- 手撕排序算法第三篇 ] 希尔排序
手撕排序算法系列之:希尔排序. 从本篇文章开始,我会介绍并分析常见的几种排序,大致包括插入排序,冒泡排序,希尔排序,选择排序,堆排序,快速排序,归并排序等. 大家可以点击此链接阅读其他排序算法:排序算 ...
- 图解排序算法之3种简单排序(选择，冒泡，直接插入)
排序是数据处理中十分常见且核心的操作,虽说实际项目开发中很小几率会需要我们手动实现,毕竟每种语言的类库中都有n多种关于排序算法的实现.但是了解这些精妙的思想对我们还是大有裨益的.本文简单温习下最基础的 ...
- 数据结构与算法 | 直接插入排序、希尔排序
前几章讲了选择排序中的直直接选择排序.双向选择排序.堆排序,这次来讲讲利用'插入'为核心来实现的插入排序算法. 插入排序 把待排序的记录按其关键码值的大小逐个插入到一 个已经排好序的有序序列中,直到所 ...
- java冒泡遍历对象_Java经典排序算法（冒泡、选择、插入）
排序算法说明 排序说明 对一序列对象根据某个关键字进行排序. 术语说明 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面: 不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b ...
最新文章
- 微信链接非80端口问题解决方案(伪处理)
- linux c 线程属性 pthread_attr_t 简介
- android 切换排列,在运行时重新排序android线性布局？
- 为什么安装了Microsoft .NET Framework 4之后我的电脑网卡启动会变得很慢很慢。。...
- 混凝土地坪机器人_地面整平机器人：精准又高效，轻松摆“平”混凝土
- java 消息队列_消息队列-RabbitMQ在JAVA中的应用（1）
- PMP课程笔记：第6章 项目进度管理
- 西门子博图安装期间反复重启的问题处理
- Rabbitmq二进制集群搭建
- 证明指数函数的导数(a^x)`=a^xlna
- ctfshow-Crypto-新生赛
- Win系统 - 局域网内电脑文件共享
- 世界观 - 经验事实和哲学性/概念性事实
- linux网络编程面试题
- JavaScript基础知识总结 18：dom基本操作
- “第三只眼”修炼手册
- 2023年国家留学基金委（CSC）有关国别申请、派出注意事项
- 纯css变换图片颜色png
- 台式计算机突然连接不到网络,电脑突然网络感叹号导致不能上网的解决方法
- 大snbsp;汪小菲nbsp;闪婚