ZT 9种排序

9种排序

2012-09-19 14:58 66人阅读评论(0) 收藏编辑删除

algorithm fp file merge integer float

[cpp] view plain copy

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <time.h>
void Swap(float &x, float &y)
{
x = x + y;
y = x - y;
x = x - y;
}
void PrintData(int *pDataArray, int iDataNum)
{
for (int i = 0; i < iDataNum; i++)
printf("%d ", pDataArray[i]);
printf("\n");
fflush(stdout);
}
//交换data1和data2所指向的整形
void DataSwap(int* data1, int* data2)
{
int temp = *data1;
*data1 = *data2;
*data2 = temp;
}
/********************************************************
*函数名称：ShellInsert
*参数说明：pDataArray 无序数组；
* d 增量大小
* iDataNum为无序数据个数
*说明：希尔按增量d的插入排序
*********************************************************/
void ShellInsert(int* pDataArray, int d, int iDataNum)
{
for (int i = d; i < iDataNum; i += 1) //从第2个数据开始插入
{
int j = i - d;
int temp = pDataArray[i]; //记录要插入的数据
while (j >= 0 && pDataArray[j] > temp) //从后向前，找到比其小的数的位置
{
pDataArray[j+d] = pDataArray[j]; //向后挪动
j -= d;
}
if (j != i - d) //存在比其小的数
pDataArray[j+d] = temp;
}
}
/********************************************************
*函数名称：ShellSort
*参数说明：pDataArray 无序数组；
* iDataNum为无序数据个数
*说明：希尔排序
*********************************************************/
void ShellSort(int* pDataArray, int iDataNum)
{
int d = iDataNum / 2; //初始增量设为数组长度的一半
while(d >= 1)
{
ShellInsert(pDataArray, d, iDataNum);
d = d / 2; //每次增量变为上次的二分之一
}
}
/********************************************************
*函数名称：GetNumInPos
*参数说明：num 一个整形数据
* pos 表示要获得的整形的第pos位数据
*说明：找到num的从低到高的第pos位的数据
*********************************************************/
int GetNumInPos(int num,int pos)
{
int temp = 1;
for (int i = 0; i < pos - 1; i++)
temp *= 10;
return (num / temp) % 10;
}
/********************************************************
*函数名称：RadixSort
*参数说明：pDataArray 无序数组；
* iDataNum为无序数据个数
*说明：基数排序
*********************************************************/
#define RADIX_10 10 //整形排序
#define KEYNUM_31 10 //关键字个数，这里为整形位数
void RadixSort(int* pDataArray, int iDataNum)
{
int *radixArrays[RADIX_10]; //分别为0~9的序列空间
for (int i = 0; i < 10; i++)
{
radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));
radixArrays[i][0] = 0; //index为0处记录这组数据的个数
}
for (int pos = 1; pos <= KEYNUM_31; pos++) //从个位开始到31位
{
for (int i = 0; i < iDataNum; i++) //分配过程
{
int num = GetNumInPos(pDataArray[i], pos);
int index = ++radixArrays[num][0];
radixArrays[num][index] = pDataArray[i];
}
for (int i = 0, j =0; i < RADIX_10; i++) //收集
{
for (int k = 1; k <= radixArrays[i][0]; k++)
pDataArray[j++] = radixArrays[i][k];
radixArrays[i][0] = 0; //复位
}
}
}
/********************************************************
*函数名称：SlipDown
*参数说明：pDataArray 无序数组；
* iCurNode为堆中需要调整的节点
* iDataNum为数组长度
*函数返回：分割后的分割数位置
*函数说明：调整iCurNode处的节点，形成大顶堆
*********************************************************/
void SlipDown(int *pDataArray,int iCurNode,int iDataNum)
{
int temp = pDataArray[iCurNode]; //记录需要调整的节点值
for (int iNextNode = iCurNode*2; iNextNode <= iDataNum; iNextNode = iCurNode*2)
{
if (iNextNode + 1 <= iDataNum
&& pDataArray[iNextNode] < pDataArray[iNextNode + 1]) //寻找iCurNode子节点中的大者
iNextNode++;
if (pDataArray[iNextNode] > temp) //大的值上移
pDataArray[iCurNode] = pDataArray[iNextNode];
else //结束调整
break;
iCurNode = iNextNode; //更新需要调整的节点
}
pDataArray[iCurNode] = temp;
}
/********************************************************
*函数名称：HeapSort
*参数说明：pDataArray 无序数组；
* iDataNum为无序数据个数
*说明：堆排序
*********************************************************/
void HeapSort(int* pDataArray, int iDataNum)
{
pDataArray--; //让原先数组下标0对应1，便于堆中节点的访问
for (int i = iDataNum/2; i > 0; i--) //调整为大顶堆
SlipDown(pDataArray, i, iDataNum);
for (int i = iDataNum; i > 1; i--) //根据大顶堆进行排序
{
DataSwap(&pDataArray[i], &pDataArray[1]);
SlipDown(pDataArray, 1, i - 1);
}
}
/********************************************************
*函数名称：Split
*参数说明：pDataArray 无序数组；
* iBegin为pDataArray需要快速排序的起始位置
* iEnd为pDataArray需要快速排序的结束位置
*函数返回：分割后的分割数位置
*说明：以iBegin处的数值value作为分割数，
使其前半段小于value，后半段大于value
*********************************************************/
int Split(int *pDataArray,int iBegin,int iEnd)
{
int rIndex = rand() % (iEnd - iBegin + 1); //随机获得偏移位置
int pData = pDataArray[iBegin + rIndex]; //将iBegin+rIndex处的值作为划分值
while (iBegin < iEnd) //循环分割数组，使其前半段小于pData，后半段大于pData
{
while (iEnd > iBegin && pDataArray[iEnd] >= pData) //从后向前寻找小于pData的数据位置
iEnd--;
if (iEnd != iBegin)
{
pDataArray[iBegin] = pDataArray[iEnd]; //将小于pData数据存放到数组前方
iBegin++;
while (iBegin < iEnd && pDataArray[iBegin] <= pData)
iBegin++;
if (iBegin != iEnd)
{
pDataArray[iEnd] = pDataArray[iBegin]; //将大于pData数据存放到数组后方
iEnd--;
}
}
}
pDataArray[iEnd] = pData; //此时iBegin=iEnd，此处存储分割数据pData
return iEnd;
}
/********************************************************
*函数名称：QSort
*参数说明：pDataArray 无序数组；
* iBegin为pDataArray需要快速排序的起始位置
* iEnd为pDataArray需要快速排序的结束位置
*说明：快速排序递归函数
*********************************************************/
void QSort(int* pDataArray, int iBegin, int iEnd)
{
if (iBegin < iEnd)
{
int pos = Split(pDataArray, iBegin, iEnd); //获得分割后的位置
QSort(pDataArray, iBegin, pos - 1); //对分割后的前半段递归快排
QSort(pDataArray, pos + 1, iEnd); //对分割后的后半段递归快排
}
}
/********************************************************
*函数名称：QuickSort
*参数说明：pDataArray 无序数组；
* iDataNum为无序数据个数
*说明：快速排序
*********************************************************/
void QuickSort(int* pDataArray, int iDataNum)
{
QSort(pDataArray, 0, iDataNum - 1);
}
/********************************************************
*函数名称：Merge
*参数说明：pDataArray 无序数组；
* int *pTempArray 临时存储合并后的序列
* bIndex 需要合并的序列1的起始位置
* mIndex 需要合并的序列1的结束位置
并且作为序列2的起始位置
* eIndex 需要合并的序列2的结束位置
*说明：将数组中连续的两个子序列合并为一个有序序列
*********************************************************/
void Merge(int* pDataArray, int *pTempArray, int bIndex, int mIndex, int eIndex)
{
int mLength = eIndex - bIndex; //合并后的序列长度
int i = 0; //记录合并后序列插入数据的偏移
int j = bIndex; //记录子序列1插入数据的偏移
int k = mIndex; //记录子序列2掺入数据的偏移
while (j < mIndex && k < eIndex)
{
if (pDataArray[j] <= pDataArray[k])
{
pTempArray[i++] = pDataArray[j];
j++;
}
else
{
pTempArray[i++] = pDataArray[k];
k++;
}
}
if (j == mIndex) //说明序列1已经插入完毕
while (k < eIndex)
pTempArray[i++] = pDataArray[k++];
else //说明序列2已经插入完毕
while (j < mIndex)
pTempArray[i++] = pDataArray[j++];
for (i = 0; i < mLength; i++) //将合并后序列重新放入pDataArray
pDataArray[bIndex + i] = pTempArray[i];
}
/********************************************************
*函数名称：BottomUpMergeSort
*参数说明：pDataArray 无序数组；
* iDataNum为无序数据个数
*说明：自底向上的归并排序
*********************************************************/
void BottomUpMergeSort(int* pDataArray, int iDataNum)
{
int *pTempArray = (int *)malloc(sizeof(int) * iDataNum); //临时存放合并后的序列
int length = 1; //初始有序子序列长度为1
while (length < iDataNum)
{
int i = 0;
for (; i + 2*length < iDataNum; i += 2*length)
Merge(pDataArray, pTempArray, i, i + length, i + 2*length);
if (i + length < iDataNum)
Merge(pDataArray, pTempArray, i, i + length, iDataNum);
length *= 2; //有序子序列长度*2
}
free(pTempArray);
}
/********************************************************
*函数名称：RecursionMergeSort
*参数说明：pDataArray 无序数组；
* int *pTempArray 临时存放合并的序列
* iBegin为pDataArray需要归并排序的起始位置
* iEnd为pDataArray需要归并排序的结束位置
*说明：自顶向下的归并排序递归函数
*********************************************************/
void RecursionMergeSort(int* pDataArray, int *pTempArray, int iBegin, int iEnd)
{
if (iBegin < iEnd)
{
int middle = (iBegin + iEnd) / 2;
RecursionMergeSort(pDataArray, pTempArray, iBegin, middle); //前半段递归归并排序
RecursionMergeSort(pDataArray, pTempArray, middle + 1, iEnd); //后半段归并排序
Merge(pDataArray, pTempArray, iBegin, middle + 1, iEnd + 1); //合并前半段和后半段
}
}
/********************************************************
*函数名称：UpBottomMergeSort
*参数说明：pDataArray 无序数组；
* iDataNum为无序数据个数
*说明：自顶向下的归并排序
*********************************************************/
void UpBottomMergeSort(int* pDataArray, int iDataNum)
{
int *pTempArray = (int *)malloc(sizeof(int) * iDataNum); //临时存放合并后的序列
RecursionMergeSort(pDataArray, pTempArray, 0, iDataNum - 1);
free(pTempArray);
}
//查找数值iData在长度为iLen的pDataArray数组中的插入位置
int FindInsertIndex(int *pDataArray, int iLen, int iData)
{
int iBegin = 0;
int iEnd = iLen - 1;
int index = -1; //记录插入位置
while (iBegin <= iEnd)
{
index = (iBegin + iEnd) / 2;
if (pDataArray[index] > iData)
iEnd = index - 1;
else
iBegin = index + 1;
}
if (pDataArray[index] <= iData)
index++;
return index;
}
/********************************************************
*函数名称：BinaryInsertSort
*参数说明：pDataArray 无序数组；
* iDataNum为无序数据个数
*说明：二分查找插入排序
*********************************************************/
void BinaryInsertSort(int* pDataArray, int iDataNum)
{
for (int i = 1; i < iDataNum; i++) //从第2个数据开始插入
{
int index = FindInsertIndex(pDataArray, i, pDataArray[i]); //二分寻找插入的位置
if (i != index) //插入位置不为i，才挪动、插入
{
int j = i;
int temp = pDataArray[i];
while (j > index) //挪动位置
{
pDataArray[j] = pDataArray[j-1];
j--;
}
pDataArray[j] = temp; //插入
}
}
}
/********************************************************
*函数名称：InsertSort
*参数说明：pDataArray 无序数组；
* iDataNum为无序数据个数
*说明：插入排序（从前向后寻找）
*********************************************************/
void InsertSort(int* pDataArray, int iDataNum)
{
for (int i = 1; i < iDataNum; i++) //从第2个数据开始插入
{
int j = 0;
while (j < i && pDataArray[j] <= pDataArray[i]) //寻找插入的位置
j++;
if (j < i) //i位置之前，有比pDataArray[i]大的数，则进行挪动和插入
{
int k = i;
int temp = pDataArray[i];
while (k > j) //挪动位置
{
pDataArray[k] = pDataArray[k-1];
k--;
}
pDataArray[k] = temp; //插入
}
}
}
/********************************************************
*函数名称：InsertSort
*参数说明：pDataArray 无序数组；
* iDataNum为无序数据个数
*说明：插入排序（从后向前寻找）
*********************************************************/
void InsertSort1(int* pDataArray, int iDataNum)
{
for (int i = 1; i < iDataNum; i++) //从第2个数据开始插入
{
int j = i - 1;
int temp = pDataArray[i]; //记录要插入的数据
while (j >= 0 && pDataArray[j] > temp) //从后向前，找到比其小的数的位置
{
pDataArray[j+1] = pDataArray[j]; //向后挪动
j--;
}
if (j != i - 1) //存在比其小的数
pDataArray[j+1] = temp;
}
}
/********************************************************
*函数名称：SelectionSort
*参数说明：pDataArray 无序数组；
* iDataNum为无序数据个数
*说明：选择排序
*********************************************************/
void SelectionSort(int* pDataArray, int iDataNum)
{
for (int i = 0; i < iDataNum - 1; i++) //从第一个位置开始
{
int index = i;
for (int j = i + 1; j < iDataNum; j++) //寻找最小的数据索引
if (pDataArray[j] < pDataArray[index])
index = j;
if (index != i) //如果最小数位置变化则交换
DataSwap(&pDataArray[index], &pDataArray[i]);
}
}
/********************************************************
*函数名称：BubbleSort
*参数说明：pDataArray 无序数组；
* iDataNum为无序数据个数
*说明：冒泡排序
*********************************************************/
void BubbleSort(int* pDataArray, int iDataNum)
{
BOOL flag = FALSE; //记录是否存在交换
for (int i = 0; i < iDataNum - 1; i++) //走iDataNum-1趟
{
flag = FALSE;
for (int j = 0; j < iDataNum - i - 1; j++)
if (pDataArray[j] > pDataArray[j + 1])
{
flag = TRUE;
DataSwap(&pDataArray[j], &pDataArray[j + 1]);
}
if (!flag) //上一趟比较中不存在交换，则退出排序
break;
}
}
//测试序列是否有序
BOOL CheckOrder(int *pDataArray, int iDataNum)
{
for (int i = 0; i < iDataNum - 1; i++)
if (pDataArray[i] > pDataArray[i+1])
return FALSE;
return TRUE;
}
UINT64 time_fre; //时钟频率
UINT64 GetTimeM()
{
//获取当前时间
LARGE_INTEGER curCounter;
QueryPerformanceCounter(&curCounter);
return curCounter.QuadPart*1000/time_fre;
}
void BubbleSortTest(int *pDataArray,int length, FILE *fp)
{
//初始化数组
for (int i = 0; i < length; i++)
pDataArray[i] = rand()%100000;
UINT64 begin;
UINT64 end;
begin = GetTimeM();
BubbleSort(pDataArray, length);
end = GetTimeM();
fprintf(fp, " %d", int(end-begin));
if (!CheckOrder(pDataArray, length))
printf("BubbleSort algorithm failed!\n");
else
printf("BubbleSort algorithm succeed!\n");
}
void SelectSortTest(int *pDataArray,int length, FILE *fp)
{
//初始化数组
for (int i = 0; i < length; i++)
pDataArray[i] = rand()%100000;
UINT64 begin;
UINT64 end;
begin = GetTimeM();
SelectionSort(pDataArray, length);
end = GetTimeM();
fprintf(fp, " %d", int(end-begin));
if (!CheckOrder(pDataArray, length))
printf("SelectSort algorithm failed!\n");
else
printf("SelectSort algorithm succeed!\n");
}
void InsertSortTest(int *pDataArray,int length, FILE *fp)
{
//初始化数组
for (int i = 0; i < length; i++)
pDataArray[i] = rand()%100000;
UINT64 begin;
UINT64 end;
begin = GetTimeM();
InsertSort(pDataArray, length);
end = GetTimeM();
fprintf(fp, " %d", int(end-begin));
if (!CheckOrder(pDataArray, length))
printf("InsertSort algorithm failed!\n");
else
printf("InsertSort algorithm succeed!\n");
}
void BottomUpMergeSortTest(int *pDataArray,int length, FILE *fp)
{
//初始化数组
for (int i = 0; i < length; i++)
pDataArray[i] = rand()%100000;
UINT64 begin;
UINT64 end;
begin = GetTimeM();
BottomUpMergeSort(pDataArray, length);
end = GetTimeM();
fprintf(fp, " %d", int(end-begin));
if (!CheckOrder(pDataArray, length))
printf("BottomUpMergeSort algorithm failed!\n");
else
printf("BottomUpMergeSort algorithm succeed!\n");
}
void UpBottomMergeSortTest(int *pDataArray,int length, FILE *fp)
{
//初始化数组
for (int i = 0; i < length; i++)
pDataArray[i] = rand()%100000;
UINT64 begin;
UINT64 end;
begin = GetTimeM();
UpBottomMergeSort(pDataArray, length);
end = GetTimeM();
fprintf(fp, " %d", int(end-begin));
if (!CheckOrder(pDataArray, length))
printf("UpBottomMergeSort algorithm failed!\n");
else
printf("UpBottomMergeSort algorithm succeed!\n");
}
void QuickSortTest(int *pDataArray,int length, FILE *fp)
{
//初始化数组
for (int i = 0; i < length; i++)
pDataArray[i] = rand()%100000;
UINT64 begin;
UINT64 end;
begin = GetTimeM();
QuickSort(pDataArray, length);
end = GetTimeM();
fprintf(fp, " %d", int(end-begin));
if (!CheckOrder(pDataArray, length))
printf("QuickSort algorithm failed!\n");
else
printf("QuickSort algorithm succeed!\n");
}
void HeapSortTest(int *pDataArray,int length, FILE *fp)
{
//初始化数组
for (int i = 0; i < length; i++)
pDataArray[i] = rand()%100000;
UINT64 begin;
UINT64 end;
begin = GetTimeM();
HeapSort(pDataArray, length);
end = GetTimeM();
fprintf(fp, " %d", int(end-begin));
if (!CheckOrder(pDataArray, length))
printf("HeapSort algorithm failed!\n");
else
printf("HeapSort algorithm succeed!\n");
}
void RadixSortTest(int *pDataArray,int length, FILE *fp)
{
//初始化数组
for (int i = 0; i < length; i++)
pDataArray[i] = rand()%100000;
UINT64 begin;
UINT64 end;
begin = GetTimeM();
RadixSort(pDataArray, length);
end = GetTimeM();
fprintf(fp, " %d", int(end-begin));
if (!CheckOrder(pDataArray, length))
printf("RadixSort algorithm failed!\n");
else
printf("RadixSort algorithm succeed!\n");
}
void ShellSortTest(int *pDataArray,int length, FILE *fp)
{
//初始化数组
for (int i = 0; i < length; i++)
pDataArray[i] = rand()%100000;
UINT64 begin;
UINT64 end;
begin = GetTimeM();
ShellSort(pDataArray, length);
end = GetTimeM();
fprintf(fp, " %d", int(end-begin));
if (!CheckOrder(pDataArray, length))
printf("ShellSort algorithm failed!\n");
else
printf("ShellSort algorithm succeed!\n");
}
int main()
{
#define ARRAYLENGTH 10000 //无序数组初始长度
#define ADDLENGTH 10000 //无序数组增幅
#define MAXLENGTH 100000 //最大无序数组长度
int length;
srand(time(NULL));
//获取时钟频率
LARGE_INTEGER litmp;
QueryPerformanceFrequency(&litmp);
time_fre = (UINT64 )litmp.QuadPart;
int *pDataArray = new int[MAXLENGTH];
FILE *fp = fopen("data.txt", "w"); //将结果存储与data.txt文件中;
//每一行代表一种排序在不同数据规模下的时间（毫秒）
length = ARRAYLENGTH;
for (; length <= MAXLENGTH; length += ADDLENGTH)
{
BubbleSortTest(pDataArray, length, fp);
}
fprintf(fp, "\n");
length = ARRAYLENGTH;
for (; length <= MAXLENGTH; length += ADDLENGTH)
{
SelectSortTest(pDataArray, length, fp);
}
fprintf(fp, "\n");
length = ARRAYLENGTH;
for (; length <= MAXLENGTH; length += ADDLENGTH)
{
InsertSortTest(pDataArray, length, fp);
}
fprintf(fp, "\n");
length = ARRAYLENGTH;
for (; length <= MAXLENGTH; length += ADDLENGTH)
{
BottomUpMergeSortTest(pDataArray, length, fp);
}
fprintf(fp, "\n");
length = ARRAYLENGTH;
for (; length <= MAXLENGTH; length += ADDLENGTH)
{
UpBottomMergeSortTest(pDataArray, length, fp);
}
fprintf(fp, "\n");
length = ARRAYLENGTH;
for (; length <= MAXLENGTH; length += ADDLENGTH)
{
QuickSortTest(pDataArray, length, fp);
}
fprintf(fp, "\n");
length = ARRAYLENGTH;
for (; length <= MAXLENGTH; length += ADDLENGTH)
{
HeapSortTest(pDataArray, length, fp);
}
fprintf(fp, "\n");
length = ARRAYLENGTH;
for (; length <= MAXLENGTH; length += ADDLENGTH)
{
RadixSortTest(pDataArray, length, fp);
}
fprintf(fp, "\n");
length = ARRAYLENGTH;
for (; length <= MAXLENGTH; length += ADDLENGTH)
{
ShellSortTest(pDataArray, length, fp);
}
fprintf(fp, "\n");
fclose(fp);
free(pDataArray);
return 0;
}

ZT 9种排序的更多相关文章

iOS可视化动态绘制八种排序过程
前面几篇博客都是关于排序的,在之前陆陆续续发布的博客中,我们先后介绍了冒泡排序.选择排序.插入排序.希尔排序.堆排序.归并排序以及快速排序.俗话说的好,做事儿要善始善终,本篇博客就算是对之前那几篇博客 ...
模板化的七种排序算法，适用于T* vector<T>以及list<T>
最近在写一些数据结构以及算法相关的代码,比如常用排序算法以及具有启发能力的智能算法.为了能够让写下的代码下次还能够被复用,直接将代码编写成类模板成员函数的方式,之所以没有将这种方式改成更方便的函数模板 ...
几种排序算法的学习，利用Python和C实现
之前学过的都忘了,也没好好做过总结,现在总结一下. 时间复杂度和空间复杂度的概念: 1.空间复杂度:是程序运行所以需要的额外消耗存储空间,一般的递归算法就要有o(n)的空间复杂度了,简单说就是递归集算 ...
ACM 一种排序
一种排序时间限制:3000 ms | 内存限制:65535 KB 难度:3 描述现在有很多长方形,每一个长方形都有一个编号,这个编号可以重复:还知道这个长方形的宽和长,编号.长.宽都是整数 ...
秒杀9种排序算法(JavaScript版)
一:你必须知道的 1> JS原型 2> 排序中的有序区和无序区 3> 二叉树的基本知识如果你不知道上面三个东西,还是去复习一下吧,否则,看下面的东西有点吃力. 二:封装丑陋的原型方 ...
nyoj 8 一种排序
一种排序时间限制:3000 ms | 内存限制:65535 KB 难度:3 描述现在有很多长方形,每一个长方形都有一个编号,这个编号可以重复:还知道这个长方形的宽和长,编号.长.宽都是整数 ...
JavaScript新手学习笔记3——三种排序方式（冒泡排序、插入排序、快速排序）
每种编程语言学到数组的时候,都会讲到排序算法,当时学C语言的时候,卡在排序算法.今天来总结一下javascript中如何实现三种排序算法. 1.冒泡排序(默认升序排列哦) 原理: 冒泡排序的原理,顾名 ...
java数组中的三种排序方法中的冒泡排序方法
我记得我大学学java的时候,怎么就是搞不明白这三种排序方法,也一直不会,现在我有发过来学习下这三种方法并记录下来. 首先说说冒泡排序方法:冒泡排序方法就是把数组中的每一个元素进行比较,如果第i个元素 ...
PHP的几种排序算法的比较
这里列出了几种PHP的排序算法的时间比较的结果,,希望对大家有所帮助 /* * php 四种排序算法的时间与内置的sort排序比较 * 3000个元素,四种算法的排序所用的时间比较 * 冒泡排序 85 ...

随机推荐

不会几个框架，都不好意思说搞过前端： Vue.js - 60分钟快速入门
Vue.js——60分钟快速入门 Vue.js是当下很火的一个JavaScript MVVM库,它是以数据驱动和组件化的思想构建的.相比于Angular.js,Vue.js提供了更加简洁.更易于理 ...
不停机不停服务，MYSQL可以这样修改亿级数据表结构
摘要:本文阐述了MySQL DDL 的问题现状.pt-online-schema-change的工作原理,并实际利用pt-online-schema-change工具在线修改生产环境下1.6亿级数 ...
【手记】解决VS2010宏功能报错
抱歉问题解决前没留截图,总之就是使用宏相关的功能都打不开,会弹窗报错,英文,大意是[一个或多个组件不存在,请尝试重装]. 尝试过: 修复安装VS2010 按此文照做:https://visualstu ...
JavaScript pop()函数弹出数组最后数据
改变数组中数据的另一种方法是用 .pop() 函数. .pop() 函数用来“抛出”一个数组末尾的值.我们可以把这个“抛出”的值赋给一个变量存储起来. 数组中任何类型的数据条目(数值,字符串,甚至是数 ...
MyEclipse中设置代码块快捷键
如果想用快捷键生成一段自定义代码,可以通过下面方式设置: Java->Editor->Templates->New 如果要设置或者更改某个快捷键,如要设置保存全部文档的快捷键(系统默 ...
oracle网页客户端工具
Oracle数据库的管理相较于其他数据库,是比较麻烦的,客户端工具的安装都要花一些时间,目前有一款treesoft软件,通过网页的方式管理Oracle. 功能包括:数据库的展示,库表的展示,表字段结构 ...
Java Web中涉及的编解码
用户从浏览器发起一个HTTP请求,存在编码的地方是URL.Cookie.Paramiter.服务器端接收到HTTP请求后要解析HTTP协议,其中URL.Cookie和POST表单参数要解码,服务器端可 ...
统计SQL Server所有表记录数
SELECT SCHEMA_NAME(t.schema_id) AS [schema] ,t.name AS tableName ,i.rows AS [rowCount] FROM sys.tabl ...
Https之SSL原理
一.HTTPS和SSL HTTP(Hyper TEXT Transfer Protocol超文本传输协议)是目前互联网上应用最为广泛的一种网络协议,用于在Web浏览器和网站服务器之间传递信息,但是HT ...
opencv3.2.0形态学滤波之形态学梯度、顶帽、黑帽
/*一.形态学梯度 (1)含义:是膨胀图和腐蚀图之差 (2)数学表达式:dst=morph-grad(src,element) =dilate(src,element) - erode(src,ele ...

ZT 9种排序

9种排序

ZT 9种排序的更多相关文章

随机推荐

热门专题