记录一下数据结构的习题

求1到n(n>=1)的和

public int GetSum(int n)
{
    if (n == 1) return 1;
    else
    {
        return n + GetSum(n - 1);
    }
}

求n(n>=1)的阶乘

public int GetFactorial(int n)
{
    if(n == 1) return 1;
    else
    {
        return n * GetFactorial(n - 1);
    }
}

直接插入排序

• 直接插入排序在第 i 趟后，前i+1个数应该是有序的
• 在待排序列基本有序的情况下，效率最高的排序方法是插入排序

void InsertSort(int A[], int n) {
	int i, j, temp;
	for (i = 0; i < n; i++)
	{
		if (A[i] < A[i - 1]) {
			temp = A[i];
			for (j = i - 1; j >= 0 && A[j] > temp; j--)
			{
				A[j + 1] = A[j];
			}
			A[j + 1] = temp;
		}
	}
}

冒泡排序

• 冒泡排序交换的次数=序列中的逆序数
• 每次排序后都能找到一个最值放到其最终位置上

void BubbleSort(int A[], int n) {
	bool flag;
	for (int i = 0; i < n-1; i++)
	{
		flag = false;
		for (int j = n-1; j > i; j--)
		{
			if (A[j-1]>A[j])
			{
				Swap(A[j - 1], A[j]); // Swap是交换元素的函数
				flag = true;
			}
		}
	}
}

或者用这种方式：
void BubbleSort(int[] A,int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n- i - 1; j++)
        {
            if (A[j] > A[j+1])
            {
                int temp = A[j];
                A[j] = A[j+1];
                A[j+1] = temp;
            }
        }
    }
}

快速排序

• 基于划分，最优秀的内部排序算法
• 若初始时，序列已经大致有序，则快排的性能最差
• 每次枢轴量都能把序列等分成两个子序列时，性能最佳

void QuickSort(int A[], int low, int high) {
	if (low < high)
	{
		int pivotPos = Partition(A, low, high);
		QuickSort(A, low, pivotPos - 1);
		QuickSort(A, pivotPos + 1, high);
	}
}

int Partition(int A[], int low, int high) {
	int pivot = A[low];
	while (low<high)
	{
		while (low < high && A[high] >= pivot) --high;
		A[low] = A[high];
		while (low < high && A[high] <= pivot) ++low;
		A[high] = A[low];
	}
	A[low] = pivot;
	return low;
}

选择排序

• 每趟排序可以确定一个元素的最终位置
• 对n个元素的序列，始终都要进行n-1趟的排序

void SelectSort(int A[], int n) {
	int min;
	for (int i = 0; i < n; i++)
	{
		min = i;
		for (int j = 0; j < n; j++)
		{
			if (A[j] < A[min]) min = j;
		}
		if (min != i) Swap(A[i], A[min]);
	}
}

求二叉树的高度

typedef struct BTNode {
	struct BTNode* lchild, * rchild;
	int data;
}BTNode;
int GetDepth(BTNode* bt) {
	int left, right;
	if (bt == null) return 0;
	else
	{
		left = GetDepth(bt->lchild);
		right = GetDepth(bt->rchild);
		return left > right ? left + 1 : right + 1;
	}
}