面试算法题

数组奇偶数分离

/// <summary>
/// 奇偶分离
/// </summary>
void JiOuFenLi(int[] data)
{
	if (data == null) return;

	int left = 0;
	int right = data.Length - 1;

	while (left < right)
	{
		while (data[left] % 2 != 0 && left < right)
			left++;

		while (data[right] % 2 == 0 && left < right)
			right--;

		int temp = data[left];
		data[left] = data[right];
		data[right] = temp;
	}
}

---

求费波切纳数

int[] data = new int[100];
/// <summary>
/// 求费波切纳数
/// </summary>
int Factorial(int n)
{
	if (n == 1 || n == 2)
		return 1;
	if (data[n] != 0)
		return data[n];
	data[n] = Factorial(n - 1) + Factorial(n - 2);
	return data[n];
}

---

0-1背包问题

int[,] result = new int[11, 3];
int MaxPrice(int curWeight, int count, int[] weight, int[] price)
{
	if (curWeight <= 0 || count <= 0)
	{
		return 0;
	}
	int index = count - 1;
	if (result[curWeight, index] != 0)
	{
		return result[curWeight, index];
	}
	if (weight[index] > curWeight)
	{
		return MaxPrice(curWeight, count - 1, weight, price);
	}
	int maxPrice1 = MaxPrice(curWeight - weight[index], count - 1, weight, price) + price[index];
	int maxPrice2 = MaxPrice(curWeight, count - 1, weight, price);
	result[curWeight, index] = maxPrice1 > maxPrice2 ? maxPrice1 : maxPrice2;
	return result[curWeight,index];
}

---

排序算法

冒泡

优化： 可以在排序的时候加个标记，如果一次冒泡过程中没有发生位置交换，则已经排序完成，直接进行break操作

private void MaoPao(int[] array)
{
	if (array == null) return;

	int length = array.Length;
	for (int i = 0; i < length; i++)
	{
		for (int j = 0; j < length - i - 1; j++)
		{
			if (array[j] > array[j + 1])
			{
				int temp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = temp;
			}
		}
	}
}

鸡尾酒

private void JWJ(int[] array)
{
	int left = 0;
	int right = array.Length - 1;
	while (left < right)
	{
		for (int i = left; i < right; i++)
		{
			if (array[i] > array[i + 1])
			{
				Swap(array, i, i + 1);
			}
		}
		right--;
		for (int i = right; i > left; i--)
		{
			if (array[i] < array[i - 1])
			{
				Swap(array, i, i - 1);
			}
		}
		left++;
	}

}

private void Swap(int[] array,int i1,int i2)
{
	if (array == null) return;
	int temp = array[i1];
	array[i1] = array[i2];
	array[i2] = temp;
}

选择

private void XZ(int[] array)
{
	int length = array.Length;

	for (int i = 0; i < length; i++)
	{
		int minIndex = i;
		for (int j = i + 1; j < length; j++)
		{
			if (array[j] < array[minIndex])
			{
				minIndex = j;
			}
		}
		if (minIndex != i)
		{
			Swap(array, i, minIndex);
		}
	}

}

private void Swap(int[] array,int i1,int i2)
{
	if (array == null) return;
	int temp = array[i1];
	array[i1] = array[i2];
	array[i2] = temp;
}

插入

优化： 二分法找到最小的下标

private void CR(int[] array)
{
	int length = array.Length;

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

快排

private void KP(int[] array, int left, int right)
{
	if (left < right)
	{
		int mid = KPUnit(array, left, right);
		KP(array, left, mid - 1);
		KP(array, mid + 1, right);
	}
}

private int KPUnit(int[] array, int left, int right)
{
	int temp = array[left];
	while (left < right)
	{
		while (left < right && array[right] > temp)
		{
			right--;
		}
		array[left] = array[right];
		while (left < right && array[left] < temp)
		{
			left++;
		}
		array[right] = array[left];
	}
	array[left] = temp;
	return left;
}

堆排

public static void sort(int []arr){
        //1.构建大顶堆
        for(int i=arr.length/2-1;i>=0;i--){
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr,0,j);//重新对堆进行调整
        }

    }

    /**
     * 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustHeap(int []arr,int i,int length){
        int temp = arr[i];//先取出当前元素i
        for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                arr[i] = arr[k];
                i = k;
            }else{
                break;
            }
        }
        arr[i] = temp;//将temp值放到最终的位置
    }

    /**
     * 交换元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a ,int b){
        int temp=arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }