数据结构 排序算法总结

排序算法分类

性能比较

插入排序

从数组开头开始一次选择元素，把该元素和位于该元素之前的所有元素比较大小并插入到合适的地方，并把插入的地方之后的元素依次往后移动
第一层循环：遍历待比较的所有数组元素
第二层循环：将本轮选择的元素(selected)与已经排好序的元素(ordered)相比较。
如果：selected > ordered，那么将二者交换,并把交换位置之后的元素往后移

void InserSort(int array[], int len) {
	int i, j, temp;
	for (i = 0; i < len; i++) {
		temp = array[i];
		for (j = i - 1; j >= 0; j--)
		{
			if (array[j] > temp) {
				array[j + 1] = array[j];
			}
			else {
				break;
			}
		}
		array[j + 1] = temp;
	}

}

希尔排序

希尔排序相当于存在一个’gap’的插入排序，gap表示整个数组被分为gap的初始值为数组长度的一半并且折半递减。把插入排序第二层循环中的j–替换为j-gap即可
第一层循环：将gap依次折半，对序列进行分组，直到gap=1
第二、三层循环：也即直接插入排序所需要的两次循环。

void ShellSort(int array[], int len) {
	int i, j, gap, temp;
	for (gap = len / 2; gap > 0; gap = gap / 2) {
		for (i = gap; i < len; i+=gap) {
			temp = array[i];
			for (j = i - gap; j >= 0; j = j - gap) {
				if (array[j] > temp) {
					array[j+gap] = array[j];
				}
				else {
					break;
				}
			}
			array[j + gap] = temp;
		}
	}
}

选择排序

选择排序和堆排序都用的是下标，注意选择排序外层循环的i<len-1，这是因为内层的为j=i
+1不能超过len，其他算法涉及到内存循环j=i+1的也要注意到这个问题
从数组的开头开始找到最小元素的下标，然后交换最小元素和数组前端有序段最后元素
第一层循环：遍历待比较的所有数组元素
第二层循环，从待排序序列中，找到关键字最小的元素；如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；
从余下的 N - 1 个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束。

void SelectSort(int array[], int len) {
	int i, j, min,temp;
	for (i = 0; i < len-1; i++) {
		min = i;
		for (j = i + 1; j < len; j++) {
			if(array[j] < array[min]){
				min = j;
			}
		}
		temp = array[i];
		array[i] = array[min];
		array[min] = temp;
	}
}

堆排序

大顶堆的性质反映在数组中为：
根结点大于左孩子arr[i] >= arr[2i+1] && 根结点大于右孩子arr[i] >= arr[2i+2] ，利用此点可以写出大顶堆对结点pos的位置调整对应在数组中应该是将array[pos]和array[2pos+1] ，array[2pos+2]

大顶堆的最大元素为堆顶，对应在数组中是array[0]

调整大顶堆或生成大顶堆的顺序为自右向左，自下向上的调整非叶子结点。在数组中array[len/2-1]对应的是堆中最右最下的非叶子结点，所以需要从array[len/2-1]开始依次往数组前端调整

堆排序步骤：
1.将待排序数组生成大顶堆,即将原数组从 array[len/2-1]开始往前调整生成大顶堆
2.生成大顶堆的最大元素对应数组的array[0],交换array[0]和array[len-1]，此时array(0:len-2)为新的无序堆
3.将array(0:len-2)生成新的大顶堆，并重复2,3步骤

void swap(int *a, int *b) {
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}
void AdjustMaxHeap(int array[], int pos, int len) {
	int left_child = 2 * pos + 1;
	int right_child = 2 * pos + 2;
	int max_pos = pos;
	if (left_child<len&&array[left_child]>array[max_pos]) { max_pos = left_child; }
	if (right_child<len&&array[right_child]>array[max_pos]) { max_pos = right_child; }
	swap(array[max_pos], array[pos]);
}
void HeapSort(int array[], int len) {
	//构建大根堆
	for (int i = len / 2 - 1; i >= 0; i--) {
		AdjustMaxHeap(array, i, len);
	}
	//调整大根堆
	for (int j = len - 1; j > 0; j--) {
		swap(array[0], array[j]);
		AdjustMaxHeap(array, j/2-1, j);
	}
}

void swap(int *a, int *b) {
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}
void AdjustMaxHeap(int array[], int pos, int len) {
	int left_child = 2 * pos + 1;
	int right_child = 2 * pos + 2;
	int max_pos = pos;
	if (left_child<len&&array[left_child]>array[max_pos]) { max_pos = left_child; }
	if (right_child<len&&array[right_child]>array[max_pos]) { max_pos = right_child; }
	if (max_pos != pos) {
		swap(array[max_pos], array[pos]);
		AdjustMaxHeap(array, max_pos, len);
	}
}
void HeapSort(int array[], int len) {
	//构建大根堆
	for (int i = len / 2 - 1; i >= 0; i--) {
		AdjustMaxHeap(array, i, len);
	}
	//调整大根堆
	for (int j = len - 1; j >0; j--) {
		swap(array[0], array[j]);
		AdjustMaxHeap(array, 0, j);
	}
}

冒泡排序

从数组首位开始，若遇到前者元素比后者元素大则交换二者位置，这样循环一轮下来最后的元素肯定是最大的
1.第一层循环用于控制冒泡次数为len
2.第二层循环用于将最大的元素放置数组末

void BubbleSort(int array[], int len) {
	int i, j, temp;
	for (i = 0; i < len; i++) {
		for (j = 0; j < len - i-1; j++) {
			if (array[j] > array[j + 1]) {
				temp = array[j + 1];
				array[j + 1] = array[j];
				array[j] = temp;
			}
		}
	}
}

快速排序

1.想象数组最左和最右有left和right两个哨兵，两个哨兵分别从两端往中间移动(对应i++和j–)，并把数组首元素array[0]作为参考值,碰到的第一个array[i]>array[0]和第一个array[j]<array[0]，则交换array[i]和array[j]，如此直到i遇到j，此时再替换参考点array[0]和array[i],完成第一轮循环。注意，一定要哨兵j先行
1.第二轮分别从array[0]到array[i-1]及array[i+1]到array[len-1],采用递归的方式完成

void quickSort(int left, int right, int arr[])
{
	if (left >= right)
		return;
	int i, j, base, temp;
	i = left, j = right;
	base = arr[left];  //取最左边的数为基准数
	while (i < j)
	{
		while (arr[j] >= base && i < j)
			j--;
		while (arr[i] <= base && i < j)
			i++;
		if (i < j)
		{
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	//基准数归位
	arr[left] = arr[i];
	arr[i] = base;
	quickSort(left, i - 1, arr);//递归左边
	quickSort(i + 1, right, arr);//递归右边
}

JAVA版

public class Sort {
    private static int[] array = {5,0,8,7,2,1,6,4,9,3};

    public static void main(String[] args) {
      //  InserSort(array);
      //  ShellSort(array);
//        SelectSort(array);
       // HeapSort(array,array.length);
       // BubbleSort(array);
        QuickSort(0,array.length-1,array);
        for (int i = 0; i <array.length ; i++) {
            System.out.print(array[i]);
        }
    }

    public static void InserSort(int[] array){
        int i,j,temp;
        for(i=0;i<array.length;i++){
            temp=array[i];
            for(j=i-1;j>=0;j--){
                if(array[j]>temp){
                    array[j+1]=array[j];
                }
                else{
                    break;
                }
            }
            array[j+1]=temp;
        }
    }
    public static void ShellSort(int[] array){
        int i,j,temp,gap;
        for(gap=array.length/2;gap>0;gap=gap/2){
            for(i=gap;i<array.length;i+=gap){
                temp=array[i];
                for(j=i-gap;j>=0;j=j-gap){
                    if(array[j]>temp){
                        array[j+gap]=array[j];
                    }
                    else{
                        break;
                    }
                }
                array[j+gap]=temp;
            }
        }
    }

    public static void  SelectSort(int[] array){
        int i,j,min,temp;
        for(i=0;i<array.length-1;i++){
            min=i;
            for(j=i+1;j<array.length;j++){
                if(array[j]<array[min]){
                    min=j;
                }
            }
            temp=array[i];
            array[i]=array[min];
            array[min]=temp;
        }
    }
    public static void swap(int a[],int n,int m){
        int temp;
        temp=a[n];
        a[n]=a[m];
        a[m]=temp;
    }

    public static void AdjustMaxHeap(int array[],int pos,int len){
        int leftchild = 2*pos+1;
        int rightchild = 2*pos+2;
        int max_pos=pos;
        if((leftchild<len)&&(array[leftchild]>array[max_pos])){max_pos=leftchild;}
        if((rightchild<len)&&(array[rightchild]>array[max_pos])){max_pos=rightchild;}
        if(max_pos!=pos){
            swap(array,max_pos,pos);
            AdjustMaxHeap(array,max_pos,len);
        }
    }
    public static void HeapSort(int array[],int len){
        for(int i=len/2-1;i>=0;i--){
            AdjustMaxHeap(array,i,len);
        }

        for(int j =len-1;j>0;j--){
            swap(array,0,j);
            AdjustMaxHeap(array,0,j);
        }
    }

    public static void BubbleSort(int array[]){
        int i,j,temp;
        for (i = 0; i <array.length ; i++) {
            for(j=0;j<array.length-i-1;j++){
                if(array[j]>array[j+1]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }

        }
    }
    public static void QuickSort(int left,int right,int array[]){
        if(left>=right){
            return;
        }
        int i,j,base,temp;
        i=left;
        j=right;
        base=array[left];
        while (i<j){
            while(array[j]>=base&&i<j){
                j--;
            }
            while(array[i]<=base&&i<j){
                i++;
            }
            if(i<j){
                temp=array[i];
                array[i]=array[j];
                array[j]=temp;
            }
        }
        array[left] = array[i];
        array[i] = base;
        QuickSort(left,i-1,array);
        QuickSort(i+1,right,array);
    }
}