七种基本排序实现源码

最新推荐文章于 2022-09-21 20:51:27 发布
最新推荐文章于 2022-09-21 20:51:27 发布
阅读量2.9k 收藏 4
点赞数
分类专栏： 基础算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iicy266/article/details/11905851
版权
本文详细介绍了两种基本的排序算法——插入排序和希尔排序，并提供了相应的源代码实现。通过测试，展示了这两种算法在不同场景下的应用和效果。
摘要由CSDN通过智能技术生成

1.【插入排序】

void InsertSort(int* p ,int size)
{
	for(int i=1;i<size;i++)
	{
		int j	=	i;
		int t	= p[i];
		for(; j > 0 && p[j-1] > t; j--)
			p[j] = p[j-1];
		p[j] = t;
	}	
}

2.【选择排序】 

void SelectSort(int* arr,int size)
{
	for(int i=0;i<size;i++)
	{
		int psn=i;
		for(int j=i;j<size;j++)
		{
			if(arr[j]<arr[psn])
				psn = j;
		}	
		swap(arr[psn],arr[i]);
	}	
}

3.【冒泡排序】 

void BubbleSort(int* arr,int size)
{
	bool cg = true;		
	int  n	= 0;
	do
	{
		cg = false;	
		for (int i=0;i<size-1-n;i++)
		{
			if (arr[i]>arr[i+1])
			{
				cg = true;
				swap(arr[i],arr[i+1]);		
			}
		}	
		n++;
	} while (cg);
}

4.【快速排序】 

void QuickSort(int* arr,int size)
{
    int *L,*R;
    if(size <= 1) return;
    if(2 == size)
    {
       if(arr[0] > arr[1])
         swap(arr[0],arr[1]);
       return;
    } 
    L = &arr[1];
    R = &arr[size -1];
    while(L < R)
   {
      while(L<R && *L < *arr) ++L;
      while(R>arr && !(*R < *arr)) --R;
     if(L<R) swap(*R,*L);
   }
   swap(*R,*arr);
   QuickSort(arr, R-arr);
   QuickSort(R+1,size -1 -(R-arr));
}

5.【堆排序】 

void Shift(int* heap, int start, int end)
{
       int tmp = heap[start]; 
       int parent = start;
       int child = parent * 2 + 1; 
       while(child <= end)
     {
       if(child < end && 
	         heap[child] < heap[child+1])
                child++;

         if(tmp < heap[child])
        {
             heap[parent] = heap[child];
             parent = child;
             child = 2 * parent +1;
        } else  break;
     }
    heap[parent] = tmp;
}

void BuildHeap(int* heap,int size)
{
      for(int i=size/2-1; i >=0; i--)
         Shift(heap,i,size-1);

}

void HeapSort(int* heap,int size)
{
    BuildHeap(heap,size);
    for(int i = size-1; i>0; i--)
    {
          swap(heap[0],heap[i]);
          Shift(heap,0,i-1);
    }
}

6.【归并排序】 

void Merge(int* arr,int first,int mid,int last)
{
     int size = last -first + 1;
     int* tmp = new int[size];
     int   b1 = first;
     int   e1 = mid;
     int   b2 = mid + 1;
     int   e2 = last;
     int    k = 0;
     while(b1<=e1 && b2<=e2)
       if(arr[b1]<arr[b2])
          tmp[k++] = arr[b1++];
       else tmp[k++] = arr[b2++];
    
     while(b1<=e1)   tmp[k++]=arr[b1++];
     while(b2<=e2)   tmp[k++]=arr[b2++];
     for(int i=0; i<size; i++)
        arr[first + i] = tmp[i];
     delete tmp;   
}

void MergeSort(int* arr,int first,int last)
{
    if(first < last)
    {
       int  mid = (first +last) / 2;
       MergeSort(arr,first,mid);
       MergeSort(arr,mid+1,last);
       Merge(arr,first,mid,last);
    }
}


7.【希尔排序】

void ShellSort(int *p, int size)
{
   int iTemp;
   for( int iStep = size/2; iStep > 0; iStep = iStep/2 ) {
     for( int i = iStep; i < size; ++i ) {
	iTemp = p[i];
	int j = i;
	for( ; j >= iStep; j -= iStep ) {   
	  if( iTemp < p[j-iStep] ) {
	    p[j] = p[j-iStep];
	  } else {
            break;
          }
	}
	p[j] = iTemp;
      }
    }
}

【代码测试】 

#include<iostream>
#include<string>
using namespace std;

typedef void(*SortFunc)(int*, int, int*, int*);

// 插入排序
void InsertSort(int* p ,int size, int* move_cnt, int* compare_cnt)  
{  
    for(int i=1;i<size;i++)  
    {  
        int j   =   i;  
        int t   = p[i]; 
        ++*move_cnt; 
        ++*compare_cnt;
        for(; j > 0 && p[j-1] > t; j--) { 
            ++*compare_cnt;
            p[j] = p[j-1];  
            ++*move_cnt; 
        }
        p[j] = t;  
        ++*move_cnt; 
    }     
}  

// 希尔排序
void ShellSort(int *p, int size, int* move_cnt, int* compare_cnt)
{
	int iTemp;

	for( int iStep = size/2; iStep > 0; iStep = iStep/2 )
	{
		for( int i = iStep; i < size; ++i )
		{
             
			iTemp = p[i];
            ++*move_cnt;
			int j = i;
			for( ; j >= iStep; j -= iStep )
			{   
                ++*compare_cnt;
				if( iTemp < p[j-iStep] )
				{
					p[j] = p[j-iStep];
					++*move_cnt;
				}
				else
				{
					break;
				}
			}
			p[j] = iTemp;
			++*move_cnt;
		}
	}
}

// 冒泡排序
void BubbleSort(int* arr,int size, int* move_cnt, int* compare_cnt)  
{  
    bool cg = true;       
    int  n  = 0;  
    do  
    {  
        cg = false;   
        for (int i=0;i<size-1-n;i++)  
        {   
            ++*compare_cnt;
            if (arr[i]>arr[i+1])  
            {  
                cg = true;  
                swap(arr[i],arr[i+1]);     
                *move_cnt += 3;   
            }  
        }     
        n++;  
    } while (cg);  
}  

// 快速排序
void QuickSort(int* arr,int size, int* move_cnt, int* compare_cnt)  
{  
    int *L,*R;  
    if(size <= 1) return;  
    if(2 == size)  
    {  
       ++*compare_cnt;
       if(arr[0] > arr[1]) { 
         swap(arr[0],arr[1]);
         *move_cnt += 3; 
       }  
       return;  
    }   
    L = &arr[1];  
    R = &arr[size -1];  
    while(L < R)  
   {  
      ++*compare_cnt;
      while(L<R && *L < *arr) {
        ++*compare_cnt;
        ++L;
      }  
      ++*compare_cnt;
      while(R>arr && !(*R < *arr)) {
         ++*compare_cnt;
         --R; 
      } 
     ++*compare_cnt;
     if(L<R){
       swap(*R,*L);
       *move_cnt += 3; 
     }  
   }  
   swap(*R,*arr);  
   *move_cnt += 3; 
   QuickSort(arr, R-arr, move_cnt, compare_cnt);  
   QuickSort(R+1,size -1 -(R-arr), move_cnt, compare_cnt);  
}  

// 简单选择排序
void SelectSort(int* arr,int size, int* move_cnt, int* compare_cnt)  
{  
    for(int i=0;i<size;i++)  
    {  
        int psn=i;  
        for(int j=i;j<size;j++)  
        {    
            ++*compare_cnt;
            if(arr[j]<arr[psn]) {  
               psn = j;  
            }
        }     
        swap(arr[psn],arr[i]);  
        *move_cnt += 3; 
    }     
}  

void Shift(int* heap, int start, int end, int* move_cnt, int* compare_cnt)  
{  
       int tmp = heap[start];   
       ++*move_cnt;
       int parent = start;  
       int child = parent * 2 + 1;   
       while(child <= end)  
     {  
       ++*compare_cnt;
       if(child < end && heap[child] < heap[child+1]) { 
         ++child;  
       }
       ++*compare_cnt;
       if(tmp < heap[child])  
       {  
             heap[parent] = heap[child];  
             ++*move_cnt;
             parent = child;  
             child = 2 * parent +1;  
       } else  break;  
     }  
    heap[parent] = tmp;  
    ++*move_cnt;
}  
  
void BuildHeap(int* heap,int size, int* move_cnt, int* compare_cnt)  
{  
      for(int i=size/2-1; i >=0; i--)  
         Shift(heap,i,size-1, move_cnt, compare_cnt);  
  
}  
  
void HeapSort(int* heap, int size, int* move_cnt, int* compare_cnt)  
{  
    BuildHeap(heap, size, move_cnt, compare_cnt);  
    for(int i = size-1; i>0; i--)  
    {  
          swap(heap[0],heap[i]);  
          Shift(heap,0,i-1, move_cnt, compare_cnt);  
    }  
}  

void Merge(int* arr,int first,int mid,int last, int* move_cnt, int* compare_cnt)  
{  
     int size = last -first + 1;  
     int* tmp = new int[size];  
     int   b1 = first;  
     int   e1 = mid;  
     int   b2 = mid + 1;  
     int   e2 = last;  
     int    k = 0;  

     while(b1<=e1 && b2<=e2) { 
       ++*compare_cnt;
       if(arr[b1]<arr[b2])  
          tmp[k++] = arr[b1++];  
       else tmp[k++] = arr[b2++];  
       ++*move_cnt;
     }
     while(b1<=e1) {  
       tmp[k++]=arr[b1++];
       ++*move_cnt;  
       ++*compare_cnt;
     }
     while(b2<=e2) { 
       tmp[k++]=arr[b2++];
       ++*move_cnt;
       ++*compare_cnt;
     }  
     for(int i=0; i<size; i++)  { 
        arr[first + i] = tmp[i]; 
        ++*move_cnt;
     } 
     delete tmp;     
}  
  
void MergeSort(int* arr,int size, int* move_cnt, int* compare_cnt)  
{  
    if(size > 1)  
    {  
       int  mid = size / 2;  
       MergeSort(arr, mid, move_cnt, compare_cnt);  
       MergeSort(arr + mid, size - mid, move_cnt, compare_cnt);
       Merge(arr, 0, mid - 1, size -1, move_cnt, compare_cnt);  
    }  
}  

// 输出数组
void ShowArray(int * p, int size)
{
	for(int i = 0; i < size; i++)
	{
		cout<< p[i];
		if(i < size-1)
		{
			cout<< ", ";
		}
	}
	cout<< endl;
}

void CopyToTmp(int* arr, int* temp, int length) {
   	for( int i = 0; i < length; ++i )
	{
		temp[i] = arr[i];
		
	} 
}

int main()
{
	int arr[4][20] = { {-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100},
	               	   {100, 99, 96, 93,89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20},
		               {99, 75, -10, 87, 41,100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79},
	                   {0} };
    const string arr_name[3] = {"顺序的数组" ,"逆序的数组", "随机的数组"};
    
    SortFunc sort_functions[7] = {InsertSort, SelectSort, BubbleSort, QuickSort, ShellSort, HeapSort, MergeSort };
    const string sort_func_name[7] = {"插入排序", "选择排序", "冒泡排序", "快速排序", "希尔排序", "堆排序", "归并排序" };
    int compare_cnt = 0, move_cnt = 0;
    cout <<  "========================================================" << endl;
    for (int i = 0; i < 7; ++i) {
        cout << "         **** " << sort_func_name[i] << " ****" << "       测试结果如下：" << endl ;
        cout <<  "========================================================" << endl;
      for (int j = 0; j < 3; ++j) {
          compare_cnt = 0;
          move_cnt = 0;
          CopyToTmp(arr[j], arr[3], 20);
          cout << endl << arr_name[j] << "："; 
          ShowArray(arr[3], 20);
          sort_functions[i](arr[3], 20, &move_cnt, &compare_cnt);
          cout << sort_func_name[i] << "后: " ; 
          ShowArray(arr[3], 20);
          cout << sort_func_name[i] << "对" << arr_name[j] << "排序,共进行 " << compare_cnt << " 次比较 和 " << move_cnt << " 次移动" << endl; 
      }    
    cout << endl << "========================================================" << endl;
    } 
	system("pause");
	return 0;
}


【测试结果】

========================================================
         **** 插入排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
插入排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
插入排序对顺序的数组排序,共进行 19 次比较 和 38 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
插入排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
插入排序对逆序的数组排序,共进行 209 次比较 和 228 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
插入排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
插入排序对随机的数组排序,共进行 132 次比较 和 151 次移动


========================================================
         **** 选择排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
选择排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
选择排序对顺序的数组排序,共进行 210 次比较 和 60 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
选择排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
选择排序对逆序的数组排序,共进行 210 次比较 和 60 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
选择排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
选择排序对随机的数组排序,共进行 210 次比较 和 60 次移动


========================================================
         **** 冒泡排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
冒泡排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
冒泡排序对顺序的数组排序,共进行 19 次比较 和 0 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
冒泡排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
冒泡排序对逆序的数组排序,共进行 190 次比较 和 570 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
冒泡排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
冒泡排序对随机的数组排序,共进行 189 次比较 和 339 次移动


========================================================
         **** 快速排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
快速排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
快速排序对顺序的数组排序,共进行 244 次比较 和 54 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
快速排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
快速排序对逆序的数组排序,共进行 235 次比较 和 57 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
快速排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
快速排序对随机的数组排序,共进行 140 次比较 和 54 次移动


========================================================
         **** 希尔排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
希尔排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
希尔排序对顺序的数组排序,共进行 62 次比较 和 124 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
希尔排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
希尔排序对逆序的数组排序,共进行 80 次比较 和 160 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
希尔排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
希尔排序对随机的数组排序,共进行 88 次比较 和 163 次移动


========================================================
         **** 堆排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
堆排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
堆排序对顺序的数组排序,共进行 126 次比较 和 119 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
堆排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
堆排序对逆序的数组排序,共进行 108 次比较 和 101 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
堆排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
堆排序对随机的数组排序,共进行 118 次比较 和 108 次移动


========================================================
         **** 归并排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
归并排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
归并排序对顺序的数组排序,共进行 88 次比较 和 176 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
归并排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
归并排序对逆序的数组排序,共进行 88 次比较 和 176 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
归并排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
归并排序对随机的数组排序,共进行 88 次比较 和 176 次移动


            原创文章，转载请注明： 转载自 IIcyZhao’s Road

          本文链接地址：http://blog.csdn.net/iicy266/article/details/11905851


IIcyZhao
关注
专栏目录
七种常见的VB排序算法示例程序
12-31
七种常见的VB排序算法示例程序，有很好的参考意义，经实测。
几种排序算法的比较源码
07-30
包含几个最常用的排序算法的源码，以及其比较
七大排序总结（附源代码）
系统 运维
03-04 112
本文实现了冒泡排序，直接插入排序，直接选择排序，快速排序，堆排序，归并排序，希尔排序其中排序算法，并指出他们的时间复杂度以及稳定性情况。 #include&lt;stdio.h&gt; void swap(int* a, int* b) { int temp; temp = *a; *a = *b; *b = temp; } /* //冒泡排序：每次都将最大值放到要排的序列末尾 //...
排序算法代码实现
java_hanyu_tel的博客
03-07 177
package cn.hanyuweb.test;import java.util.Arrays;public class PaiXu { public static void main(String[] args) { int[] arr = { 7, 0, 33, 4, 7, 2, 6, 5, 33, 23, 2, 3, 8, 9, 1, 0, 4, 7, 2, 6, 5, 3, 8, 9,...
Web前端 快速排序 冒泡排序 数组去重 选择排序 防抖 节流
m0_72686628的博客
09-21 350
如果在定时器执行的过程中再次触发 定时器从头开始计时(把之前的定时器清除，重新定义一个)如果在定时器执行的过程中再次触发 事件状态是禁用的 当定时器完成之后 事件状态解开。if (timer) { //timer有定时器id 意味着定时器没有执行完。在一个事件中 添加一个延时定时器 延迟一定的时间再执行代码。在一个事件中 添加一个延时定时器 延迟一定的时间执行代码。闭包：可以访问其他函数内部变量的函数 函数套函数。//是无法拿到对应的下标。// 判断定时器有没有完成。// 不用的时候 手动回收。
c++实现快速排序源码.zip
10-31
4. **myQuickSort.h**：这个名字可能表示这是一个自定义版本的快速排序实现，可能包含了一些特定的优化或者改进。例如，可能会包含针对已排序或接近排序情况的优化，或者处理小数组的特殊策略。 5. **print.h**：这...
八种排序源码实现.zip
06-14
这个名为“八种排序源码实现.zip”的压缩包包含了一些经典的排序算法在C语言中的实现。让我们逐一探讨这八种排序算法及其原理。 1. 冒泡排序（Bubble Sort）： 冒泡排序是一种简单的排序方法，通过重复遍历待排序的...
MFC CList 链表 排序，源码实现，已验证，VC++
06-11
本篇文章将深入探讨如何使用源码实现`CList`的排序功能，并结合提供的`ClistSort.cpp`和`ClistSort.h`文件进行解析。 首先，我们需要了解`CList`的基本操作。`CList` 提供了插入、删除、遍历等方法，如`AddHead()`,...
冒泡排序，选择排序，插入排序，希尔排序，堆排序，归并排序，快速排序源码实现
10-26
以下是关于"冒泡排序，选择排序，插入排序，希尔排序，堆排序，归并排序，快速排序"这七种常见排序算法的源码实现及相关知识点的详细解释： 1. **冒泡排序**：冒泡排序是一种简单的排序算法，它重复地遍历待排序的...
选择排序实现源码
11-30
在本主题中，我们将深入探讨选择排序的两种实现方式：简单选择排序和堆排序。这两种算法虽然都被称为“选择排序”，但在实际操作上有所不同。 ### 简单选择排序 简单选择排序是由英国计算机科学家 Tony Hoare 在...
jquery表格自动排序插件
08-09
jquery表格自动排序插件，非常好用。
web开发js实现的表格排序功能
02-22
web开发js实现的表格排序功能，web开发js实现的表格排序功能，web开发js实现的表格排序功能
七大排序源代码
07-18
该文档包含了七大排序，冒泡，选择，插入，快排，希尔，归并和最小堆排序，绝对有用，对面试很有帮助
JavaWeb练习题（含答案）
热门推荐
zag666的博客
01-21 9万+
第1章网页开发基础 习题 一、填空题 1.HTML是英文【 】的缩写。 2.标记用于定义HTML文档所要显示的内容，也称为【 】。 3.在表格标记中用于设置是否显示边框的属性是【 】。 4.引入CSS的方式有4种，分别为【 】、行内式（也称为内联样式）、【 】和导入式。 5.W3C中将DOM标准分为3个不同的部分：【 】、【 】...
jQuery：在Web页面实现表格排序功能
gyxx1998的博客
04-21 1615
jQuery each() 方法 each() 方法为每个匹配元素规定要运行的函数。 语法: $(selector).each(function(index,element)) function(index,element) 必需。为每个匹配元素规定运行的函数。 index - 选择器的 index 位置。 element - 当前的元素（也可使用 "this" 选择器）。 Example1...
在Web页面中实现数据表格的排序功能(全部数据，非当前页)
RoxLiu的专栏
06-25 1万+
在数据分页以后，点击表头，希望数据能在后台排序（数据库order by排序），然后返回当前页。
spark_3_2_0-master-3.2.3-1.el7.noarch.rpm
最新发布
09-16
Ambari+Bigtop 一站式编译和部署解决方案 https://gitee.com/tt-bigdata/ambari-env
C语言实现8种经典排序算法详解及源码
本文档详细介绍了C语言中八种经典的排序算法，包括冒泡排序、希尔排序、插入排序、选择排序、堆排序、快速排序、归并排序...理解这些基本排序算法有助于深入理解数据结构和算法设计，为今后的编程工作打下坚实基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值