Java

1. Please edit the above and use the code button to put <pre> tags around your code so it is readable.
2. Show us the line in the code where the error occurs.

Dangling pointers in computer programming are pointers that do not point to a valid object of the appropriate type. These are special cases of memory safety violations.

Dangling pointers arise when an object is deleted or deallocated, without modifying the value of the pointer, so that the pointer still points to the memory location of the deallocated memory. As the system may reallocate the previously freed memory to another process, if the original program then dereferences the (now) dangling pointer, unpredictable behavior may result, as the memory may now contain completely different data.

''' <summary>
   ''' Returns the polygon that uses the least amount of points to make the polygon that contains all the points
   ''' </summary>
   ''' <param name="points"></param>
   ''' <returns>PointCollection</returns>
   ''' <remarks>It removes duplicate points</remarks>
   Public Function ConvexHull2D(ByVal points As PointCollection) As PointCollection
       Dim SortedList As New PointCollection
       Dim Upper As New PointCollection
       Dim Lower As New PointCollection
       Dim tempPoints As New PointCollection

       For Each p As Point In points
           If Not tempPoints.Contains(p) Then tempPoints.Add(p)
       Next

       Dim res As New PointCollection

       SortedList = SortPoints(tempPoints, True)

       Upper = SortedList
       For i As Integer = SortedList.Count - 1 To 0 Step -1
           Lower.Add(SortedList(i))
       Next

       Dim j_set As Boolean = False
       Dim j As Integer = 0
       Dim r As Integer
       Do While j < Upper.Count - 2
           r = WhichSide(Upper(j + 1), Upper(j), Upper(j + 2))
           If r = -1 Or r = 0 Then
               Upper.RemoveAt(j + 1)
               j = 0
               j_set = True
           End If

           If Not j_set Then
               j += 1
           End If

           j_set = False
       Loop

       j = 0
       j_set = False
       Do While j < Lower.Count - 2
           r = WhichSide(Lower(j + 1), Lower(j), Lower(j + 2))
           If r = -1 Or r = 0 Then
               Lower.RemoveAt(j + 1)
               j = 0
               j_set = True
           End If

           If Not j_set Then
               j += 1
           End If

           j_set = False
       Loop

       For Each p As Point In Upper
           res.Add(p)
       Next

       For Each p As Point In Lower
           If Not res.Contains(p) Then
               res.Add(p)
           End If
       Next

       Return res
   End Function

   ''' <summary>
   ''' Finds which side of a line the point is
   ''' </summary>
   ''' <param name="PointToBeEvaluated">Evaluation point</param>
   ''' <param name="StartPointOnLine">Startpoint of line</param>
   ''' <param name="EndPointOnLine">Endpoint on line</param>
   ''' <returns>-1 for a point to the left, 0 for a point on the line, +1 for a point to the right</returns>
   ''' <remarks></remarks>
   Private Function WhichSide(ByVal PointToBeEvaluated As Point, ByVal StartPointOnLine As Point, ByVal EndPointOnLine As Point) As Integer
       Dim ReturnvalueEquation As Double
       ReturnvalueEquation = ((PointToBeEvaluated.Y - StartPointOnLine.Y) _
                              * (EndPointOnLine.X - StartPointOnLine.X)) - ((EndPointOnLine.Y - StartPointOnLine.Y) _
                              * (PointToBeEvaluated.X - StartPointOnLine.X))

       If ReturnvalueEquation > 0 Then
           Return -1
       ElseIf ReturnvalueEquation = 0 Then
           Return 0
       Else
           Return 1
       End If

   End Function

    ''' <summary>
    ''' Returns a sorted pointcollection based on Lexografically sorting
    ''' </summary>
    ''' <param name="samplepoints"></param>
    ''' <param name="SortByXdirection"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function SortPoints(ByVal samplepoints As PointCollection, ByVal SortByXdirection As Boolean) As PointCollection
        'Create another array so we can keep the original array out of order
        Dim copySamplePoints As Point() = New Point(samplepoints.Count - 1) {}
        samplepoints.CopyTo(copySamplePoints, 0)

        If SortByXdirection Then
            Array.Sort(copySamplePoints, New PointSort(PointSort.Mode.X))
        Else
            Array.Sort(copySamplePoints, New PointSort(PointSort.Mode.Y))
        End If

        Dim result As New PointCollection

        For Each p As Point In copySamplePoints
            result.Add(p)
        Next

        Return result
    End Function


    Private Class PointSort
        Implements IComparer
        Public Enum Mode
            X
            Y
        End Enum

        Private currentMode As Mode = Mode.X

        Public Sub New(ByVal mode As Mode)
            currentMode = mode
        End Sub

        'Comparing function
        'Returns one of three values - 0 (equal), 1 (greater than), 2 (less than)
        Private Function IComparer_Compare(ByVal a As Object, ByVal b As Object) As Integer Implements IComparer.Compare
            Dim point1 As Point = CType(a, Point)
            Dim point2 As Point = CType(b, Point)

            If currentMode = Mode.X Then
                'Compare X values
                If point1.X > point2.X Then
                    Return 1
                ElseIf point1.X < point2.X Then
                    Return -1
                Else
                    If point1.Y > point2.Y Then
                        Return 1
                    ElseIf point1.Y < point2.Y Then
                        Return -1
                    Else
                        Return 0
                    End If
                End If
            Else
                If point1.Y > point2.Y Then
                    'Compare Y Values
                    Return 1
                ElseIf point1.Y < point2.Y Then
                    Return -1
                Else
                    If point1.X > point2.X Then
                        'Compare Y Values
                        Return 1
                    ElseIf point1.X < point2.X Then
                        Return -1
                    Else
                        Return 0
                    End If
                End If
            End If
        End Function
    End Class