Hoán vị tiếp theo C++

Tôi đang tìm kiếm thứ gì đó lặp lại nhiều hơn, sau đó tôi triển khai phiên bản nghèo nàn của mình. Tôi có thể thấy một số tối ưu hóa, nhưng hiện tại nó giúp tôi. Tôi hy vọng điều này sẽ giúp bất cứ ai

#include 
#include 

#define PERM_T int
#define PERM_T_PFLAG "%d"

void swap(PERM_T *array, int i, int j) {
  PERM_T aux = array[i];
  array[i] = array[j];
  array[j] = aux;
}

void print_array_perm(PERM_T *array, int n) {
  printf("[");
  n -= 1;
  for (int i = 0; i < n; i++) {
    printf(PERM_T_PFLAG", ", array[i]);
  }
  if (n >= 0)
    printf(PERM_T_PFLAG, array[n]);
  printf("]\n");
}

void print_array_int(int *array, int n) {
  printf("[");
  n -= 1;
  for (int i = 0; i < n; i++) {
    printf("%d, ", array[i]);
  }
  if (n >= 0)
    printf("%d", array[n]);
  printf("]\n");
}

void copy_array_T(
  PERM_T *src, PERM_T *dst,
  int start, int end) {
  for (int i = start; i < end; i++) {
    dst[i] = src[i];
  }
}

void copy_array_int(
  int *src, int *dst,
  int start, int end) {
  for (int i = start; i < end; i++) {
    dst[i] = src[i];
  }
}

void rotate_array(
  PERM_T *array,
  int start, int end) {
  PERM_T aux = array[start];
  copy_array_T(
    array + 1, array, start, end);
  array[end - 1] = aux;
}

int factorial(int n) {
  int result = 1;
  while (n > 1) {
    result *= n;
    n--;
  }
  return result;
}

typedef struct {
  PERM_T *data;
  int length;
  int *ks;
  int kn;
  int _i;
} Perm;

Perm perm_(
  PERM_T *data, PERM_T *array, int n) {
  copy_array_T(array, data, 0, n);
  int kn = n > 1 ? n - 1 : 0;
  
  int *ks = kn
    ? malloc(sizeof(PERM_T) * kn)
    : NULL;
  for (int i = 0; i < kn; i++)
    ks[i] = i;

  int max_iterations = factorial(n);
  Perm p = {
    .data = data,
    .length = n,
    .ks = ks,
    .kn = kn,
    ._i = max_iterations
  };
  return p;
}

Perm perm(PERM_T *array, int n) {
  PERM_T *data = 
    malloc(sizeof(PERM_T) * n);
  return perm_(data, array, n);
}

Perm copy_perm(Perm p) {
  Perm copy = perm(p.data, p.length);
  copy_array_int(p.ks, copy.ks, 0, p.kn);
  return copy;
}

void clear_perm(Perm* p) {
  free(p->data);
  if (p->kn) free(p->ks);
}

int completed_perm(Perm *p) {
  return p->_i < 1;
}

void next_perm_self(Perm *p) {
  int n = p->length;

  if (completed_perm(p)) return;

  p->_i--;
  int k = p->kn - 1;
  int *ks = p->ks;
  PERM_T *data = p->data;

  if (ks[k] + 1 != n) {
    rotate_array(data, k, n);
    ks[k] += 1;
  } else {
    while (k >= 0 && ks[k] + 1 == n) {
      ks[k] = k;
      rotate_array(data, k, n);
      k -= 1;
    }
    if (k >= 0) {
      rotate_array(data, k, n);
      ks[k] += 1;
    }
  }
}

Perm next_perm_(Perm *p) {
  Perm next = copy_perm(*p);
  next_perm_self(&next);
  return next;
}

Perm next_perm(Perm *p) {
  Perm next = next_perm_(p);
  clear_perm(p);
  return next;
}

void print_perm(Perm p) {
  print_array_perm(p.data, p.length);
}

void print_perm_(Perm p) {
  printf("%p\n", p.data);
  print_perm(p);
  print_array_int(p.ks, p.kn);
}

Perm next_print(Perm *p) {
  print_perm(p);
  return next_perm(p);
}

void next_print_self(Perm *p) {
  print_perm(*p);
  next_perm_self(p);
}

int main() {
  int a1[] = {1,2,3,4,5};
  Perm p = perm(a1, 5);
  
  int i = 0;
  while (!completed_perm(&p)) {
    printf("%3d ", i++);
    // p = next_print(&p);
    next_print_self(&p);
  }

  clear_perm(&p);
  return 0;
}

Thuật toán C++ Hàm next_permutation() được sử dụng để sắp xếp lại các phần tử trong phạm vi [đầu tiên, cuối cùng) thành hoán vị lớn hơn về mặt từ điển tiếp theo

Một hoán vị được chỉ định là một trong số nhiều cách có thể có trong đó một tập hợp hoặc một số thứ có thể được sắp xếp hoặc sắp xếp. Nó được ký hiệu là N. trong đó N = số phần tử trong phạm vi

Các phần tử được so sánh bằng cách sử dụng toán tử < cho phiên bản đầu tiên hoặc sử dụng hàm so sánh nhị phân đã cho comp cho phiên bản thứ hai

cú pháp

Tham số

Đầu tiên. Trình lặp hai chiều trỏ đến phần tử đầu tiên trong phạm vi được hoán vị

Cuối cùng. Một trình vòng lặp đầu vào trỏ vị trí qua vị trí cuối cùng trong phạm vi được hoán vị

máy tính. Hàm vị từ nhị phân do người dùng định nghĩa chấp nhận hai đối số và trả về true nếu hai đối số theo thứ tự, nếu không thì trả về false. Nó tuân theo thứ tự yếu nghiêm ngặt để sắp xếp các phần tử

Giá trị trả về

Nó trả về true nếu hàm có thể sắp xếp lại đối tượng dưới dạng hoán vị lớn hơn về mặt từ điển

Mặt khác, hàm trả về false để cho biết rằng sắp xếp không lớn hơn sắp xếp trước, nhưng thấp nhất có thể (được sắp xếp theo thứ tự tăng dần)

phức tạp

Độ phức tạp lên đến tuyến tính trong một nửa khoảng cách giữa đầu tiên và cuối cùng

Cuộc đua dữ liệu

Các đối tượng trong phạm vi [đầu tiên, cuối cùng) được sửa đổi

ngoại lệ

Hàm này đưa ra một ngoại lệ nếu một trong hai phần tử được hoán đổi hoặc một thao tác trên trình vòng lặp sẽ đưa ra một ngoại lệ

Hoán vị tiếp theo trong C là gì?

Hoán vị tiếp theo trả về cái gì?

Hoán vị lớn hơn tiếp theo của danh sách các số là gì?

Hoán vị tiếp theo theo thứ tự từ điển từ điển là gì?