
- LISP Tutorial
- LISP - Home
- LISP - Overview
- LISP - Environment
- LISP - REPL
- LISP - Program Structure
- LISP - Basic Syntax
- LISP - Data Types
- Lisp Macros
- LISP - Macros
- LISP - Backquote and Comma
- LISP - Code Generation Using Macro
- LISP - Variable Capture and Hygienic macro
- LISP - Scope and Binding
- LISP - Macro Writing Style
- LISP - Macro Characters
- LISP - Read-Time Macros
- LISP - Compiler Macros
- LISP - Uses of Macros
- Lisp Functions
- LISP - Functions
- LISP - Functions vs Macros
- LISP - Calling Function using funcall
- LISP - Calling Function using apply
- LISP - Closures
- LISP - Functions as Arguments
- LISP - Functions as Return Values
- LISP - Recursion
- LISP - Built-in Functions
- Lisp Predicates
- LISP - Predicates
- LISP - Generic Data Type Predicates
- LISP - Specific Data Type Predicates
- LISP - Equality Predicates
- LISP - Numeric Predicates
- LISP - Comparison Predicates
- LISP - Logical Predicates
- LISP - List Predicates
- LISP - Custom Predicates
- LISP - Chaining Predicates
- Lisp Arrays
- LISP - Arrays
- LISP - Adjustable Arrays
- LISP - Fill Pointers in Arrays
- LISP - Specialized Arrays
- LISP - Arrays Properties
- LISP - Iterating over Arrays
- LISP - Multidimensional Arrays
- LISP - Row-Major Order
- Lisp Strings
- LISP - Strings
- LISP - String Concatenation
- LISP - String Comparison
- LISP - String Case Conversion
- LISP - String Trimmimg
- LISP - String Searching
- LISP - Getting Substring
- LISP - String Replacement
- LISP - Sorting Strings
- LISP - Merging Strings
- LISP - Accessing Characters of String
- LISP - String length
- LISP - Escape Sequences
- Lisp Sequences
- LISP - Sequences
- LISP - Accessing Element of Sequence
- LISP - Sequence length
- LISP - Getting Subsequence
- LISP - Search Element in Sequence
- LISP - Sequence Concatenation
- LISP - Reversing a Sequence
- LISP - Mapping Sequence Element
- LISP - position of Element
- LISP - Remove an Element
- LISP - Sort Sequence
- LISP - Merge Sequences
- LISP - every function
- LISP - some function
- LISP - notany function
- LISP - notevery function
- Lisp Lists
- LISP - Lists
- LISP - Accessing Elements of Lists
- LISP - Modifications to Lists
- LISP - Using mapcar on List
- LISP - Using mapc on List
- LISP - Using reduce on List
- LISP - Removing elements from List
- LISP - Reversing a List
- LISP - Sorting a List
- LISP - Searching a List
- LISP - List vs Vectors
- LISP - Matrix Multiplication
- Lisp Vectors
- LISP - Vectors
- LISP - Creating Vectors
- LISP - Accessing Elements of Vectors
- LISP - Modifications to Vectors
- LISP - Adjustable Vectors
- LISP - Specialized Vectors
- LISP - Vector Functions
- Lisp Set
- LISP - Set
- LISP - Adding elements to the Set
- LISP - Getting SubSet from a Set
- LISP - Set Difference
- LISP - Set Exclusive OR
- LISP - Set Intersection
- LISP - Set Union
- LISP - Representing Set with HashTable
- LISP - List as Set vs HashTable as Set
- Lisp Tree
- LISP - Tree
- LISP - Recursive Traversal
- LISP - Inorder Traversal
- LISP - Preorder Traversal
- LISP - Postorder Traversal
- LISP - Depth First Traversal
- LISP - Modifying Tree
- LISP - Search Tree
- LISP - Binary Tree
- Lisp Hash Table
- LISP - Hash Table
- Adding Values to Hash Table
- Removing Values from Hash Table
- Updating Values of Hash Table
- Iterating Hash Table Entries
- Searching key in HashTable
- Checking Size of HashTable
- Using Custom Equality Check
- Lisp - Input − Output
- LISP - Input − Output
- LISP - Streams
- LISP - Reading Data from Streams
- LISP - Writing Data to Streams
- LISP - File I/O
- LISP - String I/O
- LISP - Formatting with Format
- LISP - Interactive I/O
- LISP - Error Handling
- LISP - Binary I/O
- Lisp - Structures
- LISP - Structures
- LISP - Accessors and Mutators
- LISP - Structure Options
- LISP - Structure Types
- LISP - Applications and Best Practices
- Lisp - CLOS
- LISP - CLOS
- Lisp - Objects
- LISP - Class
- LISP - Slots and Accessors
- LISP - Generic Functions
- LISP - Class Precedence
- LISP - Metaobject Protocol
- LISP - Multimethods
- LISP - Multiple Inheritance
- LISP - Method Combinations
- LISP - Method Combinations
- LISP - :before Method Combination
- LISP - :primary Method Combination
- LISP - :after Method Combination
- LISP - :around Method Combination
- LISP - + Method Combination
- LISP - and Method Combination
- LISP - append Method Combination
- LISP Useful Resources
- Lisp - Quick Guide
- Lisp - Useful Resources
- Lisp - Discussion
Lisp - Adding element to a Set
Lisp is not having Set as built-in data structure but we can implement a Set using List. We can add elements to the Set while maintaining the set property that is no duplicate value is allowed in a Set. In this chapter, we'll disucss various methods to add an element to a set.
Using adjoin function
adjoin function is the most commonly used method to add an element to the set.
adjoin function first checks if an element is already present in the list or not. If element is present, same list is returned without any modification otherwise element is added at the beginning of the list and a new list is returned.
By this way adjoin function maintains the set property.
adjoin function is used in conjuction with setf function to modify a set variable to reflect the changes.
main.lisp
; define a set of 3 elements with given list of values (defvar my-set '(1 2 3)) ; print the set (print my-set) ; add a new value (setf my-set (adjoin 4 my-set)) (terpri) ; print the updated set (print my-set) ; try to add a duplicate value (setf my-set (adjoin 2 my-set)) (terpri) ; print the set, still no duplicate (print my-set)
Output
When you execute the code, it returns the following result −
(1 2 3) (4 1 2 3) (4 1 2 3)
Using pushnew function
pushnew function can also be used to add an element to the set maintaining the set property.
pushnew function first checks if an element is already present in the list or not. If element is present, list is not updated otherwise element is added.
By this way pushnew function maintains the set property.
pushnew function is used without setf function to modify a set variable to reflect the changes.
main.lisp
; define a set of 3 elements with given list of values (defvar my-set '(1 2 3)) ; print the set (print my-set) ; add a new value (pushnew 4 my-set) (terpri) ; print the updated set (print my-set) ; try to add a duplicate value (pushnew 2 my-set) (terpri) ; print the set, still no duplicate (print my-set)
Output
When you execute the code, it returns the following result −
(1 2 3) (4 1 2 3) (4 1 2 3)
Using custom function to add element to Set
We can define a custom function as well while checking the element in a list as shown below −
main.lisp
; define a function (defun add (element set) ; if element is a member of set return the set (if (member element set) set ; otherwise add element to the list (cons element set))) ; define a set of 3 elements with given list of values (defvar my-set '(1 2 3)) ; print the set (print my-set) ; add a new value (setf my-set (add 4 my-set)) (terpri) ; print the updated set (print my-set) ; try to add a duplicate value (setf my-set (add 2 my-set)) (terpri) ; print the set, still no duplicate (print my-set)
Output
When you execute the code, it returns the following result −
(1 2 3) (4 1 2 3) (4 1 2 3)
Key Considerations
Order− A List is not preserving the order of element so in a Set implemented using List, order of elements in a Set is not gurranteed.adjoin and pushnew functions add element to the beginning of the List. Although we can use sort function to sort the list and maintain an order with elements.
Equality− adjoin and pushnew functions internally use member function to check an existing element. And member function uses eql method for comparison. Using :test we can use any other equality method to compare elements.
Efficiency− A list based implementation of a large Set can be inefficient during membership check. For high performance, hashtable or tree can be used to represent a Set.