Powerbuilder Sort Array Objects

Used

Long arr[] = {10,1234,25,66,43,567,123,345,1123,5232,6,1,6,8,0,22,73}

nvo_quicksort lsort

lsort.of_quicksort( arr[], 1, UpperBound(arr))

Long arr[] = {10,1234,25,66,43,567,123,345,1123,5232,6,1,6,8,0,22,73}

nvo_quicksort lsort

lsort.of_quicksort( arr[], 1, UpperBound(arr))

nvo_quicksort from nonvisualobject

forward
global type nvo_quicksort from nonvisualobject
end type
end forward

global type nvo_quicksort from nonvisualobject autoinstantiate
end type

forward prototypes
public subroutine of_swap (ref long al_num[], long i, long j)
public subroutine of_quicksort (ref long arr[], long low, long high)
public function long of_partition (ref long arr[], long low, long high)
end prototypes

public subroutine of_swap (ref long al_num[], long i, long j);//====================================================================
// Function: nvo_quicksort.of_swap()
//--------------------------------------------------------------------
// Description:
//--------------------------------------------------------------------
// Arguments:
// 	reference	long	al_num[]
// 	value    	long	i
// 	value    	long	j
//--------------------------------------------------------------------
// Returns:  (none)
//--------------------------------------------------------------------
// Author:	PB.BaoGa		Date: 2023/03/24
//--------------------------------------------------------------------
// Usage: nvo_quicksort.of_swap ( ref long al_num[], long i, long j )
//--------------------------------------------------------------------
//	Copyright (c) PB.BaoGa(TM), All rights reserved.
//--------------------------------------------------------------------
// Modify History:
//
//====================================================================

Long temp
temp = al_num[i];
al_num[i] = al_num[j];
al_num[j] = temp;

end subroutine

public subroutine of_quicksort (ref long arr[], long low, long high);//====================================================================
// Function: nvo_quicksort.of_quicksort()
//--------------------------------------------------------------------
// Description:
//--------------------------------------------------------------------
// Arguments:
// 	reference	long	arr[]
// 	value    	long	low
// 	value    	long	high
//--------------------------------------------------------------------
// Returns:  (none)
//--------------------------------------------------------------------
// Author:	PB.BaoGa		Date: 2023/03/24
//--------------------------------------------------------------------
// Usage: nvo_quicksort.of_quicksort ( ref long arr[], long low, long high )
//--------------------------------------------------------------------
//	Copyright (c) PB.BaoGa(TM), All rights reserved.
//--------------------------------------------------------------------
// Modify History:
//
//====================================================================

Long Pi

If (low < high) Then

	// pi is partitioning index, arr[p]
	// is now at right place
	Pi = of_partition(arr, low, high);

	// Separately sort elements before
	// partition and after partition
	of_quickSort(arr, low, Pi - 1);
	of_quickSort(arr, Pi + 1, high);

End If

end subroutine

public function long of_partition (ref long arr[], long low, long high);//====================================================================
// Function: nvo_quicksort.of_partition()
//--------------------------------------------------------------------
// Description:
//--------------------------------------------------------------------
// Arguments:
// 	reference	long	arr[]
// 	value    	long	low
// 	value    	long	high
//--------------------------------------------------------------------
// Returns:  long
//--------------------------------------------------------------------
// Author:	PB.BaoGa		Date: 2023/03/24
//--------------------------------------------------------------------
// Usage: nvo_quicksort.of_partition ( ref long arr[], long low, long high )
//--------------------------------------------------------------------
//	Copyright (c) PB.BaoGa(TM), All rights reserved.
//--------------------------------------------------------------------
// Modify History:
//
//====================================================================

// pivot
Long pivot

pivot = arr[high];

// Index of smaller element and
// indicates the right position
// of pivot found so far

Long i
i = (low - 1);
Long j

For j = low To high

	// If current element is smaller
	// than the pivot

	If (arr[j] < pivot) Then

		// Increment index of
		// smaller element
		i++;
		of_swap(arr, i, j);
	End If
Next

of_swap(arr, i + 1, high);
Return (i + 1);


end function

on nvo_quicksort.create
call super::create
TriggerEvent( this, "constructor" )
end on

on nvo_quicksort.destroy
TriggerEvent( this, "destructor" )
call super::destroy
end on

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

forward

global type nvo_quicksort from nonvisualobject

end type

end forward

global type nvo_quicksort from nonvisualobject autoinstantiate

end type

forward prototypes

public subroutine of_swap (ref long al_num[], long i, long j)

public subroutine of_quicksort (ref long arr[], long low, long high)

public function long of_partition (ref long arr[], long low, long high)

end prototypes

public subroutine of_swap (ref long al_num[], long i, long j);//====================================================================

// Function: nvo_quicksort.of_swap()

//--------------------------------------------------------------------

// Description:

//--------------------------------------------------------------------

// Arguments:

// reference long al_num[]

// value long i

// value long j

//--------------------------------------------------------------------

// Returns: (none)

//--------------------------------------------------------------------

// Author: PB.BaoGa Date: 2023/03/24

//--------------------------------------------------------------------

// Usage: nvo_quicksort.of_swap ( ref long al_num[], long i, long j )

//--------------------------------------------------------------------

// Modify History:

//====================================================================

Long temp

temp = al_num[i];

al_num[i] = al_num[j];

al_num[j] = temp;

end subroutine

public subroutine of_quicksort (ref long arr[], long low, long high);//====================================================================

// Function: nvo_quicksort.of_quicksort()

//--------------------------------------------------------------------

// Description:

//--------------------------------------------------------------------

// Arguments:

// reference long arr[]

// value long low

// value long high

//--------------------------------------------------------------------

// Returns: (none)

//--------------------------------------------------------------------

// Author: PB.BaoGa Date: 2023/03/24

//--------------------------------------------------------------------

// Usage: nvo_quicksort.of_quicksort ( ref long arr[], long low, long high )

//--------------------------------------------------------------------

// Modify History:

//====================================================================

Long Pi

If (low < high) Then

// pi is partitioning index, arr[p]

// is now at right place

Pi = of_partition(arr, low, high);

// Separately sort elements before

// partition and after partition

of_quickSort(arr, low, Pi - 1);

of_quickSort(arr, Pi + 1, high);

End If

end subroutine

public function long of_partition (ref long arr[], long low, long high);//====================================================================

// Function: nvo_quicksort.of_partition()

//--------------------------------------------------------------------

// Description:

//--------------------------------------------------------------------

// Arguments:

// reference long arr[]

// value long low

// value long high

//--------------------------------------------------------------------

// Returns: long

//--------------------------------------------------------------------

// Author: PB.BaoGa Date: 2023/03/24

//--------------------------------------------------------------------

// Usage: nvo_quicksort.of_partition ( ref long arr[], long low, long high )

//--------------------------------------------------------------------

// Modify History:

//====================================================================

// pivot

Long pivot

pivot = arr[high];

// Index of smaller element and

// indicates the right position

// of pivot found so far

Long i

i = (low - 1);

Long j

For j = low To high

// If current element is smaller

// than the pivot

If (arr[j] < pivot) Then

// Increment index of

// smaller element

i++;

of_swap(arr, i, j);

End If

of_swap(arr, i + 1, high);

Return (i + 1);

end function

on nvo_quicksort.create

call super::create

TriggerEvent( this, "constructor" )

end on

on nvo_quicksort.destroy

TriggerEvent( this, "destructor" )

call super::destroy

end on

Good Luck!

PowerBuilder Tips & Tricks

PB PowerBuilder PowerBuilder Example PowerBuilder Function Powerbuilder Sort Array Objects PowerBuilder Tips PowerBuilder Tricks PowerScript Tips & Tricks

March 24, 2023

Was this article helpful?

1 Comment

Oldest

Newest Most Voted

Inline Feedbacks

View all comments

Bunker

1 year ago

Hello
There will be an example of a schedule for shifts of a medical clinic where you can register many patients for the same shift.
I have seen components like Codejock I have tried via ole with outlook. but they have not been satisfactory
Thank you very much if you have any example or component greetings