数据结构-排序算法

一：直接插入排序

1. 算法思想：把数组a[n]中待排序的n个元素看作一个有序表和一个无序表。
   （1）开始时有序表只包含一个元素a[0]，无序表中包含n-1个元素a[1]…a[n-1]；
   （2）排序过程中每次从无序表中退出第一个元素，把它插入有序表的适当位置，使之成为新的有序表，元素个数加1。
   （3）经过n-1次插入后，无序表变成空表，有序表包含了n个元素，排序完毕。

2. 排序示例：
   原始序列：（49，37，65，97，76，13，87）
   

3. 代码

   void InsertSort(DataList & L)
   {
   	DataType tmp;
   	int i,j;
   	for(i=0;i<L.n;i++){
   		if (L.data[i]<L.data[i-1])
   		{
   			tmp=L.data[i];
   			for(j=0;j>=0&&tmp<L.data[j];j--)
   				L.data[j+1]=L.data.[j];
   			L.data[j+1]=tmp;
   		}
   }
   

完整代码可参考： https://blog.csdn.net/qq_29542611/article/details/79348969

4. 时间复杂度：O(n^2)

选择排序

1. 算法思想：
   （1）设待排序元素序列有n个元素，第一趟排序从待排序序列中选择排序码最小的元素；
   （2）若它不是第一个元素，则与待排序序列的第一个元素交换；
   （3）第二趟从剩下的待排序序列中选取排序码最小的元素，重复以上步骤，总共通过n-1趟排序，排序完毕。

2. 排序示例：
   原始序列：（49，37，65，97，76，13，87）
   

3. 代码实现：

   void SelectSort(int *arr,int length)
   {
   	int i,j,k;
   	for(i=0;j<length;i++)
   	{
   		int tmp=arr[i];
   		k=i;
   		for(j=0;j<length;j++);
   		{
   			if(arr[j]<arr[k])
   			k=j;
   		}
   		if(k!=i)
   		{
   			arr[i]=arr[j];
   			arr[j]=tmp;
   			tmp=arr[i];
   		}
   	}
   		return ;
   }
   

4. 时间复杂度：O(n^2)；

快速排序

1. 算法思想：
   （1）首先选取基准数，这里取的是数组的第一个数；
   （2）设置索引low和high分别指向数组的首和尾的位置；
   （3）high–向前找小于基准数的数，找到后挖出这个数填到上一个坑k[low++]中；
   （4）low++向后找大于基准数的数，找到后挖出这个数填到上一个坑a[high–]中；
   （5）当low== high时循环结束，挖坑结束，将基准数填入坑a[low]中;
   （6）对low左右两边的区间分别重复执行以上步骤.

2. 排序示例：
   原始序列：（49，37，65，97，76，13，87）

3. 代码实现：

   template<typename T>
   int QSort(T k[], int low, int high) {
   if (low < high) {
       T temp = k[low];//以第一个元素为基准
       int l = low, r = high;
       while (low < high) {
           while (low < high && k[high] >= temp)
               high--;
           if (low < high)
               k[low++] = k[high];
   
           while (low < high && k[low] <= temp)
               low++;
           if (low < high)
               k[high--] = k[low];
       }
       k[low] = temp;
       QSort(k, l, low - 1);
       QSort(k, low + 1, r);
   }
   }  
   template<typename T>
   void QuickSort(T k[], int len) {
   QSort(k, 0, len - 1);
   }
   

4. 时间复杂度：O（nlogn）

冒泡排序

1. 算法思想：
   比较两两相邻的关键字，如果反序则进行交换，直到没有反序的为止。
   （1）比较相邻的元素。如果第一个比第二个大（小），就交换他们两个。
   （2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大（小）的数。
   （3）针对所有的元素重复以上的步骤，除了最后已经选出的元素（有序）。
   （4）持续每次对越来越少的元素（无序元素）重复上面的步骤，直到没有任何一对数字需要比较，则序列最终有序。。

2. 排序示例：
   原始序列：（49，37，65，97，76，13，87）
   

3. 代码实现：

   #include <iostream>
   using namespace std;
   
   void BubbleSortUp(int k[], int len) {
   	int i, j, temp, count1 = 0, count2 = 0;
   	for (i = 0; i < len - 1; i++) {
       	for (j = 0; j < len - 1 - i; j++) {
          		count1++;
           	if (k[j] > k[j + 1]) {
               	count2++;
               	temp = k[j + 1];
               	k[j + 1] = k[j];
               	k[j] = temp;
           	}
       	}
   	}
   	cout << "总共进行了" << count1 << "次比较， " << count2 << "次移动" << endl;
    	}
   
   int main() {
   	int i;
   	int arr[10] = {1, 3, 15, 2, 4, 17, 8, 6, 9, 0};
   	BubbleSortUp(arr, 10);
   	cout << "after sort: arr =  " << endl;
   	for (i = 0; i < 10; i++) {
       	cout << arr[i] << ' ';
   	}
   	cout << endl;
   
   	return 0;
   }
   

4. 时间复杂度：O（n^2）