通过理解插入排序算法,我编写了这段代码。我的老师说它是冒泡排序,但我的朋友说它是插入的。有没有人可以检查一下并向我简要介绍一下。
#include <stdio.h>
void sort(int n) {
int i, j;
float arr[n], k;
for (i = 0; i <= n - 1; i++) {
printf("Enter the number");
scanf("%f", &arr[i]);
}
for (i = 1; i <= n - 1; i++) {
j
这个算法是为了确定一个矩阵是不是不同的。如何提高该算法的时间复杂度?
int IsMatrixDistinct(int n, int A[0..n-1,0..n-1])
{
for int i=0 to n-1 do
for int j = 0 to n-1 do
for int k = 0 to n-1 do
for int m = 0 to n-1 do
if ( A[i,j] == A[k,m] && !( i==k && j==m) )
我正在讨论计数排序算法,我理解它是如何工作的,但是我想知道是否有一种特定的方法来证明计数排序是一个稳定的算法。我有一个想法,如何归纳地证明这一点,但我不知道如何做到这一点。
for i = 1 to k
C[i] = 0
for j = 1 to n
C[A[j]] = C[A[i]] + 1
for i = 2 to k
C[i] = C[i] + C[i-1]
for j=n to 1
B[C[A[j]]] = A[j]
C[A[j]]--
我假设证明将以一个基本情况开始,其中数组只有一个元素。
大小写= 1,未排序数组A1 = a1,排序数组B1 =
让我们有一个大小为N的向量。例如:
x = rand(N,1)
我想要计算向量中长度K子集的最小标准差。
当N和K很小时,很容易找到最佳子集,因为我可以使用nchoosek(N,K)枚举所有可能的子集。但是当N和K的值大于N=50和K=25时,nchoosek无法计算组合,因为可能的子集的大小很大。
我想知道是否有更好的算法可以有效地计算出数组中最小标准差的子集。例如,通过动态规划。有什么想法吗?
更新
我在答案后面的循环中实现了它,并将其与组合解进行了比较。结果总是一样的,但速度的增长是前所未有的。
n = 20;
k = 10;
x = rand(n,1);
C = nchoosek(x,
private void merge(int[] array, int[] aux, int low, int mid, int hi) {
int i = low, j = mid + 1, k;
for (k = low; k <= hi; k++) {
aux[k] = array[k];
}
for (k = low; k <= hi; k++) {
if (i > mid) {
array[k] = aux[j++];
} else if (j > hi)
我创建了一个类,在其中创建了一个用于选择排序的方法。我将数组作为用户输入,并在选择排序中传递。在调用之前,它会显示值。调用之后,所有元素都为0。
import java.util.Scanner;
public class Selectionsortarray {
public static void Selectionsort(int num[]) {
for (int i=0;i<num.length;i++) {
for (int j=i+1;j<num.length;j++) {
if (nu
我试图使用Arrays.sort()方法对整数数组进行排序。调用此方法后,数组元素将变为0。
下面是我的代码
import java.util.Arrays;
import java.util.Scanner;
public class WillMuggerWin {
public static void main(String ar[]){
int t,n=10,m=5,sum=0,flag=0;
int notes[]=new int[20];
Scanner s=new Scanner(System.in);
t=s.nextInt();
我需要实现一个对未排序的数组或整数进行k路合并排序的函数。
该函数接受两个参数,一个整数K,它是排序的“方式”,始终是2的幂。第二个参数是要排序的整数数组,其长度也是2的幂。
该函数返回一个包含已排序元素的数组。到目前为止,我知道如何实现常规的合并排序。我如何修改这段代码,使其实现K-way合并排序?(注意:此函数不返回已排序的数组,我也需要帮助。它也不接受K,因为它是一个常规的合并排序)
下面的代码:
public class MergeSort {
public static void main(String[] args) {
}
public static void
基本上,我正在尝试用Java编写一个算法来确定数组中乱序的对的数量。所以如果我们取i和j,并且j在数组中的位置比i更高,但是Ai > Aj,那么它把这两个数算作反转。目前,我所拥有的是:
for(int i = 0; i<n-1; i++){
if (A[i] > A[i+1]){
k++;
我知道如何做这样的事情,但我希望运行时是(n+k),其中n是数组的长度,k是数组中的反转次数。
编辑:这是我实现插入排序的尝试:
int k = 0;
int [] A = {5, 4, 3, 2, 1};
int n = A.length;
for(int i
我很确定我的答案,但是今天我和我的朋友讨论了一下,他说我错了。
我认为这个函数的复杂度在平均和最坏情况下是O(n^2),在最好情况下是O(n)。对吗?
那么当k不是数组的长度时会发生什么呢?K是要排序的元素数(而不是整个数组)。
在最好和最坏的情况下是O(nk),在最好的情况下是O(n)?
下面是我的代码:
#include <stdio.h>
void bubblesort(int *arr, int k)
{
// k is the number of item of array you want to sort
// e.g. arr[] = { 4,15,
中使用的排序的名称是什么?我在谷歌上搜索了“完美插入排序”,但什么也没找到。以下是该答案的代码:
#this is O(n) instead of O(n log n) or worse
sub perfect_insert_sort {
my $h = shift;
my @k;
for my $k (keys %$h) {
$k[$h->{$k}{order}] = $k;
}
return @k;
}
为什么外壳排序比冒泡排序和插入排序的时间复杂度低?我们如何计算时间复杂度,我的意思是,我们认为我们的代码是高时间复杂度还是低时间复杂度?
#include <stdio.h>
void shellsort(int arr[], int num)
{
int i, j, k, tmp;
for (i = num / 2; i > 0; i = i / 2)
{
for (j = i; j < num; j++)
{
for (k = j - i; k >= 0; k = k - i)
我最近在C++中学习了合并排序算法,并且遇到了两种在教程中实现合并排序算法的不同方法。
第一条路:
void merge(int arr[], int low, int mid, int high) {
const int n1 = (mid - low + 1);
const int n2 = (high - mid);
int *a = new int[n1], *b = new int[n2];//dynamically allocated because of MSVC compiler
for (int i = 0; i < n1; i++)
我已经构建了与快速排序和合并排序相关的函数。我没有得到任何错误,但我仍然没有得到所需的输出。 #include <iostream>
using namespace std;
void swap(int *a, int *b);
void printarray(int array[], int size);
int partition(int array[], int low, int high, int select);
void quicksort(int array[], int low, int high, int select);
void merge(in
#include <iostream>
using namespace std;
int main()
{
//declaring the size of array and taking input from the user
int n = 0;
cout<<"Enter the Number of elements you want in the Array : ";
cin>>n;
//checking the user
我被要求写两种类型的合并排序。一种是带有时间θ的二进制合并排序(N)和一种与时间O(n )的自然合并排序。我到处找,想了解他们每个人都做了些什么。我很难理解其中的不同之处,我只是需要一些解释,或者举一些很棒的例子。我写了一个合并排序,但是我拥有的是一个自然的或二进制的合并排序吗?
bool compareElements(int i, int j)
{
++COMPARE_COUNT;
//int *t = i;
return i < j;
}
void merge(int values[], int left[], int right[], int middl
我有下面的插入排序,其中的数字是不同的
InsertionSort(A[1,...., n])
1 for i from 2 to n do
2 for j from 1 to i - 1 do
3 if A[i ] <= A[j ] then
4 tmp <- A[i ]
5 for k from i downto j + 1 do
6 A[k] <- A[k - 1]
7 A[j ] <- tmp
我的问题是,如果第3行中的