diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 6e2294371e7a6..eb9860b240f16 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -771,13 +771,14 @@ if(ARROW_COMPUTE)
        compute/kernels/scalar_validity.cc
        compute/kernels/vector_array_sort.cc
        compute/kernels/vector_cumulative_ops.cc
-       compute/kernels/vector_pairwise.cc
        compute/kernels/vector_nested.cc
+       compute/kernels/vector_pairwise.cc
        compute/kernels/vector_rank.cc
        compute/kernels/vector_replace.cc
        compute/kernels/vector_run_end_encode.cc
        compute/kernels/vector_select_k.cc
        compute/kernels/vector_sort.cc
+       compute/kernels/vector_swizzle.cc
        compute/key_hash_internal.cc
        compute/key_map_internal.cc
        compute/light_array_internal.cc
diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index f0d5c0fcc3d72..22ecf1cc87844 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -155,6 +155,12 @@ static auto kPairwiseOptionsType = GetFunctionOptionsType<PairwiseOptions>(
     DataMember("periods", &PairwiseOptions::periods));
 static auto kListFlattenOptionsType = GetFunctionOptionsType<ListFlattenOptions>(
     DataMember("recursive", &ListFlattenOptions::recursive));
+static auto kInversePermutationOptionsType =
+    GetFunctionOptionsType<InversePermutationOptions>(
+        DataMember("max_index", &InversePermutationOptions::max_index),
+        DataMember("output_type", &InversePermutationOptions::output_type));
+static auto kScatterOptionsType = GetFunctionOptionsType<ScatterOptions>(
+    DataMember("max_index", &ScatterOptions::max_index));
 }  // namespace
 }  // namespace internal
 
@@ -230,6 +236,17 @@ ListFlattenOptions::ListFlattenOptions(bool recursive)
     : FunctionOptions(internal::kListFlattenOptionsType), recursive(recursive) {}
 constexpr char ListFlattenOptions::kTypeName[];
 
+InversePermutationOptions::InversePermutationOptions(
+    int64_t max_index, std::shared_ptr<DataType> output_type)
+    : FunctionOptions(internal::kInversePermutationOptionsType),
+      max_index(max_index),
+      output_type(std::move(output_type)) {}
+constexpr char InversePermutationOptions::kTypeName[];
+
+ScatterOptions::ScatterOptions(int64_t max_index)
+    : FunctionOptions(internal::kScatterOptionsType), max_index(max_index) {}
+constexpr char ScatterOptions::kTypeName[];
+
 namespace internal {
 void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kFilterOptionsType));
@@ -244,6 +261,8 @@ void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kRankOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPairwiseOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kListFlattenOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kInversePermutationOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kScatterOptionsType));
 }
 }  // namespace internal
 
@@ -429,5 +448,19 @@ Result<Datum> CumulativeMean(const Datum& values, const CumulativeOptions& optio
   return CallFunction("cumulative_mean", {Datum(values)}, &options, ctx);
 }
 
+// ----------------------------------------------------------------------
+// Swizzle functions
+
+Result<Datum> InversePermutation(const Datum& indices,
+                                 const InversePermutationOptions& options,
+                                 ExecContext* ctx) {
+  return CallFunction("inverse_permutation", {indices}, &options, ctx);
+}
+
+Result<Datum> Scatter(const Datum& values, const Datum& indices,
+                      const ScatterOptions& options, ExecContext* ctx) {
+  return CallFunction("scatter", {values, indices}, &options, ctx);
+}
+
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index e5bcc37329661..48b4e8068f3b9 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -257,6 +257,40 @@ class ARROW_EXPORT ListFlattenOptions : public FunctionOptions {
   bool recursive = false;
 };
 
+/// \brief Options for inverse_permutation function
+class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
+ public:
+  explicit InversePermutationOptions(int64_t max_index = -1,
+                                     std::shared_ptr<DataType> output_type = NULLPTR);
+  static constexpr char const kTypeName[] = "InversePermutationOptions";
+  static InversePermutationOptions Defaults() { return InversePermutationOptions(); }
+
+  /// \brief The max value in the input indices to allow. The length of the function's
+  /// output will be this value plus 1. If negative, this value will be set to the length
+  /// of the input indices minus 1 and the length of the function's output will be the
+  /// length of the input indices.
+  int64_t max_index = -1;
+  /// \brief The type of the output inverse permutation. If null, the output will be of
+  /// the same type as the input indices, otherwise must be signed integer type. An
+  /// invalid error will be reported if this type is not able to store the length of the
+  /// input indices.
+  std::shared_ptr<DataType> output_type = NULLPTR;
+};
+
+/// \brief Options for scatter function
+class ARROW_EXPORT ScatterOptions : public FunctionOptions {
+ public:
+  explicit ScatterOptions(int64_t max_index = -1);
+  static constexpr char const kTypeName[] = "ScatterOptions";
+  static ScatterOptions Defaults() { return ScatterOptions(); }
+
+  /// \brief The max value in the input indices to allow. The length of the function's
+  /// output will be this value plus 1. If negative, this value will be set to the length
+  /// of the input indices minus 1 and the length of the function's output will be the
+  /// length of the input indices.
+  int64_t max_index = -1;
+};
+
 /// @}
 
 /// \brief Filter with a boolean selection filter
@@ -705,5 +739,52 @@ Result<std::shared_ptr<Array>> PairwiseDiff(const Array& array,
                                             bool check_overflow = false,
                                             ExecContext* ctx = NULLPTR);
 
+/// \brief Return the inverse permutation of the given indices.
+///
+/// For indices[i] = x, inverse_permutation[x] = i. And inverse_permutation[x] = null if x
+/// does not appear in the input indices. Indices must be in the range of [0, max_index],
+/// or null, which will be ignored. If multiple indices point to the same value, the last
+/// one is used.
+///
+/// For example, with indices = [null, 0, 3, 2, 4, 1, 1], the inverse permutation is
+/// [1, 6, 3, 2, 4, null, null] if max_index = 6.
+///
+/// \param[in] indices array-like indices
+/// \param[in] options configures the max index and the output type
+/// \param[in] ctx the function execution context, optional
+/// \return the resulting inverse permutation
+///
+/// \since 19.0.0
+/// \note API not yet finalized
+ARROW_EXPORT
+Result<Datum> InversePermutation(
+    const Datum& indices,
+    const InversePermutationOptions& options = InversePermutationOptions::Defaults(),
+    ExecContext* ctx = NULLPTR);
+
+/// \brief Scatter the values into specified positions according to the indices.
+///
+/// For indices[i] = x, output[x] = values[i]. And output[x] = null if x does not appear
+/// in the input indices. Indices must be in the range of [0, max_index], or null, in
+/// which case the corresponding value will be ignored. If multiple indices point to the
+/// same value, the last one is used.
+///
+/// For example, with values = [a, b, c, d, e, f, g] and indices = [null, 0,
+/// 3, 2, 4, 1, 1], the output is
+/// [b, g, d, c, e, null, null] if max_index = 6.
+///
+/// \param[in] values datum to scatter
+/// \param[in] indices array-like indices
+/// \param[in] options configures the max index of to scatter
+/// \param[in] ctx the function execution context, optional
+/// \return the resulting datum
+///
+/// \since 19.0.0
+/// \note API not yet finalized
+ARROW_EXPORT
+Result<Datum> Scatter(const Datum& values, const Datum& indices,
+                      const ScatterOptions& options = ScatterOptions::Defaults(),
+                      ExecContext* ctx = NULLPTR);
+
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/function_test.cc b/cpp/src/arrow/compute/function_test.cc
index c269de0763217..b7d017d482013 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -136,6 +136,10 @@ TEST(FunctionOptions, Equality) {
   options.emplace_back(new SelectKOptions(5, {{SortKey("key", SortOrder::Ascending)}}));
   options.emplace_back(new Utf8NormalizeOptions());
   options.emplace_back(new Utf8NormalizeOptions(Utf8NormalizeOptions::NFD));
+  options.emplace_back(
+      new InversePermutationOptions(/*max_index=*/42, /*output_type=*/int32()));
+  options.emplace_back(new ScatterOptions());
+  options.emplace_back(new ScatterOptions(/*max_index=*/42));
 
   for (size_t i = 0; i < options.size(); i++) {
     const size_t prev_i = i == 0 ? options.size() - 1 : i - 1;
diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index 7c7b9c8b68d45..84b508f5d9be4 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -115,6 +115,12 @@ add_arrow_compute_test(vector_selection_test
                        EXTRA_LINK_LIBS
                        arrow_compute_kernels_testing)
 
+add_arrow_compute_test(vector_swizzle_test
+                       SOURCES
+                       vector_swizzle_test.cc
+                       EXTRA_LINK_LIBS
+                       arrow_compute_kernels_testing)
+
 add_arrow_benchmark(vector_hash_benchmark PREFIX "arrow-compute")
 add_arrow_benchmark(vector_sort_benchmark PREFIX "arrow-compute")
 add_arrow_benchmark(vector_partition_benchmark PREFIX "arrow-compute")
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 594bd1fce0b84..2a492f581f53b 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -1037,8 +1037,9 @@ ArrayKernelExec GenerateFloatingPoint(detail::GetTypeId get_id) {
 // Generate a kernel given a templated functor for integer types
 //
 // See "Numeric" above for description of the generator functor
-template <template <typename...> class Generator, typename Type0, typename... Args>
-ArrayKernelExec GenerateInteger(detail::GetTypeId get_id) {
+template <template <typename...> class Generator, typename Type0,
+          typename KernelType = ArrayKernelExec, typename... Args>
+KernelType GenerateInteger(detail::GetTypeId get_id) {
   switch (get_id.id) {
     case Type::INT8:
       return Generator<Type0, Int8Type, Args...>::Exec;
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
new file mode 100644
index 0000000000000..1611a2e90b271
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -0,0 +1,422 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.#include "arrow/compute/api_vector.h"
+
+#include "arrow/compute/api_vector.h"
+#include "arrow/compute/function.h"
+#include "arrow/compute/kernels/codegen_internal.h"
+#include "arrow/compute/registry.h"
+#include "arrow/util/checked_cast.h"
+#include "arrow/util/logging.h"
+
+namespace arrow::compute::internal {
+
+namespace {
+
+// ----------------------------------------------------------------------
+// InversePermutation
+
+const FunctionDoc inverse_permutation_doc(
+    "Return the inverse permutation of the given indices",
+    "For the `i`-th `index` in `indices`, the `index`-th output is `i`", {"indices"});
+
+const InversePermutationOptions* GetDefaultInversePermutationOptions() {
+  static const auto kDefaultInversePermutationOptions =
+      InversePermutationOptions::Defaults();
+  return &kDefaultInversePermutationOptions;
+}
+
+using InversePermutationState = OptionsWrapper<InversePermutationOptions>;
+
+/// Resolve the output type of inverse_permutation. The output type is specified in the
+/// options, and if null, set it to the input type. The output type must be signed
+/// integer.
+Result<TypeHolder> ResolveInversePermutationOutputType(
+    KernelContext* ctx, const std::vector<TypeHolder>& input_types) {
+  DCHECK_EQ(input_types.size(), 1);
+  DCHECK_NE(input_types[0], nullptr);
+
+  std::shared_ptr<DataType> output_type = InversePermutationState::Get(ctx).output_type;
+  if (!output_type) {
+    output_type = input_types[0].owned_type;
+  }
+  if (!is_signed_integer(output_type->id())) {
+    return Status::TypeError(
+        "Output type of inverse_permutation must be signed integer, got " +
+        output_type->ToString());
+  }
+
+  return TypeHolder(std::move(output_type));
+}
+
+template <typename ExecType>
+struct InversePermutationImpl {
+  using ThisType = InversePermutationImpl<ExecType>;
+  using IndexType = typename ExecType::IndexType;
+  using IndexCType = typename IndexType::c_type;
+  using ShapeType = typename ExecType::ShapeType;
+
+  static Result<std::shared_ptr<ArrayData>> Exec(
+      KernelContext* ctx, const ShapeType& indices, int64_t input_length,
+      const std::shared_ptr<DataType>& input_type) {
+    const auto& options = InversePermutationState::Get(ctx);
+
+    // Apply default options semantics.
+    int64_t output_length = options.max_index < 0 ? input_length : options.max_index + 1;
+    std::shared_ptr<DataType> output_type = options.output_type;
+    if (!output_type) {
+      output_type = input_type;
+    }
+
+    ThisType impl(ctx, indices, input_length, output_length);
+    RETURN_NOT_OK(VisitTypeInline(*output_type, &impl));
+
+    return ArrayData::Make(std::move(output_type), output_length,
+                           {std::move(impl.validity_buf_), std::move(impl.data_buf_)});
+  }
+
+  template <typename Type>
+  enable_if_t<is_integer_type<Type>::value, Status> Visit(const Type& output_type) {
+    using OutputCType = typename Type::c_type;
+
+    RETURN_NOT_OK(CheckInput(output_type));
+
+    // Dispatch the execution based on whether there are likely many nulls in the output.
+    // - If many nulls (i.e. the output is "sparse"), preallocate an all-false validity
+    // buffer and a zero-initialized data buffer (just to avoid exposing previous memory
+    // contents - even if it is shadowed by the validity bit). The subsequent processing
+    // will fill the valid values only.
+    // - Otherwise (i.e. the output is "dense"), the validity buffer is lazily allocated
+    // and initialized all-true in the subsequent processing only when needed. The data
+    // buffer is preallocated and filled with "impossible" values (that is, input_length -
+    // note that the range of inverse_permutation is [0, input_length)) for the subsequent
+    // processing to detect validity.
+    if (LikelyManyNulls()) {
+      RETURN_NOT_OK(AllocateValidityBufAndFill(false));
+      RETURN_NOT_OK(AllocateDataBufAndZero(output_type));
+      return Execute<Type, true>();
+    } else {
+      RETURN_NOT_OK(
+          AllocateDataBufAndFill(output_type, static_cast<OutputCType>(input_length_)));
+      return Execute<Type, false>();
+    }
+  }
+
+  Status Visit(const DataType& output_type) {
+    DCHECK(false) << "Shouldn't reach here";
+    return Status::Invalid("Shouldn't reach here");
+  }
+
+ private:
+  KernelContext* ctx_;
+  const ShapeType& indices_;
+  const int64_t input_length_;
+  const int64_t output_length_;
+
+  std::shared_ptr<Buffer> validity_buf_;
+  std::shared_ptr<Buffer> data_buf_;
+
+  InversePermutationImpl(KernelContext* ctx, const ShapeType& indices,
+                         int64_t input_length, int64_t output_length)
+      : ctx_(ctx),
+        indices_(indices),
+        input_length_(input_length),
+        output_length_(output_length) {}
+
+  template <typename Type>
+  Status CheckInput(const Type& output_type) {
+    using OutputCType = typename Type::c_type;
+
+    if (static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) < input_length_) {
+      return Status::Invalid(
+          "Output type " + output_type.ToString() +
+          " of inverse_permutation is insufficient to store indices of length " +
+          std::to_string(input_length_));
+    }
+
+    return Status::OK();
+  }
+
+  bool LikelyManyNulls() { return output_length_ > 2 * input_length_; }
+
+  Status AllocateValidityBufAndFill(bool valid) {
+    DCHECK_EQ(validity_buf_, nullptr);
+
+    ARROW_ASSIGN_OR_RAISE(validity_buf_,
+                          AllocateEmptyBitmap(output_length_, ctx_->memory_pool()));
+    auto validity = validity_buf_->mutable_data_as<uint8_t>();
+    std::memset(validity, valid ? 0xff : 0, validity_buf_->size());
+
+    return Status::OK();
+  }
+
+  Status AllocateDataBuf(const DataType& output_type) {
+    DCHECK_EQ(data_buf_, nullptr);
+
+    ARROW_ASSIGN_OR_RAISE(data_buf_,
+                          ctx_->Allocate(output_length_ * output_type.byte_width()));
+
+    return Status::OK();
+  }
+
+  Status AllocateDataBufAndZero(const DataType& output_type) {
+    RETURN_NOT_OK(AllocateDataBuf(output_type));
+
+    uint8_t* data = data_buf_->mutable_data();
+    std::memset(data, 0, output_length_ * output_type.byte_width());
+
+    return Status::OK();
+  }
+
+  template <typename Type, typename OutputCType = typename Type::c_type>
+  Status AllocateDataBufAndFill(const Type& output_type, OutputCType value) {
+    RETURN_NOT_OK(AllocateDataBuf(output_type));
+
+    OutputCType* data = data_buf_->mutable_data_as<OutputCType>();
+    for (int64_t i = 0; i < output_length_; ++i) {
+      data[i] = value;
+    }
+
+    return Status::OK();
+  }
+
+  template <typename Type, bool likely_many_nulls>
+  Status Execute() {
+    using OutputCType = typename Type::c_type;
+
+    uint8_t* validity = nullptr;
+    if constexpr (likely_many_nulls) {
+      DCHECK_NE(validity_buf_, nullptr);
+      validity = validity_buf_->mutable_data_as<uint8_t>();
+    } else {
+      DCHECK_EQ(validity_buf_, nullptr);
+    }
+    DCHECK_NE(data_buf_, nullptr);
+    OutputCType* data = data_buf_->mutable_data_as<OutputCType>();
+    int64_t inverse = 0;
+    RETURN_NOT_OK(ExecType::VisitIndices(
+        indices_,
+        [&](IndexCType index) {
+          if (ARROW_PREDICT_FALSE(index < 0 ||
+                                  static_cast<int64_t>(index) >= output_length_)) {
+            return Status::IndexError("Index out of bounds: ", std::to_string(index));
+          }
+          data[index] = static_cast<OutputCType>(inverse);
+          // If many nulls, set validity to true for valid values.
+          if constexpr (likely_many_nulls) {
+            bit_util::SetBitTo(validity, index, true);
+          }
+          ++inverse;
+          return Status::OK();
+        },
+        [&]() {
+          ++inverse;
+          return Status::OK();
+        }));
+
+    // If not many nulls, run another pass iterating over the data to set the validity
+    // to false if the value is "impossible". The validity buffer is on demand allocated
+    // and initialized all-true when the first "impossible" value is seen.
+    if constexpr (!likely_many_nulls) {
+      for (int64_t i = 0; i < output_length_; ++i) {
+        if (data[i] == static_cast<OutputCType>(input_length_)) {
+          if (ARROW_PREDICT_FALSE(!validity_buf_)) {
+            RETURN_NOT_OK(AllocateValidityBufAndFill(true));
+            validity = validity_buf_->mutable_data_as<uint8_t>();
+          }
+          bit_util::SetBitTo(validity, i, false);
+        }
+      }
+    }
+
+    return Status::OK();
+  }
+};
+
+template <typename Ignored, typename Type>
+struct InversePermutation {
+  using ThisType = InversePermutation<Ignored, Type>;
+  using IndexType = Type;
+  using ShapeType = ArraySpan;
+
+  template <typename ValidFunc, typename NullFunc>
+  static Status VisitIndices(const ArraySpan& span, ValidFunc&& valid_func,
+                             NullFunc&& null_func) {
+    return VisitArraySpanInline<IndexType>(span, std::forward<ValidFunc>(valid_func),
+                                           std::forward<NullFunc>(null_func));
+  }
+
+  static Status Exec(KernelContext* ctx, const ExecSpan& span, ExecResult* result) {
+    DCHECK_EQ(span.num_values(), 1);
+    DCHECK(span[0].is_array());
+    const auto& indices = span[0].array;
+    ARROW_ASSIGN_OR_RAISE(
+        result->value, InversePermutationImpl<ThisType>::Exec(
+                           ctx, indices, indices.length, indices.type->GetSharedPtr()));
+    return Status::OK();
+  }
+};
+
+template <typename Ignored, typename Type>
+struct InversePermutationChunked {
+  using ThisType = InversePermutationChunked<Ignored, Type>;
+  using IndexType = Type;
+  using ShapeType = std::shared_ptr<ChunkedArray>;
+
+  template <typename ValidFunc, typename NullFunc>
+  static Status VisitIndices(const std::shared_ptr<ChunkedArray>& chunked_array,
+                             ValidFunc&& valid_func, NullFunc&& null_func) {
+    for (const auto& chunk : chunked_array->chunks()) {
+      ArraySpan span(*chunk->data());
+      RETURN_NOT_OK(VisitArraySpanInline<IndexType>(
+          span, std::forward<ValidFunc>(valid_func), std::forward<NullFunc>(null_func)));
+    }
+    return Status::OK();
+  }
+
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* result) {
+    DCHECK_EQ(batch.num_values(), 1);
+    DCHECK(batch[0].is_chunked_array());
+    const auto& indices = batch[0].chunked_array();
+    ARROW_ASSIGN_OR_RAISE(auto inverse_permutation,
+                          InversePermutationImpl<ThisType>::Exec(
+                              ctx, indices, indices->length(), indices->type()));
+    *result =
+        Datum(std::make_shared<ChunkedArray>(MakeArray(std::move(inverse_permutation))));
+    return Status::OK();
+  }
+};
+
+void RegisterVectorInversePermutation(FunctionRegistry* registry) {
+  auto function = std::make_shared<VectorFunction>("inverse_permutation", Arity::Unary(),
+                                                   inverse_permutation_doc,
+                                                   GetDefaultInversePermutationOptions());
+
+  auto add_kernel = [&function](Type::type type_id) {
+    VectorKernel kernel;
+    kernel.signature =
+        KernelSignature::Make({InputType(match::SameTypeId(type_id))},
+                              OutputType(ResolveInversePermutationOutputType));
+    kernel.init = InversePermutationState::Init;
+    kernel.exec = GenerateInteger<InversePermutation, void, ArrayKernelExec>(type_id);
+    kernel.exec_chunked =
+        GenerateInteger<InversePermutationChunked, void, VectorKernel::ChunkedExec>(
+            type_id);
+    kernel.can_execute_chunkwise = false;
+    kernel.output_chunked = false;
+    DCHECK_OK(function->AddKernel(std::move(kernel)));
+  };
+  for (const auto& t : SignedIntTypes()) {
+    add_kernel(t->id());
+  }
+
+  DCHECK_OK(registry->AddFunction(std::move(function)));
+}
+
+// ----------------------------------------------------------------------
+// Scatter
+
+const FunctionDoc scatter_doc(
+    "Scatter the values into specified positions according to the indices",
+    "Place the `i`-th value at the position specified by the `i`-th index",
+    {"values", "indices"});
+
+const ScatterOptions* GetDefaultScatterOptions() {
+  static const auto kDefaultScatterOptions = ScatterOptions::Defaults();
+  return &kDefaultScatterOptions;
+}
+
+class ScatterMetaFunction : public MetaFunction {
+ public:
+  ScatterMetaFunction()
+      : MetaFunction("scatter", Arity::Binary(), scatter_doc,
+                     GetDefaultScatterOptions()) {}
+
+  Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
+                            const FunctionOptions* options,
+                            ExecContext* ctx) const override {
+    DCHECK_EQ(args.size(), 2);
+    const auto& values = args[0];
+    const auto& indices = args[1];
+    // Though the way how scatter is currently implemented may support record batch or
+    // table, we don't want to promise that yet.
+    if (!values.is_arraylike()) {
+      return Status::NotImplemented("Scatter does not support " +
+                                    ToString(values.kind()) + " values");
+    }
+    if (!indices.is_arraylike()) {
+      return Status::NotImplemented("Scatter does not support " +
+                                    ToString(values.kind()) + " indices");
+    }
+    auto* scatter_options = checked_cast<const ScatterOptions*>(options);
+    if (values.length() != indices.length()) {
+      return Status::Invalid(
+          "Input and indices of scatter must have the same length, got " +
+          std::to_string(values.length()) + " and " + std::to_string(indices.length()));
+    }
+    if (!is_signed_integer(indices.type()->id())) {
+      return Status::TypeError("Indices of scatter must be of signed integer type, got ",
+                               indices.type()->ToString());
+    }
+    // Internally invoke Take(values, InversePermutation(indices)) to implement scatter.
+    // For example, with
+    //   values = [a, b, c, d, e, f, g]
+    //   indices = [null, 0, 3, 2, 4, 1, 1]
+    // the InversePermutation(indices) is
+    // [1, 6, 3, 2, 4, null, null]  if max_index = 6.
+    // and Take(values, InversePermutation(indices)) is
+    // [b, g, d, c, e, null, null]  if max_index = 6.
+    InversePermutationOptions inverse_permutation_options{
+        scatter_options->max_index,
+        // Use the smallest possible uint type to store inverse permutation.
+        InferSmallestInversePermutationType(values.length())};
+    ARROW_ASSIGN_OR_RAISE(auto inverse_permutation,
+                          CallFunction("inverse_permutation", {indices},
+                                       &inverse_permutation_options, ctx));
+    TakeOptions take_options{/*boundcheck=*/false};
+    return CallFunction("take", {values, inverse_permutation}, &take_options, ctx);
+  }
+
+ private:
+  static std::shared_ptr<DataType> InferSmallestInversePermutationType(
+      int64_t input_length) {
+    DCHECK_GE(input_length, 0);
+    if (input_length <= std::numeric_limits<int8_t>::max()) {
+      return int8();
+    } else if (input_length <= std::numeric_limits<int16_t>::max()) {
+      return int16();
+    } else if (input_length <= std::numeric_limits<int32_t>::max()) {
+      return int32();
+    } else {
+      return int64();
+    }
+  }
+};
+
+void RegisterVectorScatter(FunctionRegistry* registry) {
+  DCHECK_OK(registry->AddFunction(std::make_shared<ScatterMetaFunction>()));
+}
+
+}  // namespace
+
+// ----------------------------------------------------------------------
+
+void RegisterVectorSwizzle(FunctionRegistry* registry) {
+  RegisterVectorInversePermutation(registry);
+  RegisterVectorScatter(registry);
+}
+
+}  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
new file mode 100644
index 0000000000000..be5fbdeaed506
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -0,0 +1,781 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <gtest/gtest.h>
+
+#include "arrow/array/concatenate.h"
+#include "arrow/chunked_array.h"
+#include "arrow/compute/api_vector.h"
+#include "arrow/compute/kernels/test_util.h"
+#include "arrow/testing/generator.h"
+#include "arrow/testing/gtest_util.h"
+#include "arrow/testing/random.h"
+#include "arrow/util/logging.h"
+
+namespace arrow::compute {
+
+namespace {
+
+static const std::vector<std::shared_ptr<DataType>> kSignedIntegerTypes = {
+    int8(), int16(), int32(), int64()};
+
+static const std::vector<std::shared_ptr<DataType>> kBinaryTypes = {
+    binary(), utf8(), large_binary(), large_utf8()};
+
+using SmallSignedIntegerTypes = ::testing::Types<Int8Type, Int16Type>;
+
+}  // namespace
+
+// ----------------------------------------------------------------------
+// InversePermutation tests
+
+namespace {
+
+Result<Datum> InversePermutation(const Datum& indices, int64_t max_index,
+                                 std::shared_ptr<DataType> output_type) {
+  InversePermutationOptions options{max_index, std::move(output_type)};
+  return InversePermutation(indices, options);
+}
+
+void AssertInversePermutation(const Datum& indices, int64_t max_index,
+                              const std::shared_ptr<DataType>& output_type,
+                              const Datum& expected, bool validity_must_be_null) {
+  ASSERT_OK_AND_ASSIGN(auto result, InversePermutation(indices, max_index, output_type));
+  ValidateOutput(result);
+  ASSERT_EQ(indices.kind(), result.kind());
+  std::shared_ptr<Array> result_array;
+  if (result.is_array()) {
+    result_array = result.make_array();
+  } else {
+    ASSERT_TRUE(result.is_chunked_array());
+    ASSERT_OK_AND_ASSIGN(result_array, Concatenate(result.chunked_array()->chunks()));
+  }
+  AssertDatumsEqual(expected, result_array);
+  if (validity_must_be_null) {
+    ASSERT_FALSE(result_array->data()->HasValidityBitmap());
+  }
+}
+
+template <typename InputFunc>
+void DoTestInversePermutationForInputTypes(
+    const std::vector<std::shared_ptr<DataType>>& input_types, InputFunc&& input,
+    int64_t max_index, const std::shared_ptr<DataType>& output_type,
+    const Datum& expected, bool validity_must_be_null = false) {
+  for (const auto& input_type : input_types) {
+    ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
+    ASSERT_OK_AND_ASSIGN(auto indices, input(input_type));
+    AssertInversePermutation(indices, max_index, output_type, expected,
+                             validity_must_be_null);
+  }
+}
+
+template <typename InputFunc>
+void DoTestInversePermutationForInputOutputTypes(
+    const std::vector<std::shared_ptr<DataType>>& input_types,
+    const std::vector<std::shared_ptr<DataType>>& output_types, InputFunc&& input,
+    int64_t max_index, const std::string& expected_str, bool validity_must_be_null) {
+  for (const auto& output_type : output_types) {
+    ARROW_SCOPED_TRACE("Output type: " + output_type->ToString());
+    auto expected = ArrayFromJSON(output_type, expected_str);
+    DoTestInversePermutationForInputTypes(input_types, std::forward<InputFunc>(input),
+                                          max_index, output_type, expected,
+                                          validity_must_be_null);
+  }
+}
+
+void TestInversePermutationForInputOutputTypes(
+    const std::vector<std::shared_ptr<DataType>>& input_types,
+    const std::vector<std::shared_ptr<DataType>>& output_types,
+    const std::vector<std::string>& indices_chunked_str, int64_t max_index,
+    const std::string& expected_str, bool validity_must_be_null) {
+  {
+    ARROW_SCOPED_TRACE("Array");
+    DoTestInversePermutationForInputOutputTypes(
+        input_types, output_types,
+        [&](const std::shared_ptr<DataType>& input_type) -> Result<Datum> {
+          auto chunked = ChunkedArrayFromJSON(input_type, indices_chunked_str);
+          return Concatenate(chunked->chunks());
+        },
+        max_index, expected_str, validity_must_be_null);
+  }
+  {
+    ARROW_SCOPED_TRACE("Chunked");
+    DoTestInversePermutationForInputOutputTypes(
+        input_types, output_types,
+        [&](const std::shared_ptr<DataType>& input_type) -> Result<Datum> {
+          return ChunkedArrayFromJSON(input_type, indices_chunked_str);
+        },
+        max_index, expected_str, validity_must_be_null);
+  }
+}
+
+void TestInversePermutation(const std::vector<std::string>& indices_chunked_str,
+                            int64_t max_index, const std::string& expected_str,
+                            bool validity_must_be_null = false) {
+  TestInversePermutationForInputOutputTypes(kSignedIntegerTypes, kSignedIntegerTypes,
+                                            indices_chunked_str, max_index, expected_str,
+                                            validity_must_be_null);
+}
+
+}  // namespace
+
+TEST(InversePermutation, InvalidOutputType) {
+  {
+    ARROW_SCOPED_TRACE("Output type unsigned");
+    auto indices = ArrayFromJSON(int32(), "[]");
+    ASSERT_RAISES_WITH_MESSAGE(
+        TypeError,
+        "Type error: Output type of inverse_permutation must be signed integer, got "
+        "uint32",
+        InversePermutation(indices, /*max_index=*/0, /*output_type=*/uint32()));
+  }
+  {
+    ARROW_SCOPED_TRACE("Output type float");
+    auto indices = ArrayFromJSON(int32(), "[]");
+    ASSERT_RAISES_WITH_MESSAGE(
+        TypeError,
+        "Type error: Output type of inverse_permutation must be signed integer, got "
+        "float",
+        InversePermutation(indices, /*max_index=*/0, /*output_type=*/float32()));
+  }
+  {
+    ARROW_SCOPED_TRACE("Output type string");
+    auto indices = ArrayFromJSON(int32(), "[]");
+    ASSERT_RAISES_WITH_MESSAGE(
+        TypeError,
+        "Type error: Output type of inverse_permutation must be signed integer, got "
+        "string",
+        InversePermutation(indices, /*max_index=*/0, /*output_type=*/utf8()));
+  }
+}
+
+TEST(InversePermutation, DefaultOptions) {
+  {
+    ARROW_SCOPED_TRACE("Default options values");
+    InversePermutationOptions options;
+    ASSERT_EQ(options.max_index, -1);
+    ASSERT_EQ(options.output_type, nullptr);
+  }
+  {
+    ARROW_SCOPED_TRACE("Default options semantics");
+    for (const auto& input_type : kSignedIntegerTypes) {
+      ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
+      auto indices = ArrayFromJSON(input_type, "[0]");
+      ASSERT_OK_AND_ASSIGN(Datum result, InversePermutation(indices));
+      AssertDatumsEqual(indices, result);
+    }
+  }
+}
+
+TEST(InversePermutation, InvalidIndex) {
+  {
+    ARROW_SCOPED_TRACE("Negative index");
+    auto indices = ArrayFromJSON(int32(), "[-1]");
+    ASSERT_RAISES_WITH_MESSAGE(IndexError, "Index error: Index out of bounds: -1",
+                               InversePermutation(indices));
+  }
+  {
+    ARROW_SCOPED_TRACE("Exceeds max_index");
+    auto indices = ArrayFromJSON(int32(), "[42]");
+    ASSERT_RAISES_WITH_MESSAGE(
+        IndexError, "Index error: Index out of bounds: 42",
+        InversePermutation(indices, /*max_index=*/1, /*output_type=*/int32()));
+  }
+}
+
+TEST(InversePermutation, Basic) {
+  {
+    ARROW_SCOPED_TRACE("Basic");
+    std::vector<std::string> indices_chunked{
+        "[]", "[9, 7, 5, 3, 1]", "[0]", "[2, 4, 6]", "[8]", "[]"};
+    int64_t max_index = 9;
+    auto expected = "[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]";
+    TestInversePermutation(indices_chunked, max_index, expected,
+                           /*validity_must_be_null=*/true);
+  }
+  {
+    ARROW_SCOPED_TRACE("Basic with nulls");
+    std::vector<std::string> indices_chunked{
+        "[]", "[9, 7, 5, 3, 1]", "[null]", "[null, null, null]", "[null]", "[]"};
+    int64_t max_index = 9;
+    auto expected = "[null, 4, null, 3, null, 2, null, 1, null, 0]";
+    TestInversePermutation(indices_chunked, max_index, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Output greater than input");
+    std::vector<std::string> indices_chunked{"[]", "[1]", "[]", "[2]"};
+    int64_t max_index = 6;
+    auto expected = "[null, 0, 1, null, null, null, null]";
+    TestInversePermutation(indices_chunked, max_index, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Input all null");
+    std::vector<std::string> indices_chunked{"[]", "[null]", "[]", "[null]"};
+    int64_t max_index = 1;
+    auto expected = "[null, null]";
+    TestInversePermutation(indices_chunked, max_index, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Empty input output null");
+    std::vector<std::string> indices_chunked{"[]", "[]", "[]", "[]"};
+    int64_t max_index = 6;
+    auto expected = "[null, null, null, null, null, null, null]";
+    TestInversePermutation(indices_chunked, max_index, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Input duplicated indices");
+    std::vector<std::string> indices_chunked{"[]", "[1, 2]", "[3, 1, 2, 3, 1]",
+                                             "[]", "[2]",    "[3]"};
+    int64_t max_index = 4;
+    auto expected = "[null, 6, 7, 8, null]";
+    TestInversePermutation(indices_chunked, max_index, expected);
+  }
+}
+
+template <typename ArrowType>
+class TestInversePermutationSmallOutputType : public ::testing::Test {
+ protected:
+  using CType = typename TypeTraits<ArrowType>::CType;
+
+  std::shared_ptr<DataType> type_singleton() {
+    return TypeTraits<ArrowType>::type_singleton();
+  }
+};
+
+TYPED_TEST_SUITE(TestInversePermutationSmallOutputType, SmallSignedIntegerTypes);
+
+TYPED_TEST(TestInversePermutationSmallOutputType, JustEnoughOutputType) {
+  auto output_type = this->type_singleton();
+  int64_t input_length =
+      static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max());
+  auto expected =
+      ArrayFromJSON(output_type, "[" + std::to_string(input_length - 1) + "]");
+  DoTestInversePermutationForInputTypes(
+      kSignedIntegerTypes,
+      [&](const std::shared_ptr<DataType>& input_type) -> Result<Datum> {
+        return ConstantArrayGenerator::Zeroes(input_length, input_type);
+      },
+      /*max_index=*/0, output_type, expected);
+}
+
+TYPED_TEST(TestInversePermutationSmallOutputType, InsufficientOutputType) {
+  auto output_type = this->type_singleton();
+  int64_t input_length =
+      static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max()) + 1;
+  for (const auto& input_type : kSignedIntegerTypes) {
+    ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
+    auto indices = ConstantArrayGenerator::Zeroes(input_length, input_type);
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid,
+        "Invalid: Output type " + output_type->ToString() +
+            " of inverse_permutation is insufficient to store indices of length " +
+            std::to_string(input_length),
+        InversePermutation(indices, /*max_index=*/0, output_type));
+  }
+}
+
+// ----------------------------------------------------------------------
+// Scatter tests
+//
+// Shorthand notation:
+//
+//   A = Array
+//   C = ChunkedArray
+
+namespace {
+
+Result<Datum> Scatter(const Datum& values, const Datum& indices, int64_t max_index) {
+  ScatterOptions options{max_index};
+  ARROW_ASSIGN_OR_RAISE(Datum result, Scatter(values, indices, options));
+  ValidateOutput(result);
+  return result;
+}
+
+void AssertScatterAAA(const std::shared_ptr<Array>& values,
+                      const std::shared_ptr<Array>& indices, int64_t max_index,
+                      const std::shared_ptr<Array>& expected) {
+  ASSERT_OK_AND_ASSIGN(Datum result, Scatter(values, indices, max_index));
+  AssertDatumsEqual(expected, result);
+}
+
+void AssertScatterCAC(const std::shared_ptr<ChunkedArray>& values,
+                      const std::shared_ptr<Array>& indices, int64_t max_index,
+                      const std::shared_ptr<Array>& expected) {
+  ASSERT_OK_AND_ASSIGN(Datum result, Scatter(values, indices, max_index));
+  ASSERT_TRUE(result.is_chunked_array());
+  ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
+  AssertDatumsEqual(expected, result_array);
+}
+
+void AssertScatterACC(const std::shared_ptr<Array>& values,
+                      const std::shared_ptr<ChunkedArray>& indices, int64_t max_index,
+                      const std::shared_ptr<Array>& expected) {
+  ASSERT_OK_AND_ASSIGN(Datum result, Scatter(values, indices, max_index));
+  ASSERT_TRUE(result.is_chunked_array());
+  ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
+  AssertDatumsEqual(expected, result_array);
+}
+
+void AssertScatterCCC(const std::shared_ptr<ChunkedArray>& values,
+                      const std::shared_ptr<ChunkedArray>& indices, int64_t max_index,
+                      const std::shared_ptr<Array>& expected) {
+  ASSERT_OK_AND_ASSIGN(Datum result, Scatter(values, indices, max_index));
+  ASSERT_TRUE(result.is_chunked_array());
+  ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
+  AssertDatumsEqual(expected, result_array);
+}
+
+void DoTestScatterAAA(const std::shared_ptr<Array>& values,
+                      const std::shared_ptr<Array>& indices, int64_t max_index,
+                      const std::shared_ptr<Array>& expected) {
+  AssertScatterAAA(values, indices, max_index, expected);
+}
+
+/// The following helper functions are based on the invariant:
+/// Scatter([V, V], [I', I''], 2 * (m + 1) - 1) == Concat(E, E)
+///
+/// where
+///   V = values
+///   I = indices
+///   m = max_index
+///   I' = ReplaceWithMask(I, i > m, null)
+///   I'' = ReplaceWithMask(I, i < 0, null) + m + 1
+///   E = Scatter(V, I, m)
+
+/// Make indices prefix I' = ReplaceWithMask(I, i > m, null).
+Result<std::shared_ptr<Array>> MakeIndicesPrefix(const std::shared_ptr<Array>& indices,
+                                                 int64_t max_index) {
+  ARROW_ASSIGN_OR_RAISE(auto m, MakeScalar(indices->type(), max_index));
+  ARROW_ASSIGN_OR_RAISE(auto ge_than_l, CallFunction("greater", {indices, m}));
+  ARROW_ASSIGN_OR_RAISE(auto all_null,
+                        MakeArrayOfNull(indices->type(), indices->length()));
+  ARROW_ASSIGN_OR_RAISE(auto prefix, ReplaceWithMask(indices, ge_than_l, all_null));
+  return prefix.make_array();
+}
+
+/// Make indices suffix I'' = ReplaceWithMask(I, i < 0, null) + m + 1.
+Result<std::shared_ptr<Array>> MakeIndicesSuffix(const std::shared_ptr<Array>& indices,
+                                                 int64_t max_index) {
+  ARROW_ASSIGN_OR_RAISE(auto zero, MakeScalar(indices->type(), 0));
+  ARROW_ASSIGN_OR_RAISE(auto negative, CallFunction("less", {indices, zero}));
+  ARROW_ASSIGN_OR_RAISE(auto all_null,
+                        MakeArrayOfNull(indices->type(), indices->length()));
+  ARROW_ASSIGN_OR_RAISE(auto replaced, ReplaceWithMask(indices, negative, all_null));
+  ARROW_ASSIGN_OR_RAISE(auto m, MakeScalar(indices->type(), max_index));
+  ARROW_ASSIGN_OR_RAISE(auto replaced_plus_m, Add(replaced, m));
+  ARROW_ASSIGN_OR_RAISE(auto one, MakeScalar(indices->type(), 1));
+  ARROW_ASSIGN_OR_RAISE(auto suffix, Add(replaced_plus_m, one));
+  return suffix.make_array();
+}
+
+void DoTestScatterCACWithArrays(const std::shared_ptr<Array>& values,
+                                const std::shared_ptr<Array>& indices, int64_t max_index,
+                                const std::shared_ptr<Array>& expected) {
+  auto chunked_values2 = std::make_shared<ChunkedArray>(ArrayVector{values, values});
+
+  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, max_index));
+  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, max_index));
+  ASSERT_OK_AND_ASSIGN(auto concat_indices2,
+                       Concatenate({indices_prefix, indices_suffix}));
+
+  ASSERT_OK_AND_ASSIGN(auto concat_expected2,
+                       Concatenate(ArrayVector{expected, expected}));
+
+  AssertScatterCAC(chunked_values2, concat_indices2, (max_index + 1) * 2 - 1,
+                   concat_expected2);
+}
+
+void DoTestScatterACCWithArrays(const std::shared_ptr<Array>& values,
+                                const std::shared_ptr<Array>& indices, int64_t max_index,
+                                const std::shared_ptr<Array>& expected) {
+  ASSERT_OK_AND_ASSIGN(auto concat_values2, Concatenate(ArrayVector{values, values}));
+
+  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, max_index));
+  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, max_index));
+  auto chunked_indices2 =
+      std::make_shared<ChunkedArray>(ArrayVector{indices_prefix, indices_suffix});
+
+  ASSERT_OK_AND_ASSIGN(auto concat_expected2,
+                       Concatenate(ArrayVector{expected, expected}));
+
+  AssertScatterACC(concat_values2, chunked_indices2, (max_index + 1) * 2 - 1,
+                   concat_expected2);
+}
+
+void DoTestScatterCCCWithArrays(const std::shared_ptr<Array>& values,
+                                const std::shared_ptr<Array>& indices, int64_t max_index,
+                                const std::shared_ptr<Array>& expected) {
+  auto chunked_values2 = std::make_shared<ChunkedArray>(ArrayVector{values, values});
+
+  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, max_index));
+  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, max_index));
+  auto chunked_indices2 =
+      std::make_shared<ChunkedArray>(ArrayVector{indices_prefix, indices_suffix});
+
+  ASSERT_OK_AND_ASSIGN(auto concat_expected2,
+                       Concatenate(ArrayVector{expected, expected}));
+
+  AssertScatterCCC(chunked_values2, chunked_indices2, (max_index + 1) * 2 - 1,
+                   concat_expected2);
+}
+
+void DoTestScatterForIndicesTypes(
+    const std::vector<std::shared_ptr<DataType>>& indices_types,
+    const std::shared_ptr<Array>& values, const std::shared_ptr<Array>& indices,
+    int64_t max_index, const std::shared_ptr<Array>& expected) {
+  for (const auto& indices_type : indices_types) {
+    ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
+    ASSERT_OK_AND_ASSIGN(auto casted, Cast(indices, indices_type));
+    ASSERT_TRUE(casted.is_array());
+    auto casted_indices = casted.make_array();
+    {
+      ARROW_SCOPED_TRACE("AAA");
+      DoTestScatterAAA(values, casted_indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("CAA");
+      DoTestScatterCACWithArrays(values, casted_indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("ACA");
+      DoTestScatterACCWithArrays(values, casted_indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("CCA");
+      DoTestScatterCCCWithArrays(values, casted_indices, max_index, expected);
+    }
+  }
+}
+
+void DoTestScatter(const std::shared_ptr<Array>& values,
+                   const std::shared_ptr<Array>& indices, int64_t max_index,
+                   const std::shared_ptr<Array>& expected) {
+  DoTestScatterForIndicesTypes(kSignedIntegerTypes, values, indices, max_index, expected);
+}
+
+void TestScatter(const std::shared_ptr<DataType>& type, const std::string& values_str,
+                 const std::string& indices_str, int64_t max_index,
+                 const std::string& expected_str) {
+  auto values = ArrayFromJSON(type, values_str);
+  auto indices = ArrayFromJSON(int8(), indices_str);
+  auto expected = ArrayFromJSON(type, expected_str);
+  DoTestScatter(values, indices, max_index, expected);
+}
+
+}  // namespace
+
+TEST(Scatter, Invalid) {
+  {
+    ARROW_SCOPED_TRACE("Length mismatch");
+    auto values = ArrayFromJSON(int32(), "[0, 1]");
+    auto indices = ArrayFromJSON(int32(), "[0]");
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid,
+        "Invalid: Input and indices of scatter must have the same length, got 2 and 1",
+        Scatter(values, indices));
+  }
+  {
+    ARROW_SCOPED_TRACE("Invalid input type");
+    auto values = ArrayFromJSON(int32(), "[0]");
+    {
+      ARROW_SCOPED_TRACE("uint32");
+      auto indices = ArrayFromJSON(uint32(), R"([0])");
+      ASSERT_RAISES_WITH_MESSAGE(
+          TypeError,
+          "Type error: Indices of scatter must be of signed integer type, got uint32",
+          Scatter(values, indices));
+    }
+    {
+      ARROW_SCOPED_TRACE("string");
+      auto indices = ArrayFromJSON(utf8(), R"(["a"])");
+      ASSERT_RAISES_WITH_MESSAGE(
+          TypeError,
+          "Type error: Indices of scatter must be of signed integer type, got string",
+          Scatter(values, indices));
+    }
+  }
+}
+
+TEST(Scatter, DefaultOptions) {
+  {
+    ARROW_SCOPED_TRACE("Default options values");
+    ScatterOptions options;
+    ASSERT_EQ(options.max_index, -1);
+  }
+  {
+    ARROW_SCOPED_TRACE("Default options semantics");
+    auto values = ArrayFromJSON(utf8(), R"(["a"])");
+    for (const auto& indices_type : kSignedIntegerTypes) {
+      ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
+      auto indices = ArrayFromJSON(indices_type, "[0]");
+      ASSERT_OK_AND_ASSIGN(Datum result, Scatter(values, indices));
+      AssertDatumsEqual(values, result);
+    }
+  }
+}
+
+TEST(Scatter, InvalidIndex) {
+  {
+    ARROW_SCOPED_TRACE("Negative index");
+    auto values = ArrayFromJSON(utf8(), R"(["a"])");
+    auto indices = ArrayFromJSON(int32(), "[-1]");
+    ASSERT_RAISES_WITH_MESSAGE(IndexError, "Index error: Index out of bounds: -1",
+                               Scatter(values, indices));
+  }
+  {
+    ARROW_SCOPED_TRACE("Exceeds max_index");
+    auto values = ArrayFromJSON(utf8(), R"(["a"])");
+    auto indices = ArrayFromJSON(int32(), "[42]");
+    ASSERT_RAISES_WITH_MESSAGE(IndexError, "Index error: Index out of bounds: 42",
+                               Scatter(values, indices, /*max_index=*/1));
+  }
+}
+
+template <typename ArrowType>
+class TestScatterSmallIndicesTypes : public ::testing::Test {
+ protected:
+  using CType = typename TypeTraits<ArrowType>::CType;
+
+  std::shared_ptr<DataType> type_singleton() {
+    return TypeTraits<ArrowType>::type_singleton();
+  }
+};
+
+TYPED_TEST_SUITE(TestScatterSmallIndicesTypes, SmallSignedIntegerTypes);
+
+TYPED_TEST(TestScatterSmallIndicesTypes, MaxIntegerIndex) {
+  auto values = ArrayFromJSON(utf8(), R"(["a"])");
+  auto indices_type = this->type_singleton();
+  int64_t max_integer =
+      static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max());
+  auto indices = ArrayFromJSON(indices_type, "[" + std::to_string(max_integer - 1) + "]");
+  ASSERT_OK_AND_ASSIGN(auto expected_prefix_nulls,
+                       MakeArrayOfNull(utf8(), max_integer - 1));
+  auto expected_suffix_value = values;
+  ASSERT_OK_AND_ASSIGN(auto expected,
+                       Concatenate({expected_prefix_nulls, expected_suffix_value}));
+  DoTestScatterAAA(values, indices, /*max_index=*/max_integer - 1, expected);
+}
+
+TEST(Scatter, Boolean) {
+  {
+    ARROW_SCOPED_TRACE("Basic");
+    auto values = "[true, false, true, true, false, false, true, true, true, false]";
+    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+    int64_t max_index = 9;
+    auto expected = "[false, true, true, true, false, false, true, true, false, true]";
+    TestScatter(boolean(), values, indices, max_index, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Values with nulls");
+    auto values = "[true, false, null, true, true, false, false, null, null, true]";
+    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+    int64_t max_index = 9;
+    auto expected = "[true, null, null, false, false, true, true, null, false, true]";
+    TestScatter(boolean(), values, indices, max_index, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices with nulls");
+    auto values = "[true, false, true, true, false, false, true, true, true, false]";
+    auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
+    int64_t max_index = 9;
+    auto expected = "[null, true, null, true, null, false, null, true, null, true]";
+    TestScatter(boolean(), values, indices, max_index, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Output greater than input");
+    auto values = "[true, true, true, false, false, false]";
+    auto indices = "[0, 3, 6, 1, 4, 7]";
+    int64_t max_index = 8;
+    auto expected = "[true, false, null, true, false, null, true, false, null]";
+    TestScatter(boolean(), values, indices, max_index, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Values all null");
+    auto values = "[null, null]";
+    auto indices = "[0, 1]";
+    int64_t max_index = 1;
+    auto expected = "[null, null]";
+    TestScatter(boolean(), values, indices, max_index, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices all null");
+    auto values = "[true, false]";
+    auto indices = "[null, null]";
+    int64_t max_index = 1;
+    auto expected = "[null, null]";
+    TestScatter(boolean(), values, indices, max_index, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Empty input output null");
+    auto values = "[]";
+    auto indices = "[]";
+    int64_t max_index = 1;
+    auto expected = "[null, null]";
+    TestScatter(boolean(), values, indices, max_index, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices duplicated indices");
+    auto values = "[true, false, null, null]";
+    auto indices = "[0, 1, 0, 1]";
+    int64_t max_index = 3;
+    auto expected = "[null, null, null, null]";
+    TestScatter(boolean(), values, indices, max_index, expected);
+  }
+}
+
+TEST(Scatter, Numeric) {
+  for (const auto& type : kSignedIntegerTypes) {
+    ARROW_SCOPED_TRACE(type->ToString());
+    {
+      ARROW_SCOPED_TRACE("Basic");
+      auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
+      auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+      int64_t max_index = 9;
+      auto expected = "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Values with nulls");
+      auto values = "[null, 11, null, 13, null, 15, null, 17, null, 19]";
+      auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+      int64_t max_index = 9;
+      auto expected = "[19, null, 17, null, 15, null, 13, null, 11, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices with nulls");
+      auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
+      auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
+      int64_t max_index = 9;
+      auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Output greater than input");
+      auto values = "[0, 0, 0, 1, 1, 1]";
+      auto indices = "[0, 3, 6, 1, 4, 7]";
+      int64_t max_index = 8;
+      auto expected = "[0, 1, null, 0, 1, null, 0, 1, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Values all null");
+      auto values = "[null, null]";
+      auto indices = "[0, 1]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices all null");
+      auto values = "[0, 1]";
+      auto indices = "[null, null]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Empty input output null");
+      auto values = "[]";
+      auto indices = "[]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices duplicated indices");
+      auto values = "[1, 0, null, null]";
+      auto indices = "[0, 1, 0, 1]";
+      int64_t max_index = 3;
+      auto expected = "[null, null, null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+  }
+}
+
+TEST(Scatter, Binary) {
+  for (const auto& type : kBinaryTypes) {
+    ARROW_SCOPED_TRACE(type->ToString());
+    {
+      ARROW_SCOPED_TRACE("Basic");
+      auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
+      auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+      int64_t max_index = 9;
+      auto expected = R"(["j", "i", "h", "g", "f", "e", "d", "c", "b", "a"])";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Values with nulls");
+      auto values = R"([null, "b", null, "d", null, "f", null, "h", null, "j"])";
+      auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+      int64_t max_index = 9;
+      auto expected = R"(["j", null, "h", null, "f", null, "d", null, "b", null])";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices with nulls");
+      auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
+      auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
+      int64_t max_index = 9;
+      auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Output greater than input");
+      auto values = R"(["a", "a", "a", "b", "b", "b"])";
+      auto indices = "[0, 3, 6, 1, 4, 7]";
+      int64_t max_index = 8;
+      auto expected = R"(["a", "b", null, "a", "b", null, "a", "b", null])";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Values all null");
+      auto values = "[null, null]";
+      auto indices = "[0, 1]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices all null");
+      auto values = R"(["a", "b"])";
+      auto indices = "[null, null]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Empty input output null");
+      auto values = "[]";
+      auto indices = "[]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices duplicated indices");
+      auto values = R"(["a", "b", null, null])";
+      auto indices = "[0, 1, 0, 1]";
+      int64_t max_index = 3;
+      auto expected = "[null, null, null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+  }
+}
+
+}  // namespace arrow::compute
diff --git a/cpp/src/arrow/compute/registry.cc b/cpp/src/arrow/compute/registry.cc
index 0f535eb373269..ef9f3c7e1fbf5 100644
--- a/cpp/src/arrow/compute/registry.cc
+++ b/cpp/src/arrow/compute/registry.cc
@@ -321,6 +321,7 @@ static std::unique_ptr<FunctionRegistry> CreateBuiltInRegistry() {
   RegisterVectorRunEndEncode(registry.get());
   RegisterVectorRunEndDecode(registry.get());
   RegisterVectorPairwise(registry.get());
+  RegisterVectorSwizzle(registry.get());
 
   // Aggregate functions
   RegisterHashAggregateBasic(registry.get());
diff --git a/cpp/src/arrow/compute/registry_internal.h b/cpp/src/arrow/compute/registry_internal.h
index cdc9f804e72f1..8287e6305086d 100644
--- a/cpp/src/arrow/compute/registry_internal.h
+++ b/cpp/src/arrow/compute/registry_internal.h
@@ -56,6 +56,7 @@ void RegisterVectorSort(FunctionRegistry* registry);
 void RegisterVectorRunEndEncode(FunctionRegistry* registry);
 void RegisterVectorRunEndDecode(FunctionRegistry* registry);
 void RegisterVectorPairwise(FunctionRegistry* registry);
+void RegisterVectorSwizzle(FunctionRegistry* registry);
 void RegisterVectorOptions(FunctionRegistry* registry);
 
 // Aggregate functions
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index ec53fb04688bc..04d1123cf235f 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1929,3 +1929,28 @@ operation to the n-th and (n+abs(p))-th inputs.
   ``Subtract``. The period can be specified in :struct:`PairwiseOptions`.
 * \(2) Wraps around the result when overflow is detected.
 * \(3) Returns an ``Invalid`` :class:`Status` when overflow is detected.
+
+Swizzle functions
+~~~~~~~~~~~~~~~~~~~
+
+Swizzle functions reorder the input array based on the specified indices.
+
++---------------------+--------+----------------+--------------+---------------------+-------------------------------------+-------+
+| Function name       | Arity  | Input type 1   | Input type 2 | Output type         | Options class                       | Notes |
++=====================+========+================+==============+=====================+=====================================+=======+
+| inverse_permutation | Unary  | Signed Integer |              | Signed Integer \(1) | :struct:`InversePermutationOptions` | \(2)  |
++---------------------+--------+----------------+--------------+---------------------+-------------------------------------+-------+
+| scatter             | Binary | Any            | Integer      | Input type 1        | :struct:`ScatterOptions`            | \(3)  |
++---------------------+--------+----------------+--------------+---------------------+-------------------------------------+-------+
+
+* \(1) The output type is specified in :struct:`InversePermutationOptions`.
+
+* \(2) For ``indices[i] = x``, ``inverse_permutation[x] = i``. And ``inverse_permutation[x]
+  = null`` if ``x`` does not appear in the input ``indices``. Indices must be in the range
+  of ``[0, max_index]``, or null, which will be ignored. If multiple indices point to the
+  same value, the last one is used.
+
+* \(3) For ``indices[i] = x``, ``output[x] = values[i]``. And ``output[x] = null``
+  if ``x`` does not appear in the input ``indices``. Indices must be in the range
+  of ``[0, max_index]``, or null, in which case the corresponding value will be
+  ignored. If multiple indices point to the same value, the last one is used.