diff --git a/cpp/src/arrow/compute/kernels/vector_array_sort.cc b/cpp/src/arrow/compute/kernels/vector_array_sort.cc
index ccf691669b8..1499554a960 100644
--- a/cpp/src/arrow/compute/kernels/vector_array_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_array_sort.cc
@@ -143,9 +143,9 @@ class ArrayCompareSorter {
   using GetView = GetViewType<ArrowType>;
 
  public:
-  NullPartitionResult operator()(uint64_t* indices_begin, uint64_t* indices_end,
-                                 const Array& array, int64_t offset,
-                                 const ArraySortOptions& options) {
+  Result<NullPartitionResult> operator()(uint64_t* indices_begin, uint64_t* indices_end,
+                                         const Array& array, int64_t offset,
+                                         const ArraySortOptions& options, ExecContext*) {
     const auto& values = checked_cast<const ArrayType&>(array);
 
     const auto p = PartitionNulls<ArrayType, StablePartitioner>(
@@ -173,6 +173,95 @@ class ArrayCompareSorter {
   }
 };
 
+template <>
+class ArrayCompareSorter<DictionaryType> {
+ public:
+  Result<NullPartitionResult> operator()(uint64_t* indices_begin, uint64_t* indices_end,
+                                         const Array& array, int64_t offset,
+                                         const ArraySortOptions& options,
+                                         ExecContext* ctx) {
+    const auto& dict_array = checked_cast<const DictionaryArray&>(array);
+    // TODO: These methods should probably return a const&? They seem capable.
+    // https://github.com/apache/arrow/issues/35437
+    auto dict_values = dict_array.dictionary();
+    auto dict_indices = dict_array.indices();
+
+    // Algorithm:
+    // 1) Use the Rank function to get an exactly-equivalent-order array
+    //    of the dictionary values, but with a datatype that's friendlier to
+    //    sorting (uint64).
+    // 2) Act as if we were sorting a dictionary array with the same indices,
+    //    but with the ranks as dictionary values.
+    // 2a) Dictionary-decode the ranks by calling Take.
+    // 2b) Sort the decoded ranks. Not only those are uint64, they are dense
+    //     in a [0, k) range where k is the number of unique dictionary values.
+    //     Therefore, unless the dictionary is very large, a fast counting sort
+    //     will be used.
+    //
+    // The bottom line is that performance will usually be much better
+    // (potentially an order of magnitude faster) than by naively decoding
+    // the original dictionary and sorting the decoded version.
+
+    std::shared_ptr<Array> decoded_ranks;
+    // Skip the rank/take steps for cases with only nulls or no indices
+    if (dict_indices->length() == 0 ||
+        dict_indices->null_count() == dict_indices->length() ||
+        dict_values->null_count() == dict_values->length()) {
+      ARROW_ASSIGN_OR_RAISE(decoded_ranks, MakeArrayOfNull(uint64(), dict_array.length(),
+                                                           ctx->memory_pool()));
+    } else {
+      ARROW_ASSIGN_OR_RAISE(auto ranks, RanksWithNulls(dict_values, ctx));
+
+      ARROW_ASSIGN_OR_RAISE(decoded_ranks,
+                            Take(*ranks, *dict_indices, TakeOptions::Defaults(), ctx));
+    }
+
+    DCHECK_EQ(decoded_ranks->type_id(), Type::UINT64);
+    DCHECK_EQ(decoded_ranks->length(), dict_array.length());
+    ARROW_ASSIGN_OR_RAISE(auto rank_sorter, GetArraySorter(*decoded_ranks->type()));
+
+    return rank_sorter(indices_begin, indices_end, *decoded_ranks, offset, options, ctx);
+  }
+
+ private:
+  static Result<std::shared_ptr<Array>> RanksWithNulls(
+      const std::shared_ptr<Array>& array, ExecContext* ctx) {
+    // Notes:
+    // * The order is always ascending here, since the goal is to produce
+    //   an exactly-equivalent-order of the dictionary values.
+    // * We're going to re-emit nulls in the output, so we can just always consider
+    //   them "at the end".  Note that choosing AtStart would merely shift other
+    //   ranks by 1 if there are any nulls...
+    RankOptions rank_options(SortOrder::Ascending, NullPlacement::AtEnd,
+                             RankOptions::Dense);
+
+    // XXX Should this support Type::NA?
+    auto data = array->data();
+    std::shared_ptr<Buffer> null_bitmap;
+    if (array->null_count() > 0) {
+      null_bitmap = array->null_bitmap();
+      data = array->data()->Copy();
+      if (data->offset > 0) {
+        ARROW_ASSIGN_OR_RAISE(null_bitmap, arrow::internal::CopyBitmap(
+                                               ctx->memory_pool(), null_bitmap->data(),
+                                               data->offset, data->length));
+      }
+      data->buffers[0] = nullptr;
+      data->null_count = 0;
+    }
+    ARROW_ASSIGN_OR_RAISE(auto rank_datum,
+                          CallFunction("rank", {std::move(data)}, &rank_options, ctx));
+    auto rank_data = rank_datum.array();
+    DCHECK_EQ(rank_data->GetNullCount(), 0);
+    // If there were nulls in the input, paste them in the output
+    if (null_bitmap) {
+      rank_data->buffers[0] = std::move(null_bitmap);
+      rank_data->null_count = array->null_count();
+    }
+    return MakeArray(rank_data);
+  }
+};
+
 template <typename ArrowType>
 class ArrayCountSorter {
   using ArrayType = typename TypeTraits<ArrowType>::ArrayType;
@@ -189,9 +278,10 @@ class ArrayCountSorter {
     value_range_ = static_cast<uint32_t>(max - min) + 1;
   }
 
-  NullPartitionResult operator()(uint64_t* indices_begin, uint64_t* indices_end,
-                                 const Array& array, int64_t offset,
-                                 const ArraySortOptions& options) const {
+  Result<NullPartitionResult> operator()(uint64_t* indices_begin, uint64_t* indices_end,
+                                         const Array& array, int64_t offset,
+                                         const ArraySortOptions& options,
+                                         ExecContext*) const {
     const auto& values = checked_cast<const ArrayType&>(array);
 
     // 32bit counter performs much better than 64bit one
@@ -273,9 +363,9 @@ class ArrayCountSorter<BooleanType> {
  public:
   ArrayCountSorter() = default;
 
-  NullPartitionResult operator()(uint64_t* indices_begin, uint64_t* indices_end,
-                                 const Array& array, int64_t offset,
-                                 const ArraySortOptions& options) {
+  Result<NullPartitionResult> operator()(uint64_t* indices_begin, uint64_t* indices_end,
+                                         const Array& array, int64_t offset,
+                                         const ArraySortOptions& options, ExecContext*) {
     const auto& values = checked_cast<const BooleanArray&>(array);
 
     std::array<int64_t, 3> counts{0, 0, 0};  // false, true, null
@@ -318,9 +408,10 @@ class ArrayCountOrCompareSorter {
   using c_type = typename ArrowType::c_type;
 
  public:
-  NullPartitionResult operator()(uint64_t* indices_begin, uint64_t* indices_end,
-                                 const Array& array, int64_t offset,
-                                 const ArraySortOptions& options) {
+  Result<NullPartitionResult> operator()(uint64_t* indices_begin, uint64_t* indices_end,
+                                         const Array& array, int64_t offset,
+                                         const ArraySortOptions& options,
+                                         ExecContext* ctx) {
     const auto& values = checked_cast<const ArrayType&>(array);
 
     if (values.length() >= countsort_min_len_ && values.length() > values.null_count()) {
@@ -332,11 +423,11 @@ class ArrayCountOrCompareSorter {
       if (static_cast<uint64_t>(max) - static_cast<uint64_t>(min) <=
           countsort_max_range_) {
         count_sorter_.SetMinMax(min, max);
-        return count_sorter_(indices_begin, indices_end, values, offset, options);
+        return count_sorter_(indices_begin, indices_end, values, offset, options, ctx);
       }
     }
 
-    return compare_sorter_(indices_begin, indices_end, values, offset, options);
+    return compare_sorter_(indices_begin, indices_end, values, offset, options, ctx);
   }
 
  private:
@@ -358,9 +449,9 @@ class ArrayCountOrCompareSorter {
 
 class ArrayNullSorter {
  public:
-  NullPartitionResult operator()(uint64_t* indices_begin, uint64_t* indices_end,
-                                 const Array& values, int64_t offset,
-                                 const ArraySortOptions& options) {
+  Result<NullPartitionResult> operator()(uint64_t* indices_begin, uint64_t* indices_end,
+                                         const Array& values, int64_t offset,
+                                         const ArraySortOptions& options, ExecContext*) {
     return NullPartitionResult::NullsOnly(indices_begin, indices_end,
                                           options.null_placement);
   }
@@ -405,7 +496,8 @@ struct ArraySorter<Type, enable_if_t<is_integer_type<Type>::value &&
 template <typename Type>
 struct ArraySorter<
     Type, enable_if_t<is_floating_type<Type>::value || is_base_binary_type<Type>::value ||
-                      is_fixed_size_binary_type<Type>::value>> {
+                      is_fixed_size_binary_type<Type>::value ||
+                      is_dictionary_type<Type>::value>> {
   ArrayCompareSorter<Type> impl;
 };
 
@@ -445,8 +537,7 @@ struct ArraySortIndices {
     ArrayType arr(batch[0].array.ToArrayData());
     ARROW_ASSIGN_OR_RAISE(auto sorter, GetArraySorter(*GetPhysicalType(arr.type())));
 
-    sorter(out_begin, out_end, arr, 0, options);
-    return Status::OK();
+    return sorter(out_begin, out_end, arr, 0, options, ctx->exec_context()).status();
   }
 };
 
@@ -508,6 +599,13 @@ void AddArraySortingKernels(VectorKernel base, VectorFunction* func) {
   DCHECK_OK(func->AddKernel(base));
 }
 
+template <template <typename...> class ExecTemplate>
+void AddDictArraySortingKernels(VectorKernel base, VectorFunction* func) {
+  base.signature = KernelSignature::Make({Type::DICTIONARY}, uint64());
+  base.exec = ExecTemplate<UInt64Type, DictionaryType>::Exec;
+  DCHECK_OK(func->AddKernel(base));
+}
+
 const ArraySortOptions* GetDefaultArraySortOptions() {
   static const auto kDefaultArraySortOptions = ArraySortOptions::Defaults();
   return &kDefaultArraySortOptions;
@@ -562,6 +660,7 @@ void RegisterVectorArraySort(FunctionRegistry* registry) {
   base.init = ArraySortIndicesState::Init;
   base.exec_chunked = ArraySortIndicesChunked;
   AddArraySortingKernels<ArraySortIndices>(base, array_sort_indices.get());
+  AddDictArraySortingKernels<ArraySortIndices>(base, array_sort_indices.get());
   DCHECK_OK(registry->AddFunction(std::move(array_sort_indices)));
 
   // partition_nth_indices has a parameter so needs its init function
diff --git a/cpp/src/arrow/compute/kernels/vector_rank.cc b/cpp/src/arrow/compute/kernels/vector_rank.cc
index 828316514f6..780ae25d963 100644
--- a/cpp/src/arrow/compute/kernels/vector_rank.cc
+++ b/cpp/src/arrow/compute/kernels/vector_rank.cc
@@ -202,8 +202,9 @@ class Ranker<Array> : public RankerMixin<Array, Ranker<Array>> {
     ARROW_ASSIGN_OR_RAISE(auto array_sorter, GetArraySorter(*physical_type_));
 
     ArrayType array(input_.data());
-    NullPartitionResult sorted = array_sorter(indices_begin_, indices_end_, array, 0,
-                                              ArraySortOptions(order_, null_placement_));
+    ARROW_ASSIGN_OR_RAISE(NullPartitionResult sorted,
+                          array_sorter(indices_begin_, indices_end_, array, 0,
+                                       ArraySortOptions(order_, null_placement_), ctx_));
 
     auto value_selector = [&array](int64_t index) {
       return GetView::LogicalValue(array.GetView(index));
diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 110abd27d8f..1de90cac35b 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -95,9 +95,9 @@ class ChunkedArraySorter : public TypeVisitor {
       const auto array = checked_cast<const ArrayType*>(arrays[i]);
       end_offset += array->length();
       null_count += array->null_count();
-      sorted[i] =
-          array_sorter_(indices_begin_ + begin_offset, indices_begin_ + end_offset,
-                        *array, begin_offset, options);
+      ARROW_ASSIGN_OR_RAISE(sorted[i], array_sorter_(indices_begin_ + begin_offset,
+                                                     indices_begin_ + end_offset, *array,
+                                                     begin_offset, options, ctx_));
       begin_offset = end_offset;
     }
     DCHECK_EQ(end_offset, indices_end_ - indices_begin_);
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc b/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
index 67f03c1eb6c..0cefddff5a1 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
@@ -27,7 +27,9 @@
 
 namespace arrow {
 namespace compute {
+
 constexpr auto kSeed = 0x0ff1ce;
+constexpr int32_t kDictionarySize = 24;  // a typical dictionary size
 
 //
 // Array sort/rank benchmark helpers
@@ -70,6 +72,22 @@ static void ArraySortFuncBenchmark(benchmark::State& state, const Runner& runner
   state.SetItemsProcessed(state.iterations() * values->length());
 }
 
+// Compute the number of values in a StringArray based on a target `num_bytes`
+static int64_t GetStringArraySize(int64_t num_bytes, int32_t min_length,
+                                  int32_t max_length, double null_proportion,
+                                  int num_chunks = 1) {
+  // The array_size is derived from these two equations:
+  //
+  //     num_bytes = array_size * (1.0 - null_proportion) * string_mean_length
+  //     string_mean_length = (max_length + min_length) / 2.0
+  const double valid_proportion = 1.0 - null_proportion;
+  const double array_size =
+      (valid_proportion > std::numeric_limits<double>::epsilon())
+          ? (num_bytes * 2) / (valid_proportion * (max_length + min_length))
+          : (num_bytes * 2) / (max_length + min_length);
+  return static_cast<int64_t>(std::round(array_size / num_chunks));
+}
+
 template <typename Runner>
 static void ArraySortFuncInt64Benchmark(benchmark::State& state, const Runner& runner,
                                         int64_t min, int64_t max) {
@@ -83,50 +101,64 @@ static void ArraySortFuncInt64Benchmark(benchmark::State& state, const Runner& r
 }
 
 template <typename Runner>
-static void ChunkedArraySortFuncInt64Benchmark(benchmark::State& state,
-                                               const Runner& runner, int64_t min,
-                                               int64_t max) {
+static void ArraySortFuncInt64DictBenchmark(benchmark::State& state, const Runner& runner,
+                                            int64_t min, int64_t max, int32_t dict_size) {
   RegressionArgs args(state);
 
-  const int64_t n_chunks = 10;
-  const int64_t array_size = args.size / n_chunks / sizeof(int64_t);
-  auto rand = random::RandomArrayGenerator(kSeed);
-  ArrayVector chunks;
-  for (int64_t i = 0; i < n_chunks; ++i) {
-    chunks.push_back(rand.Int64(array_size, min, max, args.null_proportion));
+  double null_proportion = args.null_proportion;
+  double values_null_proportion = null_proportion / 2;
+  if (1.0 - null_proportion < std::numeric_limits<double>::epsilon()) {
+    values_null_proportion = null_proportion = 1.0;
   }
+  double indices_null_proportion = null_proportion - values_null_proportion;
 
-  ArraySortFuncBenchmark(state, runner, std::make_shared<ChunkedArray>(chunks));
+  const int64_t array_size = args.size / sizeof(int64_t);
+
+  auto rand = random::RandomArrayGenerator(kSeed);
+  auto dict_values = rand.Int64(dict_size, min, max, values_null_proportion);
+  auto dict_indices = rand.Int64(array_size, 0, dict_size - 1, indices_null_proportion);
+  auto dict_array = *DictionaryArray::FromArrays(dict_indices, dict_values);
+
+  ArraySortFuncBenchmark(state, runner, dict_array);
 }
 
 template <typename Runner>
-static void ChunkedArraySortFuncStringBenchmark(benchmark::State& state,
-                                                const Runner& runner, int32_t min_length,
-                                                int32_t max_length) {
+static void ArraySortFuncStringBenchmark(benchmark::State& state, const Runner& runner,
+                                         int32_t min_length, int32_t max_length) {
   RegressionArgs args(state);
 
-  // The array_size is derived from these two equations:
-  //
-  //     size = array_size * (1.0 - args.null_proportion) * string_mean_length
-  //     string_mean_length = (max_length + min_length) / 2.0
-  const double valid_proportion = 1.0 - args.null_proportion;
-  const double array_size =
-      (valid_proportion > std::numeric_limits<double>::epsilon())
-          ? (args.size * 2) / (valid_proportion * (max_length + min_length))
-          : (args.size * 2) / (max_length + min_length);
+  const int64_t array_size =
+      GetStringArraySize(args.size, min_length, max_length, args.null_proportion);
 
-  const auto n_chunks = 10;
-  const auto array_chunk_size = static_cast<int64_t>(std::round(array_size / n_chunks));
   auto rand = random::RandomArrayGenerator(kSeed);
+  auto values = rand.String(array_size, min_length, max_length, args.null_proportion);
 
-  ArrayVector chunks;
-  for (auto i = 0; i < n_chunks; ++i) {
-    auto values =
-        rand.String(array_chunk_size, min_length, max_length, args.null_proportion);
-    chunks.push_back(std::move(values));
+  ArraySortFuncBenchmark(state, runner, values);
+}
+
+template <typename Runner>
+static void ArraySortFuncStringDictBenchmark(benchmark::State& state,
+                                             const Runner& runner, int32_t min_length,
+                                             int32_t max_length, int32_t dict_size) {
+  RegressionArgs args(state);
+
+  double null_proportion = args.null_proportion;
+  double values_null_proportion = null_proportion / 2;
+  if (1.0 - null_proportion < std::numeric_limits<double>::epsilon()) {
+    values_null_proportion = null_proportion = 1.0;
   }
+  double indices_null_proportion = null_proportion - values_null_proportion;
 
-  ArraySortFuncBenchmark(state, runner, std::make_shared<ChunkedArray>(chunks));
+  const int64_t array_size =
+      GetStringArraySize(args.size, min_length, max_length, null_proportion);
+
+  auto rand = random::RandomArrayGenerator(kSeed);
+  auto dict_values =
+      rand.String(dict_size, min_length, max_length, values_null_proportion);
+  auto dict_indices = rand.Int64(array_size, 0, dict_size - 1, indices_null_proportion);
+  auto dict_array = *DictionaryArray::FromArrays(dict_indices, dict_values);
+
+  ArraySortFuncBenchmark(state, runner, dict_array);
 }
 
 template <typename Runner>
@@ -141,21 +173,41 @@ static void ArraySortFuncBoolBenchmark(benchmark::State& state, const Runner& ru
 }
 
 template <typename Runner>
-static void ArraySortFuncStringBenchmark(benchmark::State& state, const Runner& runner,
-                                         int32_t min_length, int32_t max_length) {
+static void ChunkedArraySortFuncInt64Benchmark(benchmark::State& state,
+                                               const Runner& runner, int64_t min,
+                                               int64_t max) {
   RegressionArgs args(state);
 
-  const double valid_proportion = 1.0 - args.null_proportion;
-  const double array_size =
-      (valid_proportion > std::numeric_limits<double>::epsilon())
-          ? (args.size * 2) / (valid_proportion * (max_length + min_length))
-          : (args.size * 2) / (max_length + min_length);
-  const auto array_size_i = static_cast<int64_t>(std::round(array_size));
+  const int64_t n_chunks = 10;
+  const int64_t array_size = args.size / n_chunks / sizeof(int64_t);
+  auto rand = random::RandomArrayGenerator(kSeed);
+  ArrayVector chunks;
+  for (int64_t i = 0; i < n_chunks; ++i) {
+    chunks.push_back(rand.Int64(array_size, min, max, args.null_proportion));
+  }
+
+  ArraySortFuncBenchmark(state, runner, std::make_shared<ChunkedArray>(chunks));
+}
+
+template <typename Runner>
+static void ChunkedArraySortFuncStringBenchmark(benchmark::State& state,
+                                                const Runner& runner, int32_t min_length,
+                                                int32_t max_length) {
+  RegressionArgs args(state);
 
+  const auto n_chunks = 10;
+  const auto array_chunk_size = GetStringArraySize(args.size, min_length, max_length,
+                                                   args.null_proportion, n_chunks);
   auto rand = random::RandomArrayGenerator(kSeed);
-  auto values = rand.String(array_size_i, min_length, max_length, args.null_proportion);
 
-  ArraySortFuncBenchmark(state, runner, values);
+  ArrayVector chunks;
+  for (auto i = 0; i < n_chunks; ++i) {
+    auto values =
+        rand.String(array_chunk_size, min_length, max_length, args.null_proportion);
+    chunks.push_back(std::move(values));
+  }
+
+  ArraySortFuncBenchmark(state, runner, std::make_shared<ChunkedArray>(chunks));
 }
 
 static void ArraySortIndicesInt64Narrow(benchmark::State& state) {
@@ -176,6 +228,13 @@ static void ArraySortIndicesInt64Wide(benchmark::State& state) {
   ArraySortFuncInt64Benchmark(state, SortRunner(state), min, max);
 }
 
+static void ArraySortIndicesInt64WideDict(benchmark::State& state) {
+  const auto dict_size = kDictionarySize;
+  const auto min = std::numeric_limits<int64_t>::min();
+  const auto max = std::numeric_limits<int64_t>::max();
+  ArraySortFuncInt64DictBenchmark(state, SortRunner(state), min, max, dict_size);
+}
+
 static void ArrayRankInt64Wide(benchmark::State& state) {
   const auto min = std::numeric_limits<int64_t>::min();
   const auto max = std::numeric_limits<int64_t>::max();
@@ -204,6 +263,14 @@ static void ArraySortIndicesStringWide(benchmark::State& state) {
   ArraySortFuncStringBenchmark(state, SortRunner(state), min_length, max_length);
 }
 
+static void ArraySortIndicesStringWideDict(benchmark::State& state) {
+  const auto dict_size = kDictionarySize;
+  const auto min_length = 0;
+  const auto max_length = 64;
+  ArraySortFuncStringDictBenchmark(state, SortRunner(state), min_length, max_length,
+                                   dict_size);
+}
+
 static void ArrayRankStringNarrow(benchmark::State& state) {
   const auto min_length = 0;
   const auto max_length = 16;
@@ -386,9 +453,11 @@ void ArraySortIndicesSetArgs(benchmark::internal::Benchmark* bench) {
 
 BENCHMARK(ArraySortIndicesInt64Narrow)->Apply(ArraySortIndicesSetArgs);
 BENCHMARK(ArraySortIndicesInt64Wide)->Apply(ArraySortIndicesSetArgs);
+BENCHMARK(ArraySortIndicesInt64WideDict)->Apply(ArraySortIndicesSetArgs);
 BENCHMARK(ArraySortIndicesBool)->Apply(ArraySortIndicesSetArgs);
 BENCHMARK(ArraySortIndicesStringNarrow)->Apply(ArraySortIndicesSetArgs);
 BENCHMARK(ArraySortIndicesStringWide)->Apply(ArraySortIndicesSetArgs);
+BENCHMARK(ArraySortIndicesStringWideDict)->Apply(ArraySortIndicesSetArgs);
 
 BENCHMARK(ChunkedArraySortIndicesInt64Narrow)->Apply(ArraySortIndicesSetArgs);
 BENCHMARK(ChunkedArraySortIndicesInt64Wide)->Apply(ArraySortIndicesSetArgs);
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_internal.h b/cpp/src/arrow/compute/kernels/vector_sort_internal.h
index 4645c593901..d78e5130617 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_internal.h
+++ b/cpp/src/arrow/compute/kernels/vector_sort_internal.h
@@ -447,9 +447,9 @@ struct MergeImpl {
 // TODO make this usable if indices are non trivial on input
 // (see ConcreteRecordBatchColumnSorter)
 // `offset` is used when this is called on a chunk of a chunked array
-using ArraySortFunc = std::function<NullPartitionResult(
+using ArraySortFunc = std::function<Result<NullPartitionResult>(
     uint64_t* indices_begin, uint64_t* indices_end, const Array& values, int64_t offset,
-    const ArraySortOptions& options)>;
+    const ArraySortOptions& options, ExecContext* ctx)>;
 
 Result<ArraySortFunc> GetArraySorter(const DataType& type);
 
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_test.cc b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
index d6b10467631..3429a5a8785 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
@@ -368,6 +368,138 @@ TEST(ArraySortIndicesFunction, Array) {
   AssertDatumsEqual(expected, actual, /*verbose=*/true);
 }
 
+TEST(ArraySortIndicesFunction, DictionaryArray) {
+  // Decoded dictionary array:
+  // (["b", "c", null, null, null, "b", "c", "c", "a"])
+
+  std::vector<std::string> expected_str = {
+      "[8, 0, 5, 1, 6, 7, 2, 3, 4]",  // SortOrder::Ascending NullPlacement::AtEnd
+      "[2, 3, 4, 8, 0, 5, 1, 6, 7]",  // SortOrder::Ascending NullPlacement::AtStart
+      "[1, 6, 7, 0, 5, 8, 2, 3, 4]",  // SortOrder::Descending NullPlacement::AtEnd
+      "[2, 3, 4, 1, 6, 7, 0, 5, 8]"   // SortOrder::Descending NullPlacement::AtStart
+  };
+
+  for (const auto& index_type : all_dictionary_index_types()) {
+    ARROW_SCOPED_TRACE("index_type = ", index_type->ToString());
+    int i = 0;
+    auto dict_arr = DictArrayFromJSON(dictionary(index_type, utf8()),
+                                      "[0, 4, null, 1, null, 0, 4, 2, 3]",
+                                      "[ \"b\", null, \"c\", \"a\", \"c\"]");
+    for (auto order : AllOrders()) {
+      for (auto null_placement : AllNullPlacements()) {
+        ARROW_SCOPED_TRACE("i = ", i);
+        ArraySortOptions options{order, null_placement};
+        auto expected = ArrayFromJSON(uint64(), expected_str[i++]);
+        ASSERT_OK_AND_ASSIGN(auto actual,
+                             CallFunction("array_sort_indices", {dict_arr}, &options));
+        ValidateOutput(actual);
+        AssertDatumsEqual(expected, actual, /*verbose=*/true);
+      }
+    }
+  }
+}
+
+TEST(ArraySortIndicesFunction, EmptyDictionaryArray) {
+  auto expected = ArrayFromJSON(uint64(), "[]");
+  auto dict_arr = DictArrayFromJSON(dictionary(int32(), utf8()), "[]", "[\"b\", \"a\"]");
+  auto options = ArraySortOptions::Defaults();
+
+  ASSERT_OK_AND_ASSIGN(auto actual,
+                       CallFunction("array_sort_indices", {dict_arr}, &options));
+  ValidateOutput(actual);
+  AssertDatumsEqual(expected, actual, /*verbose=*/true);
+}
+
+TEST(ArraySortIndicesFunction, AllNullDictionaryArray) {
+  auto expected = ArrayFromJSON(uint64(), "[0, 1, 2, 3]");
+  auto dict_type = dictionary(int32(), utf8());
+  ArrayVector dict_arrs = {
+      DictArrayFromJSON(dict_type, "[null, 3, null, 1]", "[\"b\", null, \"a\", null]"),
+      DictArrayFromJSON(dict_type, "[null, null, null, null]", "[\"c\", \"a\"]"),
+      DictArrayFromJSON(dict_type, "[0, 1, 1, 0]", "[null, null]"),
+  };
+
+  int i = 0;
+  for (auto order : AllOrders()) {
+    for (auto null_placement : AllNullPlacements()) {
+      ArraySortOptions options{order, null_placement};
+
+      for (const auto& dict_arr : dict_arrs) {
+        ARROW_SCOPED_TRACE("i = ", i);
+        ASSERT_OK_AND_ASSIGN(auto actual,
+                             CallFunction("array_sort_indices", {dict_arr}, &options));
+        ValidateOutput(actual);
+        AssertDatumsEqual(expected, actual, /*verbose=*/true);
+        ++i;
+      }
+    }
+  }
+}
+
+Result<std::shared_ptr<Array>> DecodeDictionary(const Array& array) {
+  const auto& dict_array = checked_cast<const DictionaryArray&>(array);
+  ARROW_ASSIGN_OR_RAISE(auto decoded_datum,
+                        Take(dict_array.dictionary(), dict_array.indices()));
+  return decoded_datum.make_array();
+}
+
+TEST(ArraySortIndicesFunction, RandomDictionaryArray) {
+  ::arrow::random::RandomArrayGenerator rng(/*seed=*/1234);
+  constexpr int64_t kLength = 200;
+  constexpr int64_t kDictLength = 20;
+  // Lengths of source arrays which each dictionary array's index and value arrays are
+  // sliced from
+  constexpr int64_t kNumIndices = kLength * 4;
+  constexpr int64_t kNumValues = kDictLength * 8;
+
+  // Ensure there are duplicates in the dictionary and the indices, and nulls in both as
+  // well.
+  auto source_values = rng.StringWithRepeats(kNumValues, /*unique=*/kNumValues / 2,
+                                             /*min_length=*/1, /*max_length=*/10,
+                                             /*null_probability=*/0.2);
+  auto source_indices =
+      rng.Int64(kNumIndices, 0, kDictLength - 1, /*null_probability = */ 0.2);
+
+  auto get_test_array = [&](int64_t indices_offset,
+                            int64_t values_offset) -> std::shared_ptr<Array> {
+    auto out = *DictionaryArray::FromArrays(
+        *source_indices->SliceSafe(indices_offset, kLength),
+        *source_values->SliceSafe(values_offset, kDictLength));
+    ARROW_CHECK_EQ(out->length(), kLength);
+    ARROW_CHECK_EQ(checked_cast<const DictionaryArray&>(*out).dictionary()->length(),
+                   kDictLength);
+    return out;
+  };
+
+  // Test cases are sliced from the beginning/middle/end
+  ArrayVector dict_arrays;
+  dict_arrays.push_back(get_test_array(0, 0));
+  dict_arrays.push_back(get_test_array(kNumIndices / 3, kNumValues / 3));
+  dict_arrays.push_back(get_test_array(kNumIndices - kLength, kNumValues - kDictLength));
+
+  for (size_t i = 0; i < dict_arrays.size(); ++i) {
+    ARROW_SCOPED_TRACE("i = ", i);
+    auto dict_array = dict_arrays[i];
+
+    ASSERT_OK_AND_ASSIGN(auto decoded, DecodeDictionary(*dict_array));
+
+    for (auto order : AllOrders()) {
+      for (auto null_placement : AllNullPlacements()) {
+        ArraySortOptions options{order, null_placement};
+        // Sorting the dictionary array...
+        ASSERT_OK_AND_ASSIGN(auto actual,
+                             CallFunction("array_sort_indices", {dict_array}, &options));
+        ValidateOutput(actual);
+
+        // should give identical results to sorting the decoded array
+        ASSERT_OK_AND_ASSIGN(auto expected,
+                             CallFunction("array_sort_indices", {decoded}, &options));
+        AssertDatumsEqual(expected, actual, /*verbose=*/true);
+      }
+    }
+  }
+}
+
 TEST(ArraySortIndicesFunction, ChunkedArray) {
   auto arr = ChunkedArrayFromJSON(int16(), {"[0, 1]", "[null, -3, null, -42, 5]"});
   auto expected = ChunkedArrayFromJSON(uint64(), {"[5, 3, 0, 1, 6, 2, 4]"});
diff --git a/cpp/src/arrow/util/benchmark_util.h b/cpp/src/arrow/util/benchmark_util.h
index 319730f5bad..2a3dcf56f88 100644
--- a/cpp/src/arrow/util/benchmark_util.h
+++ b/cpp/src/arrow/util/benchmark_util.h
@@ -108,7 +108,7 @@ void RegressionSetArgs(benchmark::internal::Benchmark* bench) {
 // RAII struct to handle some of the boilerplate in regression benchmarks
 struct RegressionArgs {
   // size of memory tested (per iteration) in bytes
-  const int64_t size;
+  int64_t size;
 
   // proportion of nulls in generated arrays
   double null_proportion;