冒泡排序和快速排序以及时间空间稳定分析

冒泡排序的结构：

   for (let i = 0; i < length - 1; i++) {
      for (let j = 0; j < length - i -1; j++) {
            if() 换序;
     }
  }

#include<stdio.h> //c语言版
#include<string.h>
#include<stdlib.h>
int main(){
	int a[]={11,31,10,6,9,7,3};
	for (int i = 0; i < 7 - 1; i++) {
      for (int j = 0; j < 7 - i -1; j++) {
		  if(a[j]>a[j+1]){int temp=a[j];a[j]=a[j+1];a[j+1]=temp;};
     }
  }
printf("%d",a[0]);return 0;
}

function bubbleSort(arr) {//冒泡排序：javascript版，带标志
  const length = arr.length;
  for (let i = 0; i < length - 1; i++) {
    let changeOccur = false; //用于标记某次外循环中，是否方式内循环交换事件
    for (let j = 0; j < length - i -1; j++) {
      if (arr[j] > arr[j+1]) {const temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}
    }
    if (!changeOccur) { break;}/*如果一次外循环中，没有发生一次内循环交换，那么可以直接结束排序比较*/
  }
}
var a=[11,102,33];bubbleSort(a);console.log(a)

快速排序是一次尽量改变多个逆序的(以支点为界进行交换) 递归的 对冒泡的(交换类的) 改进排序算法。

一般的程序步骤：
每次都选择a[0]位置的作为枢纽(比较对象)
low high两个指针分别从头向中间移动
因为要从小到大排序，所以当发现右小左大交换(先high 后low)

一趟排序示例

function quick_one_pass(arr) {
  var i=1;/*low*/ var j= arr.length-1;/*high*/
  arr[0]=arr[i];/*临时单元兼职哨兵*/

 while(i!=j)/*相遇时推出扫描*/
 {
 /*在j所指的位置向前搜索*/
 /*如果值大于或等于关键字则继续*/
 /*如果值小于关键字则停止，等待“交换”*/
while(arr[j]>=arr[0]&&(j>i)){j--;}                         console.log(a)
if(j>i){arr[i]=arr[j];i++;}/*arr[1]保存了“第一个”小于哨兵的*/console.log(a)
while(arr[i]<arr[0]&&(j>i)){i++;}
if(j>i){arr[j]=arr[i];j--;}/*赋值*/
 }
arr[i]=arr[0];
}
var a=[0,29,38,22,45,23,67,31];quick_one_pass(a);console.log(a)

整体代码

function quick_one_pass(arr,low,high) {
  var i=low;//low
  var j= high;//high
  arr[0]=arr[i];/*临时单元兼职哨兵*/

 while(i!=j)/*相遇时推出扫描*/
 {
 /*在j所指的位置向前搜索*/
 /*如果值大于或等于关键字则继续*/
 /*如果值小于关键字则停止，等待“交换”*/
while(arr[j]>=arr[0]&&(j>i)){j--;}
if(j>i){arr[i]=arr[j];i++;}/*arr[1]保存了“第一个”小于哨兵的*/
while(arr[i]<arr[0]&&(j>i)){i++;}
if(j>i){arr[j]=arr[i];j--;}/*赋值*/
 }
arr[i]=arr[0];
console.log(a);
return(i);
}

function quick_sort(a,low,high) {
   var k;
   if(low<high)
   {
    k=quick_one_pass(a,low,high);                          console.log(k);
    quick_sort(a,low,k-1);
    quick_sort(a,k+1,high);
   }
 }

var a=[0,29,38,22,45,23,67,31];
quick_sort(a,1,a.length-1);

一趟排序的过程与结果

排序结果：

整体排序的过程

分析：

$$\begin{gathered} 每次划分，都要经过划分长度-1次的比较才能得出下一次的划分 \\ 最好的情况：nlo{g}_{2}n执行了n次二分操作(比较\ast 划分) \\ 最坏的情况：划分不起作用n^2 \end{gathered}$$
当所划分的区域的长度为1时停止划分，所以当每次的划分比较均匀时，递归的系统栈的最大深度为$$lo{g}_{2}n+1,算法的空间复杂度为O（lo{g}_{2}n）$$
$$和希尔排序，堆排序一样，快速排序也是不稳定的$$

---------------------------------分割线：快排C语言--------------------------------------------

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct BiTNode{//二叉树节点
char data;
struct BiTNode *lc,*rc;
}BiTNode,*BiTree ;

int onepass(int arr[],int low,int high){
	
	arr[0]=arr[low];
	while(low!=high)
	{
		while(arr[high]>=arr[0]&&(high>low)){high--;}
		if(high>low){arr[low]=arr[high];low++;};/*小换大*/
		while(arr[low]<arr[0]&&(high>low)){low++;}
		if(high>low){arr[high]=arr[low];high--;};/*大换小*/
	}
	arr[low]=arr[0];return low;
}

void quickpass(int arr[],int low,int high){
	int k;
	if(high>low){
	k=onepass(arr,low,high);
	 quickpass(arr,low,k-1);
	 quickpass(arr,k+1,high);
	}
}

int main(){
	int a[]={0,29,38,22,45,23,67,31};quickpass(a,1,7);printf("%d",a[1]);return 0;
}