数据结构与算法之三 深入学习排序

Posted 2020-07-23 tea_year

在本章中，你将学习：

通过使用快速排序来排序数据

通过使用归并排序来排序数据

快速排序算法：

快速排序是最有效率的排序算法之一，此算法基于分治法

连续将问题细分为更小的问题，直到问题成为可以直接解决的小问题

在快速排序算法中，你：

从名为枢轴的列表处选择元素。

将列表划分为两部分：

列表左端的所有元素小于等于枢轴。

列表右端的所有元素大于枢轴。

在此列表两部分的正确位置存储枢轴。

划分之后为创建的两个子列表重复此过程(找枢轴的过程)。

直到每个子列表中只剩一个元素。

思想：就是不断找出符合条件的枢轴位置

编写一个算法以实现快速排序：

QuickSort(low,high)

1. 如果 (low > high):

  a.  返回

2. 设置 pivot = arr[low]

3. 设置 i = low + 1

4. 设置 j = high

5. 重复第 6步直到 i > high 或 arr[i] > pivot // 搜索大于枢轴的元素

6. 按1递增 i

7. 重复第 8步直到 j < low 或 arr[j] < pivot // 搜索小于枢轴的元素

      8. 按1递减 j

9. 如果 i < j: //如果较大的元素位于较小元素的左侧

  a.  交换 arr[i] 与 arr[j]

10. 如果 i <= j:

  a.  转到第 5步// 继续搜索

11. 如果low < j:

  a.  交换 arr[low] 与 arr[j]//交换枢轴与列表第一部分的最后一个元素

12. QuickSort(low,J – 1) //对枢轴左侧的列表应用快速排序

13. QuickSort(J + 1, high) //对枢轴右侧的列表应用快速排序

此排序算法的总时间取决于枢轴值的位置。

最糟的情形出现在列表已经排序时。

通常，选择第一个元素作为枢轴，但是其会导致O(n2)的最糟用例效率。

如果您选择所有值的中间值作为枢轴，则效率将是O(n log n)。

什么是快速排序算法的平均用例的比较总次数。

答案：

O(n log n)

归并排序算法：

其使用分治法来排序列表

要排序的列表将分为两个几乎相等的两个子列表

这两个子列表将通过使用归并排序单独排序

这两个排序的子列表归并为单个排序的列表

编写一个算法以实现归并排序：

MergeSort(low,high)

1. 如果 (low >= high):

  a.  返回调用本函数的地方.

2. 设置 mid = (low + high)/2

3. 将列表划分为几乎完全相等的两个子列表，并通过使用归并排序来排序每个子列表。执行的步骤如下：:

    a. MergeSort （low, mid）

  b. MergeSort（mid + 1, high）

4. 归并两个排序的子列表：通过一merge()方法实现.

  a. 设置 i = low 

    b. 设置 j = mid + 1

  c. 设置k = low

  d. 重复直到 i > mid 或 j > high: //  此循环将终止，前提是达到两个子列表的其中一个结束处。 

 

  i.如果 (arr[I] <= arr[J])

     将arr[I] 存储到数组B中的索引k处

        按1递增i

   Else

将arr[j] 存储到数组B中的索引k处

按1递增j

     ii. 按1递增k

  e. 重复直到j > high: //如果第二个中仍然有某些元素                                                                      // 追加到新列表的子列表

  i. 将arr[j] 存储到数组B中的索引k处

  ii. 按1递增j

  iii. 按1递增k

  f. 重复直到i > mid:  //如果在第一个子列表中仍然有一些元素

                                            // 将它们追加到新类别中

  i. 将arr[i] 存储到数组B中的索引k处

  ii.按1递增i

  iii. 按1递增k

5. 将排序的数组B中的所有元素复制到原始数组arr中

若要排序此列表，您需要按递归方式将列表划分为两个几乎完全相等的子列表，直到每个子列表仅包含一个元素。

 将列表划分为大小为1的子列表需要log n 次通行。

在每个通行中，最多执行n次比较。

 因此，比较总数将是最多n × log n次。

归并排序的效率等于O(n log n)。

归并列表的最佳、平均和最糟用例效率之间没有差异，因为所有这些效率均需要相同的时间量。

哪个算法使用以下步骤来排序给出的元素列表？

      1.    选择名为枢轴的列表中的元素。

      2. 将列表分为两个部分，以便一部分包含小于枢轴的元素，另一部分包含大于枢轴的元素。

      3. 然后将枢轴放到两个列表之间的正确位置。

      4. 使用相同的算法排序列表的两个部分。

答案：

快速排序

小结

在本章中，你已经学到：

快速排序和归并排序算法基于分治技巧。

若要通过使用快速排序算法来排序项目列表，您需要：

选择枢轴值。

将列表分为两个子列表，以便一个子列表包含了所有小于枢轴的项，另一个子列表包含了大于枢轴的所有项。

然后将枢轴放到两个子列表之间的正确位置。

通过使用快速排序来排序两个子列表。

快速排序算法采用的总时间取决于枢轴值的位置和最初的元素分阶。

快速排序算法的最差效率是O(n2)阶的。

快速排序算法的最佳效率是O(n log n)阶的。

若要通过使用归并排序来排序项目列表，您需要：

将列表分为两个子列表。

通过使用归并排序来排序每个子列表。

归并两个排序的子列表。

归并排序算法具有O(n log n)的效率。

/*
问题描述：编写在数组中存储10个数字的程序，并通过使用快速排序算法来排序。
*/
using System;
using System.Text;

class Merge_Sort
{
	private int[]arr=new int[20];	//定义数组，你输入数字，接受存储的数组
	private int[]dest=new int[20];	//在归并排序中用来存储已经排序的数组，就是咱说的新数组.
	private int cmp_count;	//比较总次数
	private int mov_count;	//移动总次数
	//数组元素个数
	public int n;
	//****************构造方法
	public Merge_Sort()
	{
		cmp_count=0;
		mov_count=0;	
	}	
	//用户输入数据方法
	void read()
	{
		while(true)
		{
			Console.WriteLine("请输入数组的元素个数:");
			string s=Console.ReadLine();
			n=Int32.Parse(s);
			if(n<=20)
				break;
			else
				Console.WriteLine("\n数组的最大元素个数为20.\n");	
		}
		Console.WriteLine("\n---------------------------------");
		Console.WriteLine("-----------请输入数组元素---------");
		Console.WriteLine("---------------------------------");
		//获得数组元素
		for(int i=0;i<n;i++)
		{
			Console.Write("<"+(i+1)+">");
			string s=Console.ReadLine();
			arr[i]=Int32.Parse(s);	
		}
	}
	//交换两个数组索引的方法
	void swap(int x,int y)
	{
		int temp;
		
		temp=arr[x];
		arr[x]=arr[y];
		arr[y]=temp;	
	}
	/**************归并排序算法****************/
	public void m_sort(int low,int high)
	{
		if(low>=high)
			return;
		else
		{
			int mid=(low+high)/2;
			m_sort(low,mid);
			m_sort(mid+1,high);
			merge(low,mid,high);
		}
	}
	public void merge(int low,int mid,int high)
	{
			int i=low;
			int j=mid+1;
			int k=low;
			while((i<=mid)&&(j<=high))
			{
				if(arr[i]<=arr[j])
					{
						dest[k]=arr[i];
						k++;
						i++;
					}	
				else
				{
					dest[k]=arr[j];
					k++;
					j++;	
				}
			}
			while(j<=high)
			{
					dest[k]=arr[j];
					k++;
					j++;		
			}
			while(i<=mid)
			{
				dest[k]=arr[i];
				k++;
				i++;
					
			}
			//Array.Copy(dest,arr,arr.Length);
			for(i=low;i<=high;i++)
			{
				arr[i]=dest[i];	
			}
	}
	//显示方法
	void display()
	{
		Console.WriteLine("\n------------------------------------");	
		Console.WriteLine("---------已经排序后的数组元素为------");	
		Console.WriteLine("------------------------------------");	
		
		for(int j=0;j<=n;j++)
		{
			Console.Write(arr[j]+" ");	
			//Console.Write(dest[j]+" ");
		}
		//Console.WriteLine("\n比较的总次数为："+cmp_count);
		//Console.WriteLine("\n移动的总次数为:"+mov_count);
	}
	int getSize()
	{
		return (n);	
	}
	public static void Main(string[]args)
	{
		Merge_Sort mySort=new Merge_Sort();
		mySort.read();
		mySort.m_sort(0,mySort.n-1);
		mySort.display();
		
		Console.WriteLine("\n\n按任意键退出.");
		Console.Read();
	}
}